openai-client-base 0.12.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 [`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 [`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),
}

/// 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(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(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(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(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(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(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(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(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(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(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Sent when Realtime API Receives a incoming SIP call.
#[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(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(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(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(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(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}