late 0.0.721

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

/// struct for typed errors of method [`generate_keyword_ideas`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GenerateKeywordIdeasError {
    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_ads_search_terms`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetAdsSearchTermsError {
    Status400(models::ErrorResponse),
    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 [`list_local_services_lead_conversations`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ListLocalServicesLeadConversationsError {
    Status400(models::ErrorResponse),
    Status401(models::InlineObject),
    Status429(),
    Status501(),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`list_local_services_leads`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ListLocalServicesLeadsError {
    Status400(models::ErrorResponse),
    Status401(models::InlineObject),
    Status429(),
    Status501(),
    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,
        }))
    }
}

/// Google Ads only. Runs Keyword Planner's generateKeywordHistoricalMetrics for up to 1,000 exact keywords: historical search volume, competition and top-of-page bid ranges, plus averageCpcMicros when includeAverageCpc is set. Rows come back verbatim; counters are int64s encoded as strings, bid/CPC values are micros of the account currency.
pub async fn generate_keyword_historical_metrics(
    configuration: &configuration::Configuration,
    generate_keyword_historical_metrics_request: models::GenerateKeywordHistoricalMetricsRequest,
) -> Result<
    models::GenerateKeywordHistoricalMetrics200Response,
    Error<GenerateKeywordHistoricalMetricsError>,
> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_generate_keyword_historical_metrics_request =
        generate_keyword_historical_metrics_request;

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

/// Google Ads only. Runs Keyword Planner's generateKeywordIdeas from seed keywords, a seed URL, or both, returning idea rows verbatim (avgMonthlySearches, competition, competitionIndex, top-of-page bid micros, monthlySearchVolumes). Counters are int64s encoded as strings; bid values are micros of the account currency. Omitting `countries` targets worldwide.
pub async fn generate_keyword_ideas(
    configuration: &configuration::Configuration,
    generate_keyword_ideas_request: models::GenerateKeywordIdeasRequest,
) -> Result<models::GenerateKeywordIdeas200Response, Error<GenerateKeywordIdeasError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_generate_keyword_ideas_request = generate_keyword_ideas_request;

    let uri_str = format!("{}/v1/ads/keywords/ideas", 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_generate_keyword_ideas_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::GenerateKeywordIdeas200Response`"))),
            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::GenerateKeywordIdeas200Response`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GenerateKeywordIdeasError> = 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::AdAnalyticsResponse, 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::AdAnalyticsResponse`"))),
            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::AdAnalyticsResponse`")))),
        }
    } 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,
        }))
    }
}

/// The actual search queries that triggered your ads, with matched-keyword status and spend metrics — the raw material for wasted-spend analysis and negative-keyword lists. Reads Google's `search_term_view` live; defaults to the last 30 days. Rows are ordered by cost, descending. Draws on the shared Google Ads operations budget.
pub async fn get_ads_search_terms(
    configuration: &configuration::Configuration,
    account_id: &str,
    customer_id: Option<&str>,
    from_date: Option<String>,
    to_date: Option<String>,
    campaign_id: Option<&str>,
    ad_group_id: Option<&str>,
    page_token: Option<&str>,
) -> Result<models::GetAdsSearchTerms200Response, Error<GetAdsSearchTermsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_account_id = account_id;
    let p_query_customer_id = customer_id;
    let p_query_from_date = from_date;
    let p_query_to_date = to_date;
    let p_query_campaign_id = campaign_id;
    let p_query_ad_group_id = ad_group_id;
    let p_query_page_token = page_token;

    let uri_str = format!("{}/v1/ads/search-terms", 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())]);
    if let Some(ref param_value) = p_query_customer_id {
        req_builder = req_builder.query(&[("customerId", &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_campaign_id {
        req_builder = req_builder.query(&[("campaignId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_ad_group_id {
        req_builder = req_builder.query(&[("adGroupId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_page_token {
        req_builder = req_builder.query(&[("pageToken", &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::GetAdsSearchTerms200Response`"))),
            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::GetAdsSearchTerms200Response`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetAdsSearchTermsError> = 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::CampaignAnalyticsResponse, 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::CampaignAnalyticsResponse`"))),
            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::CampaignAnalyticsResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetCampaignAnalyticsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Conversation entries of one Local Services lead: phone calls (duration, recording URL) and messages (text, attachment URLs), oldest first. Read live from `local_services_lead_conversation`, always scoped to a single lead. Call-recording URLs require read access on the Google Ads account. Draws on the shared Google Ads operations budget.
