openai-client-base 0.16.0

/*
 * OpenAI API
 *
 * The OpenAI REST API. Please see https://platform.openai.com/docs/api-reference for more details.
 *
 * The version of the OpenAPI document: 2.3.0
 *
 * Generated by: https://openapi-generator.tech
 */

#![allow(clippy::needless_return, clippy::into_iter_on_ref)]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// Sent when an agent environment expires and can no longer resume from a snapshot.
#[bon::builder]
pub async fn agent_environment_expired_post(
    configuration: &configuration::Configuration,
    webhook_agent_environment_expired: Option<models::WebhookAgentEnvironmentExpired>,
) -> Result<(), Error<AgentEnvironmentExpiredPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_agent_environment_expired = webhook_agent_environment_expired;

    let uri_str = format!("{}/agent_environment_expired", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_agent_environment_expired);

    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<AgentEnvironmentExpiredPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when setup fails for a prewarmed OpenAI-hosted environment before it is attached to a session.
#[bon::builder]
pub async fn agent_environment_failed_post(
    configuration: &configuration::Configuration,
    webhook_agent_environment_failed: Option<models::WebhookAgentEnvironmentFailed>,
) -> Result<(), Error<AgentEnvironmentFailedPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_agent_environment_failed = webhook_agent_environment_failed;

    let uri_str = format!("{}/agent_environment_failed", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_agent_environment_failed);

    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<AgentEnvironmentFailedPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when a prewarmed OpenAI-hosted environment finishes setup before being attached to a session.
#[bon::builder]
pub async fn agent_environment_ready_post(
    configuration: &configuration::Configuration,
    webhook_agent_environment_ready: Option<models::WebhookAgentEnvironmentReady>,
) -> Result<(), Error<AgentEnvironmentReadyPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_agent_environment_ready = webhook_agent_environment_ready;

    let uri_str = format!("{}/agent_environment_ready", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_agent_environment_ready);

    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<AgentEnvironmentReadyPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when an agent environment is suspended and can resume from a snapshot.
#[bon::builder]
pub async fn agent_environment_suspended_post(
    configuration: &configuration::Configuration,
    webhook_agent_environment_suspended: Option<models::WebhookAgentEnvironmentSuspended>,
) -> Result<(), Error<AgentEnvironmentSuspendedPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_agent_environment_suspended = webhook_agent_environment_suspended;

    let uri_str = format!("{}/agent_environment_suspended", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_agent_environment_suspended);

    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<AgentEnvironmentSuspendedPostError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when an agent session requires an action. Retrieve the session for action details.
#[bon::builder]
pub async fn agent_session_action_required_post(
    configuration: &configuration::Configuration,
    webhook_agent_session_action_required: Option<models::WebhookAgentSessionActionRequired>,
) -> Result<(), Error<AgentSessionActionRequiredPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_agent_session_action_required = webhook_agent_session_action_required;

    let uri_str = format!("{}/agent_session_action_required", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_agent_session_action_required);

    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<AgentSessionActionRequiredPostError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when an agent session is created.
#[bon::builder]
pub async fn agent_session_created_post(
    configuration: &configuration::Configuration,
    webhook_agent_session_created: Option<models::WebhookAgentSessionCreated>,
) -> Result<(), Error<AgentSessionCreatedPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_agent_session_created = webhook_agent_session_created;

    let uri_str = format!("{}/agent_session_created", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_agent_session_created);

    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<AgentSessionCreatedPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when an agent session fails.
#[bon::builder]
pub async fn agent_session_failed_post(
    configuration: &configuration::Configuration,
    webhook_agent_session_failed: Option<models::WebhookAgentSessionFailed>,
) -> Result<(), Error<AgentSessionFailedPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_agent_session_failed = webhook_agent_session_failed;

    let uri_str = format!("{}/agent_session_failed", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_agent_session_failed);

    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<AgentSessionFailedPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when an agent session becomes idle.
#[bon::builder]
pub async fn agent_session_idle_post(
    configuration: &configuration::Configuration,
    webhook_agent_session_idle: Option<models::WebhookAgentSessionIdle>,
) -> Result<(), Error<AgentSessionIdlePostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_agent_session_idle = webhook_agent_session_idle;

    let uri_str = format!("{}/agent_session_idle", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_agent_session_idle);

    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<AgentSessionIdlePostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when an agent session enters the in-progress state.
#[bon::builder]
pub async fn agent_session_in_progress_post(
    configuration: &configuration::Configuration,
    webhook_agent_session_in_progress: Option<models::WebhookAgentSessionInProgress>,
) -> Result<(), Error<AgentSessionInProgressPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_agent_session_in_progress = webhook_agent_session_in_progress;

    let uri_str = format!("{}/agent_session_in_progress", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_agent_session_in_progress);

    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<AgentSessionInProgressPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when a batch has been cancelled.
