fireblocks-sdk 2026.3.28

// Fireblocks API
//
// Fireblocks provides a suite of applications to manage digital asset operations and a complete development platform to build your business on the blockchain.  - Visit our website for more information: [Fireblocks Website](https://fireblocks.com) - Visit our developer docs: [Fireblocks DevPortal](https://developers.fireblocks.com)
//
// The version of the OpenAPI document: 1.8.0
// Contact: developers@fireblocks.com
// Generated by: https://openapi-generator.tech

use {
    super::{Error, configuration},
    crate::{
        apis::{ContentType, ResponseContent},
        models,
    },
    async_trait::async_trait,
    reqwest,
    serde::{Deserialize, Serialize, de::Error as _},
    std::sync::Arc,
};

#[async_trait]
pub trait WebhooksV2Api: Send + Sync {
    /// POST /webhooks
    ///
    /// Creates a new webhook, which will be triggered on the specified events
    /// **Endpoint Permissions:** Owner, Admin, Non-Signing Admin.
    async fn create_webhook(
        &self,
        params: CreateWebhookParams,
    ) -> Result<models::Webhook, Error<CreateWebhookError>>;

    /// DELETE /webhooks/{webhookId}
    ///
    /// Delete a webhook by its ID.  **Endpoint Permissions:** Owner, Admin,
    /// Non-Signing Admin.
    async fn delete_webhook(
        &self,
        params: DeleteWebhookParams,
    ) -> Result<models::Webhook, Error<DeleteWebhookError>>;

    /// GET /webhooks/{webhookId}/notifications/{notificationId}
    ///
    /// Get a notification by its notification ID.  **Endpoint Permissions:**
    /// Owner, Admin, Non-Signing Admin.
    async fn get_notification(
        &self,
        params: GetNotificationParams,
    ) -> Result<models::NotificationWithData, Error<GetNotificationError>>;

    /// GET /webhooks/{webhookId}/notifications/{notificationId}/attempts
    ///
    /// Get notification attempts by notification ID.
    async fn get_notification_attempts(
        &self,
        params: GetNotificationAttemptsParams,
    ) -> Result<models::NotificationAttemptsPaginatedResponse, Error<GetNotificationAttemptsError>>;

    /// GET /webhooks/{webhookId}/notifications
    ///
    /// Get all notifications by webhook ID (paginated).  **Endpoint
    /// Permissions:** Owner, Admin, Non-Signing Admin.
    async fn get_notifications(
        &self,
        params: GetNotificationsParams,
    ) -> Result<models::NotificationPaginatedResponse, Error<GetNotificationsError>>;

    /// GET /webhooks/{webhookId}/notifications/resend_failed/jobs/{jobId}
    ///
    /// Get the status of a resend job.
    async fn get_resend_job_status(
        &self,
        params: GetResendJobStatusParams,
    ) -> Result<models::ResendFailedNotificationsJobStatusResponse, Error<GetResendJobStatusError>>;

    /// GET /webhooks/{webhookId}
    ///
    /// Retrieve a webhook by its ID.  **Endpoint Permissions:** Owner, Admin,
    /// Non-Signing Admin.
    async fn get_webhook(
        &self,
        params: GetWebhookParams,
    ) -> Result<models::Webhook, Error<GetWebhookError>>;

    /// GET /webhooks
    ///
    /// Get all webhooks (paginated).  **Endpoint Permissions:** Owner, Admin,
    /// Non-Signing Admin.
    async fn get_webhooks(
        &self,
        params: GetWebhooksParams,
    ) -> Result<models::WebhookPaginatedResponse, Error<GetWebhooksError>>;

    /// POST /webhooks/{webhookId}/notifications/resend_failed
    ///
    /// Resend all failed notifications for a webhook in the last 24 hours.
    /// **Endpoint Permission:** Owner, Admin, Non-Signing Admin, Signer,
    /// Editor.
    async fn resend_failed_notifications(
        &self,
        params: ResendFailedNotificationsParams,
    ) -> Result<models::ResendFailedNotificationsResponse, Error<ResendFailedNotificationsError>>;

    /// POST /webhooks/{webhookId}/notifications/{notificationId}/resend
    ///
    /// Resend a notification by its ID.  **Endpoint Permissions:** Owner,
    /// Admin, Non-Signing Admin, Signer, Editor.
    async fn resend_notification_by_id(
        &self,
        params: ResendNotificationByIdParams,
    ) -> Result<(), Error<ResendNotificationByIdError>>;

