babelforce-manager-sdk 0.42.3

/*
 * 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 [`clear_all_settings`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ClearAllSettingsError {
    UnknownValue(serde_json::Value),
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// Reset all customer settings (all scopes) to their defaults
pub async fn clear_all_settings(
    configuration: &configuration::Configuration,
) -> Result<models::SettingsListResponse, Error<ClearAllSettingsError>> {
    let uri_str = format!("{}/api/v2/settings", 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());
    };

    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::SettingsListResponse`"))),
            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::SettingsListResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ClearAllSettingsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Reset a single customer setting to its default
pub async fn clear_setting(
    configuration: &configuration::Configuration,
    scope: &str,
    key: &str,
) -> Result<models::SettingItemResponse, Error<ClearSettingError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_scope = scope;
    let p_path_key = key;

    let uri_str = format!(
        "{}/api/v2/settings/{scope}/{key}",
        configuration.base_path,
        scope = crate::gen::manager::apis::urlencode(p_path_scope),
        key = crate::gen::manager::apis::urlencode(p_path_key)
    );
    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::SettingItemResponse`"))),
            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::SettingItemResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ClearSettingError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Reset all customer settings in a scope to their defaults
pub async fn clear_settings_in_scope(
    configuration: &configuration::Configuration,
    scope: &str,
) -> Result<models::SettingsListResponse, Error<ClearSettingsInScopeError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_scope = scope;

    let uri_str = format!(
        "{}/api/v2/settings/{scope}",
        configuration.base_path,
        scope = crate::gen::manager::apis::urlencode(p_path_scope)
    );
    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::SettingsListResponse`"))),
            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::SettingsListResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ClearSettingsInScopeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Get the app-scope `agent.status` settings. Returns the current values in `{ item: { scope, key, data } }`.
pub async fn get_settings_for_app_agent_status(
    configuration: &configuration::Configuration,
) -> Result<models::SettingsAppAgentStatusResponse, Error<GetSettingsForAppAgentStatusError>> {
    let uri_str = format!(
        "{}/api/v2/settings/app/agent.status",
        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::SettingsAppAgentStatusResponse`"))),
            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::SettingsAppAgentStatusResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetSettingsForAppAgentStatusError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Get the app-scope `conversations` settings. Returns the current values in `{ item: { scope, key, data } }`.
pub async fn get_settings_for_app_conversations(
    configuration: &configuration::Configuration,
) -> Result<models::SettingsAppConversationsResponse, Error<GetSettingsForAppConversationsError>> {
    let uri_str = format!(
        "{}/api/v2/settings/app/conversations",
        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::SettingsAppConversationsResponse`"))),
            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::SettingsAppConversationsResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetSettingsForAppConversationsError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Get the app-scope `customer.logging` settings. Returns the current values in `{ item: { scope, key, data } }`.
pub async fn get_settings_for_app_customer_logging(
    configuration: &configuration::Configuration,
) -> Result<models::SettingsAppCustomerLoggingResponse, Error<GetSettingsForAppCustomerLoggingError>>
{
    let uri_str = format!(
        "{}/api/v2/settings/app/customer.logging",
        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::SettingsAppCustomerLoggingResponse`"))),
            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::SettingsAppCustomerLoggingResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetSettingsForAppCustomerLoggingError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Get the app-scope `integrations` settings. Returns the current values in `{ item: { scope, key, data } }`.
pub async fn get_settings_for_app_integrations(
    configuration: &configuration::Configuration,
) -> Result<models::SettingsAppIntegrationsResponse, Error<GetSettingsForAppIntegrationsError>> {
    let uri_str = format!(
        "{}/api/v2/settings/app/integrations",
        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::SettingsAppIntegrationsResponse`"))),
            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::SettingsAppIntegrationsResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetSettingsForAppIntegrationsError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Get the audit-scope `default` settings. Returns the current values in `{ item: { scope, key, data } }`.
pub async fn get_settings_for_audit_default(
    configuration: &configuration::Configuration,
) -> Result<models::SettingsAuditDefaultResponse, Error<GetSettingsForAuditDefaultError>> {
    let uri_str = format!("{}/api/v2/settings/audit/default", 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::SettingsAuditDefaultResponse`"))),
            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::SettingsAuditDefaultResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetSettingsForAuditDefaultError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Get the retention-scope `periods` settings. Returns the current values in `{ item: { scope, key, data } }`.
pub async fn get_settings_for_retention_periods(
    configuration: &configuration::Configuration,
) -> Result<models::SettingsRetentionPeriodsResponse, Error<GetSettingsForRetentionPeriodsError>> {
    let uri_str = format!(
        "{}/api/v2/settings/retention/periods",
        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::SettingsRetentionPeriodsResponse`"))),
            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::SettingsRetentionPeriodsResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetSettingsForRetentionPeriodsError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Get the telephony-scope `agent.inbound` settings. Returns the current values in `{ item: { scope, key, data } }`.
pub async fn get_settings_for_telephony_agent_inbound(
    configuration: &configuration::Configuration,
) -> Result<
    models::SettingsTelephonyAgentInboundResponse,
    Error<GetSettingsForTelephonyAgentInboundError>,
> {
    let uri_str = format!(
        "{}/api/v2/settings/telephony/agent.inbound",
        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::SettingsTelephonyAgentInboundResponse`"))),
            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::SettingsTelephonyAgentInboundResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetSettingsForTelephonyAgentInboundError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Get the telephony-scope `agent.outbound` settings. Returns the current values in `{ item: { scope, key, data } }`.
pub async fn get_settings_for_telephony_agent_outbound(
    configuration: &configuration::Configuration,
) -> Result<
    models::SettingsTelephonyAgentOutboundResponse,
    Error<GetSettingsForTelephonyAgentOutboundError>,
> {
    let uri_str = format!(
        "{}/api/v2/settings/telephony/agent.outbound",
        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::SettingsTelephonyAgentOutboundResponse`"))),
            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::SettingsTelephonyAgentOutboundResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetSettingsForTelephonyAgentOutboundError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Get the telephony-scope `agent.recording` settings. Returns the current values in `{ item: { scope, key, data } }`.
pub async fn get_settings_for_telephony_agent_recording(
    configuration: &configuration::Configuration,
) -> Result<
    models::SettingsTelephonyAgentRecordingResponse,
    Error<GetSettingsForTelephonyAgentRecordingError>,
> {
    let uri_str = format!(
        "{}/api/v2/settings/telephony/agent.recording",
        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::SettingsTelephonyAgentRecordingResponse`"))),
            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::SettingsTelephonyAgentRecordingResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetSettingsForTelephonyAgentRecordingError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Get the telephony-scope `agent.wrapup` settings. Returns the current values in `{ item: { scope, key, data } }`.
pub async fn get_settings_for_telephony_agent_wrapup(
    configuration: &configuration::Configuration,
) -> Result<
    models::SettingsTelephonyAgentWrapupResponse,
    Error<GetSettingsForTelephonyAgentWrapupError>,
> {
    let uri_str = format!(
        "{}/api/v2/settings/telephony/agent.wrapup",
        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::SettingsTelephonyAgentWrapupResponse`"))),
            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::SettingsTelephonyAgentWrapupResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetSettingsForTelephonyAgentWrapupError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Get the telephony-scope `post-call` settings. Returns the current values in `{ item: { scope, key, data } }`.
pub async fn get_settings_for_telephony_post_call(
    configuration: &configuration::Configuration,
) -> Result<models::SettingsTelephonyPostCallResponse, Error<GetSettingsForTelephonyPostCallError>>
{
    let uri_str = format!(
        "{}/api/v2/settings/telephony/post-call",
        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::SettingsTelephonyPostCallResponse`"))),
            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::SettingsTelephonyPostCallResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetSettingsForTelephonyPostCallError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Get the ui-scope `i18n` settings. Returns the current values in `{ item: { scope, key, data } }`.
pub async fn get_settings_for_ui_i18n(
    configuration: &configuration::Configuration,
) -> Result<models::SettingsUiI18nResponse, Error<GetSettingsForUiI18nError>> {
    let uri_str = format!("{}/api/v2/settings/ui/i18n", 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::SettingsUiI18nResponse`"))),
            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::SettingsUiI18nResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetSettingsForUiI18nError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Get all customer settings across all scopes
pub async fn list_all_settings(
    configuration: &configuration::Configuration,
) -> Result<models::SettingsListResponse, Error<ListAllSettingsError>> {
    let uri_str = format!("{}/api/v2/settings", 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::SettingsListResponse`"))),
            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::SettingsListResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListAllSettingsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Get all customer settings in a scope
pub async fn list_settings_in_scope(
    configuration: &configuration::Configuration,
    scope: &str,
) -> Result<models::SettingsListResponse, Error<ListSettingsInScopeError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_scope = scope;

    let uri_str = format!(
        "{}/api/v2/settings/{scope}",
        configuration.base_path,
        scope = crate::gen::manager::apis::urlencode(p_path_scope)
    );
    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::SettingsListResponse`"))),
            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::SettingsListResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListSettingsInScopeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Update the app-scope `agent.status` settings. The request body carries the new values under `data`.
pub async fn update_settings_for_app_agent_status(
    configuration: &configuration::Configuration,
    settings_app_agent_status_request: Option<models::SettingsAppAgentStatusRequest>,
) -> Result<models::SettingsAppAgentStatusResponse, Error<UpdateSettingsForAppAgentStatusError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_settings_app_agent_status_request = settings_app_agent_status_request;

    let uri_str = format!(
        "{}/api/v2/settings/app/agent.status",
        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_settings_app_agent_status_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::SettingsAppAgentStatusResponse`"))),
            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::SettingsAppAgentStatusResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateSettingsForAppAgentStatusError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Update the app-scope `conversations` settings. The request body carries the new values under `data`.
pub async fn update_settings_for_app_conversations(
    configuration: &configuration::Configuration,
    settings_app_conversations_request: Option<models::SettingsAppConversationsRequest>,
) -> Result<models::SettingsAppConversationsResponse, Error<UpdateSettingsForAppConversationsError>>
{
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_settings_app_conversations_request = settings_app_conversations_request;

    let uri_str = format!(
        "{}/api/v2/settings/app/conversations",
        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_settings_app_conversations_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::SettingsAppConversationsResponse`"))),
            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::SettingsAppConversationsResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateSettingsForAppConversationsError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Update the app-scope `customer.logging` settings. The request body carries the new values under `data`.
pub async fn update_settings_for_app_customer_logging(
    configuration: &configuration::Configuration,
    settings_app_customer_logging_request: Option<models::SettingsAppCustomerLoggingRequest>,
) -> Result<
    models::SettingsAppCustomerLoggingResponse,
    Error<UpdateSettingsForAppCustomerLoggingError>,
> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_settings_app_customer_logging_request = settings_app_customer_logging_request;

    let uri_str = format!(
        "{}/api/v2/settings/app/customer.logging",
        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_settings_app_customer_logging_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::SettingsAppCustomerLoggingResponse`"))),
            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::SettingsAppCustomerLoggingResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateSettingsForAppCustomerLoggingError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Update the app-scope `integrations` settings. The request body carries the new values under `data`.
pub async fn update_settings_for_app_integrations(
    configuration: &configuration::Configuration,
    settings_app_integrations_request: Option<models::SettingsAppIntegrationsRequest>,
) -> Result<models::SettingsAppIntegrationsResponse, Error<UpdateSettingsForAppIntegrationsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_settings_app_integrations_request = settings_app_integrations_request;

    let uri_str = format!(
        "{}/api/v2/settings/app/integrations",
        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_settings_app_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::SettingsAppIntegrationsResponse`"))),
            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::SettingsAppIntegrationsResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateSettingsForAppIntegrationsError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Update the audit-scope `default` settings. The request body carries the new values under `data`.
pub async fn update_settings_for_audit_default(
    configuration: &configuration::Configuration,
    settings_audit_default_request: Option<models::SettingsAuditDefaultRequest>,
) -> Result<models::SettingsAuditDefaultResponse, Error<UpdateSettingsForAuditDefaultError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_settings_audit_default_request = settings_audit_default_request;

    let uri_str = format!("{}/api/v2/settings/audit/default", 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_settings_audit_default_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::SettingsAuditDefaultResponse`"))),
            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::SettingsAuditDefaultResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateSettingsForAuditDefaultError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Update the retention-scope `periods` settings. The request body carries the new values under `data`.
pub async fn update_settings_for_retention_periods(
    configuration: &configuration::Configuration,
    settings_retention_periods_request: Option<models::SettingsRetentionPeriodsRequest>,
) -> Result<models::SettingsRetentionPeriodsResponse, Error<UpdateSettingsForRetentionPeriodsError>>
{
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_settings_retention_periods_request = settings_retention_periods_request;

    let uri_str = format!(
        "{}/api/v2/settings/retention/periods",
        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_settings_retention_periods_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::SettingsRetentionPeriodsResponse`"))),
            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::SettingsRetentionPeriodsResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateSettingsForRetentionPeriodsError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Update the telephony-scope `agent.inbound` settings. The request body carries the new values under `data`.
pub async fn update_settings_for_telephony_agent_inbound(
    configuration: &configuration::Configuration,
    settings_telephony_agent_inbound_request: Option<models::SettingsTelephonyAgentInboundRequest>,
) -> Result<
    models::SettingsTelephonyAgentInboundResponse,
    Error<UpdateSettingsForTelephonyAgentInboundError>,
> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_settings_telephony_agent_inbound_request = settings_telephony_agent_inbound_request;

    let uri_str = format!(
        "{}/api/v2/settings/telephony/agent.inbound",
        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_settings_telephony_agent_inbound_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::SettingsTelephonyAgentInboundResponse`"))),
            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::SettingsTelephonyAgentInboundResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateSettingsForTelephonyAgentInboundError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Update the telephony-scope `agent.outbound` settings. The request body carries the new values under `data`.
pub async fn update_settings_for_telephony_agent_outbound(
    configuration: &configuration::Configuration,
    settings_telephony_agent_outbound_request: Option<
        models::SettingsTelephonyAgentOutboundRequest,
    >,
) -> Result<
    models::SettingsTelephonyAgentOutboundResponse,
    Error<UpdateSettingsForTelephonyAgentOutboundError>,
> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_settings_telephony_agent_outbound_request =
        settings_telephony_agent_outbound_request;

    let uri_str = format!(
        "{}/api/v2/settings/telephony/agent.outbound",
        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_settings_telephony_agent_outbound_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::SettingsTelephonyAgentOutboundResponse`"))),
            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::SettingsTelephonyAgentOutboundResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateSettingsForTelephonyAgentOutboundError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Update the telephony-scope `agent.recording` settings. The request body carries the new values under `data`.
pub async fn update_settings_for_telephony_agent_recording(
    configuration: &configuration::Configuration,
    settings_telephony_agent_recording_request: Option<
        models::SettingsTelephonyAgentRecordingRequest,
    >,
) -> Result<
    models::SettingsTelephonyAgentRecordingResponse,
    Error<UpdateSettingsForTelephonyAgentRecordingError>,
> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_settings_telephony_agent_recording_request =
        settings_telephony_agent_recording_request;

    let uri_str = format!(
        "{}/api/v2/settings/telephony/agent.recording",
        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_settings_telephony_agent_recording_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::SettingsTelephonyAgentRecordingResponse`"))),
            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::SettingsTelephonyAgentRecordingResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateSettingsForTelephonyAgentRecordingError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Update the telephony-scope `agent.wrapup` settings. The request body carries the new values under `data`.
pub async fn update_settings_for_telephony_agent_wrapup(
    configuration: &configuration::Configuration,
    settings_telephony_agent_wrapup_request: Option<models::SettingsTelephonyAgentWrapupRequest>,
) -> Result<
    models::SettingsTelephonyAgentWrapupResponse,
    Error<UpdateSettingsForTelephonyAgentWrapupError>,
> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_settings_telephony_agent_wrapup_request = settings_telephony_agent_wrapup_request;

    let uri_str = format!(
        "{}/api/v2/settings/telephony/agent.wrapup",
        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_settings_telephony_agent_wrapup_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::SettingsTelephonyAgentWrapupResponse`"))),
            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::SettingsTelephonyAgentWrapupResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateSettingsForTelephonyAgentWrapupError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Update the telephony-scope `post-call` settings. The request body carries the new values under `data`.
pub async fn update_settings_for_telephony_post_call(
    configuration: &configuration::Configuration,
    settings_telephony_post_call_request: Option<models::SettingsTelephonyPostCallRequest>,
) -> Result<models::SettingsTelephonyPostCallResponse, Error<UpdateSettingsForTelephonyPostCallError>>
{
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_settings_telephony_post_call_request = settings_telephony_post_call_request;

    let uri_str = format!(
        "{}/api/v2/settings/telephony/post-call",
        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_settings_telephony_post_call_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::SettingsTelephonyPostCallResponse`"))),
            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::SettingsTelephonyPostCallResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateSettingsForTelephonyPostCallError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Update the ui-scope `i18n` settings. The request body carries the new values under `data`.
pub async fn update_settings_for_ui_i18n(
    configuration: &configuration::Configuration,
    settings_ui_i18n_request: Option<models::SettingsUiI18nRequest>,
) -> Result<models::SettingsUiI18nResponse, Error<UpdateSettingsForUiI18nError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_settings_ui_i18n_request = settings_ui_i18n_request;

    let uri_str = format!("{}/api/v2/settings/ui/i18n", 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_settings_ui_i18n_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::SettingsUiI18nResponse`"))),
            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::SettingsUiI18nResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateSettingsForUiI18nError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}