#[bon::builder]
pub async fn batch_cancelled_post(
    configuration: &configuration::Configuration,
    webhook_batch_cancelled: Option<models::WebhookBatchCancelled>,
) -> Result<(), Error<BatchCancelledPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_batch_cancelled = webhook_batch_cancelled;

    let uri_str = format!("{}/batch_cancelled", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_batch_cancelled);

    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<BatchCancelledPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when a batch has completed processing.
#[bon::builder]
pub async fn batch_completed_post(
    configuration: &configuration::Configuration,
    webhook_batch_completed: Option<models::WebhookBatchCompleted>,
) -> Result<(), Error<BatchCompletedPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_batch_completed = webhook_batch_completed;

    let uri_str = format!("{}/batch_completed", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_batch_completed);

    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<BatchCompletedPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when a batch has expired before completion.
#[bon::builder]
pub async fn batch_expired_post(
    configuration: &configuration::Configuration,
    webhook_batch_expired: Option<models::WebhookBatchExpired>,
) -> Result<(), Error<BatchExpiredPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_batch_expired = webhook_batch_expired;

    let uri_str = format!("{}/batch_expired", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_batch_expired);

    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<BatchExpiredPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when a batch has failed.
#[bon::builder]
pub async fn batch_failed_post(
    configuration: &configuration::Configuration,
    webhook_batch_failed: Option<models::WebhookBatchFailed>,
) -> Result<(), Error<BatchFailedPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_batch_failed = webhook_batch_failed;

    let uri_str = format!("{}/batch_failed", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_batch_failed);

    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<BatchFailedPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when an eval run has been canceled.
#[bon::builder]
pub async fn eval_run_canceled_post(
    configuration: &configuration::Configuration,
    webhook_eval_run_canceled: Option<models::WebhookEvalRunCanceled>,
) -> Result<(), Error<EvalRunCanceledPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_eval_run_canceled = webhook_eval_run_canceled;

    let uri_str = format!("{}/eval_run_canceled", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_eval_run_canceled);

    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<EvalRunCanceledPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when an eval run has failed.
#[bon::builder]
pub async fn eval_run_failed_post(
    configuration: &configuration::Configuration,
    webhook_eval_run_failed: Option<models::WebhookEvalRunFailed>,
) -> Result<(), Error<EvalRunFailedPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_eval_run_failed = webhook_eval_run_failed;

    let uri_str = format!("{}/eval_run_failed", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_eval_run_failed);

    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<EvalRunFailedPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when an eval run has succeeded.
#[bon::builder]
pub async fn eval_run_succeeded_post(
    configuration: &configuration::Configuration,
    webhook_eval_run_succeeded: Option<models::WebhookEvalRunSucceeded>,
) -> Result<(), Error<EvalRunSucceededPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_eval_run_succeeded = webhook_eval_run_succeeded;

    let uri_str = format!("{}/eval_run_succeeded", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_eval_run_succeeded);

    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<EvalRunSucceededPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when a fine-tuning job has been cancelled.
#[bon::builder]
pub async fn fine_tuning_job_cancelled_post(
    configuration: &configuration::Configuration,
    webhook_fine_tuning_job_cancelled: Option<models::WebhookFineTuningJobCancelled>,
) -> Result<(), Error<FineTuningJobCancelledPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_fine_tuning_job_cancelled = webhook_fine_tuning_job_cancelled;

    let uri_str = format!("{}/fine_tuning_job_cancelled", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_fine_tuning_job_cancelled);

    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<FineTuningJobCancelledPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when a fine-tuning job has failed.
#[bon::builder]
pub async fn fine_tuning_job_failed_post(
    configuration: &configuration::Configuration,
    webhook_fine_tuning_job_failed: Option<models::WebhookFineTuningJobFailed>,
) -> Result<(), Error<FineTuningJobFailedPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_fine_tuning_job_failed = webhook_fine_tuning_job_failed;

    let uri_str = format!("{}/fine_tuning_job_failed", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_fine_tuning_job_failed);

    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<FineTuningJobFailedPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when a fine-tuning job has succeeded.
#[bon::builder]
pub async fn fine_tuning_job_succeeded_post(
    configuration: &configuration::Configuration,
    webhook_fine_tuning_job_succeeded: Option<models::WebhookFineTuningJobSucceeded>,
) -> Result<(), Error<FineTuningJobSucceededPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_fine_tuning_job_succeeded = webhook_fine_tuning_job_succeeded;

    let uri_str = format!("{}/fine_tuning_job_succeeded", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_fine_tuning_job_succeeded);

    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<FineTuningJobSucceededPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Deprecated: use `live.transport.incoming`. Retained only for existing subscriptions. Sent when an incoming API SIP session is available for Live acceptance.
#[bon::builder]
pub async fn live_call_incoming_post(
    configuration: &configuration::Configuration,
    webhook_live_call_incoming: Option<models::WebhookLiveCallIncoming>,
) -> Result<(), Error<LiveCallIncomingPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_live_call_incoming = webhook_live_call_incoming;

    let uri_str = format!("{}/live_call_incoming", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_live_call_incoming);

    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<LiveCallIncomingPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when an incoming API SIP session is available for Live acceptance.