    /// POST /webhooks/{webhookId}/notifications/resend_by_resource
    ///
    /// Resend notifications by their resource ID.  **Endpoint Permissions:**
    /// Owner, Admin, Non-Signing Admin, Signer, Editor.
    async fn resend_notifications_by_resource_id(
        &self,
        params: ResendNotificationsByResourceIdParams,
    ) -> Result<(), Error<ResendNotificationsByResourceIdError>>;

    /// PATCH /webhooks/{webhookId}
    ///
    /// Update a webhook by its ID.  **Endpoint Permissions:** Owner, Admin,
    /// Non-Signing Admin.
    async fn update_webhook(
        &self,
        params: UpdateWebhookParams,
    ) -> Result<models::Webhook, Error<UpdateWebhookError>>;
}

pub struct WebhooksV2ApiClient {
    configuration: Arc<configuration::Configuration>,
}

impl WebhooksV2ApiClient {
    pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
        Self { configuration }
    }
}

/// struct for passing parameters to the method
/// [`WebhooksV2Api::create_webhook`]
#[derive(Clone, Debug)]
#[cfg_attr(feature = "bon", derive(::bon::Builder))]
pub struct CreateWebhookParams {
    pub create_webhook_request: models::CreateWebhookRequest,
    /// A unique identifier for the request. If the request is sent multiple
    /// times with the same idempotency key, the server will return the same
    /// response as the first request. The idempotency key is valid for 24
    /// hours.
    pub idempotency_key: Option<String>,
}

/// struct for passing parameters to the method
/// [`WebhooksV2Api::delete_webhook`]
#[derive(Clone, Debug)]
#[cfg_attr(feature = "bon", derive(::bon::Builder))]
pub struct DeleteWebhookParams {
    /// The unique identifier of the webhook
    pub webhook_id: String,
}

/// struct for passing parameters to the method
/// [`WebhooksV2Api::get_notification`]
#[derive(Clone, Debug)]
#[cfg_attr(feature = "bon", derive(::bon::Builder))]
pub struct GetNotificationParams {
    /// The ID of the webhook to fetch
    pub webhook_id: String,
    /// The ID of the notification to fetch
    pub notification_id: String,
    /// Include the data of the notification
    pub include_data: Option<bool>,
}

/// struct for passing parameters to the method
/// [`WebhooksV2Api::get_notification_attempts`]
#[derive(Clone, Debug)]
#[cfg_attr(feature = "bon", derive(::bon::Builder))]
pub struct GetNotificationAttemptsParams {
    /// The ID of the webhook to fetch
    pub webhook_id: String,
    /// The ID of the notification to fetch
    pub notification_id: String,
    /// Cursor of the required page
    pub page_cursor: Option<String>,
    /// Maximum number of items in the page
    pub page_size: Option<f64>,
}

/// struct for passing parameters to the method
/// [`WebhooksV2Api::get_notifications`]
#[derive(Clone, Debug)]
#[cfg_attr(feature = "bon", derive(::bon::Builder))]
pub struct GetNotificationsParams {
    pub webhook_id: String,
    /// ASC / DESC ordering (default DESC)
    pub order: Option<String>,
    /// Sort by field (id, createdAt, updatedAt, status, eventType, resourceId)
    pub sort_by: Option<String>,
    /// Cursor of the required page
    pub page_cursor: Option<String>,
    /// Maximum number of items on the page
    pub page_size: Option<f64>,
    /// Start time in milliseconds since epoch to filter by notifications
    /// created after this time (default 31 days ago)
    pub start_time: Option<String>,
    /// End time in milliseconds since epoch to filter by notifications created
    /// before this time (default current time)
    pub end_time: Option<String>,
    /// List of notification statuses to filter by
    pub statuses: Option<Vec<models::NotificationStatus>>,
    /// List of webhook event types to filter by
    pub events: Option<Vec<models::WebhookEvent>>,
    /// Resource ID to filter by
    pub resource_id: Option<String>,
}

/// struct for passing parameters to the method
/// [`WebhooksV2Api::get_resend_job_status`]
#[derive(Clone, Debug)]
#[cfg_attr(feature = "bon", derive(::bon::Builder))]
pub struct GetResendJobStatusParams {
    /// The ID of the webhook
    pub webhook_id: String,
    /// The ID of the resend job
    pub job_id: String,
}

