late 0.0.525

/*
 * Zernio API
 *
 * API reference for Zernio. Authenticate with a Bearer API key. Base URL: https://zernio.com/api
 *
 * The version of the OpenAPI document: 1.0.4
 * Contact: support@zernio.com
 * Generated by: https://openapi-generator.tech
 */

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 [`create_ad_insights_report`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateAdInsightsReportError {
    Status400(),
    Status401(models::InlineObject),
    Status429(),
    Status501(),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_ad_analytics`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetAdAnalyticsError {
    Status400(models::ErrorResponse),
    Status401(models::InlineObject),
    Status403(),
    Status404(models::InlineObject1),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_ad_insights_report`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetAdInsightsReportError {
    Status400(),
    Status401(models::InlineObject),
    Status429(),
    Status501(),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_campaign_analytics`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetCampaignAnalyticsError {
    Status400(models::ErrorResponse),
    Status401(models::InlineObject),
    Status403(),
    Status404(models::InlineObject1),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`query_ad_insights`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum QueryAdInsightsError {
    Status400(),
    Status401(models::InlineObject),
    Status429(),
    Status501(),
    UnknownValue(serde_json::Value),
}

/// Submits an asynchronous Meta insights report. Same query surface as GET /v1/ads/insights, but in the JSON body; Meta processes the report server-side, which is the right choice for long ranges or large accounts where the sync query is slow or rate-limited. Returns a `reportRunId` to poll via GET /v1/ads/insights/reports/{reportRunId}.
pub async fn create_ad_insights_report(
    configuration: &configuration::Configuration,
    create_ad_insights_report_request: models::CreateAdInsightsReportRequest,
) -> Result<models::CreateAdInsightsReport202Response, Error<CreateAdInsightsReportError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_ad_insights_report_request = create_ad_insights_report_request;

    let uri_str = format!("{}/v1/ads/insights/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());
    }
    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_create_ad_insights_report_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::CreateAdInsightsReport202Response`"))),
            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::CreateAdInsightsReport202Response`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateAdInsightsReportError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Returns detailed performance analytics for an ad. Includes summary metrics, a daily timeline over the requested date range, and optional demographic breakdowns (Meta and TikTok only). If no date range is provided, defaults to the last 90 days. Date range is capped at 730 days max.
pub async fn get_ad_analytics(
    configuration: &configuration::Configuration,
    ad_id: &str,
    from_date: Option<String>,
    to_date: Option<String>,
    breakdowns: Option<&str>,
) -> Result<models::GetAdAnalytics200Response, Error<GetAdAnalyticsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_ad_id = ad_id;
    let p_query_from_date = from_date;
    let p_query_to_date = to_date;
    let p_query_breakdowns = breakdowns;

    let uri_str = format!(
        "{}/v1/ads/{adId}/analytics",
        configuration.base_path,
        adId = crate::apis::urlencode(p_path_ad_id)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_from_date {
        req_builder = req_builder.query(&[("fromDate", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_to_date {
        req_builder = req_builder.query(&[("toDate", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_breakdowns {
        req_builder = req_builder.query(&[("breakdowns", &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());
    }
    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::GetAdAnalytics200Response`"))),
            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::GetAdAnalytics200Response`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetAdAnalyticsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Status and results for a report run created via POST /v1/ads/insights/reports. While the job runs, returns `status` and `percentCompletion`. Once `status` is \"Job Completed\" the response also carries a `data` page, cursor-paginated via `limit` / `after`.
pub async fn get_ad_insights_report(
    configuration: &configuration::Configuration,
    report_run_id: &str,
    account_id: &str,
    limit: Option<i32>,
    after: Option<&str>,
) -> Result<models::GetAdInsightsReport200Response, Error<GetAdInsightsReportError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_report_run_id = report_run_id;
    let p_query_account_id = account_id;
    let p_query_limit = limit;
    let p_query_after = after;

    let uri_str = format!(
        "{}/v1/ads/insights/reports/{reportRunId}",
        configuration.base_path,
        reportRunId = crate::apis::urlencode(p_path_report_run_id)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("accountId", &p_query_account_id.to_string())]);
    if let Some(ref param_value) = p_query_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_after {
        req_builder = req_builder.query(&[("after", &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());
    }
    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::GetAdInsightsReport200Response`"))),
            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::GetAdInsightsReport200Response`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetAdInsightsReportError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Returns performance analytics for a whole campaign in one call: summary metrics, a daily timeline over the requested date range (summed across the campaign's ads), and optional demographic breakdowns. Breakdowns are fetched live from Meta at the campaign level (one call per dimension, no per-ad fan-out), so an agency dashboard gets campaign-level age/gender/etc. without summing thousands of per-ad reads. `campaignId` is the platform campaign id; pass `platform` when a campaign id could be ambiguous across platforms. If no date range is provided, defaults to the last 90 days. Date range is capped at 730 days max.
pub async fn get_campaign_analytics(
    configuration: &configuration::Configuration,
    campaign_id: &str,
    platform: Option<&str>,
    from_date: Option<String>,
    to_date: Option<String>,
    breakdowns: Option<&str>,
) -> Result<models::GetCampaignAnalytics200Response, Error<GetCampaignAnalyticsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_campaign_id = campaign_id;
    let p_query_platform = platform;
    let p_query_from_date = from_date;
    let p_query_to_date = to_date;
    let p_query_breakdowns = breakdowns;

    let uri_str = format!(
        "{}/v1/ads/campaigns/{campaignId}/analytics",
        configuration.base_path,
        campaignId = crate::apis::urlencode(p_path_campaign_id)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_platform {
        req_builder = req_builder.query(&[("platform", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_from_date {
        req_builder = req_builder.query(&[("fromDate", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_to_date {
        req_builder = req_builder.query(&[("toDate", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_breakdowns {
        req_builder = req_builder.query(&[("breakdowns", &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());
    }
    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::GetCampaignAnalytics200Response`"))),
            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::GetCampaignAnalytics200Response`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetCampaignAnalyticsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Live, flexible insights query against Meta's Graph API. Unlike GET /v1/ads/{adId}/analytics (fixed metric set, cached), this forwards caller-chosen `fields`, `breakdowns` and `filtering` to any Meta insights node and returns Meta's rows verbatim.  `objectId` selects the node: an ad account, campaign, ad set or ad platform id. `level` sets row granularity independently of the node.  Semantic validation is Meta's: an unknown field or invalid breakdown combination returns a 400 carrying Meta's message. For long ranges or agency-scale accounts prefer the async variant (POST /v1/ads/insights/reports).
pub async fn query_ad_insights(
    configuration: &configuration::Configuration,
    account_id: &str,
    object_id: &str,
    level: Option<&str>,
    fields: Option<&str>,
    breakdowns: Option<&str>,
    action_breakdowns: Option<&str>,
    action_attribution_windows: Option<&str>,
    action_report_time: Option<&str>,
    use_unified_attribution_setting: Option<bool>,
    filtering: Option<&str>,
    date_preset: Option<&str>,
    from_date: Option<String>,
    to_date: Option<String>,
    time_increment: Option<&str>,
    limit: Option<i32>,
    after: Option<&str>,
) -> Result<models::QueryAdInsights200Response, Error<QueryAdInsightsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_account_id = account_id;
    let p_query_object_id = object_id;
    let p_query_level = level;
    let p_query_fields = fields;
    let p_query_breakdowns = breakdowns;
    let p_query_action_breakdowns = action_breakdowns;
    let p_query_action_attribution_windows = action_attribution_windows;
    let p_query_action_report_time = action_report_time;
    let p_query_use_unified_attribution_setting = use_unified_attribution_setting;
    let p_query_filtering = filtering;
    let p_query_date_preset = date_preset;
    let p_query_from_date = from_date;
    let p_query_to_date = to_date;
    let p_query_time_increment = time_increment;
    let p_query_limit = limit;
    let p_query_after = after;

    let uri_str = format!("{}/v1/ads/insights", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("accountId", &p_query_account_id.to_string())]);
    req_builder = req_builder.query(&[("objectId", &p_query_object_id.to_string())]);
    if let Some(ref param_value) = p_query_level {
        req_builder = req_builder.query(&[("level", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_fields {
        req_builder = req_builder.query(&[("fields", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_breakdowns {
        req_builder = req_builder.query(&[("breakdowns", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_action_breakdowns {
        req_builder = req_builder.query(&[("actionBreakdowns", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_action_attribution_windows {
        req_builder = req_builder.query(&[("actionAttributionWindows", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_action_report_time {
        req_builder = req_builder.query(&[("actionReportTime", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_use_unified_attribution_setting {
        req_builder =
            req_builder.query(&[("useUnifiedAttributionSetting", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_filtering {
        req_builder = req_builder.query(&[("filtering", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_date_preset {
        req_builder = req_builder.query(&[("datePreset", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_from_date {
        req_builder = req_builder.query(&[("fromDate", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_to_date {
        req_builder = req_builder.query(&[("toDate", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_time_increment {
        req_builder = req_builder.query(&[("timeIncrement", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_after {
        req_builder = req_builder.query(&[("after", &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());
    }
    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::QueryAdInsights200Response`"))),
            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::QueryAdInsights200Response`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<QueryAdInsightsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}