scrapebadger 0.2.0

// @generated by `cargo run -p xtask -- gen` from specs/twitter.json — do not edit by hand.
#![allow(clippy::all)]
#![allow(
    dead_code,
    unused_imports,
    unused_variables,
    non_snake_case,
    rustdoc::all
)]

use crate::core::{Client, Error, Method, QueryParams, Result};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::collections::HashMap;

/// Handle for the `twitter` platform. Obtain via [`crate::ScrapeBadger::twitter`].
#[derive(Clone)]
pub struct Twitter {
    client: Client,
}

impl Twitter {
    pub(crate) fn new(client: Client) -> Self {
        Self { client }
    }

    /// Access the underlying transport client.
    pub fn client(&self) -> &Client {
        &self.client
    }

    /// Search communities
    ///
    /// Search for Twitter communities by name, description, or keywords. Returns matching communities with comprehensive information including member count, join policy, and description. Useful for discovering communities related to specific topics.
    /// `GET /v1/twitter/communities/search`
    pub async fn search_communities(
        &self,
        params: SearchCommunitiesParams,
    ) -> Result<CommunitiesResponse> {
        let path = "/v1/twitter/communities/search".to_string();
        let mut q = QueryParams::new();
        q.opt("query", params.query.as_ref());
        q.opt("cursor", params.cursor.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get community details
    ///
    /// Get detailed information about a Twitter community. Returns comprehensive community data including name, description, member count, join policy, banner image, creator/admin info, and community rules. Useful for understanding a community before exploring its content.
    /// `GET /v1/twitter/communities/{community_id}`
    pub async fn get_community_detail(
        &self,
        community_id: impl AsRef<str>,
        params: GetCommunityDetailParams,
    ) -> Result<CommunityData> {
        let path = format!(
            "/v1/twitter/communities/{community_id}",
            community_id = community_id.as_ref()
        );
        let query: Vec<(String, String)> = Vec::new();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get community tweets
    ///
    /// Get tweets from a specific community. Returns tweets posted within the community, filterable by type (Top, Latest, or Media). Supports pagination for communities with extensive content.
    /// `GET /v1/twitter/communities/{community_id}/tweets`
    pub async fn get_community_tweets(
        &self,
        community_id: impl AsRef<str>,
        params: GetCommunityTweetsParams,
    ) -> Result<TweetsResponse> {
        let path = format!(
            "/v1/twitter/communities/{community_id}/tweets",
            community_id = community_id.as_ref()
        );
        let mut q = QueryParams::new();
        q.opt("tweet_type", params.tweet_type.as_ref());
        q.opt("cursor", params.cursor.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get place details
    ///
    /// Get detailed information about a specific geographic place. Returns comprehensive place data including full name, country, place type, bounding box coordinates, and additional attributes. Use place IDs obtained from the geo search endpoint.
    /// `GET /v1/twitter/geo/places/{place_id}`
    pub async fn get_place_detail(
        &self,
        place_id: impl AsRef<str>,
        params: GetPlaceDetailParams,
    ) -> Result<PlaceData> {
        let path = format!(
            "/v1/twitter/geo/places/{place_id}",
            place_id = place_id.as_ref()
        );
        let query: Vec<(String, String)> = Vec::new();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Search places
    ///
    /// Search for geographic places that can be attached to tweets. At least one of `query`, `lat`/`long`, or `ip` must be provided. Results can be filtered by granularity (neighborhood, city, admin, country). Useful for geo-tagging and location-based analysis.
    /// `GET /v1/twitter/geo/search`
    pub async fn search_places(&self, params: SearchPlacesParams) -> Result<PlacesResponse> {
        let path = "/v1/twitter/geo/search".to_string();
        let mut q = QueryParams::new();
        q.opt("query", params.query.as_ref());
        q.opt("lat", params.lat.as_ref());
        q.opt("long", params.long.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get list details
    ///
    /// Get detailed information about a Twitter list. Returns comprehensive list details including name, description, member count, subscriber count, visibility mode, and owner information. Useful for understanding list composition before fetching its tweets.
    /// `GET /v1/twitter/lists/{list_id}/detail`
    pub async fn get_list_detail(
        &self,
        list_id: impl AsRef<str>,
        params: GetListDetailParams,
    ) -> Result<ListData> {
        let path = format!(
            "/v1/twitter/lists/{list_id}/detail",
            list_id = list_id.as_ref()
        );
        let query: Vec<(String, String)> = Vec::new();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Search list tweets
    ///
    /// Search for tweets within a specific Twitter list. Returns tweets from the list that match the given search query. Useful for finding specific content within curated tweet collections.
    /// `GET /v1/twitter/lists/{list_id}/search_tweets`
    pub async fn search_list_tweets(
        &self,
        list_id: impl AsRef<str>,
        params: SearchListTweetsParams,
    ) -> Result<TweetsResponse> {
        let path = format!(
            "/v1/twitter/lists/{list_id}/search_tweets",
            list_id = list_id.as_ref()
        );
        let mut q = QueryParams::new();
        q.opt("query", params.query.as_ref());
        q.opt("cursor", params.cursor.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get list tweets
    ///
    /// Get tweets from a specific Twitter list. Returns comprehensive tweet data from the list's timeline including all metadata, media attachments, and engagement metrics. Supports pagination for lists with many tweets.
    /// `GET /v1/twitter/lists/{list_id}/tweets`
    pub async fn get_list_tweets(
        &self,
        list_id: impl AsRef<str>,
        params: GetListTweetsParams,
    ) -> Result<TweetsResponse> {
        let path = format!(
            "/v1/twitter/lists/{list_id}/tweets",
            list_id = list_id.as_ref()
        );
        let mut q = QueryParams::new();
        q.opt("cursor", params.cursor.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get broadcast details
    ///
    /// Get details of a live video broadcast on Twitter. Returns broadcast metadata including title, current state, media key, dimensions, viewer counts, and timestamps. Useful for monitoring live content on the platform.
    /// `GET /v1/twitter/spaces/broadcast/{broadcast_id}`
    pub async fn get_broadcast_detail(
        &self,
        broadcast_id: impl AsRef<str>,
        params: GetBroadcastDetailParams,
    ) -> Result<BroadcastData> {
        let path = format!(
            "/v1/twitter/spaces/broadcast/{broadcast_id}",
            broadcast_id = broadcast_id.as_ref()
        );
        let query: Vec<(String, String)> = Vec::new();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get Space details
    ///
    /// Get details of a Twitter Space (audio room). Returns Space metadata including title, current state, creator information, participant counts, and scheduling details. Useful for monitoring live audio content and upcoming events.
    /// `GET /v1/twitter/spaces/{space_id}`
    pub async fn get_space_detail(
        &self,
        space_id: impl AsRef<str>,
        params: GetSpaceDetailParams,
    ) -> Result<SpaceData> {
        let path = format!(
            "/v1/twitter/spaces/{space_id}",
            space_id = space_id.as_ref()
        );
        let query: Vec<(String, String)> = Vec::new();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// List billing logs
    ///
    /// List billing logs for stream monitors. Shows credit deductions with billing cadence details, tier rates, and account counts. Useful for tracking streaming costs and verifying billing accuracy.
    /// `GET /v1/twitter/stream/billing-logs`
    pub async fn list_stream_billing_logs(
        &self,
        params: ListStreamBillingLogsParams,
    ) -> Result<ListStreamBillingLogsResponse> {
        let path = "/v1/twitter/stream/billing-logs".to_string();
        let mut q = QueryParams::new();
        q.opt("monitor_id", params.monitor_id.as_ref());
        q.opt("page", params.page.as_ref());
        q.opt("page_size", params.page_size.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// List filter rules
    ///
    /// List all filter rules for the authenticated API key. Supports pagination and optional filtering by status.
    /// `GET /v1/twitter/stream/filter-rules`
    pub async fn list_filter_rules(
        &self,
        params: ListFilterRulesParams,
    ) -> Result<ListFilterRulesResponse> {
        let path = "/v1/twitter/stream/filter-rules".to_string();
        let mut q = QueryParams::new();
        q.opt("page", params.page.as_ref());
        q.opt("page_size", params.page_size.as_ref());
        q.opt("status", params.status.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Create filter rule
    ///
    /// Create a new filter rule that monitors Twitter using an Advanced Search query at a configurable polling interval. Matching tweets are delivered via WebSocket and optionally via webhook. Pricing is based on the polling interval tier.
    /// `POST /v1/twitter/stream/filter-rules`
    pub async fn create_filter_rule(
        &self,
        params: CreateFilterRuleParams,
    ) -> Result<FilterRuleResponse> {
        let path = "/v1/twitter/stream/filter-rules".to_string();
        let query: Vec<(String, String)> = Vec::new();
        let mut body = serde_json::Map::new();
        if let Some(v) = &params.interval_seconds {
            body.insert("interval_seconds".to_string(), serde_json::json!(v));
        }
        if let Some(v) = &params.max_results_per_poll {
            body.insert("max_results_per_poll".to_string(), serde_json::json!(v));
        }
        if let Some(v) = &params.query {
            body.insert("query".to_string(), serde_json::json!(v));
        }
        if let Some(v) = &params.tag {
            body.insert("tag".to_string(), serde_json::json!(v));
        }
        if let Some(v) = &params.webhook_secret {
            body.insert("webhook_secret".to_string(), serde_json::json!(v));
        }
        if let Some(v) = &params.webhook_url {
            body.insert("webhook_url".to_string(), serde_json::json!(v));
        }
        let body = if body.is_empty() {
            None
        } else {
            Some(Value::Object(body))
        };
        self.client.send(Method::POST, &path, &query, body).await
    }

    /// Get filter rule pricing tiers
    ///
    /// Retrieve the pricing tiers for filter rules. Each tier defines a maximum polling interval and the corresponding credit cost per rule per day. Use this to estimate costs before creating filter rules.
    /// `GET /v1/twitter/stream/filter-rules-pricing`
    pub async fn get_filter_rule_pricing_tiers(
        &self,
        params: GetFilterRulePricingTiersParams,
    ) -> Result<GetFilterRulePricingTiersResponse> {
        let path = "/v1/twitter/stream/filter-rules-pricing".to_string();
        let query: Vec<(String, String)> = Vec::new();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Validate filter rule query
    ///
    /// Validate a Twitter Advanced Search query without creating a filter rule. Returns whether the query syntax is valid and any errors found. Use this to test queries before creating filter rules.
    /// `POST /v1/twitter/stream/filter-rules/validate`
    pub async fn validate_filter_rule_query(
        &self,
        params: ValidateFilterRuleQueryParams,
    ) -> Result<ValidateFilterRuleQueryResponse> {
        let path = "/v1/twitter/stream/filter-rules/validate".to_string();
        let query: Vec<(String, String)> = Vec::new();
        let mut body = serde_json::Map::new();
        if let Some(v) = &params.query {
            body.insert("query".to_string(), serde_json::json!(v));
        }
        let body = if body.is_empty() {
            None
        } else {
            Some(Value::Object(body))
        };
        self.client.send(Method::POST, &path, &query, body).await
    }

    /// Get filter rule
    ///
    /// Retrieve details of a specific filter rule by its ID. Returns full rule configuration, status, and pricing information.
    /// `GET /v1/twitter/stream/filter-rules/{rule_id}`
    pub async fn get_filter_rule(
        &self,
        rule_id: impl AsRef<str>,
        params: GetFilterRuleParams,
    ) -> Result<FilterRuleResponse> {
        let path = format!(
            "/v1/twitter/stream/filter-rules/{rule_id}",
            rule_id = rule_id.as_ref()
        );
        let query: Vec<(String, String)> = Vec::new();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Update filter rule
    ///
    /// Update an existing filter rule. All fields are optional; only provided fields will be updated. Changing the interval may affect the pricing tier.
    /// `PATCH /v1/twitter/stream/filter-rules/{rule_id}`
    pub async fn update_filter_rule(
        &self,
        rule_id: impl AsRef<str>,
        params: UpdateFilterRuleParams,
    ) -> Result<FilterRuleResponse> {
        let path = format!(
            "/v1/twitter/stream/filter-rules/{rule_id}",
            rule_id = rule_id.as_ref()
        );
        let query: Vec<(String, String)> = Vec::new();
        let mut body = serde_json::Map::new();
        if let Some(v) = &params.interval_seconds {
            body.insert("interval_seconds".to_string(), serde_json::json!(v));
        }
        if let Some(v) = &params.max_results_per_poll {
            body.insert("max_results_per_poll".to_string(), serde_json::json!(v));
        }
        if let Some(v) = &params.query {
            body.insert("query".to_string(), serde_json::json!(v));
        }
        if let Some(v) = &params.status {
            body.insert("status".to_string(), serde_json::json!(v));
        }
        if let Some(v) = &params.tag {
            body.insert("tag".to_string(), serde_json::json!(v));
        }
        if let Some(v) = &params.webhook_secret {
            body.insert("webhook_secret".to_string(), serde_json::json!(v));
        }
        if let Some(v) = &params.webhook_url {
            body.insert("webhook_url".to_string(), serde_json::json!(v));
        }
        let body = if body.is_empty() {
            None
        } else {
            Some(Value::Object(body))
        };
        self.client.send(Method::PATCH, &path, &query, body).await
    }

    /// Delete filter rule
    ///
    /// Permanently delete a filter rule and stop all associated polling. This action cannot be undone.
    /// `DELETE /v1/twitter/stream/filter-rules/{rule_id}`
    pub async fn delete_filter_rule(
        &self,
        rule_id: impl AsRef<str>,
        params: DeleteFilterRuleParams,
    ) -> Result<Value> {
        let path = format!(
            "/v1/twitter/stream/filter-rules/{rule_id}",
            rule_id = rule_id.as_ref()
        );
        let query: Vec<(String, String)> = Vec::new();
        let body = None;
        self.client.send(Method::DELETE, &path, &query, body).await
    }

    /// Get filter rule delivery logs
    ///
    /// List tweet delivery logs for a specific filter rule. Shows each detected tweet with detection latency, delivery status, and webhook response details.
    /// `GET /v1/twitter/stream/filter-rules/{rule_id}/logs`
    pub async fn get_filter_rule_delivery_logs(
        &self,
        rule_id: impl AsRef<str>,
        params: GetFilterRuleDeliveryLogsParams,
    ) -> Result<GetFilterRuleDeliveryLogsResponse> {
        let path = format!(
            "/v1/twitter/stream/filter-rules/{rule_id}/logs",
            rule_id = rule_id.as_ref()
        );
        let mut q = QueryParams::new();
        q.opt("page", params.page.as_ref());
        q.opt("page_size", params.page_size.as_ref());
        q.opt("author_username", params.author_username.as_ref());
        q.opt("delivery_status", params.delivery_status.as_ref());
        q.opt("sort", params.sort.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// List delivery logs
    ///
    /// List tweet delivery logs for stream monitors. Shows each detected tweet with detection latency, delivery status, and webhook response details. Useful for monitoring stream health and debugging delivery issues.
    /// `GET /v1/twitter/stream/logs`
    pub async fn list_stream_delivery_logs(
        &self,
        params: ListStreamDeliveryLogsParams,
    ) -> Result<ListStreamDeliveryLogsResponse> {
        let path = "/v1/twitter/stream/logs".to_string();
        let mut q = QueryParams::new();
        q.opt("monitor_id", params.monitor_id.as_ref());
        q.opt("page", params.page.as_ref());
        q.opt("page_size", params.page_size.as_ref());
        q.opt("author_username", params.author_username.as_ref());
        q.opt("delivery_status", params.delivery_status.as_ref());
        q.opt("sort", params.sort.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// List stream monitors
    ///
    /// List all stream monitors for the authenticated API key. Supports pagination and optional filtering by status.
    /// `GET /v1/twitter/stream/monitors`
    pub async fn list_stream_monitors(
        &self,
        params: ListStreamMonitorsParams,
    ) -> Result<ListStreamMonitorsResponse> {
        let path = "/v1/twitter/stream/monitors".to_string();
        let mut q = QueryParams::new();
        q.opt("page", params.page.as_ref());
        q.opt("page_size", params.page_size.as_ref());
        q.opt("status", params.status.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Create stream monitor
    ///
    /// Create a new stream monitor to track one or more Twitter accounts in real time. New tweets from monitored accounts are delivered via WebSocket and optionally via webhook. Each monitored account consumes credits per day based on volume pricing.
    /// `POST /v1/twitter/stream/monitors`
    pub async fn create_stream_monitor(
        &self,
        params: CreateStreamMonitorParams,
    ) -> Result<StreamMonitorResponse> {
        let path = "/v1/twitter/stream/monitors".to_string();
        let query: Vec<(String, String)> = Vec::new();
        let mut body = serde_json::Map::new();
        if let Some(v) = &params.filter_types {
            body.insert("filter_types".to_string(), serde_json::json!(v));
        }
        if let Some(v) = &params.name {
            body.insert("name".to_string(), serde_json::json!(v));
        }
        if let Some(v) = &params.usernames {
            body.insert("usernames".to_string(), serde_json::json!(v));
        }
        if let Some(v) = &params.webhook_secret {
            body.insert("webhook_secret".to_string(), serde_json::json!(v));
        }
        if let Some(v) = &params.webhook_url {
            body.insert("webhook_url".to_string(), serde_json::json!(v));
        }
        let body = if body.is_empty() {
            None
        } else {
            Some(Value::Object(body))
        };
        self.client.send(Method::POST, &path, &query, body).await
    }

    /// Get stream monitor
    ///
    /// Retrieve details of a specific stream monitor by its ID. Returns full monitor configuration, status, and pricing information.
    /// `GET /v1/twitter/stream/monitors/{monitor_id}`
    pub async fn get_stream_monitor(
        &self,
        monitor_id: impl AsRef<str>,
        params: GetStreamMonitorParams,
    ) -> Result<StreamMonitorResponse> {
        let path = format!(
            "/v1/twitter/stream/monitors/{monitor_id}",
            monitor_id = monitor_id.as_ref()
        );
        let query: Vec<(String, String)> = Vec::new();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Update stream monitor
    ///
    /// Update an existing stream monitor. All fields are optional; only provided fields will be updated. Use status field to pause or resume monitoring.
    /// `PATCH /v1/twitter/stream/monitors/{monitor_id}`
    pub async fn update_stream_monitor(
        &self,
        monitor_id: impl AsRef<str>,
        params: UpdateStreamMonitorParams,
    ) -> Result<StreamMonitorResponse> {
        let path = format!(
            "/v1/twitter/stream/monitors/{monitor_id}",
            monitor_id = monitor_id.as_ref()
        );
        let query: Vec<(String, String)> = Vec::new();
        let mut body = serde_json::Map::new();
        if let Some(v) = &params.filter_types {
            body.insert("filter_types".to_string(), serde_json::json!(v));
        }
        if let Some(v) = &params.name {
            body.insert("name".to_string(), serde_json::json!(v));
        }
        if let Some(v) = &params.status {
            body.insert("status".to_string(), serde_json::json!(v));
        }
        if let Some(v) = &params.usernames {
            body.insert("usernames".to_string(), serde_json::json!(v));
        }
        if let Some(v) = &params.webhook_secret {
            body.insert("webhook_secret".to_string(), serde_json::json!(v));
        }
        if let Some(v) = &params.webhook_url {
            body.insert("webhook_url".to_string(), serde_json::json!(v));
        }
        let body = if body.is_empty() {
            None
        } else {
            Some(Value::Object(body))
        };
        self.client.send(Method::PATCH, &path, &query, body).await
    }

    /// Delete stream monitor
    ///
    /// Permanently delete a stream monitor and stop all associated monitoring. This action cannot be undone.
    /// `DELETE /v1/twitter/stream/monitors/{monitor_id}`
    pub async fn delete_stream_monitor(
        &self,
        monitor_id: impl AsRef<str>,
        params: DeleteStreamMonitorParams,
    ) -> Result<Value> {
        let path = format!(
            "/v1/twitter/stream/monitors/{monitor_id}",
            monitor_id = monitor_id.as_ref()
        );
        let query: Vec<(String, String)> = Vec::new();
        let body = None;
        self.client.send(Method::DELETE, &path, &query, body).await
    }

    /// List webhooks
    ///
    /// List all webhooks for the authenticated API key. Optionally filter by monitor ID.
    /// `GET /v1/twitter/stream/webhooks`
    pub async fn list_stream_webhooks(
        &self,
        params: ListStreamWebhooksParams,
    ) -> Result<ListStreamWebhooksResponse> {
        let path = "/v1/twitter/stream/webhooks".to_string();
        let mut q = QueryParams::new();
        q.opt("monitor_id", params.monitor_id.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Create webhook
    ///
    /// Create a new webhook endpoint for a stream monitor. Webhooks receive HMAC-SHA256 signed POST requests when new tweets are detected.
    /// `POST /v1/twitter/stream/webhooks`
    pub async fn create_stream_webhook(
        &self,
        params: CreateStreamWebhookParams,
    ) -> Result<WebhookResponse> {
        let path = "/v1/twitter/stream/webhooks".to_string();
        let query: Vec<(String, String)> = Vec::new();
        let mut body = serde_json::Map::new();
        if let Some(v) = &params.monitor_id {
            body.insert("monitor_id".to_string(), serde_json::json!(v));
        }
        if let Some(v) = &params.secret {
            body.insert("secret".to_string(), serde_json::json!(v));
        }
        if let Some(v) = &params.url {
            body.insert("url".to_string(), serde_json::json!(v));
        }
        let body = if body.is_empty() {
            None
        } else {
            Some(Value::Object(body))
        };
        self.client.send(Method::POST, &path, &query, body).await
    }

    /// Test webhook
    ///
    /// Send a test payload to the webhook configured for a stream monitor. Returns the HTTP status code and response time from the webhook endpoint. Useful for verifying webhook connectivity before going live.
    /// `POST /v1/twitter/stream/webhooks/test`
    pub async fn test_stream_webhook(
        &self,
        params: TestStreamWebhookParams,
    ) -> Result<TestStreamWebhookResponse> {
        let path = "/v1/twitter/stream/webhooks/test".to_string();
        let query: Vec<(String, String)> = Vec::new();
        let mut body = serde_json::Map::new();
        if let Some(v) = &params.monitor_id {
            body.insert("monitor_id".to_string(), serde_json::json!(v));
        }
        let body = if body.is_empty() {
            None
        } else {
            Some(Value::Object(body))
        };
        self.client.send(Method::POST, &path, &query, body).await
    }

    /// Delete webhook
    ///
    /// Permanently delete a webhook endpoint. The stream monitor will continue operating but will no longer deliver to this webhook URL.
    /// `DELETE /v1/twitter/stream/webhooks/{webhook_id}`
    pub async fn delete_stream_webhook(
        &self,
        webhook_id: impl AsRef<str>,
        params: DeleteStreamWebhookParams,
    ) -> Result<Value> {
        let path = format!(
            "/v1/twitter/stream/webhooks/{webhook_id}",
            webhook_id = webhook_id.as_ref()
        );
        let query: Vec<(String, String)> = Vec::new();
        let body = None;
        self.client.send(Method::DELETE, &path, &query, body).await
    }

    /// Get trending topics
    ///
    /// Get current trending topics on Twitter. Results can be filtered by category: trending (default), for-you, news, sports, or entertainment. Returns trend names, tweet counts, and context information.
    /// `GET /v1/twitter/trends/`
    pub async fn get_trends(&self, params: GetTrendsParams) -> Result<TrendsResponse> {
        let path = "/v1/twitter/trends/".to_string();
        let mut q = QueryParams::new();
        q.opt("category", params.category.as_ref());
        q.opt("count", params.count.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get trends by location
    ///
    /// Get trending topics for a specific geographic location identified by its WOEID (Where On Earth ID). Returns location-specific trends including trend names, tweet volumes, and search URLs. Use WOEID 1 for worldwide trends, or 23424977 for United States.
    /// `GET /v1/twitter/trends/place/{woeid}`
    pub async fn get_trends_by_place(
        &self,
        woeid: impl AsRef<str>,
        params: GetTrendsByPlaceParams,
    ) -> Result<PlaceTrendsData> {
        let path = format!("/v1/twitter/trends/place/{woeid}", woeid = woeid.as_ref());
        let query: Vec<(String, String)> = Vec::new();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get tweets by IDs
    ///
    /// Retrieve multiple tweets by their IDs in a single request. Returns comprehensive tweet data for each requested ID including text, media attachments, engagement metrics, and all available metadata. Useful for bulk tweet lookups and monitoring specific tweets.
    /// `GET /v1/twitter/tweets/`
    pub async fn get_tweets_by_ids(&self, params: GetTweetsByIdsParams) -> Result<TweetsResponse> {
        let path = "/v1/twitter/tweets/".to_string();
        let mut q = QueryParams::new();
        q.opt("tweets", params.tweets.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Advanced tweet search
    ///
    /// Search for tweets using advanced query syntax. Supports filtering by Top, Latest, or Media results. Use Twitter's advanced search operators in the query (e.g., `from:username`, `since:2024-01-01`, `min_faves:100`). Essential for monitoring, research, and content discovery.
    /// `GET /v1/twitter/tweets/advanced_search`
    pub async fn advanced_search_tweets(
        &self,
        params: AdvancedSearchTweetsParams,
    ) -> Result<TweetsResponse> {
        let path = "/v1/twitter/tweets/advanced_search".to_string();
        let mut q = QueryParams::new();
        q.opt("query", params.query.as_ref());
        q.opt("query_type", params.query_type.as_ref());
        q.opt("count", params.count.as_ref());
        q.opt("cursor", params.cursor.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get article by ID
    ///
    /// Get a Twitter Article (long-form post) by its unique ID. Returns the full article content including title, body text, cover image, and author information. Twitter Articles are long-form content published directly on the platform.
    /// `GET /v1/twitter/tweets/article/{article_id}`
    pub async fn get_article_detail(
        &self,
        article_id: impl AsRef<str>,
        params: GetArticleDetailParams,
    ) -> Result<ArticleData> {
        let path = format!(
            "/v1/twitter/tweets/article/{article_id}",
            article_id = article_id.as_ref()
        );
        let query: Vec<(String, String)> = Vec::new();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get tweet details
    ///
    /// Fetch detailed information about a single tweet. Returns comprehensive tweet data including author info, engagement stats, media attachments, polls, referenced tweets, and edit history. Use this for deep inspection of individual tweets.
    /// `GET /v1/twitter/tweets/tweet/{tweet_id}`
    pub async fn get_tweet_detail(
        &self,
        tweet_id: impl AsRef<str>,
        params: GetTweetDetailParams,
    ) -> Result<TweetData> {
        let path = format!(
            "/v1/twitter/tweets/tweet/{tweet_id}",
            tweet_id = tweet_id.as_ref()
        );
        let mut q = QueryParams::new();
        q.opt("cursor", params.cursor.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get community notes
    ///
    /// Get community notes (formerly Birdwatch) attached to a specific tweet. Community notes provide crowd-sourced context and fact-checking for tweets. Returns note text, status, and creation date.
    /// `GET /v1/twitter/tweets/tweet/{tweet_id}/community_notes`
    pub async fn get_tweet_community_notes(
        &self,
        tweet_id: impl AsRef<str>,
        params: GetTweetCommunityNotesParams,
    ) -> Result<CommunityNotesResponse> {
        let path = format!(
            "/v1/twitter/tweets/tweet/{tweet_id}/community_notes",
            tweet_id = tweet_id.as_ref()
        );
        let query: Vec<(String, String)> = Vec::new();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get tweet edit history
    ///
    /// Get the edit history of a tweet. Returns all versions of the tweet in chronological order, from the original to the most recent edit. Useful for tracking changes to tweet content over time.
    /// `GET /v1/twitter/tweets/tweet/{tweet_id}/edit_history`
    pub async fn get_tweet_edit_history(
        &self,
        tweet_id: impl AsRef<str>,
        params: GetTweetEditHistoryParams,
    ) -> Result<TweetsResponse> {
        let path = format!(
            "/v1/twitter/tweets/tweet/{tweet_id}/edit_history",
            tweet_id = tweet_id.as_ref()
        );
        let query: Vec<(String, String)> = Vec::new();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get tweet favoriters
    ///
    /// Get the list of users who favorited (liked) a specific tweet. Returns comprehensive user profile data for each user who liked the tweet. Useful for audience analysis and engagement tracking.
    /// `GET /v1/twitter/tweets/tweet/{tweet_id}/favoriters`
    pub async fn get_tweet_favoriters(
        &self,
        tweet_id: impl AsRef<str>,
        params: GetTweetFavoritersParams,
    ) -> Result<UsersResponse> {
        let path = format!(
            "/v1/twitter/tweets/tweet/{tweet_id}/favoriters",
            tweet_id = tweet_id.as_ref()
        );
        let mut q = QueryParams::new();
        q.opt("cursor", params.cursor.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get tweet quotes
    ///
    /// Get tweets that quote the specified tweet. Returns comprehensive tweet data for each quote tweet including text, media, engagement metrics, and author information. Useful for tracking how a tweet is being discussed and shared.
    /// `GET /v1/twitter/tweets/tweet/{tweet_id}/quotes`
    pub async fn get_tweet_quotes(
        &self,
        tweet_id: impl AsRef<str>,
        params: GetTweetQuotesParams,
    ) -> Result<TweetsResponse> {
        let path = format!(
            "/v1/twitter/tweets/tweet/{tweet_id}/quotes",
            tweet_id = tweet_id.as_ref()
        );
        let mut q = QueryParams::new();
        q.opt("cursor", params.cursor.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get tweet replies
    ///
    /// Get replies to a specific tweet. Returns comprehensive tweet data for each reply including text, media, engagement metrics, and author information. Supports pagination for tweets with many replies.
    /// `GET /v1/twitter/tweets/tweet/{tweet_id}/replies`
    pub async fn get_tweet_replies(
        &self,
        tweet_id: impl AsRef<str>,
        params: GetTweetRepliesParams,
    ) -> Result<TweetsResponse> {
        let path = format!(
            "/v1/twitter/tweets/tweet/{tweet_id}/replies",
            tweet_id = tweet_id.as_ref()
        );
        let mut q = QueryParams::new();
        q.opt("cursor", params.cursor.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get tweet retweeters
    ///
    /// Get the list of users who retweeted a specific tweet. Returns comprehensive user profile data for each retweeter with pagination support. Useful for analyzing tweet reach and audience engagement.
    /// `GET /v1/twitter/tweets/tweet/{tweet_id}/retweeters`
    pub async fn get_tweet_retweeters(
        &self,
        tweet_id: impl AsRef<str>,
        params: GetTweetRetweetersParams,
    ) -> Result<UsersResponse> {
        let path = format!(
            "/v1/twitter/tweets/tweet/{tweet_id}/retweeters",
            tweet_id = tweet_id.as_ref()
        );
        let mut q = QueryParams::new();
        q.opt("cursor", params.cursor.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get similar tweets
    ///
    /// Get tweets that are similar in content or topic to the specified tweet. Returns tweets that Twitter's algorithm considers related. Useful for content discovery and topic analysis.
    /// `GET /v1/twitter/tweets/tweet/{tweet_id}/similar`
    pub async fn get_similar_tweets(
        &self,
        tweet_id: impl AsRef<str>,
        params: GetSimilarTweetsParams,
    ) -> Result<TweetsResponse> {
        let path = format!(
            "/v1/twitter/tweets/tweet/{tweet_id}/similar",
            tweet_id = tweet_id.as_ref()
        );
        let query: Vec<(String, String)> = Vec::new();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Batch get users by IDs
    ///
    /// Fetch multiple user profiles by their numeric IDs in a single request. Returns comprehensive user profile data for each requested ID. More efficient than making individual requests when you need data for multiple users.
    /// `GET /v1/twitter/users/batch_by_ids`
    pub async fn get_users_by_ids(&self, params: GetUsersByIdsParams) -> Result<UsersResponse> {
        let path = "/v1/twitter/users/batch_by_ids".to_string();
        let mut q = QueryParams::new();
        q.opt("user_ids", params.user_ids.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Batch get users by usernames
    ///
    /// Fetch multiple user profiles by their usernames (screen names) in a single request. Returns comprehensive user profile data for each requested username. More efficient than making individual requests when you need data for multiple users.
    /// `GET /v1/twitter/users/batch_by_usernames`
    pub async fn get_users_by_usernames(
        &self,
        params: GetUsersByUsernamesParams,
    ) -> Result<UsersResponse> {
        let path = "/v1/twitter/users/batch_by_usernames".to_string();
        let mut q = QueryParams::new();
        q.opt("usernames", params.usernames.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Search users
    ///
    /// Search for users by username, display name, or keywords in their bio. Returns matching user profiles with comprehensive data. Useful for finding accounts related to specific topics or interests.
    /// `GET /v1/twitter/users/search_users`
    pub async fn search_users(&self, params: SearchUsersParams) -> Result<UsersResponse> {
        let path = "/v1/twitter/users/search_users".to_string();
        let mut q = QueryParams::new();
        q.opt("query", params.query.as_ref());
        q.opt("cursor", params.cursor.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get user articles
    ///
    /// Get long-form articles (Twitter Articles) written by a specific user. Returns article metadata including title, body text, cover image, and publication date. Requires the user's numeric ID.
    /// `GET /v1/twitter/users/{user_id}/articles`
    pub async fn get_user_articles(
        &self,
        user_id: impl AsRef<str>,
        params: GetUserArticlesParams,
    ) -> Result<ArticlesResponse> {
        let path = format!(
            "/v1/twitter/users/{user_id}/articles",
            user_id = user_id.as_ref()
        );
        let mut q = QueryParams::new();
        q.opt("cursor", params.cursor.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get user by ID
    ///
    /// Get a user profile by their numeric Twitter ID. Returns comprehensive profile data including bio, follower/following counts, verification status, and account metadata. Use this when you have the numeric ID and need full profile details.
    /// `GET /v1/twitter/users/{user_id}/by_id`
    pub async fn get_user_by_id(
        &self,
        user_id: impl AsRef<str>,
        params: GetUserByIdParams,
    ) -> Result<UserData> {
        let path = format!(
            "/v1/twitter/users/{user_id}/by_id",
            user_id = user_id.as_ref()
        );
        let query: Vec<(String, String)> = Vec::new();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get user subscriptions
    ///
    /// Get the premium account subscriptions for a specific user. Returns the list of accounts that the user subscribes to for premium content. Requires the user's numeric ID.
    /// `GET /v1/twitter/users/{user_id}/subscriptions`
    pub async fn get_user_subscriptions(
        &self,
        user_id: impl AsRef<str>,
        params: GetUserSubscriptionsParams,
    ) -> Result<UsersResponse> {
        let path = format!(
            "/v1/twitter/users/{user_id}/subscriptions",
            user_id = user_id.as_ref()
        );
        let mut q = QueryParams::new();
        q.opt("cursor", params.cursor.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get user by username
    ///
    /// Get a user profile by their username (screen name). Returns comprehensive profile data including bio, follower/following counts, verification status, and account metadata. The most common way to look up a user profile.
    /// `GET /v1/twitter/users/{username}/by_username`
    pub async fn get_user_by_username(
        &self,
        username: impl AsRef<str>,
        params: GetUserByUsernameParams,
    ) -> Result<UserData> {
        let path = format!(
            "/v1/twitter/users/{username}/by_username",
            username = username.as_ref()
        );
        let query: Vec<(String, String)> = Vec::new();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get user followers
    ///
    /// Get the list of followers for a specific user. Returns comprehensive user profile data for each follower with pagination support. Useful for audience analysis and social graph exploration.
    /// `GET /v1/twitter/users/{username}/followers`
    pub async fn get_user_followers(
        &self,
        username: impl AsRef<str>,
        params: GetUserFollowersParams,
    ) -> Result<UsersResponse> {
        let path = format!(
            "/v1/twitter/users/{username}/followers",
            username = username.as_ref()
        );
        let mut q = QueryParams::new();
        q.opt("cursor", params.cursor.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get user following
    ///
    /// Get the list of users that a specific user is following. Returns comprehensive user profile data for each followed account with pagination support. Useful for understanding a user's interests and network.
    /// `GET /v1/twitter/users/{username}/followings`
    pub async fn get_user_followings(
        &self,
        username: impl AsRef<str>,
        params: GetUserFollowingsParams,
    ) -> Result<UsersResponse> {
        let path = format!(
            "/v1/twitter/users/{username}/followings",
            username = username.as_ref()
        );
        let mut q = QueryParams::new();
        q.opt("cursor", params.cursor.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get user tweets
    ///
    /// Get the latest tweets from a specific user's timeline. Returns comprehensive tweet data including text, media, engagement metrics, and all metadata. Supports pagination to retrieve the full tweet history.
    /// `GET /v1/twitter/users/{username}/latest_tweets`
    pub async fn get_user_latest_tweets(
        &self,
        username: impl AsRef<str>,
        params: GetUserLatestTweetsParams,
    ) -> Result<TweetsResponse> {
        let path = format!(
            "/v1/twitter/users/{username}/latest_tweets",
            username = username.as_ref()
        );
        let mut q = QueryParams::new();
        q.opt("cursor", params.cursor.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get user mentions
    ///
    /// Get tweets that mention a specific user. Returns tweets containing @username from the latest search results. Useful for monitoring brand mentions, tracking conversations, and reputation management.
    /// `GET /v1/twitter/users/{username}/mentions`
    pub async fn get_user_mentions(
        &self,
        username: impl AsRef<str>,
        params: GetUserMentionsParams,
    ) -> Result<TweetsResponse> {
        let path = format!(
            "/v1/twitter/users/{username}/mentions",
            username = username.as_ref()
        );
        let mut q = QueryParams::new();
        q.opt("count", params.count.as_ref());
        q.opt("cursor", params.cursor.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }
}

// ===== Models =====

/// Allowed values for a fixed-value query parameter.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum AdvancedSearchTweetsQueryType {
    /// `Top`
    Top,
    /// `Latest`
    Latest,
    /// `Media`
    Media,
}

impl std::fmt::Display for AdvancedSearchTweetsQueryType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(match self {
            AdvancedSearchTweetsQueryType::Top => "Top",
            AdvancedSearchTweetsQueryType::Latest => "Latest",
            AdvancedSearchTweetsQueryType::Media => "Media",
        })
    }
}

/// Twitter Article (long-form post) data.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct ArticleData {
    /// Numeric ID of the article author.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub author_id: Option<String>,
    /// Display name of the article author.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub author_name: Option<String>,
    /// Username of the article author.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub author_username: Option<String>,
    /// URL of the article's cover image.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub cover_image_url: Option<String>,
    /// Timestamp when the article was published.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub created_at: Option<String>,
    /// Unique article identifier.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub id: Option<String>,
    /// Full body text of the article.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub text: Option<String>,
    /// Title of the article.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub title: Option<String>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Paginated list of articles.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct ArticlesResponse {
    /// Array of article objects.
    pub data: Option<Vec<ArticleData>>,
    /// Cursor for fetching the next page. Null if no more results.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub next_cursor: Option<String>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Billing log entry for a stream monitor credit deduction.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct BillingLogResponse {
    /// Timestamp of the billing event.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub billed_at: Option<String>,
    /// Total credits deducted in this billing cycle.
    #[serde(default, deserialize_with = "crate::core::flex::opt_f64")]
    pub credits_deducted: Option<f64>,
    /// Unique billing log identifier.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub id: Option<String>,
    /// ID of the stream monitor.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub monitor_id: Option<String>,
    /// Name of the stream monitor.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub monitor_name: Option<String>,
    /// Number of monitored accounts at the time of billing.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub num_accounts: Option<i64>,
    /// Credit rate per account per day that was applied.
    #[serde(default, deserialize_with = "crate::core::flex::opt_f64")]
    pub rate_applied: Option<f64>,
    /// Pricing tier label applied.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub tier_label: Option<String>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Live video broadcast data.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct BroadcastData {
    /// Timestamp when the broadcast was created.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub created_at: Option<String>,
    /// Video height in pixels.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub height: Option<i64>,
    /// Unique broadcast identifier.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub id: Option<String>,
    /// Media key for the broadcast stream.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub media_key: Option<String>,
    /// Timestamp when the broadcast started.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub started_at: Option<String>,
    /// Current state of the broadcast (e.g., running, ended).
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub state: Option<String>,
    /// Title of the broadcast.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub title: Option<String>,
    /// Total number of viewers.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub total_viewers: Option<i64>,
    /// Video width in pixels.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub width: Option<i64>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Paginated list of communities.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct CommunitiesResponse {
    /// Array of community objects.
    pub data: Option<Vec<CommunityData>>,
    /// Cursor for fetching the next page. Null if no more results.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub next_cursor: Option<String>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Community banner image information.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct CommunityBanner {
    /// Height of the banner in pixels.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub height: Option<i64>,
    /// URL of the banner image.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub url: Option<String>,
    /// Width of the banner in pixels.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub width: Option<i64>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Comprehensive Twitter community data.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct CommunityData {
    /// Numeric ID of the community admin.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub admin_id: Option<String>,
    /// Display name of the community admin.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub admin_name: Option<String>,
    /// Username of the community admin.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub admin_username: Option<String>,
    /// Community banner image.
    pub banner: Option<CommunityBanner>,
    /// Creation timestamp in milliseconds.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub created_at: Option<i64>,
    /// Creation date in ISO 8601 format.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub created_at_datetime: Option<String>,
    /// Numeric ID of the community creator.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub creator_id: Option<String>,
    /// Display name of the community creator.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub creator_name: Option<String>,
    /// Username of the community creator.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub creator_username: Option<String>,
    /// Description of the community.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub description: Option<String>,
    /// Unique community identifier.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub id: Option<String>,
    /// Invites policy for the community.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub invites_policy: Option<String>,
    /// Whether the authenticated user is a member.
    #[serde(default, deserialize_with = "crate::core::flex::opt_bool")]
    pub is_member: Option<bool>,
    /// Whether the community is marked as NSFW.
    #[serde(default, deserialize_with = "crate::core::flex::opt_bool")]
    pub is_nsfw: Option<bool>,
    /// Join policy for the community.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub join_policy: Option<String>,
    /// Number of members.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub member_count: Option<i64>,
    /// Name of the community.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub name: Option<String>,
    /// Role of the authenticated user.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub role: Option<String>,
    /// Community rules.
    pub rules: Option<Vec<CommunityRule>>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Community note (fact-check) data.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct CommunityNoteData {
    /// Timestamp when the note was created.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub created_at: Option<String>,
    /// Unique note identifier.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub id: Option<String>,
    /// Current status of the note.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub status: Option<String>,
    /// Text content of the community note.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub text: Option<String>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// List of community notes for a tweet.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct CommunityNotesResponse {
    /// Array of community note objects.
    pub data: Option<Vec<CommunityNoteData>>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// A community rule.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct CommunityRule {
    /// Detailed description of the rule.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub description: Option<String>,
    /// Name/title of the rule.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub name: Option<String>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Error response returned for failed requests.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct ErrorResponse {
    /// Human-readable error message describing what went wrong.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub error: Option<String>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Log entry for a tweet delivered by a filter rule.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct FilterRuleDeliveryLogResponse {
    /// Username of the tweet author.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub author_username: Option<String>,
    /// Overall delivery status (e.g., "delivered", "failed", "pending").
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub delivery_status: Option<String>,
    /// Timestamp when the tweet was detected by the filter rule.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub detected_at: Option<String>,
    /// Unique log entry identifier.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub id: Option<String>,
    /// Human-readable latency badge (e.g., "fast", "normal", "slow").
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub latency_badge: Option<String>,
    /// Detection latency in milliseconds.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub latency_ms: Option<i64>,
    /// ID of the filter rule that matched the tweet.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub rule_id: Option<String>,
    /// Tag label of the filter rule.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub rule_tag: Option<String>,
    /// ID of the matched tweet.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub tweet_id: Option<String>,
    /// Timestamp when the tweet was originally published.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub tweet_published_at: Option<String>,
    /// Truncated preview of the tweet text.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub tweet_text_preview: Option<String>,
    /// Full URL to the tweet on Twitter/X.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub tweet_url: Option<String>,
    /// Number of webhook delivery attempts.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub webhook_attempts: Option<i64>,
    /// HTTP status code returned by the webhook endpoint, if applicable.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub webhook_status_code: Option<i64>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Filter rule configuration and status.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct FilterRuleResponse {
    /// Timestamp when the rule was created.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub created_at: Option<String>,
    /// Credit cost per day for this rule at the current interval.
    #[serde(default, deserialize_with = "crate::core::flex::opt_f64")]
    pub credits_per_rule_per_day: Option<f64>,
    /// Unique filter rule identifier.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub id: Option<String>,
    /// Polling interval in seconds.
    #[serde(default, deserialize_with = "crate::core::flex::opt_f64")]
    pub interval_seconds: Option<f64>,
    /// Maximum number of tweets returned per poll cycle.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub max_results_per_poll: Option<i64>,
    /// Current pricing tier label based on interval.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub pricing_tier: Option<String>,
    /// Twitter Advanced Search query.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub query: Option<String>,
    /// Current status of the rule. Suspended indicates the rule was auto-paused due to insufficient credits.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub status: Option<String>,
    /// Reason for the current status, if applicable.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub status_reason: Option<String>,
    /// Human-readable label for the rule.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub tag: Option<String>,
    /// Timestamp when the rule was last updated.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub updated_at: Option<String>,
    /// Whether a webhook secret is configured. The actual secret is never returned.
    #[serde(default, deserialize_with = "crate::core::flex::opt_bool")]
    pub webhook_secret_set: Option<bool>,
    /// HTTPS URL receiving webhook deliveries.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub webhook_url: Option<String>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Allowed values for a fixed-value query parameter.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum GetCommunityTweetsTweetType {
    /// `Top`
    Top,
    /// `Latest`
    Latest,
    /// `Media`
    Media,
}

impl std::fmt::Display for GetCommunityTweetsTweetType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(match self {
            GetCommunityTweetsTweetType::Top => "Top",
            GetCommunityTweetsTweetType::Latest => "Latest",
            GetCommunityTweetsTweetType::Media => "Media",
        })
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct GetFilterRuleDeliveryLogsResponse {
    pub logs: Vec<FilterRuleDeliveryLogResponse>,
    /// Current page number.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub page: Option<i64>,
    /// Number of items per page.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub page_size: Option<i64>,
    /// Total number of delivery logs.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub total: Option<i64>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Allowed values for a fixed-value query parameter.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum GetFilterRuleDeliveryLogsSort {
    /// `asc`
    #[serde(rename = "asc")]
    Asc,
    /// `desc`
    #[serde(rename = "desc")]
    Desc,
}

impl std::fmt::Display for GetFilterRuleDeliveryLogsSort {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(match self {
            GetFilterRuleDeliveryLogsSort::Asc => "asc",
            GetFilterRuleDeliveryLogsSort::Desc => "desc",
        })
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct GetFilterRulePricingTiersResponse {
    /// List of pricing tiers ordered by interval.
    pub tiers: Vec<GetFilterRulePricingTiersResponseTiersItem>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct GetFilterRulePricingTiersResponseTiersItem {
    /// Credit cost per rule per day at this tier.
    #[serde(default, deserialize_with = "crate::core::flex::opt_f64")]
    pub credits_per_rule_per_day: Option<f64>,
    /// Maximum polling interval for this tier in seconds.
    #[serde(default, deserialize_with = "crate::core::flex::opt_f64")]
    pub max_interval_seconds: Option<f64>,
    /// Human-readable tier name.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub tier_label: Option<String>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Allowed values for a fixed-value query parameter.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum GetTrendsCategory {
    /// `trending`
    #[serde(rename = "trending")]
    Trending,
    /// `for-you`
    #[serde(rename = "for-you")]
    ForYou,
    /// `news`
    #[serde(rename = "news")]
    News,
    /// `sports`
    #[serde(rename = "sports")]
    Sports,
    /// `entertainment`
    #[serde(rename = "entertainment")]
    Entertainment,
}

impl std::fmt::Display for GetTrendsCategory {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(match self {
            GetTrendsCategory::Trending => "trending",
            GetTrendsCategory::ForYou => "for-you",
            GetTrendsCategory::News => "news",
            GetTrendsCategory::Sports => "sports",
            GetTrendsCategory::Entertainment => "entertainment",
        })
    }
}

/// Hashtag entity in a tweet.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct Hashtag {
    /// Start and end positions of the hashtag in the tweet text.
    pub indices: Option<Vec<i64>>,
    /// The hashtag text (without the # symbol).
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub text: Option<String>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Twitter list metadata.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct ListData {
    /// Timestamp when the list was created.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub created_at: Option<String>,
    /// Description of the list.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub description: Option<String>,
    /// Unique list identifier.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub id: Option<String>,
    /// Number of members in the list.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub member_count: Option<i64>,
    /// Visibility mode of the list.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub mode: Option<String>,
    /// Name of the list.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub name: Option<String>,
    /// Number of subscribers to the list.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub subscriber_count: Option<i64>,
    /// Numeric ID of the list owner.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub user_id: Option<String>,
    /// Username of the list owner.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub username: Option<String>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct ListFilterRulesResponse {
    /// Current page number.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub page: Option<i64>,
    /// Number of items per page.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub page_size: Option<i64>,
    pub rules: Vec<FilterRuleResponse>,
    /// Total number of filter rules.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub total: Option<i64>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Allowed values for a fixed-value query parameter.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum ListFilterRulesStatus {
    /// `active`
    #[serde(rename = "active")]
    Active,
    /// `paused`
    #[serde(rename = "paused")]
    Paused,
}

impl std::fmt::Display for ListFilterRulesStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(match self {
            ListFilterRulesStatus::Active => "active",
            ListFilterRulesStatus::Paused => "paused",
        })
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct ListStreamBillingLogsResponse {
    pub logs: Vec<BillingLogResponse>,
    /// Current page number.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub page: Option<i64>,
    /// Number of items per page.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub page_size: Option<i64>,
    /// Total number of billing logs.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub total: Option<i64>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct ListStreamDeliveryLogsResponse {
    pub logs: Vec<TweetDeliveryLogResponse>,
    /// Current page number.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub page: Option<i64>,
    /// Number of items per page.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub page_size: Option<i64>,
    /// Total number of delivery logs.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub total: Option<i64>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Allowed values for a fixed-value query parameter.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum ListStreamDeliveryLogsSort {
    /// `asc`
    #[serde(rename = "asc")]
    Asc,
    /// `desc`
    #[serde(rename = "desc")]
    Desc,
}

impl std::fmt::Display for ListStreamDeliveryLogsSort {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(match self {
            ListStreamDeliveryLogsSort::Asc => "asc",
            ListStreamDeliveryLogsSort::Desc => "desc",
        })
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct ListStreamMonitorsResponse {
    pub monitors: Vec<StreamMonitorResponse>,
    /// Current page number.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub page: Option<i64>,
    /// Number of items per page.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub page_size: Option<i64>,
    /// Total number of monitors.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub total: Option<i64>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Allowed values for a fixed-value query parameter.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum ListStreamMonitorsStatus {
    /// `active`
    #[serde(rename = "active")]
    Active,
    /// `paused`
    #[serde(rename = "paused")]
    Paused,
}

impl std::fmt::Display for ListStreamMonitorsStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(match self {
            ListStreamMonitorsStatus::Active => "active",
            ListStreamMonitorsStatus::Paused => "paused",
        })
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct ListStreamWebhooksResponse {
    /// Total number of webhooks.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub total: Option<i64>,
    pub webhooks: Vec<WebhookListItem>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Media attachment in a tweet (photo, video, or animated GIF).
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct Media {
    /// Alt text description of the media.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub alt_text: Option<String>,
    /// Duration in milliseconds (for video/GIF).
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub duration_ms: Option<i64>,
    /// Height of the media in pixels.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub height: Option<i64>,
    /// Unique identifier for the media.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub media_key: Option<String>,
    /// URL of the preview/thumbnail image.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub preview_image_url: Option<String>,
    /// Type of media.
    #[serde(rename = "type")]
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub type_: Option<String>,
    /// URL of the media resource.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub url: Option<String>,
    /// Number of views (for video).
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub view_count: Option<i64>,
    /// Width of the media in pixels.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub width: Option<i64>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Geographic place information attached to a tweet.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct Place {
    /// Country name.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub country: Option<String>,
    /// ISO country code.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub country_code: Option<String>,
    /// Full human-readable place name.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub full_name: Option<String>,
    /// Unique place identifier.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub id: Option<String>,
    /// Short place name.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub name: Option<String>,
    /// Type of place.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub place_type: Option<String>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Geographic place data.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct PlaceData {
    /// Additional place attributes.
    pub attributes: Option<HashMap<String, String>>,
    /// Geographical bounding box coordinates.
    pub bounding_box: Option<PlaceDataBoundingBox>,
    /// Country name.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub country: Option<String>,
    /// ISO country code.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub country_code: Option<String>,
    /// Full place name including region.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub full_name: Option<String>,
    /// Unique place identifier.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub id: Option<String>,
    /// Place name.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub name: Option<String>,
    /// Type of place.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub place_type: Option<String>,
    /// Twitter URL for the place.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub url: Option<String>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Geographical bounding box coordinates.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct PlaceDataBoundingBox {
    /// Array of coordinate arrays defining the bounding box.
    pub coordinates: Vec<Vec<Vec<f64>>>,
    #[serde(rename = "type")]
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub type_: Option<String>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Trending topics for a specific geographic location.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct PlaceTrendsData {
    /// Country name.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub country: Option<String>,
    /// Name of the location.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub name: Option<String>,
    /// List of trending topics at this location.
    pub trends: Vec<TrendData>,
    /// Where On Earth ID of the location.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub woeid: Option<i64>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// List of geographic places.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct PlacesResponse {
    /// Array of place objects.
    pub data: Option<Vec<PlaceData>>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Poll data in a tweet.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct Poll {
    /// Total duration of the poll in minutes.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub duration_minutes: Option<i64>,
    /// When the poll ends or ended.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub end_datetime: Option<String>,
    /// Unique poll identifier.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub id: Option<String>,
    /// Poll options with vote counts.
    pub options: Vec<PollOption>,
    /// Current voting status.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub voting_status: Option<String>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// A single poll option with its vote count.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct PollOption {
    /// Text label of the poll option.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub label: Option<String>,
    /// Position of the option (1-indexed).
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub position: Option<i64>,
    /// Number of votes for this option.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub votes: Option<i64>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Twitter Space (audio room) data.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct SpaceData {
    /// Timestamp when the Space was created.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub created_at: Option<String>,
    /// Numeric ID of the Space creator.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub creator_id: Option<String>,
    /// Display name of the Space creator.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub creator_name: Option<String>,
    /// Username of the Space creator.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub creator_username: Option<String>,
    /// Timestamp when the Space ended.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub ended_at: Option<String>,
    /// Unique Space identifier.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub id: Option<String>,
    /// Whether the Space requires a ticket.
    #[serde(default, deserialize_with = "crate::core::flex::opt_bool")]
    pub is_ticketed: Option<bool>,
    /// Current number of participants.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub participant_count: Option<i64>,
    /// Scheduled start time for upcoming Spaces.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub scheduled_start: Option<String>,
    /// Timestamp when the Space started.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub started_at: Option<String>,
    /// Current state of the Space (e.g., live, scheduled, ended).
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub state: Option<String>,
    /// Title of the Space.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub title: Option<String>,
    /// Number of live listeners.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub total_live_listeners: Option<i64>,
    /// Total number of users who participated.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub total_participated: Option<i64>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Stream monitor configuration and status.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct StreamMonitorResponse {
    /// Timestamp when the monitor was created.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub created_at: Option<String>,
    /// Credit cost per monitored account per day.
    #[serde(default, deserialize_with = "crate::core::flex::opt_f64")]
    pub credits_per_account_per_day: Option<f64>,
    /// Estimated total credit cost per day based on current account count.
    #[serde(default, deserialize_with = "crate::core::flex::opt_f64")]
    pub estimated_credits_per_day: Option<f64>,
    /// Tweet types being delivered. Null means all types.
    pub filter_types: Option<Vec<String>>,
    /// Unique stream monitor identifier.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub id: Option<String>,
    /// Human-readable name of the monitor.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub name: Option<String>,
    /// Current pricing tier label.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub pricing_tier: Option<String>,
    /// Current status of the monitor. Suspended indicates the monitor was auto-paused due to insufficient credits.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub status: Option<String>,
    /// Reason for the current status, if applicable (e.g., "insufficient_credits").
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub status_reason: Option<String>,
    /// Timestamp when the monitor was last updated.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub updated_at: Option<String>,
    /// List of monitored Twitter usernames.
    pub usernames: Vec<String>,
    /// Whether a webhook secret is configured. The actual secret is never returned.
    #[serde(default, deserialize_with = "crate::core::flex::opt_bool")]
    pub webhook_secret_set: Option<bool>,
    /// HTTPS URL receiving webhook deliveries.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub webhook_url: Option<String>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct TestStreamWebhookResponse {
    /// Error message if the webhook test failed.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub error: Option<String>,
    /// Response time in milliseconds.
    #[serde(default, deserialize_with = "crate::core::flex::opt_f64")]
    pub response_time_ms: Option<f64>,
    /// HTTP status code returned by the webhook endpoint.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub status_code: Option<i64>,
    /// Whether the webhook responded with a 2xx status code.
    #[serde(default, deserialize_with = "crate::core::flex::opt_bool")]
    pub success: Option<bool>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// A single trending topic.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct TrendData {
    /// Contextual category of the trend (e.g., 'Entertainment', 'Sports').
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub domain_context: Option<String>,
    /// Name of the trending topic or hashtag.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub name: Option<String>,
    /// Search query string for this trend.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub query: Option<String>,
    /// Approximate number of tweets about this trend.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub tweet_count: Option<i64>,
    /// Twitter search URL for this trend.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub url: Option<String>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// List of trending topics.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct TrendsResponse {
    /// Array of trend objects.
    pub data: Option<Vec<TrendData>>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Comprehensive tweet data including text, author info, engagement metrics, media, and metadata.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct TweetData {
    /// Number of times this tweet has been bookmarked.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub bookmark_count: Option<i64>,
    /// Whether the authenticated user has bookmarked this tweet.
    #[serde(default, deserialize_with = "crate::core::flex::opt_bool")]
    pub bookmarked: Option<bool>,
    /// ID of the conversation thread this tweet belongs to.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub conversation_id: Option<String>,
    /// Timestamp when the tweet was created.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub created_at: Option<String>,
    /// List of tweet IDs in the edit chain.
    pub edit_tweet_ids: Option<Vec<String>>,
    /// Timestamp (milliseconds) until the tweet can be edited.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub editable_until_msecs: Option<i64>,
    /// Number of remaining edits allowed.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub edits_remaining: Option<i64>,
    /// Number of times this tweet has been liked.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub favorite_count: Option<i64>,
    /// Whether the authenticated user has liked this tweet.
    #[serde(default, deserialize_with = "crate::core::flex::opt_bool")]
    pub favorited: Option<bool>,
    /// Full text of the tweet, including extended content beyond 280 characters.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub full_text: Option<String>,
    /// Whether the tweet has a link preview card.
    #[serde(default, deserialize_with = "crate::core::flex::opt_bool")]
    pub has_card: Option<bool>,
    /// Whether the tweet has community notes attached.
    #[serde(default, deserialize_with = "crate::core::flex::opt_bool")]
    pub has_community_notes: Option<bool>,
    /// Hashtags in the tweet.
    pub hashtags: Vec<Hashtag>,
    /// Unique tweet identifier.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub id: Option<String>,
    /// ID of the tweet this is a reply to, if applicable.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub in_reply_to_status_id: Option<String>,
    /// ID of the user this tweet is replying to.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub in_reply_to_user_id: Option<String>,
    /// Whether the tweet is eligible for editing.
    #[serde(default, deserialize_with = "crate::core::flex::opt_bool")]
    pub is_edit_eligible: Option<bool>,
    /// Whether the tweet is a quote tweet.
    #[serde(default, deserialize_with = "crate::core::flex::opt_bool")]
    pub is_quote_status: Option<bool>,
    /// Whether the tweet is a retweet.
    #[serde(default, deserialize_with = "crate::core::flex::opt_bool")]
    pub is_retweet: Option<bool>,
    /// BCP 47 language tag of the tweet content.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub lang: Option<String>,
    /// Media attachments (photos, videos, GIFs).
    pub media: Vec<Media>,
    /// Geographic place associated with the tweet.
    pub place: Option<Place>,
    /// Poll data if the tweet contains a poll.
    pub poll: Option<Poll>,
    /// Whether the tweet is flagged as possibly containing sensitive content.
    #[serde(default, deserialize_with = "crate::core::flex::opt_bool")]
    pub possibly_sensitive: Option<bool>,
    /// Number of times this tweet has been quoted.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub quote_count: Option<i64>,
    /// ID of the quoted tweet, if this is a quote tweet.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub quoted_status_id: Option<String>,
    /// Number of replies to this tweet.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub reply_count: Option<i64>,
    /// Number of times this tweet has been retweeted.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub retweet_count: Option<i64>,
    /// Whether the authenticated user has retweeted this tweet.
    #[serde(default, deserialize_with = "crate::core::flex::opt_bool")]
    pub retweeted: Option<bool>,
    /// ID of the original tweet, if this is a retweet.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub retweeted_status_id: Option<String>,
    /// Client application used to post the tweet.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub source: Option<String>,
    /// The tweet text content.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub text: Option<String>,
    /// Title of the link preview card.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub thumbnail_title: Option<String>,
    /// URL of the link preview thumbnail.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub thumbnail_url: Option<String>,
    /// URLs mentioned in the tweet.
    pub urls: Vec<Url>,
    /// Numeric ID of the tweet author.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub user_id: Option<String>,
    /// Users mentioned in the tweet.
    pub user_mentions: Vec<UserMention>,
    /// Display name of the tweet author.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub user_name: Option<String>,
    /// Username (screen name) of the tweet author.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub username: Option<String>,
    /// Number of times this tweet has been viewed.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub view_count: Option<i64>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Log entry for a tweet delivered by a stream monitor.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct TweetDeliveryLogResponse {
    /// Username of the tweet author.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub author_username: Option<String>,
    /// Overall delivery status (e.g., "delivered", "failed", "pending").
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub delivery_status: Option<String>,
    /// Timestamp when the tweet was detected by the monitor.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub detected_at: Option<String>,
    /// Unique log entry identifier.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub id: Option<String>,
    /// Human-readable latency badge (e.g., "fast", "normal", "slow").
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub latency_badge: Option<String>,
    /// Detection latency in milliseconds (time between tweet publication and detection).
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub latency_ms: Option<i64>,
    /// ID of the stream monitor that detected the tweet.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub monitor_id: Option<String>,
    /// Name of the stream monitor.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub monitor_name: Option<String>,
    /// ID of the detected tweet.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub tweet_id: Option<String>,
    /// Timestamp when the tweet was originally published.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub tweet_published_at: Option<String>,
    /// Truncated preview of the tweet text.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub tweet_text_preview: Option<String>,
    /// Full URL to the tweet on Twitter/X.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub tweet_url: Option<String>,
    /// Number of webhook delivery attempts.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub webhook_attempts: Option<i64>,
    /// HTTP status code returned by the webhook endpoint, if applicable.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub webhook_status_code: Option<i64>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Paginated list of tweets.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct TweetsResponse {
    /// Array of tweet objects.
    pub data: Option<Vec<TweetData>>,
    /// Cursor for fetching the next page. Null if no more results.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub next_cursor: Option<String>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Set rule status. Use "paused" to stop polling and "active" to resume.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum UpdateFilterRuleStatus {
    /// `active`
    #[serde(rename = "active")]
    Active,
    /// `paused`
    #[serde(rename = "paused")]
    Paused,
}

impl std::fmt::Display for UpdateFilterRuleStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(match self {
            UpdateFilterRuleStatus::Active => "active",
            UpdateFilterRuleStatus::Paused => "paused",
        })
    }
}

/// Set monitor status. Use "paused" to stop monitoring and "active" to resume.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum UpdateStreamMonitorStatus {
    /// `active`
    #[serde(rename = "active")]
    Active,
    /// `paused`
    #[serde(rename = "paused")]
    Paused,
}

impl std::fmt::Display for UpdateStreamMonitorStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(match self {
            UpdateStreamMonitorStatus::Active => "active",
            UpdateStreamMonitorStatus::Paused => "paused",
        })
    }
}

/// URL entity in a tweet or user profile.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct Url {
    /// Display-friendly version of the URL.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub display_url: Option<String>,
    /// The fully expanded URL.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub expanded_url: Option<String>,
    /// Fully resolved URL after following redirects.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub unwound_url: Option<String>,
    /// The shortened t.co URL.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub url: Option<String>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Comprehensive user profile data including bio, metrics, verification status, and account metadata.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct UserData {
    /// Whether the authenticated user can send a DM to this user.
    #[serde(default, deserialize_with = "crate::core::flex::opt_bool")]
    pub can_dm: Option<bool>,
    /// Account creation timestamp.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub created_at: Option<String>,
    /// Account creation date in ISO 8601 format.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub created_at_datetime: Option<String>,
    /// The user's bio/description.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub description: Option<String>,
    /// Number of tweets this user has liked.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub favourites_count: Option<i64>,
    /// Whether this user follows the authenticated user.
    #[serde(default, deserialize_with = "crate::core::flex::opt_bool")]
    pub followed_by: Option<bool>,
    /// Number of followers.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub followers_count: Option<i64>,
    /// Whether the authenticated user follows this user.
    #[serde(default, deserialize_with = "crate::core::flex::opt_bool")]
    pub following: Option<bool>,
    /// Number of accounts this user follows.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub following_count: Option<i64>,
    /// Unique numeric user identifier.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub id: Option<String>,
    /// Whether the user has a Twitter Blue/Premium subscription.
    #[serde(default, deserialize_with = "crate::core::flex::opt_bool")]
    pub is_blue_verified: Option<bool>,
    /// Number of lists this user appears on.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub listed_count: Option<i64>,
    /// The user's self-reported location.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub location: Option<String>,
    /// Number of media items posted.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub media_count: Option<i64>,
    /// The user's display name.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub name: Option<String>,
    /// IDs of the user's pinned tweets.
    pub pinned_tweet_ids: Option<Vec<String>>,
    /// Whether the user's content may be sensitive.
    #[serde(default, deserialize_with = "crate::core::flex::opt_bool")]
    pub possibly_sensitive: Option<bool>,
    /// Professional account type, if applicable.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub professional_type: Option<String>,
    /// URL of the user's profile banner.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub profile_banner_url: Option<String>,
    /// URL of the user's profile image.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub profile_image_url: Option<String>,
    /// Whether the user's tweets are protected (private).
    #[serde(default, deserialize_with = "crate::core::flex::opt_bool")]
    pub protected: Option<bool>,
    /// Total number of tweets posted.
    #[serde(default, deserialize_with = "crate::core::flex::opt_i64")]
    pub tweet_count: Option<i64>,
    /// URL in the user's profile.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub url: Option<String>,
    /// The user's screen name (handle).
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub username: Option<String>,
    /// Whether the user is verified (legacy verification).
    #[serde(default, deserialize_with = "crate::core::flex::opt_bool")]
    pub verified: Option<bool>,
    /// Type of verification (e.g., Government, Business).
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub verified_type: Option<String>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// User mention entity in a tweet.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct UserMention {
    /// Numeric ID of the mentioned user.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub id: Option<String>,
    /// Start and end positions of the mention in the tweet text.
    pub indices: Option<Vec<i64>>,
    /// Display name of the mentioned user.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub name: Option<String>,
    /// Username of the mentioned user.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub username: Option<String>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Paginated list of users.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct UsersResponse {
    /// Array of user objects.
    pub data: Option<Vec<UserData>>,
    /// Cursor for fetching the next page. Null if no more results.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub next_cursor: Option<String>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct ValidateFilterRuleQueryResponse {
    /// Error message if the query is invalid.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub error: Option<String>,
    /// The query that was validated.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub query: Option<String>,
    /// Whether the query syntax is valid.
    #[serde(default, deserialize_with = "crate::core::flex::opt_bool")]
    pub valid: Option<bool>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Webhook endpoint summary for list responses.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct WebhookListItem {
    /// Timestamp when the webhook was created.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub created_at: Option<String>,
    /// Unique webhook identifier.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub id: Option<String>,
    /// ID of the associated stream monitor.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub monitor_id: Option<String>,
    /// Name of the associated stream monitor.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub monitor_name: Option<String>,
    /// Whether a secret is configured for this webhook.
    #[serde(default, deserialize_with = "crate::core::flex::opt_bool")]
    pub secret_set: Option<bool>,
    /// HTTPS URL of the webhook endpoint.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub url: Option<String>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Webhook endpoint details. Only returned on creation; the secret is included in the response.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct WebhookResponse {
    /// Timestamp when the webhook was created.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub created_at: Option<String>,
    /// Unique webhook identifier.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub id: Option<String>,
    /// ID of the associated stream monitor.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub monitor_id: Option<String>,
    /// Webhook secret for HMAC-SHA256 signing. Only returned once on creation.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub secret: Option<String>,
    /// HTTPS URL of the webhook endpoint.
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub url: Option<String>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Parameters for [`SearchCommunitiesParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct SearchCommunitiesParams {
    /// Search query to match against community names and descriptions.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
    /// Pagination cursor for fetching the next page of results.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
}

/// Parameters for [`GetCommunityDetailParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetCommunityDetailParams {}

/// Parameters for [`GetCommunityTweetsParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetCommunityTweetsParams {
    /// Type of tweets to return from the community.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tweet_type: Option<GetCommunityTweetsTweetType>,
    /// Pagination cursor for fetching the next page of results.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
}

/// Parameters for [`GetPlaceDetailParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetPlaceDetailParams {}

/// Parameters for [`SearchPlacesParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct SearchPlacesParams {
    /// Free-form text search for place names.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
    /// Latitude coordinate for location-based search.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lat: Option<f64>,
    /// Longitude coordinate for location-based search.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub long: Option<f64>,
}

/// Parameters for [`GetListDetailParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetListDetailParams {}

/// Parameters for [`SearchListTweetsParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct SearchListTweetsParams {
    /// Search query to filter tweets within the list.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
    /// Pagination cursor for fetching the next page of results.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
}

/// Parameters for [`GetListTweetsParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetListTweetsParams {
    /// Pagination cursor for fetching the next page of results.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
}

/// Parameters for [`GetBroadcastDetailParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetBroadcastDetailParams {}

/// Parameters for [`GetSpaceDetailParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetSpaceDetailParams {}

/// Parameters for [`ListStreamBillingLogsParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct ListStreamBillingLogsParams {
    /// Filter logs by stream monitor ID.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monitor_id: Option<String>,
    /// Page number for pagination.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub page: Option<i64>,
    /// Number of logs per page.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub page_size: Option<i64>,
}

/// Parameters for [`ListFilterRulesParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct ListFilterRulesParams {
    /// Page number for pagination.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub page: Option<i64>,
    /// Number of rules per page.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub page_size: Option<i64>,
    /// Filter rules by status.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<ListFilterRulesStatus>,
}

/// Parameters for [`CreateFilterRuleParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct CreateFilterRuleParams {
    /// Polling interval in seconds. Lower intervals detect tweets faster but cost more credits per day.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interval_seconds: Option<f64>,
    /// Maximum number of tweets to return per poll cycle.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results_per_poll: Option<i64>,
    /// Twitter Advanced Search query. Supports operators like from:, to:, min_faves:, lang:, etc.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
    /// Human-readable label for the filter rule.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tag: Option<String>,
    /// Secret used to sign webhook payloads with HMAC-SHA256.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub webhook_secret: Option<String>,
    /// HTTPS URL to receive webhook deliveries. Must use HTTPS.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub webhook_url: Option<String>,
}

/// Parameters for [`GetFilterRulePricingTiersParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetFilterRulePricingTiersParams {}

/// Parameters for [`ValidateFilterRuleQueryParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct ValidateFilterRuleQueryParams {
    /// Twitter Advanced Search query to validate.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
}

/// Parameters for [`GetFilterRuleParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetFilterRuleParams {}

/// Parameters for [`UpdateFilterRuleParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct UpdateFilterRuleParams {
    /// Updated polling interval in seconds.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interval_seconds: Option<f64>,
    /// Updated maximum results per poll cycle.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_results_per_poll: Option<i64>,
    /// Updated Twitter Advanced Search query.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
    /// Set rule status. Use "paused" to stop polling and "active" to resume.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<UpdateFilterRuleStatus>,
    /// Updated label for the filter rule.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tag: Option<String>,
    /// Updated webhook secret. Set to null to remove.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub webhook_secret: Option<String>,
    /// Updated webhook URL. Set to null to remove webhook delivery.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub webhook_url: Option<String>,
}

/// Parameters for [`DeleteFilterRuleParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct DeleteFilterRuleParams {}

/// Parameters for [`GetFilterRuleDeliveryLogsParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetFilterRuleDeliveryLogsParams {
    /// Page number for pagination.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub page: Option<i64>,
    /// Number of logs per page.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub page_size: Option<i64>,
    /// Filter delivery logs by the tweet author's username.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub author_username: Option<String>,
    /// Filter delivery logs by delivery status.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub delivery_status: Option<String>,
    /// Sort order for delivery logs by time.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort: Option<GetFilterRuleDeliveryLogsSort>,
}

/// Parameters for [`ListStreamDeliveryLogsParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct ListStreamDeliveryLogsParams {
    /// Filter logs by stream monitor ID.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monitor_id: Option<String>,
    /// Page number for pagination.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub page: Option<i64>,
    /// Number of logs per page.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub page_size: Option<i64>,
    /// Filter delivery logs by the tweet author's username.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub author_username: Option<String>,
    /// Filter delivery logs by delivery status.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub delivery_status: Option<String>,
    /// Sort order for delivery logs by time.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort: Option<ListStreamDeliveryLogsSort>,
}

/// Parameters for [`ListStreamMonitorsParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct ListStreamMonitorsParams {
    /// Page number for pagination.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub page: Option<i64>,
    /// Number of monitors per page.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub page_size: Option<i64>,
    /// Filter monitors by status.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<ListStreamMonitorsStatus>,
}

/// Parameters for [`CreateStreamMonitorParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct CreateStreamMonitorParams {
    /// Filter which tweet types to deliver. Null or omitted means all types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub filter_types: Option<Vec<String>>,
    /// Human-readable name for the stream monitor.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// List of Twitter usernames to monitor (without @ symbol).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub usernames: Option<Vec<String>>,
    /// Secret used to sign webhook payloads with HMAC-SHA256.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub webhook_secret: Option<String>,
    /// HTTPS URL to receive webhook deliveries. Must use HTTPS.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub webhook_url: Option<String>,
}

/// Parameters for [`GetStreamMonitorParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetStreamMonitorParams {}

/// Parameters for [`UpdateStreamMonitorParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct UpdateStreamMonitorParams {
    /// Updated tweet type filter. Set to null to deliver all types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub filter_types: Option<Vec<String>>,
    /// Updated name for the stream monitor.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Set monitor status. Use "paused" to stop monitoring and "active" to resume.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<UpdateStreamMonitorStatus>,
    /// Updated list of Twitter usernames to monitor.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub usernames: Option<Vec<String>>,
    /// Updated webhook secret. Set to null to remove.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub webhook_secret: Option<String>,
    /// Updated webhook URL. Set to null to remove webhook delivery.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub webhook_url: Option<String>,
}

/// Parameters for [`DeleteStreamMonitorParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct DeleteStreamMonitorParams {}

/// Parameters for [`ListStreamWebhooksParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct ListStreamWebhooksParams {
    /// Filter webhooks by stream monitor ID.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monitor_id: Option<String>,
}

/// Parameters for [`CreateStreamWebhookParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct CreateStreamWebhookParams {
    /// The ID of the stream monitor to attach this webhook to.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monitor_id: Option<String>,
    /// Secret used to sign webhook payloads with HMAC-SHA256.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub secret: Option<String>,
    /// HTTPS URL to receive webhook deliveries. Must use HTTPS.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
}

/// Parameters for [`TestStreamWebhookParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct TestStreamWebhookParams {
    /// The ID of the stream monitor whose webhook to test.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monitor_id: Option<String>,
}

/// Parameters for [`DeleteStreamWebhookParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct DeleteStreamWebhookParams {}

/// Parameters for [`GetTrendsParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetTrendsParams {
    /// Category to filter trends by.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub category: Option<GetTrendsCategory>,
    /// Number of trends to return.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub count: Option<i64>,
}

/// Parameters for [`GetTrendsByPlaceParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetTrendsByPlaceParams {}

/// Parameters for [`GetTweetsByIdsParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetTweetsByIdsParams {
    /// Comma-separated list of tweet IDs to retrieve.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tweets: Option<String>,
}

/// Parameters for [`AdvancedSearchTweetsParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct AdvancedSearchTweetsParams {
    /// Search query string. Supports Twitter advanced search operators like `from:`, `to:`, `since:`, `until:`, `min_faves:`, `min_retweets:`, `lang:`, etc.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
    /// Type of search results to return.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub query_type: Option<AdvancedSearchTweetsQueryType>,
    /// Number of tweets to return per page.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub count: Option<i64>,
    /// Pagination cursor for fetching the next page of results.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
}

/// Parameters for [`GetArticleDetailParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetArticleDetailParams {}

/// Parameters for [`GetTweetDetailParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetTweetDetailParams {
    /// Pagination cursor from a previous response for fetching additional data.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
}

/// Parameters for [`GetTweetCommunityNotesParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetTweetCommunityNotesParams {}

/// Parameters for [`GetTweetEditHistoryParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetTweetEditHistoryParams {}

/// Parameters for [`GetTweetFavoritersParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetTweetFavoritersParams {
    /// Pagination cursor for fetching the next page of results.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
}

/// Parameters for [`GetTweetQuotesParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetTweetQuotesParams {
    /// Pagination cursor for fetching the next page of results.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
}

/// Parameters for [`GetTweetRepliesParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetTweetRepliesParams {
    /// Pagination cursor for fetching the next page of results.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
}

/// Parameters for [`GetTweetRetweetersParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetTweetRetweetersParams {
    /// Pagination cursor for fetching the next page of results.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
}

/// Parameters for [`GetSimilarTweetsParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetSimilarTweetsParams {}

/// Parameters for [`GetUsersByIdsParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetUsersByIdsParams {
    /// Comma-separated list of numeric user IDs.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_ids: Option<String>,
}

/// Parameters for [`GetUsersByUsernamesParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetUsersByUsernamesParams {
    /// Comma-separated list of usernames (without the @ symbol).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub usernames: Option<String>,
}

/// Parameters for [`SearchUsersParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct SearchUsersParams {
    /// Search query to match against usernames, display names, and bios.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
    /// Pagination cursor for fetching the next page of results.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
}

/// Parameters for [`GetUserArticlesParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetUserArticlesParams {
    /// Pagination cursor for fetching the next page of results.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
}

/// Parameters for [`GetUserByIdParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetUserByIdParams {}

/// Parameters for [`GetUserSubscriptionsParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetUserSubscriptionsParams {
    /// Pagination cursor for fetching the next page of results.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
}

/// Parameters for [`GetUserByUsernameParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetUserByUsernameParams {}

/// Parameters for [`GetUserFollowersParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetUserFollowersParams {
    /// Pagination cursor for fetching the next page of results.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
}

/// Parameters for [`GetUserFollowingsParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetUserFollowingsParams {
    /// Pagination cursor for fetching the next page of results.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
}

/// Parameters for [`GetUserLatestTweetsParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetUserLatestTweetsParams {
    /// Pagination cursor for fetching the next page of results.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
}

/// Parameters for [`GetUserMentionsParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetUserMentionsParams {
    /// Number of tweets to return per page.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub count: Option<i64>,
    /// Pagination cursor for fetching the next page of results.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
}