babelforce-manager-sdk 0.42.1

/*
 * Manager API
 *
 * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
 *
 * The version of the OpenAPI document: 0.0.0-dev
 * Contact: support@babelforce.com
 * Generated by: https://openapi-generator.tech
 */

use super::{configuration, ContentType, Error};
use crate::gen::manager::{apis::ResponseContent, models};
use reqwest;
use serde::{de::Error as _, Deserialize, Serialize};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// Associates an agent, group, or tag with the integration so the integration's actions become available in that context. Returns `{ success, message }`.
pub async fn add_integration_association(
    configuration: &configuration::Configuration,
    integration_id: &str,
    association_id: &str,
    action_name: &str,
) -> Result<models::IntegrationAddAssociationResponse, Error<AddIntegrationAssociationError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_integration_id = integration_id;
    let p_path_association_id = association_id;
    let p_path_action_name = action_name;

    let uri_str = format!(
        "{}/api/v2/integrations/{integrationId}/association/{associationId}/{actionName}",
        configuration.base_path,
        integrationId = crate::gen::manager::apis::urlencode(p_path_integration_id),
        associationId = crate::gen::manager::apis::urlencode(p_path_association_id),
        actionName = crate::gen::manager::apis::urlencode(p_path_action_name)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::IntegrationAddAssociationResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::IntegrationAddAssociationResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AddIntegrationAssociationError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Authorizes babelforce to use the integration, typically by completing the provider's OAuth flow.
pub async fn authorize_integration(
    configuration: &configuration::Configuration,
    id: &str,
    request_body: Option<std::collections::HashMap<String, serde_json::Value>>,
) -> Result<models::IntegrationItemResponse, Error<AuthorizeIntegrationError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_id = id;
    let p_body_request_body = request_body;

    let uri_str = format!(
        "{}/api/v2/integrations/{id}/authorize",
        configuration.base_path,
        id = crate::gen::manager::apis::urlencode(p_path_id)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_request_body);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::IntegrationItemResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::IntegrationItemResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthorizeIntegrationError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Deletes several integrations in one request, given their ids. Returns the default `{ success, message }` envelope.
pub async fn bulk_delete_integrations(
    configuration: &configuration::Configuration,
    integration_bulk_ids_request: models::IntegrationBulkIdsRequest,
) -> Result<models::DefaultV2MessageResponse, Error<BulkDeleteIntegrationsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_integration_bulk_ids_request = integration_bulk_ids_request;

    let uri_str = format!("{}/api/v2/integrations/bulk", configuration.base_path);
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_integration_bulk_ids_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::DefaultV2MessageResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DefaultV2MessageResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<BulkDeleteIntegrationsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Updates several integrations in one request — each item must include its `id`. Returns the default `{ success, message }` envelope.
pub async fn bulk_update_integrations(
    configuration: &configuration::Configuration,
    bulk_update_integrations_request: models::BulkUpdateIntegrationsRequest,
) -> Result<models::DefaultV2MessageResponse, Error<BulkUpdateIntegrationsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_bulk_update_integrations_request = bulk_update_integrations_request;

    let uri_str = format!("{}/api/v2/integrations/bulk", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_bulk_update_integrations_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::DefaultV2MessageResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DefaultV2MessageResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<BulkUpdateIntegrationsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Creates a copy of an existing integration, including its config and provider. Returns the cloned integration in the single-item envelope `{ item, success }`.
pub async fn clone_integration(
    configuration: &configuration::Configuration,
    id: &str,
) -> Result<models::IntegrationItemResponse, Error<CloneIntegrationError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_id = id;

    let uri_str = format!(
        "{}/api/v2/integrations/{id}/clone",
        configuration.base_path,
        id = crate::gen::manager::apis::urlencode(p_path_id)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::IntegrationItemResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::IntegrationItemResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CloneIntegrationError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Create Integration
pub async fn create_integration(
    configuration: &configuration::Configuration,
    integration_create_request: models::IntegrationCreateRequest,
) -> Result<models::IntegrationItemResponse, Error<CreateIntegrationError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_integration_create_request = integration_create_request;

    let uri_str = format!("{}/api/v2/integrations", configuration.base_path);
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_integration_create_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::IntegrationItemResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::IntegrationItemResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateIntegrationError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Delete Integration
pub async fn delete_integration(
    configuration: &configuration::Configuration,
    id: &str,
) -> Result<serde_json::Value, Error<DeleteIntegrationError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_id = id;

    let uri_str = format!(
        "{}/api/v2/integrations/{id}",
        configuration.base_path,
        id = crate::gen::manager::apis::urlencode(p_path_id)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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 `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteIntegrationError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Removes an agent, group, or tag association from the integration. Returns `{ success, message }`.
pub async fn delete_integration_association(
    configuration: &configuration::Configuration,
    integration_id: &str,
    association_id: &str,
    action_name: &str,
) -> Result<models::IntegrationRemoveAssociationResponse, Error<DeleteIntegrationAssociationError>>
{
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_integration_id = integration_id;
    let p_path_association_id = association_id;
    let p_path_action_name = action_name;

    let uri_str = format!(
        "{}/api/v2/integrations/{integrationId}/association/{associationId}/{actionName}",
        configuration.base_path,
        integrationId = crate::gen::manager::apis::urlencode(p_path_integration_id),
        associationId = crate::gen::manager::apis::urlencode(p_path_association_id),
        actionName = crate::gen::manager::apis::urlencode(p_path_action_name)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::IntegrationRemoveAssociationResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::IntegrationRemoveAssociationResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteIntegrationAssociationError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Revokes and deletes an integration access token — notifying the issuer to revoke it and removing it locally.
pub async fn delete_integration_token(
    configuration: &configuration::Configuration,
    id: &str,
    token_id: &str,
) -> Result<models::DefaultV2MessageResponse, Error<DeleteIntegrationTokenError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_id = id;
    let p_path_token_id = token_id;

    let uri_str = format!(
        "{}/api/v2/integrations/{id}/tokens/{tokenId}",
        configuration.base_path,
        id = crate::gen::manager::apis::urlencode(p_path_id),
        tokenId = crate::gen::manager::apis::urlencode(p_path_token_id)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::DefaultV2MessageResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DefaultV2MessageResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteIntegrationTokenError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Runs one of the integration's actions and returns the result in `{ action, params, context, data }`. Pass the action input as `params`, optionally scoped to a call or session via `context`.
pub async fn dispatch_action(
    configuration: &configuration::Configuration,
    integration_id: &str,
    action: &str,
    call_id: Option<&str>,
    session_id: Option<&str>,
    integration_dispatch_action_request: Option<models::IntegrationDispatchActionRequest>,
) -> Result<models::IntegrationDispatchActionResponse, Error<DispatchActionError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_integration_id = integration_id;
    let p_path_action = action;
    let p_query_call_id = call_id;
    let p_query_session_id = session_id;
    let p_body_integration_dispatch_action_request = integration_dispatch_action_request;

    let uri_str = format!(
        "{}/api/v2/integrations/{integrationId}/dispatch/{action}",
        configuration.base_path,
        integrationId = crate::gen::manager::apis::urlencode(p_path_integration_id),
        action = crate::gen::manager::apis::urlencode(p_path_action)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref param_value) = p_query_call_id {
        req_builder = req_builder.query(&[("callId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_session_id {
        req_builder = req_builder.query(&[("sessionId", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_integration_dispatch_action_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::IntegrationDispatchActionResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::IntegrationDispatchActionResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DispatchActionError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Run an action for a specific integration (read-only / GET variant; pass input parameters as query string instead of a request body)
pub async fn dispatch_action_get(
    configuration: &configuration::Configuration,
    integration_id: &str,
    action: &str,
    call_id: Option<&str>,
    session_id: Option<&str>,
) -> Result<models::IntegrationDispatchActionResponse, Error<DispatchActionGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_integration_id = integration_id;
    let p_path_action = action;
    let p_query_call_id = call_id;
    let p_query_session_id = session_id;

    let uri_str = format!(
        "{}/api/v2/integrations/{integrationId}/dispatch/{action}",
        configuration.base_path,
        integrationId = crate::gen::manager::apis::urlencode(p_path_integration_id),
        action = crate::gen::manager::apis::urlencode(p_path_action)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_call_id {
        req_builder = req_builder.query(&[("callId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_session_id {
        req_builder = req_builder.query(&[("sessionId", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::IntegrationDispatchActionResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::IntegrationDispatchActionResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DispatchActionGetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Dispatches an action for a specific integration, addressed by its type, id, and action name. Returns the raw action result.
pub async fn dispatch_integration_type_action(
    configuration: &configuration::Configuration,
    r#type: &str,
    id: &str,
    action: &str,
    request_body: Option<std::collections::HashMap<String, serde_json::Value>>,
) -> Result<
    std::collections::HashMap<String, serde_json::Value>,
    Error<DispatchIntegrationTypeActionError>,
> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_type = r#type;
    let p_path_id = id;
    let p_path_action = action;
    let p_body_request_body = request_body;

    let uri_str = format!("{}/api/v2/integrations/{type}/{id}/{action}", configuration.base_path, type=crate::gen::manager::apis::urlencode(p_path_type), id=crate::gen::manager::apis::urlencode(p_path_id), action=crate::gen::manager::apis::urlencode(p_path_action));
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_request_body);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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 `std::collections::HashMap&lt;String, serde_json::Value&gt;`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `std::collections::HashMap&lt;String, serde_json::Value&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DispatchIntegrationTypeActionError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Get Integration
pub async fn get_integration(
    configuration: &configuration::Configuration,
    id: &str,
) -> Result<models::IntegrationItemResponse, Error<GetIntegrationError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_id = id;

    let uri_str = format!(
        "{}/api/v2/integrations/{id}",
        configuration.base_path,
        id = crate::gen::manager::apis::urlencode(p_path_id)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::IntegrationItemResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::IntegrationItemResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetIntegrationError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Get a base64-encoded integration provider logo (PNG)
pub async fn get_integration_provider_logo(
    configuration: &configuration::Configuration,
    provider_name: models::IntegrationProvider,
    size: &str,
) -> Result<models::GetIntegrationProviderLogoResponse, Error<GetIntegrationProviderLogoError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_provider_name = provider_name;
    let p_path_size = size;

    let uri_str = format!(
        "{}/api/v2/integrations/{providerName}/logo/{size}",
        configuration.base_path,
        providerName = p_path_provider_name.to_string(),
        size = crate::gen::manager::apis::urlencode(p_path_size)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::GetIntegrationProviderLogoResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GetIntegrationProviderLogoResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetIntegrationProviderLogoError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Returns the config template for a provider — the shape a new integration's `config` should follow.
pub async fn get_integration_provider_template(
    configuration: &configuration::Configuration,
    provider: &str,
) -> Result<
    std::collections::HashMap<String, serde_json::Value>,
    Error<GetIntegrationProviderTemplateError>,
> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_provider = provider;

    let uri_str = format!(
        "{}/api/v2/integrations/{provider}/template",
        configuration.base_path,
        provider = crate::gen::manager::apis::urlencode(p_path_provider)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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 `std::collections::HashMap&lt;String, serde_json::Value&gt;`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `std::collections::HashMap&lt;String, serde_json::Value&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetIntegrationProviderTemplateError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Returns the config template for a given integration type and provider — the shape a new integration's `config` should follow.
pub async fn get_integration_template(
    configuration: &configuration::Configuration,
    r#type: &str,
    provider: &str,
) -> Result<std::collections::HashMap<String, serde_json::Value>, Error<GetIntegrationTemplateError>>
{
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_type = r#type;
    let p_path_provider = provider;

    let uri_str = format!("{}/api/v2/integrations/{type}/{provider}/template", configuration.base_path, type=crate::gen::manager::apis::urlencode(p_path_type), provider=crate::gen::manager::apis::urlencode(p_path_provider));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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 `std::collections::HashMap&lt;String, serde_json::Value&gt;`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `std::collections::HashMap&lt;String, serde_json::Value&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetIntegrationTemplateError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Returns a single integration access token in the `{ item, success }` envelope.
pub async fn get_integration_token(
    configuration: &configuration::Configuration,
    id: &str,
    token_id: &str,
) -> Result<models::IntegrationTokenItemResponse, Error<GetIntegrationTokenError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_id = id;
    let p_path_token_id = token_id;

    let uri_str = format!(
        "{}/api/v2/integrations/{id}/tokens/{tokenId}",
        configuration.base_path,
        id = crate::gen::manager::apis::urlencode(p_path_id),
        tokenId = crate::gen::manager::apis::urlencode(p_path_token_id)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::IntegrationTokenItemResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::IntegrationTokenItemResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetIntegrationTokenError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Completes an integration's setup — exchanging tokens and running the initial sync — after it has been created and authorized.
pub async fn integrate_integration(
    configuration: &configuration::Configuration,
    id: &str,
    request_body: Option<std::collections::HashMap<String, serde_json::Value>>,
) -> Result<models::IntegrationItemResponse, Error<IntegrateIntegrationError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_id = id;
    let p_body_request_body = request_body;

    let uri_str = format!(
        "{}/api/v2/integrations/{id}/integrate",
        configuration.base_path,
        id = crate::gen::manager::apis::urlencode(p_path_id)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_request_body);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::IntegrationItemResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::IntegrationItemResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<IntegrateIntegrationError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Transparent API proxy passthrough to the external provider. The request (method, headers, body) is forwarded to the provider and the raw provider response is returned. Any HTTP method is accepted.
pub async fn integration_api_proxy_get(
    configuration: &configuration::Configuration,
    integration_id: &str,
    uri: &str,
) -> Result<(), Error<IntegrationApiProxyGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_integration_id = integration_id;
    let p_path_uri = uri;

    let uri_str = format!(
        "{}/api/v2/integrations/{integrationId}/api/{uri}",
        configuration.base_path,
        integrationId = crate::gen::manager::apis::urlencode(p_path_integration_id),
        uri = crate::gen::manager::apis::urlencode(p_path_uri)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<IntegrationApiProxyGetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Forwards a POST request (body and headers) to the external provider and returns the raw provider response.
pub async fn integration_api_proxy_post(
    configuration: &configuration::Configuration,
    integration_id: &str,
    uri: &str,
    request_body: Option<std::collections::HashMap<String, serde_json::Value>>,
) -> Result<(), Error<IntegrationApiProxyPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_integration_id = integration_id;
    let p_path_uri = uri;
    let p_body_request_body = request_body;

    let uri_str = format!(
        "{}/api/v2/integrations/{integrationId}/api/{uri}",
        configuration.base_path,
        integrationId = crate::gen::manager::apis::urlencode(p_path_integration_id),
        uri = crate::gen::manager::apis::urlencode(p_path_uri)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_request_body);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<IntegrationApiProxyPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Lists the integration types available to install in this environment (each entry carries its provider, capabilities, and pagination style).
pub async fn list_available_integrations(
    configuration: &configuration::Configuration,
) -> Result<
    models::IntegrationListAvailableIntegrationsResponse,
    Error<ListAvailableIntegrationsError>,
> {
    let uri_str = format!("{}/api/v2/integrations/available", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::IntegrationListAvailableIntegrationsResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::IntegrationListAvailableIntegrationsResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListAvailableIntegrationsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Lists the known integration providers, in the `{ items }` envelope.
pub async fn list_integration_providers(
    configuration: &configuration::Configuration,
) -> Result<models::IntegrationObjectListResponse, Error<ListIntegrationProvidersError>> {
    let uri_str = format!("{}/api/v2/integrations/providers", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::IntegrationObjectListResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::IntegrationObjectListResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListIntegrationProvidersError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Lists the access tokens issued to babelforce for this integration, in the `{ items }` envelope.
pub async fn list_integration_tokens(
    configuration: &configuration::Configuration,
    id: &str,
) -> Result<models::IntegrationTokenListResponse, Error<ListIntegrationTokensError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_id = id;

    let uri_str = format!(
        "{}/api/v2/integrations/{id}/tokens",
        configuration.base_path,
        id = crate::gen::manager::apis::urlencode(p_path_id)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::IntegrationTokenListResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::IntegrationTokenListResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListIntegrationTokensError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Lists the actions an integration type supports, in the `{ items }` envelope.
pub async fn list_integration_type_actions(
    configuration: &configuration::Configuration,
    r#type: &str,
) -> Result<models::IntegrationObjectListResponse, Error<ListIntegrationTypeActionsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_type = r#type;

    let uri_str = format!("{}/api/v2/integrations/{type}/actions", configuration.base_path, type=crate::gen::manager::apis::urlencode(p_path_type));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::IntegrationObjectListResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::IntegrationObjectListResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListIntegrationTypeActionsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Returns a paginated list of the customer's integrations in the `{ items, pagination }` envelope.
pub async fn list_integrations(
    configuration: &configuration::Configuration,
    page: Option<i32>,
    max: Option<i32>,
) -> Result<models::PaginatedIntegrationResponse, Error<ListIntegrationsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_page = page;
    let p_query_max = max;

    let uri_str = format!("{}/api/v2/integrations", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_page {
        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_max {
        req_builder = req_builder.query(&[("max", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::PaginatedIntegrationResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::PaginatedIntegrationResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListIntegrationsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Lists every session variable exposed across all of the provider's actions.
pub async fn list_provider_session_variables(
    configuration: &configuration::Configuration,
    provider: &str,
) -> Result<models::IntegrationSessionVariableItemsResponse, Error<ListProviderSessionVariablesError>>
{
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_provider = provider;

    let uri_str = format!(
        "{}/api/v2/integrations/{provider}/actions/variables",
        configuration.base_path,
        provider = crate::gen::manager::apis::urlencode(p_path_provider)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::IntegrationSessionVariableItemsResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::IntegrationSessionVariableItemsResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListProviderSessionVariablesError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Lists the session variables a single provider action exposes — the keys you can read from or write to the call session when the action runs.
pub async fn list_single_action_session_variables(
    configuration: &configuration::Configuration,
    provider: models::IntegrationProvider,
    action_name: &str,
) -> Result<models::VariableDefinitionItemsResponse, Error<ListSingleActionSessionVariablesError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_provider = provider;
    let p_path_action_name = action_name;

    let uri_str = format!(
        "{}/api/v2/actions/{provider}/{actionName}/variables",
        configuration.base_path,
        provider = p_path_provider.to_string(),
        actionName = crate::gen::manager::apis::urlencode(p_path_action_name)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::VariableDefinitionItemsResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::VariableDefinitionItemsResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListSingleActionSessionVariablesError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Refreshes an integration access token using its stored refresh token, returning the renewed token.
pub async fn refresh_integration_token(
    configuration: &configuration::Configuration,
    id: &str,
    token_id: &str,
) -> Result<models::IntegrationTokenItemResponse, Error<RefreshIntegrationTokenError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_id = id;
    let p_path_token_id = token_id;

    let uri_str = format!(
        "{}/api/v2/integrations/{id}/tokens/{tokenId}/refresh",
        configuration.base_path,
        id = crate::gen::manager::apis::urlencode(p_path_id),
        tokenId = crate::gen::manager::apis::urlencode(p_path_token_id)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::IntegrationTokenItemResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::IntegrationTokenItemResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RefreshIntegrationTokenError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Update Integration
pub async fn update_integration(
    configuration: &configuration::Configuration,
    id: &str,
    integration_update_request: models::IntegrationUpdateRequest,
) -> Result<models::IntegrationItemResponse, Error<UpdateIntegrationError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_id = id;
    let p_body_integration_update_request = integration_update_request;

    let uri_str = format!(
        "{}/api/v2/integrations/{id}",
        configuration.base_path,
        id = crate::gen::manager::apis::urlencode(p_path_id)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_integration_update_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&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::IntegrationItemResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::IntegrationItemResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateIntegrationError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}