#[bon::builder]
pub async fn live_transport_incoming_post(
    configuration: &configuration::Configuration,
    webhook_live_transport_incoming: Option<models::WebhookLiveTransportIncoming>,
) -> Result<(), Error<LiveTransportIncomingPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_live_transport_incoming = webhook_live_transport_incoming;

    let uri_str = format!("{}/live_transport_incoming", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_live_transport_incoming);

    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<LiveTransportIncomingPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when an incoming API SIP session is available for Realtime acceptance.
#[bon::builder]
pub async fn realtime_call_incoming_post(
    configuration: &configuration::Configuration,
    webhook_realtime_call_incoming: Option<models::WebhookRealtimeCallIncoming>,
) -> Result<(), Error<RealtimeCallIncomingPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_realtime_call_incoming = webhook_realtime_call_incoming;

    let uri_str = format!("{}/realtime_call_incoming", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_realtime_call_incoming);

    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<RealtimeCallIncomingPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when a background response has been cancelled.
#[bon::builder]
pub async fn response_cancelled_post(
    configuration: &configuration::Configuration,
    webhook_response_cancelled: Option<models::WebhookResponseCancelled>,
) -> Result<(), Error<ResponseCancelledPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_response_cancelled = webhook_response_cancelled;

    let uri_str = format!("{}/response_cancelled", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_response_cancelled);

    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<ResponseCancelledPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when a background response has completed successfully.
#[bon::builder]
pub async fn response_completed_post(
    configuration: &configuration::Configuration,
    webhook_response_completed: Option<models::WebhookResponseCompleted>,
) -> Result<(), Error<ResponseCompletedPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_response_completed = webhook_response_completed;

    let uri_str = format!("{}/response_completed", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_response_completed);

    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<ResponseCompletedPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when a background response has failed.
#[bon::builder]
pub async fn response_failed_post(
    configuration: &configuration::Configuration,
    webhook_response_failed: Option<models::WebhookResponseFailed>,
) -> Result<(), Error<ResponseFailedPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_response_failed = webhook_response_failed;

    let uri_str = format!("{}/response_failed", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_response_failed);

    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<ResponseFailedPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when a background response is incomplete.
#[bon::builder]
pub async fn response_incomplete_post(
    configuration: &configuration::Configuration,
    webhook_response_incomplete: Option<models::WebhookResponseIncomplete>,
) -> Result<(), Error<ResponseIncompletePostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_response_incomplete = webhook_response_incomplete;

    let uri_str = format!("{}/response_incomplete", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_response_incomplete);

    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<ResponseIncompletePostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when an approved safety alert is available for an API project. Retrieve the alert with a project API key granted `api.safety.alerts.read`.
#[bon::builder]
pub async fn safety_alert_created_post(
    configuration: &configuration::Configuration,
    webhook_safety_alert_created: Option<models::WebhookSafetyAlertCreated>,
) -> Result<(), Error<SafetyAlertCreatedPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_safety_alert_created = webhook_safety_alert_created;

    let uri_str = format!("{}/safety_alert_created", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_safety_alert_created);

    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<SafetyAlertCreatedPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when a deactivation is issued for a safety identifier in your organization. Retrieve the case details with `GET /v1/safety/cases/{id}` using `data.id`.
#[bon::builder]
pub async fn safety_deactivation_issued_post(
    configuration: &configuration::Configuration,
    webhook_safety_deactivation_issued: Option<models::WebhookSafetyDeactivationIssued>,
) -> Result<(), Error<SafetyDeactivationIssuedPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_safety_deactivation_issued = webhook_safety_deactivation_issued;

    let uri_str = format!("{}/safety_deactivation_issued", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_safety_deactivation_issued);

    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<SafetyDeactivationIssuedPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when an approved safety alert is available for an enterprise workspace. Retrieve the alert from `https://api.chatgpt.com/v1/safety/alerts/{id}` with an administrator API key for the workspace's backing organization granted `chatgpt.enterprise.safety_alerts.read`.
#[bon::builder]
pub async fn safety_org_alert_created_post(
    configuration: &configuration::Configuration,
    webhook_safety_org_alert_created: Option<models::WebhookSafetyOrgAlertCreated>,
) -> Result<(), Error<SafetyOrgAlertCreatedPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_safety_org_alert_created = webhook_safety_org_alert_created;

    let uri_str = format!("{}/safety_org_alert_created", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_safety_org_alert_created);

    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<SafetyOrgAlertCreatedPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Sent when a warning is issued for a safety identifier in your organization. Retrieve the case details with `GET /v1/safety/cases/{id}` using `data.id`.
#[bon::builder]
pub async fn safety_warning_issued_post(
    configuration: &configuration::Configuration,
    webhook_safety_warning_issued: Option<models::WebhookSafetyWarningIssued>,
) -> Result<(), Error<SafetyWarningIssuedPostError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_webhook_safety_warning_issued = webhook_safety_warning_issued;

    let uri_str = format!("{}/safety_warning_issued", 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.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_webhook_safety_warning_issued);

    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<SafetyWarningIssuedPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}