amazon-spapi 2.0.3

/*
 * Selling Partner API for Reports
 *
 * The Selling Partner API for Reports lets you retrieve and manage a variety of reports that can help selling partners manage their businesses.
 *
 * The version of the OpenAPI document: 2021-06-30
 * 
 * Generated by: https://openapi-generator.tech
 */


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


/// struct for typed errors of method [`cancel_report`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CancelReportError {
    Status400(models::reports_2021_06_30::ErrorList),
    Status401(models::reports_2021_06_30::ErrorList),
    Status403(models::reports_2021_06_30::ErrorList),
    Status404(models::reports_2021_06_30::ErrorList),
    Status415(models::reports_2021_06_30::ErrorList),
    Status429(models::reports_2021_06_30::ErrorList),
    Status500(models::reports_2021_06_30::ErrorList),
    Status503(models::reports_2021_06_30::ErrorList),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`cancel_report_schedule`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CancelReportScheduleError {
    Status400(models::reports_2021_06_30::ErrorList),
    Status401(models::reports_2021_06_30::ErrorList),
    Status403(models::reports_2021_06_30::ErrorList),
    Status404(models::reports_2021_06_30::ErrorList),
    Status415(models::reports_2021_06_30::ErrorList),
    Status429(models::reports_2021_06_30::ErrorList),
    Status500(models::reports_2021_06_30::ErrorList),
    Status503(models::reports_2021_06_30::ErrorList),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`create_report`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateReportError {
    Status400(models::reports_2021_06_30::ErrorList),
    Status401(models::reports_2021_06_30::ErrorList),
    Status403(models::reports_2021_06_30::ErrorList),
    Status404(models::reports_2021_06_30::ErrorList),
    Status415(models::reports_2021_06_30::ErrorList),
    Status429(models::reports_2021_06_30::ErrorList),
    Status500(models::reports_2021_06_30::ErrorList),
    Status503(models::reports_2021_06_30::ErrorList),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`create_report_schedule`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateReportScheduleError {
    Status400(models::reports_2021_06_30::ErrorList),
    Status401(models::reports_2021_06_30::ErrorList),
    Status403(models::reports_2021_06_30::ErrorList),
    Status404(models::reports_2021_06_30::ErrorList),
    Status415(models::reports_2021_06_30::ErrorList),
    Status429(models::reports_2021_06_30::ErrorList),
    Status500(models::reports_2021_06_30::ErrorList),
    Status503(models::reports_2021_06_30::ErrorList),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_report`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetReportError {
    Status400(models::reports_2021_06_30::ErrorList),
    Status401(models::reports_2021_06_30::ErrorList),
    Status403(models::reports_2021_06_30::ErrorList),
    Status404(models::reports_2021_06_30::ErrorList),
    Status415(models::reports_2021_06_30::ErrorList),
    Status429(models::reports_2021_06_30::ErrorList),
    Status500(models::reports_2021_06_30::ErrorList),
    Status503(models::reports_2021_06_30::ErrorList),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_report_document`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetReportDocumentError {
    Status400(models::reports_2021_06_30::ErrorList),
    Status401(models::reports_2021_06_30::ErrorList),
    Status403(models::reports_2021_06_30::ErrorList),
    Status404(models::reports_2021_06_30::ErrorList),
    Status415(models::reports_2021_06_30::ErrorList),
    Status429(models::reports_2021_06_30::ErrorList),
    Status500(models::reports_2021_06_30::ErrorList),
    Status503(models::reports_2021_06_30::ErrorList),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_report_schedule`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetReportScheduleError {
    Status400(models::reports_2021_06_30::ErrorList),
    Status401(models::reports_2021_06_30::ErrorList),
    Status403(models::reports_2021_06_30::ErrorList),
    Status404(models::reports_2021_06_30::ErrorList),
    Status415(models::reports_2021_06_30::ErrorList),
    Status429(models::reports_2021_06_30::ErrorList),
    Status500(models::reports_2021_06_30::ErrorList),
    Status503(models::reports_2021_06_30::ErrorList),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_report_schedules`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetReportSchedulesError {
    Status400(models::reports_2021_06_30::ErrorList),
    Status401(models::reports_2021_06_30::ErrorList),
    Status403(models::reports_2021_06_30::ErrorList),
    Status404(models::reports_2021_06_30::ErrorList),
    Status415(models::reports_2021_06_30::ErrorList),
    Status429(models::reports_2021_06_30::ErrorList),
    Status500(models::reports_2021_06_30::ErrorList),
    Status503(models::reports_2021_06_30::ErrorList),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_reports`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetReportsError {
    Status400(models::reports_2021_06_30::ErrorList),
    Status401(models::reports_2021_06_30::ErrorList),
    Status403(models::reports_2021_06_30::ErrorList),
    Status404(models::reports_2021_06_30::ErrorList),
    Status415(models::reports_2021_06_30::ErrorList),
    Status429(models::reports_2021_06_30::ErrorList),
    Status500(models::reports_2021_06_30::ErrorList),
    Status503(models::reports_2021_06_30::ErrorList),
    UnknownValue(serde_json::Value),
}


/// Cancels the report that you specify. Only reports with `processingStatus=IN_QUEUE` can be cancelled. Cancelled reports are returned in subsequent calls to the `getReport` and `getReports` operations.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 0.0222 | 10 |  The `x-amzn-RateLimit-Limit` response header returns the usage plan rate limits that were applied to the requested operation, when available. The table above indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may see higher rate and burst values than those shown here. For more information, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
pub async fn cancel_report(configuration: &configuration::Configuration, report_id: &str) -> Result<(), Error<CancelReportError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_report_id = report_id;

    let uri_str = format!("{}/reports/2021-06-30/reports/{reportId}", configuration.base_path, reportId=crate::apis::urlencode(p_report_id));
    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);

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

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

/// Cancels the report schedule that you specify.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 0.0222 | 10 |  The `x-amzn-RateLimit-Limit` response header returns the usage plan rate limits that were applied to the requested operation, when available. The table above indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may see higher rate and burst values than those shown here. For more information, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
pub async fn cancel_report_schedule(configuration: &configuration::Configuration, report_schedule_id: &str) -> Result<(), Error<CancelReportScheduleError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_report_schedule_id = report_schedule_id;

    let uri_str = format!("{}/reports/2021-06-30/schedules/{reportScheduleId}", configuration.base_path, reportScheduleId=crate::apis::urlencode(p_report_schedule_id));
    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);

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

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

/// Creates a report.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 0.0167 | 15 |  The `x-amzn-RateLimit-Limit` response header returns the usage plan rate limits that were applied to the requested operation, when available. The table above indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may see higher rate and burst values than those shown here. For more information, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
pub async fn create_report(configuration: &configuration::Configuration, body: models::reports_2021_06_30::CreateReportSpecification) -> Result<models::reports_2021_06_30::CreateReportResponse, Error<CreateReportError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body = body;

    let uri_str = format!("{}/reports/2021-06-30/reports", 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());
    }
    req_builder = req_builder.json(&p_body);

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

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

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

/// Creates a report schedule. If a report schedule with the same report type and marketplace IDs already exists, it will be cancelled and replaced with this one.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 0.0222 | 10 |  The `x-amzn-RateLimit-Limit` response header returns the usage plan rate limits that were applied to the requested operation, when available. The table above indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may see higher rate and burst values than those shown here. For more information, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
pub async fn create_report_schedule(configuration: &configuration::Configuration, body: models::reports_2021_06_30::CreateReportScheduleSpecification) -> Result<models::reports_2021_06_30::CreateReportScheduleResponse, Error<CreateReportScheduleError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body = body;

    let uri_str = format!("{}/reports/2021-06-30/schedules", 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());
    }
    req_builder = req_builder.json(&p_body);

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

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

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

/// Returns report details (including the `reportDocumentId`, if available) for the report that you specify.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 2 | 15 |  The `x-amzn-RateLimit-Limit` response header returns the usage plan rate limits that were applied to the requested operation, when available. The table above indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may see higher rate and burst values than those shown here. For more information, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
pub async fn get_report(configuration: &configuration::Configuration, report_id: &str) -> Result<models::reports_2021_06_30::Report, Error<GetReportError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_report_id = report_id;

    let uri_str = format!("{}/reports/2021-06-30/reports/{reportId}", configuration.base_path, reportId=crate::apis::urlencode(p_report_id));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

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

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

/// Returns the information required for retrieving a report document's contents.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 0.0167 | 15 |  The `x-amzn-RateLimit-Limit` response header returns the usage plan rate limits that were applied to the requested operation, when available. The table above indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may see higher rate and burst values than those shown here. For more information, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
pub async fn get_report_document(configuration: &configuration::Configuration, report_document_id: &str) -> Result<models::reports_2021_06_30::ReportDocument, Error<GetReportDocumentError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_report_document_id = report_document_id;

    let uri_str = format!("{}/reports/2021-06-30/documents/{reportDocumentId}", configuration.base_path, reportDocumentId=crate::apis::urlencode(p_report_document_id));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

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

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

/// Returns report schedule details for the report schedule that you specify.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 0.0222 | 10 |  The `x-amzn-RateLimit-Limit` response header returns the usage plan rate limits that were applied to the requested operation, when available. The table above indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may see higher rate and burst values than those shown here. For more information, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
pub async fn get_report_schedule(configuration: &configuration::Configuration, report_schedule_id: &str) -> Result<models::reports_2021_06_30::ReportSchedule, Error<GetReportScheduleError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_report_schedule_id = report_schedule_id;

    let uri_str = format!("{}/reports/2021-06-30/schedules/{reportScheduleId}", configuration.base_path, reportScheduleId=crate::apis::urlencode(p_report_schedule_id));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

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

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

/// Returns report schedule details that match the filters that you specify.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 0.0222 | 10 |  The `x-amzn-RateLimit-Limit` response header returns the usage plan rate limits that were applied to the requested operation, when available. The table above indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may see higher rate and burst values than those shown here. For more information, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
pub async fn get_report_schedules(configuration: &configuration::Configuration, report_types: Vec<String>) -> Result<models::reports_2021_06_30::ReportScheduleList, Error<GetReportSchedulesError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_report_types = report_types;

    let uri_str = format!("{}/reports/2021-06-30/schedules", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = match "csv" {
        "multi" => req_builder.query(&p_report_types.into_iter().map(|p| ("reportTypes".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
        _ => req_builder.query(&[("reportTypes", &p_report_types.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());
    }

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

/// Returns report details for the reports that match the filters that you specify.  **Usage Plan:**  | Rate (requests per second) | Burst | | ---- | ---- | | 0.0222 | 10 |  The `x-amzn-RateLimit-Limit` response header returns the usage plan rate limits that were applied to the requested operation, when available. The table above indicates the default rate and burst values for this operation. Selling partners whose business demands require higher throughput may see higher rate and burst values than those shown here. For more information, refer to [Usage Plans and Rate Limits in the Selling Partner API](https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits-in-the-sp-api).
pub async fn get_reports(configuration: &configuration::Configuration, report_types: Option<Vec<String>>, processing_statuses: Option<Vec<String>>, marketplace_ids: Option<Vec<String>>, page_size: Option<i32>, created_since: Option<String>, created_until: Option<String>, next_token: Option<&str>) -> Result<models::reports_2021_06_30::GetReportsResponse, Error<GetReportsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_report_types = report_types;
    let p_processing_statuses = processing_statuses;
    let p_marketplace_ids = marketplace_ids;
    let p_page_size = page_size;
    let p_created_since = created_since;
    let p_created_until = created_until;
    let p_next_token = next_token;

    let uri_str = format!("{}/reports/2021-06-30/reports", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_report_types {
        req_builder = match "csv" {
            "multi" => req_builder.query(&param_value.into_iter().map(|p| ("reportTypes".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
            _ => req_builder.query(&[("reportTypes", &param_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
        };
    }
    if let Some(ref param_value) = p_processing_statuses {
        req_builder = match "csv" {
            "multi" => req_builder.query(&param_value.into_iter().map(|p| ("processingStatuses".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
            _ => req_builder.query(&[("processingStatuses", &param_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
        };
    }
    if let Some(ref param_value) = p_marketplace_ids {
        req_builder = match "csv" {
            "multi" => req_builder.query(&param_value.into_iter().map(|p| ("marketplaceIds".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
            _ => req_builder.query(&[("marketplaceIds", &param_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
        };
    }
    if let Some(ref param_value) = p_page_size {
        req_builder = req_builder.query(&[("pageSize", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_created_since {
        req_builder = req_builder.query(&[("createdSince", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_created_until {
        req_builder = req_builder.query(&[("createdUntil", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_next_token {
        req_builder = req_builder.query(&[("nextToken", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }

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