/// struct for passing parameters to the method [`WebhooksV2Api::get_webhook`]
#[derive(Clone, Debug)]
#[cfg_attr(feature = "bon", derive(::bon::Builder))]
pub struct GetWebhookParams {
    /// The unique identifier of the webhook
    pub webhook_id: String,
}

/// struct for passing parameters to the method [`WebhooksV2Api::get_webhooks`]
#[derive(Clone, Debug)]
#[cfg_attr(feature = "bon", derive(::bon::Builder))]
pub struct GetWebhooksParams {
    /// ASC / DESC ordering (default DESC)
    pub order: Option<String>,
    /// Cursor of the required page
    pub page_cursor: Option<String>,
    /// Maximum number of items on the page
    pub page_size: Option<f64>,
}

/// struct for passing parameters to the method
/// [`WebhooksV2Api::resend_failed_notifications`]
#[derive(Clone, Debug)]
#[cfg_attr(feature = "bon", derive(::bon::Builder))]
pub struct ResendFailedNotificationsParams {
    /// The ID of the webhook
    pub webhook_id: String,
    pub resend_failed_notifications_request: models::ResendFailedNotificationsRequest,
    /// A unique identifier for the request. If the request is sent multiple
    /// times with the same idempotency key, the server will return the same
    /// response as the first request. The idempotency key is valid for 24
    /// hours.
    pub idempotency_key: Option<String>,
}

/// struct for passing parameters to the method
/// [`WebhooksV2Api::resend_notification_by_id`]
#[derive(Clone, Debug)]
#[cfg_attr(feature = "bon", derive(::bon::Builder))]
pub struct ResendNotificationByIdParams {
    /// The ID of the webhook
    pub webhook_id: String,
    /// The ID of the notification
    pub notification_id: String,
    /// A unique identifier for the request. If the request is sent multiple
    /// times with the same idempotency key, the server will return the same
    /// response as the first request. The idempotency key is valid for 24
    /// hours.
    pub idempotency_key: Option<String>,
}

/// struct for passing parameters to the method
/// [`WebhooksV2Api::resend_notifications_by_resource_id`]
#[derive(Clone, Debug)]
#[cfg_attr(feature = "bon", derive(::bon::Builder))]
pub struct ResendNotificationsByResourceIdParams {
    /// The ID of the webhook
    pub webhook_id: String,
    pub resend_notifications_by_resource_id_request: models::ResendNotificationsByResourceIdRequest,
    /// A unique identifier for the request. If the request is sent multiple
    /// times with the same idempotency key, the server will return the same
    /// response as the first request. The idempotency key is valid for 24
    /// hours.
    pub idempotency_key: Option<String>,
}

/// struct for passing parameters to the method
/// [`WebhooksV2Api::update_webhook`]
#[derive(Clone, Debug)]
#[cfg_attr(feature = "bon", derive(::bon::Builder))]
pub struct UpdateWebhookParams {
    /// The unique identifier of the webhook
    pub webhook_id: String,
    pub update_webhook_request: models::UpdateWebhookRequest,
}

#[async_trait]
impl WebhooksV2Api for WebhooksV2ApiClient {
    /// Creates a new webhook, which will be triggered on the specified events
    /// **Endpoint Permissions:** Owner, Admin, Non-Signing Admin.
    async fn create_webhook(
        &self,
        params: CreateWebhookParams,
    ) -> Result<models::Webhook, Error<CreateWebhookError>> {
        let CreateWebhookParams {
            create_webhook_request,
            idempotency_key,
        } = params;

        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!("{}/webhooks", local_var_configuration.base_path);
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(local_var_param_value) = idempotency_key {
            local_var_req_builder =
                local_var_req_builder.header("Idempotency-Key", local_var_param_value.to_string());
        }
        local_var_req_builder = local_var_req_builder.json(&create_webhook_request);

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).await?;

