hatchet-sdk 0.2.8

/*
 * Hatchet API
 *
 * The Hatchet API
 *
 * The version of the OpenAPI document: 1.0.0
 *
 * Generated by: https://openapi-generator.tech
 */

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

/// struct for typed errors of method [`event_create`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum EventCreateError {
    Status400(models::V1TaskGet400Response),
    Status403(models::V1TaskGet400Response),
    Status429(models::V1TaskGet400Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`event_create_bulk`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum EventCreateBulkError {
    Status400(models::V1TaskGet400Response),
    Status403(models::V1TaskGet400Response),
    Status429(models::V1TaskGet400Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`event_data_get`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum EventDataGetError {
    Status400(models::V1TaskGet400Response),
    Status403(models::V1TaskGet400Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`event_get`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum EventGetError {
    Status400(models::V1TaskGet400Response),
    Status403(models::V1TaskGet400Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`event_key_list`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum EventKeyListError {
    Status400(models::V1TaskGet400Response),
    Status403(models::V1TaskGet400Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`event_list`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum EventListError {
    Status400(models::V1TaskGet400Response),
    Status403(models::V1TaskGet400Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`event_update_cancel`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum EventUpdateCancelError {
    Status400(models::V1TaskGet400Response),
    Status403(models::V1TaskGet400Response),
    Status429(models::V1TaskGet400Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`event_update_replay`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum EventUpdateReplayError {
    Status400(models::V1TaskGet400Response),
    Status403(models::V1TaskGet400Response),
    Status429(models::V1TaskGet400Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`v1_event_key_list`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum V1EventKeyListError {
    Status400(models::V1TaskGet400Response),
    Status403(models::V1TaskGet400Response),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`v1_event_list`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum V1EventListError {
    Status400(models::V1TaskGet400Response),
    Status403(models::V1TaskGet400Response),
    UnknownValue(serde_json::Value),
}

/// Creates a new event.
pub async fn event_create(
    configuration: &configuration::Configuration,
    tenant: &str,
    event_create_request: models::EventCreateRequest,
) -> Result<models::EventList200ResponseRowsInner, Error<EventCreateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_tenant = tenant;
    let p_event_create_request = event_create_request;

    let uri_str = format!(
        "{}/api/v1/tenants/{tenant}/events",
        configuration.base_path,
        tenant = crate::clients::rest::apis::urlencode(p_tenant)
    );
    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_event_create_request);

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

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

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

/// Bulk creates new events.
pub async fn event_create_bulk(
    configuration: &configuration::Configuration,
    tenant: &str,
    event_create_bulk_request: models::EventCreateBulkRequest,
) -> Result<models::EventCreateBulk200Response, Error<EventCreateBulkError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_tenant = tenant;
    let p_event_create_bulk_request = event_create_bulk_request;

    let uri_str = format!(
        "{}/api/v1/tenants/{tenant}/events/bulk",
        configuration.base_path,
        tenant = crate::clients::rest::apis::urlencode(p_tenant)
    );
    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_event_create_bulk_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::EventCreateBulk200Response`",
                )));
            }
            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::EventCreateBulk200Response`"
                ))));
            }
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EventCreateBulkError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Get the data for an event.
pub async fn event_data_get(
    configuration: &configuration::Configuration,
    event: &str,
) -> Result<models::EventDataGet200Response, Error<EventDataGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_event = event;

    let uri_str = format!(
        "{}/api/v1/events/{event}/data",
        configuration.base_path,
        event = crate::clients::rest::apis::urlencode(p_event)
    );
    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.bearer_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::EventDataGet200Response`",
                )));
            }
            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::EventDataGet200Response`"
                ))));
            }
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EventDataGetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Get an event.
pub async fn event_get(
    configuration: &configuration::Configuration,
    event: &str,
) -> Result<models::EventList200ResponseRowsInner, Error<EventGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_event = event;

    let uri_str = format!(
        "{}/api/v1/events/{event}",
        configuration.base_path,
        event = crate::clients::rest::apis::urlencode(p_event)
    );
    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.bearer_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::EventList200ResponseRowsInner`",
                )));
            }
            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::EventList200ResponseRowsInner`"
                ))));
            }
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EventGetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Lists all event keys for a tenant.
pub async fn event_key_list(
    configuration: &configuration::Configuration,
    tenant: &str,
) -> Result<models::V1EventKeyList200Response, Error<EventKeyListError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_tenant = tenant;

    let uri_str = format!(
        "{}/api/v1/tenants/{tenant}/events/keys",
        configuration.base_path,
        tenant = crate::clients::rest::apis::urlencode(p_tenant)
    );
    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.bearer_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::V1EventKeyList200Response`",
                )));
            }
            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::V1EventKeyList200Response`"
                ))));
            }
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EventKeyListError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Lists all events for a tenant.
pub async fn event_list(
    configuration: &configuration::Configuration,
    tenant: &str,
    offset: Option<i64>,
    limit: Option<i64>,
    keys: Option<Vec<String>>,
    workflows: Option<Vec<String>>,
    statuses: Option<Vec<String>>,
    search: Option<&str>,
    order_by_field: Option<&str>,
    order_by_direction: Option<&str>,
    additional_metadata: Option<Vec<String>>,
    event_ids: Option<Vec<uuid::Uuid>>,
) -> Result<models::EventList200Response, Error<EventListError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_tenant = tenant;
    let p_offset = offset;
    let p_limit = limit;
    let p_keys = keys;
    let p_workflows = workflows;
    let p_statuses = statuses;
    let p_search = search;
    let p_order_by_field = order_by_field;
    let p_order_by_direction = order_by_direction;
    let p_additional_metadata = additional_metadata;
    let p_event_ids = event_ids;

    let uri_str = format!(
        "{}/api/v1/tenants/{tenant}/events",
        configuration.base_path,
        tenant = crate::clients::rest::apis::urlencode(p_tenant)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_offset {
        req_builder = req_builder.query(&[("offset", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_keys {
        req_builder = match "multi" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("keys".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "keys",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref param_value) = p_workflows {
        req_builder = match "multi" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("workflows".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "workflows",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref param_value) = p_statuses {
        req_builder = match "multi" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("statuses".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "statuses",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref param_value) = p_search {
        req_builder = req_builder.query(&[("search", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_order_by_field {
        req_builder = req_builder.query(&[("orderByField", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_order_by_direction {
        req_builder = req_builder.query(&[("orderByDirection", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_additional_metadata {
        req_builder = match "multi" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("additionalMetadata".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "additionalMetadata",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref param_value) = p_event_ids {
        req_builder = match "multi" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("eventIds".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "eventIds",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_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::EventList200Response`",
                )));
            }
            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::EventList200Response`"
                ))));
            }
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EventListError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Cancels all runs for a list of events.
pub async fn event_update_cancel(
    configuration: &configuration::Configuration,
    tenant: &str,
    event_update_replay_request: models::EventUpdateReplayRequest,
) -> Result<models::EventUpdateCancel200Response, Error<EventUpdateCancelError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_tenant = tenant;
    let p_event_update_replay_request = event_update_replay_request;

    let uri_str = format!(
        "{}/api/v1/tenants/{tenant}/events/cancel",
        configuration.base_path,
        tenant = crate::clients::rest::apis::urlencode(p_tenant)
    );
    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_event_update_replay_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::EventUpdateCancel200Response`",
                )));
            }
            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::EventUpdateCancel200Response`"
                ))));
            }
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EventUpdateCancelError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Replays a list of events.
pub async fn event_update_replay(
    configuration: &configuration::Configuration,
    tenant: &str,
    event_update_replay_request: models::EventUpdateReplayRequest,
) -> Result<models::EventList200Response, Error<EventUpdateReplayError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_tenant = tenant;
    let p_event_update_replay_request = event_update_replay_request;

    let uri_str = format!(
        "{}/api/v1/tenants/{tenant}/events/replay",
        configuration.base_path,
        tenant = crate::clients::rest::apis::urlencode(p_tenant)
    );
    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_event_update_replay_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::EventList200Response`",
                )));
            }
            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::EventList200Response`"
                ))));
            }
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EventUpdateReplayError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Lists all event keys for a tenant.
pub async fn v1_event_key_list(
    configuration: &configuration::Configuration,
    tenant: &str,
) -> Result<models::V1EventKeyList200Response, Error<V1EventKeyListError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_tenant = tenant;

    let uri_str = format!(
        "{}/api/v1/stable/tenants/{tenant}/events/keys",
        configuration.base_path,
        tenant = crate::clients::rest::apis::urlencode(p_tenant)
    );
    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.bearer_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::V1EventKeyList200Response`",
                )));
            }
            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::V1EventKeyList200Response`"
                ))));
            }
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<V1EventKeyListError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Lists all events for a tenant.
pub async fn v1_event_list(
    configuration: &configuration::Configuration,
    tenant: &str,
    offset: Option<i64>,
    limit: Option<i64>,
    keys: Option<Vec<String>>,
    since: Option<String>,
    until: Option<String>,
    workflow_ids: Option<Vec<uuid::Uuid>>,
    workflow_run_statuses: Option<Vec<String>>,
    event_ids: Option<Vec<uuid::Uuid>>,
    additional_metadata: Option<Vec<String>>,
    scopes: Option<Vec<String>>,
) -> Result<models::V1EventList200Response, Error<V1EventListError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_tenant = tenant;
    let p_offset = offset;
    let p_limit = limit;
    let p_keys = keys;
    let p_since = since;
    let p_until = until;
    let p_workflow_ids = workflow_ids;
    let p_workflow_run_statuses = workflow_run_statuses;
    let p_event_ids = event_ids;
    let p_additional_metadata = additional_metadata;
    let p_scopes = scopes;

    let uri_str = format!(
        "{}/api/v1/stable/tenants/{tenant}/events",
        configuration.base_path,
        tenant = crate::clients::rest::apis::urlencode(p_tenant)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_offset {
        req_builder = req_builder.query(&[("offset", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_keys {
        req_builder = match "multi" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("keys".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "keys",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref param_value) = p_since {
        req_builder = req_builder.query(&[("since", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_until {
        req_builder = req_builder.query(&[("until", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_workflow_ids {
        req_builder = match "multi" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("workflowIds".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "workflowIds",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref param_value) = p_workflow_run_statuses {
        req_builder = match "multi" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("workflowRunStatuses".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "workflowRunStatuses",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref param_value) = p_event_ids {
        req_builder = match "multi" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("eventIds".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "eventIds",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref param_value) = p_additional_metadata {
        req_builder = match "multi" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("additionalMetadata".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "additionalMetadata",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref param_value) = p_scopes {
        req_builder = match "multi" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("scopes".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "scopes",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_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::V1EventList200Response`",
                )));
            }
            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::V1EventList200Response`"
                ))));
            }
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<V1EventListError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}