pub async fn list_local_services_lead_conversations(
    configuration: &configuration::Configuration,
    lead_id: &str,
    account_id: &str,
    customer_id: Option<&str>,
    page_token: Option<&str>,
) -> Result<
    models::ListLocalServicesLeadConversations200Response,
    Error<ListLocalServicesLeadConversationsError>,
> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_lead_id = lead_id;
    let p_query_account_id = account_id;
    let p_query_customer_id = customer_id;
    let p_query_page_token = page_token;

    let uri_str = format!(
        "{}/v1/ads/local-services/leads/{leadId}/conversations",
        configuration.base_path,
        leadId = crate::apis::urlencode(p_path_lead_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_customer_id {
        req_builder = req_builder.query(&[("customerId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_page_token {
        req_builder = req_builder.query(&[("pageToken", &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::ListLocalServicesLeadConversations200Response`"))),
            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::ListLocalServicesLeadConversations200Response`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListLocalServicesLeadConversationsError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Leads generated by Local Services Ads (phone calls, messages, bookings), read live from Google's `local_services_lead` resource, newest first. No persistence: Google is the source of truth and lead/credit statuses keep changing server-side. Google never returns healthcare-category leads, and `WIPED_OUT` leads arrive with contact erased (`contact` is null). Draws on the shared Google Ads operations budget.
pub async fn list_local_services_leads(
    configuration: &configuration::Configuration,
    account_id: &str,
    customer_id: Option<&str>,
    from_date: Option<String>,
    to_date: Option<String>,
    lead_type: Option<&str>,
    lead_status: Option<&str>,
    charged_only: Option<bool>,
    page_token: Option<&str>,
) -> Result<models::ListLocalServicesLeads200Response, Error<ListLocalServicesLeadsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_account_id = account_id;
    let p_query_customer_id = customer_id;
    let p_query_from_date = from_date;
    let p_query_to_date = to_date;
    let p_query_lead_type = lead_type;
    let p_query_lead_status = lead_status;
    let p_query_charged_only = charged_only;
    let p_query_page_token = page_token;

    let uri_str = format!("{}/v1/ads/local-services/leads", 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())]);
    if let Some(ref param_value) = p_query_customer_id {
        req_builder = req_builder.query(&[("customerId", &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_lead_type {
        req_builder = req_builder.query(&[("leadType", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_lead_status {
        req_builder = req_builder.query(&[("leadStatus", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_charged_only {
        req_builder = req_builder.query(&[("chargedOnly", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_page_token {
        req_builder = req_builder.query(&[("pageToken", &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::ListLocalServicesLeads200Response`"))),
            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::ListLocalServicesLeads200Response`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListLocalServicesLeadsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Live, flexible insights query. The account's platform picks the contract:  **Meta (facebook/instagram)**: forwards caller-chosen `fields`, `breakdowns` and `filtering` to any Meta insights node and returns Meta's rows verbatim. `objectId` (required) selects the node; `level` sets row granularity. 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).  **Google Ads (googleads)**: raw GAQL passthrough. Send any read-only GAQL SELECT via `query` (campaign/keyword/search-term/geo/demographic/asset/shopping resources, `change_event`, any `segments.*`) and rows come back verbatim (camelCase, counters as strings). Results are paged at a fixed 10,000 rows; follow `paging.nextPageToken` with `pageToken`. `customerId` is only needed when the connection has several Google Ads accounts. Semantic validation is Google's: an invalid query returns a 400 carrying Google's message (note: selecting `segments.date` requires a finite date filter).
pub async fn query_ad_insights(
    configuration: &configuration::Configuration,
    account_id: &str,
    object_id: Option<&str>,
    query: Option<&str>,
    customer_id: Option<&str>,
    page_token: Option<&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_query = query;
    let p_query_customer_id = customer_id;
    let p_query_page_token = page_token;
    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())]);
    if let Some(ref param_value) = p_query_object_id {
        req_builder = req_builder.query(&[("objectId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_query {
        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_customer_id {
        req_builder = req_builder.query(&[("customerId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_page_token {
        req_builder = req_builder.query(&[("pageToken", &param_value.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,
        }))
    }
}