        let local_var_status = local_var_resp.status();
        let local_var_content_type = local_var_resp
            .headers()
            .get("content-type")
            .and_then(|v| v.to_str().ok())
            .unwrap_or("application/octet-stream");
        let local_var_content_type = super::ContentType::from(local_var_content_type);
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            match local_var_content_type {
                ContentType::Json => {
                    crate::deserialize_wrapper(&local_var_content).map_err(Error::from)
                }
                ContentType::Text => {
                    return Err(Error::from(serde_json::Error::custom(
                        "Received `text/plain` content type response that cannot be converted to \
                         `models::Webhook`",
                    )));
                }
                ContentType::Unsupported(local_var_unknown_type) => {
                    return Err(Error::from(serde_json::Error::custom(format!(
                        "Received `{local_var_unknown_type}` content type response that cannot be \
                         converted to `models::Webhook`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<CreateWebhookError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    /// Delete a webhook by its ID.  **Endpoint Permissions:** Owner, Admin,
    /// Non-Signing Admin.
    async fn delete_webhook(
        &self,
        params: DeleteWebhookParams,
    ) -> Result<models::Webhook, Error<DeleteWebhookError>> {
        let DeleteWebhookParams { webhook_id } = params;

        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/webhooks/{webhookId}",
            local_var_configuration.base_path,
            webhookId = crate::apis::urlencode(webhook_id)
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).await?;

        let local_var_status = local_var_resp.status();
        let local_var_content_type = local_var_resp
            .headers()
            .get("content-type")
            .and_then(|v| v.to_str().ok())
            .unwrap_or("application/octet-stream");
        let local_var_content_type = super::ContentType::from(local_var_content_type);
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            match local_var_content_type {
                ContentType::Json => {
                    crate::deserialize_wrapper(&local_var_content).map_err(Error::from)
                }
                ContentType::Text => {
                    return Err(Error::from(serde_json::Error::custom(
                        "Received `text/plain` content type response that cannot be converted to \
                         `models::Webhook`",
                    )));
                }
                ContentType::Unsupported(local_var_unknown_type) => {
                    return Err(Error::from(serde_json::Error::custom(format!(
                        "Received `{local_var_unknown_type}` content type response that cannot be \
                         converted to `models::Webhook`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<DeleteWebhookError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    /// Get a notification by its notification ID.  **Endpoint Permissions:**
    /// Owner, Admin, Non-Signing Admin.
    async fn get_notification(
        &self,
        params: GetNotificationParams,
    ) -> Result<models::NotificationWithData, Error<GetNotificationError>> {
        let GetNotificationParams {
            webhook_id,
            notification_id,
            include_data,
        } = params;

        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/webhooks/{webhookId}/notifications/{notificationId}",
            local_var_configuration.base_path,
            webhookId = crate::apis::urlencode(webhook_id),
            notificationId = crate::apis::urlencode(notification_id)
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

        if let Some(ref param_value) = include_data {
            local_var_req_builder =
                local_var_req_builder.query(&[("includeData", &param_value.to_string())]);
        }
        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).await?;

        let local_var_status = local_var_resp.status();
        let local_var_content_type = local_var_resp
            .headers()
            .get("content-type")
            .and_then(|v| v.to_str().ok())
            .unwrap_or("application/octet-stream");
        let local_var_content_type = super::ContentType::from(local_var_content_type);
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            match local_var_content_type {
                ContentType::Json => {
                    crate::deserialize_wrapper(&local_var_content).map_err(Error::from)
                }
                ContentType::Text => {
                    return Err(Error::from(serde_json::Error::custom(
                        "Received `text/plain` content type response that cannot be converted to \
                         `models::NotificationWithData`",
                    )));
                }
                ContentType::Unsupported(local_var_unknown_type) => {
                    return Err(Error::from(serde_json::Error::custom(format!(
                        "Received `{local_var_unknown_type}` content type response that cannot be \
                         converted to `models::NotificationWithData`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<GetNotificationError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    /// Get notification attempts by notification ID.
    async fn get_notification_attempts(
        &self,
        params: GetNotificationAttemptsParams,
    ) -> Result<models::NotificationAttemptsPaginatedResponse, Error<GetNotificationAttemptsError>>
    {
        let GetNotificationAttemptsParams {
            webhook_id,
            notification_id,
            page_cursor,
            page_size,
        } = params;

        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/webhooks/{webhookId}/notifications/{notificationId}/attempts",
            local_var_configuration.base_path,
            webhookId = crate::apis::urlencode(webhook_id),
            notificationId = crate::apis::urlencode(notification_id)
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

        if let Some(ref param_value) = page_cursor {
            local_var_req_builder =
                local_var_req_builder.query(&[("pageCursor", &param_value.to_string())]);
        }
        if let Some(ref param_value) = page_size {
            local_var_req_builder =
                local_var_req_builder.query(&[("pageSize", &param_value.to_string())]);
        }
        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).await?;

        let local_var_status = local_var_resp.status();
        let local_var_content_type = local_var_resp
            .headers()
            .get("content-type")
            .and_then(|v| v.to_str().ok())
            .unwrap_or("application/octet-stream");
        let local_var_content_type = super::ContentType::from(local_var_content_type);
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            match local_var_content_type {
                ContentType::Json => {
                    crate::deserialize_wrapper(&local_var_content).map_err(Error::from)
                }
                ContentType::Text => {
                    return Err(Error::from(serde_json::Error::custom(
                        "Received `text/plain` content type response that cannot be converted to \
                         `models::NotificationAttemptsPaginatedResponse`",
                    )));
                }
                ContentType::Unsupported(local_var_unknown_type) => {
                    return Err(Error::from(serde_json::Error::custom(format!(
                        "Received `{local_var_unknown_type}` content type response that cannot be \
                         converted to `models::NotificationAttemptsPaginatedResponse`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<GetNotificationAttemptsError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    /// Get all notifications by webhook ID (paginated).  **Endpoint
    /// Permissions:** Owner, Admin, Non-Signing Admin.
    async fn get_notifications(
        &self,
        params: GetNotificationsParams,
    ) -> Result<models::NotificationPaginatedResponse, Error<GetNotificationsError>> {
        let GetNotificationsParams {
            webhook_id,
            order,
            sort_by,
            page_cursor,
            page_size,
            start_time,
            end_time,
            statuses,
            events,
            resource_id,
        } = params;

        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/webhooks/{webhookId}/notifications",
            local_var_configuration.base_path,
            webhookId = crate::apis::urlencode(webhook_id)
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

        if let Some(ref param_value) = order {
            local_var_req_builder =
                local_var_req_builder.query(&[("order", &param_value.to_string())]);
        }
        if let Some(ref param_value) = sort_by {
            local_var_req_builder =
                local_var_req_builder.query(&[("sortBy", &param_value.to_string())]);
        }
        if let Some(ref param_value) = page_cursor {
            local_var_req_builder =
                local_var_req_builder.query(&[("pageCursor", &param_value.to_string())]);
        }
        if let Some(ref param_value) = page_size {
            local_var_req_builder =
                local_var_req_builder.query(&[("pageSize", &param_value.to_string())]);
        }
        if let Some(ref param_value) = start_time {
            local_var_req_builder =
                local_var_req_builder.query(&[("startTime", &param_value.to_string())]);
        }
        if let Some(ref param_value) = end_time {
            local_var_req_builder =
                local_var_req_builder.query(&[("endTime", &param_value.to_string())]);
        }
        if let Some(ref param_value) = statuses {
            local_var_req_builder = match "multi" {
                "multi" => local_var_req_builder.query(
                    &param_value
                        .into_iter()
                        .map(|p| ("statuses".to_owned(), p.to_string()))
                        .collect::<Vec<(std::string::String, std::string::String)>>(),
                ),
                _ => local_var_req_builder.query(&[(
                    "statuses",
                    &param_value
                        .into_iter()
                        .map(|p| p.to_string())
                        .collect::<Vec<String>>()
                        .join(",")
                        .to_string(),
                )]),
            };
        }
        if let Some(ref param_value) = events {
            local_var_req_builder = match "multi" {
                "multi" => local_var_req_builder.query(
                    &param_value
                        .into_iter()
                        .map(|p| ("events".to_owned(), p.to_string()))
                        .collect::<Vec<(std::string::String, std::string::String)>>(),
                ),
                _ => local_var_req_builder.query(&[(
                    "events",
                    &param_value
                        .into_iter()
                        .map(|p| p.to_string())
                        .collect::<Vec<String>>()
                        .join(",")
                        .to_string(),
                )]),
            };
        }
        if let Some(ref param_value) = resource_id {
            local_var_req_builder =
                local_var_req_builder.query(&[("resourceId", &param_value.to_string())]);
        }
        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).await?;

        let local_var_status = local_var_resp.status();
        let local_var_content_type = local_var_resp
            .headers()
            .get("content-type")
            .and_then(|v| v.to_str().ok())
            .unwrap_or("application/octet-stream");
        let local_var_content_type = super::ContentType::from(local_var_content_type);
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            match local_var_content_type {
                ContentType::Json => {
                    crate::deserialize_wrapper(&local_var_content).map_err(Error::from)
                }
                ContentType::Text => {
                    return Err(Error::from(serde_json::Error::custom(
                        "Received `text/plain` content type response that cannot be converted to \
                         `models::NotificationPaginatedResponse`",
                    )));
                }
                ContentType::Unsupported(local_var_unknown_type) => {
                    return Err(Error::from(serde_json::Error::custom(format!(
                        "Received `{local_var_unknown_type}` content type response that cannot be \
                         converted to `models::NotificationPaginatedResponse`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<GetNotificationsError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    /// Get the status of a resend job.
    async fn get_resend_job_status(
        &self,
        params: GetResendJobStatusParams,
    ) -> Result<models::ResendFailedNotificationsJobStatusResponse, Error<GetResendJobStatusError>>
    {
        let GetResendJobStatusParams { webhook_id, job_id } = params;

        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/webhooks/{webhookId}/notifications/resend_failed/jobs/{jobId}",
            local_var_configuration.base_path,
            webhookId = crate::apis::urlencode(webhook_id),
            jobId = crate::apis::urlencode(job_id)
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).await?;

        let local_var_status = local_var_resp.status();
        let local_var_content_type = local_var_resp
            .headers()
            .get("content-type")
            .and_then(|v| v.to_str().ok())
            .unwrap_or("application/octet-stream");
        let local_var_content_type = super::ContentType::from(local_var_content_type);
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            match local_var_content_type {
                ContentType::Json => {
                    crate::deserialize_wrapper(&local_var_content).map_err(Error::from)
                }
                ContentType::Text => {
                    return Err(Error::from(serde_json::Error::custom(
                        "Received `text/plain` content type response that cannot be converted to \
                         `models::ResendFailedNotificationsJobStatusResponse`",
                    )));
                }
                ContentType::Unsupported(local_var_unknown_type) => {
                    return Err(Error::from(serde_json::Error::custom(format!(
                        "Received `{local_var_unknown_type}` content type response that cannot be \
                         converted to `models::ResendFailedNotificationsJobStatusResponse`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<GetResendJobStatusError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    /// Retrieve a webhook by its ID.  **Endpoint Permissions:** Owner, Admin,
    /// Non-Signing Admin.
    async fn get_webhook(
        &self,
        params: GetWebhookParams,
    ) -> Result<models::Webhook, Error<GetWebhookError>> {
        let GetWebhookParams { webhook_id } = params;

        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/webhooks/{webhookId}",
            local_var_configuration.base_path,
            webhookId = crate::apis::urlencode(webhook_id)
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).await?;

        let local_var_status = local_var_resp.status();
        let local_var_content_type = local_var_resp
            .headers()
            .get("content-type")
            .and_then(|v| v.to_str().ok())
            .unwrap_or("application/octet-stream");
        let local_var_content_type = super::ContentType::from(local_var_content_type);
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            match local_var_content_type {
                ContentType::Json => {
                    crate::deserialize_wrapper(&local_var_content).map_err(Error::from)
                }
                ContentType::Text => {
                    return Err(Error::from(serde_json::Error::custom(
                        "Received `text/plain` content type response that cannot be converted to \
                         `models::Webhook`",
                    )));
                }
                ContentType::Unsupported(local_var_unknown_type) => {
                    return Err(Error::from(serde_json::Error::custom(format!(
                        "Received `{local_var_unknown_type}` content type response that cannot be \
                         converted to `models::Webhook`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<GetWebhookError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    /// Get all webhooks (paginated).  **Endpoint Permissions:** Owner, Admin,
    /// Non-Signing Admin.
    async fn get_webhooks(
        &self,
        params: GetWebhooksParams,
    ) -> Result<models::WebhookPaginatedResponse, Error<GetWebhooksError>> {
        let GetWebhooksParams {
            order,
            page_cursor,
            page_size,
        } = params;

        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!("{}/webhooks", local_var_configuration.base_path);
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

        if let Some(ref param_value) = order {
            local_var_req_builder =
                local_var_req_builder.query(&[("order", &param_value.to_string())]);
        }
        if let Some(ref param_value) = page_cursor {
            local_var_req_builder =
                local_var_req_builder.query(&[("pageCursor", &param_value.to_string())]);
        }
        if let Some(ref param_value) = page_size {
            local_var_req_builder =
                local_var_req_builder.query(&[("pageSize", &param_value.to_string())]);
        }
        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).await?;

        let local_var_status = local_var_resp.status();
        let local_var_content_type = local_var_resp
            .headers()
            .get("content-type")
            .and_then(|v| v.to_str().ok())
            .unwrap_or("application/octet-stream");
        let local_var_content_type = super::ContentType::from(local_var_content_type);
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            match local_var_content_type {
                ContentType::Json => {
                    crate::deserialize_wrapper(&local_var_content).map_err(Error::from)
                }
                ContentType::Text => {
                    return Err(Error::from(serde_json::Error::custom(
                        "Received `text/plain` content type response that cannot be converted to \
                         `models::WebhookPaginatedResponse`",
                    )));
                }
                ContentType::Unsupported(local_var_unknown_type) => {
                    return Err(Error::from(serde_json::Error::custom(format!(
                        "Received `{local_var_unknown_type}` content type response that cannot be \
                         converted to `models::WebhookPaginatedResponse`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<GetWebhooksError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    /// Resend all failed notifications for a webhook in the last 24 hours.
    /// **Endpoint Permission:** Owner, Admin, Non-Signing Admin, Signer,
    /// Editor.
    async fn resend_failed_notifications(
        &self,
        params: ResendFailedNotificationsParams,
    ) -> Result<models::ResendFailedNotificationsResponse, Error<ResendFailedNotificationsError>>
    {
        let ResendFailedNotificationsParams {
            webhook_id,
            resend_failed_notifications_request,
            idempotency_key,
        } = params;

        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/webhooks/{webhookId}/notifications/resend_failed",
            local_var_configuration.base_path,
            webhookId = crate::apis::urlencode(webhook_id)
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(local_var_param_value) = idempotency_key {
            local_var_req_builder =
                local_var_req_builder.header("Idempotency-Key", local_var_param_value.to_string());
        }
        local_var_req_builder = local_var_req_builder.json(&resend_failed_notifications_request);

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).await?;

        let local_var_status = local_var_resp.status();
        let local_var_content_type = local_var_resp
            .headers()
            .get("content-type")
            .and_then(|v| v.to_str().ok())
            .unwrap_or("application/octet-stream");
        let local_var_content_type = super::ContentType::from(local_var_content_type);
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            match local_var_content_type {
                ContentType::Json => {
                    crate::deserialize_wrapper(&local_var_content).map_err(Error::from)
                }
                ContentType::Text => {
                    return Err(Error::from(serde_json::Error::custom(
                        "Received `text/plain` content type response that cannot be converted to \
                         `models::ResendFailedNotificationsResponse`",
                    )));
                }
                ContentType::Unsupported(local_var_unknown_type) => {
                    return Err(Error::from(serde_json::Error::custom(format!(
                        "Received `{local_var_unknown_type}` content type response that cannot be \
                         converted to `models::ResendFailedNotificationsResponse`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<ResendFailedNotificationsError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    /// Resend a notification by its ID.  **Endpoint Permissions:** Owner,
    /// Admin, Non-Signing Admin, Signer, Editor.
    async fn resend_notification_by_id(
        &self,
        params: ResendNotificationByIdParams,
    ) -> Result<(), Error<ResendNotificationByIdError>> {
        let ResendNotificationByIdParams {
            webhook_id,
            notification_id,
            idempotency_key,
        } = params;

        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/webhooks/{webhookId}/notifications/{notificationId}/resend",
            local_var_configuration.base_path,
            webhookId = crate::apis::urlencode(webhook_id),
            notificationId = crate::apis::urlencode(notification_id)
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(local_var_param_value) = idempotency_key {
            local_var_req_builder =
                local_var_req_builder.header("Idempotency-Key", local_var_param_value.to_string());
        }

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).await?;

        let local_var_status = local_var_resp.status();
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            Ok(())
        } else {
            let local_var_entity: Option<ResendNotificationByIdError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    /// Resend notifications by their resource ID.  **Endpoint Permissions:**
    /// Owner, Admin, Non-Signing Admin, Signer, Editor.
    async fn resend_notifications_by_resource_id(
        &self,
        params: ResendNotificationsByResourceIdParams,
    ) -> Result<(), Error<ResendNotificationsByResourceIdError>> {
        let ResendNotificationsByResourceIdParams {
            webhook_id,
            resend_notifications_by_resource_id_request,
            idempotency_key,
        } = params;

        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/webhooks/{webhookId}/notifications/resend_by_resource",
            local_var_configuration.base_path,
            webhookId = crate::apis::urlencode(webhook_id)
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        if let Some(local_var_param_value) = idempotency_key {
            local_var_req_builder =
                local_var_req_builder.header("Idempotency-Key", local_var_param_value.to_string());
        }
        local_var_req_builder =
            local_var_req_builder.json(&resend_notifications_by_resource_id_request);

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).await?;

        let local_var_status = local_var_resp.status();
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            Ok(())
        } else {
            let local_var_entity: Option<ResendNotificationsByResourceIdError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }

    /// Update a webhook by its ID.  **Endpoint Permissions:** Owner, Admin,
    /// Non-Signing Admin.
    async fn update_webhook(
        &self,
        params: UpdateWebhookParams,
    ) -> Result<models::Webhook, Error<UpdateWebhookError>> {
        let UpdateWebhookParams {
            webhook_id,
            update_webhook_request,
        } = params;

        let local_var_configuration = &self.configuration;

        let local_var_client = &local_var_configuration.client;

        let local_var_uri_str = format!(
            "{}/webhooks/{webhookId}",
            local_var_configuration.base_path,
            webhookId = crate::apis::urlencode(webhook_id)
        );
        let mut local_var_req_builder =
            local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());

        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
            local_var_req_builder = local_var_req_builder
                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
        }
        local_var_req_builder = local_var_req_builder.json(&update_webhook_request);

        let local_var_req = local_var_req_builder.build()?;
        let local_var_resp = local_var_client.execute(local_var_req).await?;

        let local_var_status = local_var_resp.status();
        let local_var_content_type = local_var_resp
            .headers()
            .get("content-type")
            .and_then(|v| v.to_str().ok())
            .unwrap_or("application/octet-stream");
        let local_var_content_type = super::ContentType::from(local_var_content_type);
        let local_var_content = local_var_resp.text().await?;

        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
            match local_var_content_type {
                ContentType::Json => {
                    crate::deserialize_wrapper(&local_var_content).map_err(Error::from)
                }
                ContentType::Text => {
                    return Err(Error::from(serde_json::Error::custom(
                        "Received `text/plain` content type response that cannot be converted to \
                         `models::Webhook`",
                    )));
                }
                ContentType::Unsupported(local_var_unknown_type) => {
                    return Err(Error::from(serde_json::Error::custom(format!(
                        "Received `{local_var_unknown_type}` content type response that cannot be \
                         converted to `models::Webhook`"
                    ))));
                }
            }
        } else {
            let local_var_entity: Option<UpdateWebhookError> =
                serde_json::from_str(&local_var_content).ok();
            let local_var_error = ResponseContent {
                status: local_var_status,
                content: local_var_content,
                entity: local_var_entity,
            };
            Err(Error::ResponseError(local_var_error))
        }
    }
}

/// struct for typed errors of method [`WebhooksV2Api::create_webhook`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateWebhookError {
    DefaultResponse(models::ErrorSchema),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`WebhooksV2Api::delete_webhook`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteWebhookError {
    DefaultResponse(models::ErrorSchema),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`WebhooksV2Api::get_notification`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetNotificationError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method
/// [`WebhooksV2Api::get_notification_attempts`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetNotificationAttemptsError {
    DefaultResponse(models::ErrorSchema),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`WebhooksV2Api::get_notifications`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetNotificationsError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`WebhooksV2Api::get_resend_job_status`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetResendJobStatusError {
    DefaultResponse(models::ErrorSchema),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`WebhooksV2Api::get_webhook`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetWebhookError {
    DefaultResponse(models::ErrorSchema),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`WebhooksV2Api::get_webhooks`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetWebhooksError {
    DefaultResponse(models::ErrorSchema),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method
/// [`WebhooksV2Api::resend_failed_notifications`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ResendFailedNotificationsError {
    DefaultResponse(models::ErrorSchema),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method
/// [`WebhooksV2Api::resend_notification_by_id`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ResendNotificationByIdError {
    DefaultResponse(models::ErrorSchema),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method
/// [`WebhooksV2Api::resend_notifications_by_resource_id`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ResendNotificationsByResourceIdError {
    DefaultResponse(models::ErrorSchema),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`WebhooksV2Api::update_webhook`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum UpdateWebhookError {
    DefaultResponse(models::ErrorSchema),
    UnknownValue(serde_json::Value),
}