xai-sdk 0.10.0

// This file is @generated by prost-build.
/// API key information.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ApiKey {
    /// A redacted API key. The full API key will not be displayed after it has
    /// been created.
    #[prost(string, tag = "1")]
    pub redacted_api_key: ::prost::alloc::string::String,
    /// ID of the user who created this API key.
    #[prost(string, tag = "3")]
    pub user_id: ::prost::alloc::string::String,
    /// Human-readable name for the API key.
    #[prost(string, tag = "4")]
    pub name: ::prost::alloc::string::String,
    /// Unix timestamp when the API key was created.
    #[prost(message, optional, tag = "5")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Unix timestamp when the API key was last modified.
    #[prost(message, optional, tag = "9")]
    pub modify_time: ::core::option::Option<::prost_types::Timestamp>,
    /// ID of the last user who modified the API key
    #[prost(string, tag = "11")]
    pub modified_by: ::prost::alloc::string::String,
    /// ID of the team this API key belongs to.
    #[prost(string, tag = "6")]
    pub team_id: ::prost::alloc::string::String,
    /// Access Control Lists (ACLs) associated with this key.
    /// These indicate the resources that the API key has access to.
    #[prost(string, repeated, tag = "7")]
    pub acls: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// The ID of the API key. This is different from the API key itself.
    #[prost(string, tag = "8")]
    pub api_key_id: ::prost::alloc::string::String,
    /// Whether the API key is currently blocked from making API requests.
    #[prost(bool, tag = "10")]
    pub api_key_blocked: bool,
    /// Whether the team is currently blocked from making API requests.
    #[prost(bool, tag = "13")]
    pub team_blocked: bool,
    /// Whether the API key is currently disabled.
    #[prost(bool, tag = "12")]
    pub disabled: bool,
}
/// Generated client implementations.
pub mod auth_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// An API service to check status of an API key.
    #[derive(Debug, Clone)]
    pub struct AuthClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl AuthClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> AuthClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> AuthClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            AuthClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Returns some information about an API key.
        pub async fn get_api_key_info(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<super::ApiKey>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.Auth/get_api_key_info",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.Auth", "get_api_key_info"));
            self.inner.unary(req, path, codec).await
        }
    }
}
/// The response from the service, when creating a deferred completion request.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StartDeferredResponse {
    /// The ID of this request. This ID can be used to retrieve completion results
    /// later.
    #[prost(string, tag = "1")]
    pub request_id: ::prost::alloc::string::String,
}
/// Retrieve the deferred chat request's response with the `request_id` in
/// StartDeferredResponse.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetDeferredRequest {
    /// The ID of this request to get.
    #[prost(string, tag = "1")]
    pub request_id: ::prost::alloc::string::String,
}
/// Status of deferred completion request.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum DeferredStatus {
    /// Invalid status.
    InvalidDeferredStatus = 0,
    /// The request has been processed and is available for download.
    Done = 1,
    /// The request has been processed but the content has expired and is not
    /// available anymore.
    Expired = 2,
    /// The request is still being processed.
    Pending = 3,
    /// The request failed due to an internal service error.
    /// The error message is in the `error` field of the response.
    Failed = 4,
}
impl DeferredStatus {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::InvalidDeferredStatus => "INVALID_DEFERRED_STATUS",
            Self::Done => "DONE",
            Self::Expired => "EXPIRED",
            Self::Pending => "PENDING",
            Self::Failed => "FAILED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "INVALID_DEFERRED_STATUS" => Some(Self::InvalidDeferredStatus),
            "DONE" => Some(Self::Done),
            "EXPIRED" => Some(Self::Expired),
            "PENDING" => Some(Self::Pending),
            "FAILED" => Some(Self::Failed),
            _ => None,
        }
    }
}
/// Document search using a combination of keyword and semantic search.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HybridRetrieval {
    /// Overfetch multiplier applied to the requested search limit.
    /// When set, fetches (limit * search_multiplier) results from each retrieval method
    /// before reranking, then returns the top `limit` results after reranking.
    /// Valid range is \[1, 100\]. Defaults to 1 when unset.
    #[prost(int32, optional, tag = "1")]
    pub search_multiplier: ::core::option::Option<i32>,
    /// Which reranker to use to limit results to the desired value.
    #[prost(oneof = "hybrid_retrieval::Reranker", tags = "2, 3")]
    pub reranker: ::core::option::Option<hybrid_retrieval::Reranker>,
}
/// Nested message and enum types in `HybridRetrieval`.
pub mod hybrid_retrieval {
    /// Which reranker to use to limit results to the desired value.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Reranker {
        /// Use a reranker model to perform the reranking.
        #[prost(message, tag = "2")]
        RerankerModel(super::RerankerModel),
        /// Use RRF to perform the reranking.
        #[prost(message, tag = "3")]
        ReciprocalRankFusion(super::ReciprocalRankFusion),
    }
}
/// Document search using keyword matching (sparse embeddings).
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct KeywordRetrieval {
    /// Optional, but always used when doing search across multiple collections.
    #[prost(message, optional, tag = "1")]
    pub reranker: ::core::option::Option<RerankerModel>,
}
/// Document search using semantic similarity (dense embeddings).
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SemanticRetrieval {
    /// Optional, but always used when doing search across multiple collections.
    #[prost(message, optional, tag = "1")]
    pub reranker: ::core::option::Option<RerankerModel>,
}
/// Configuration for reciprocal rank fusion (RRF) reranking.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ReciprocalRankFusion {
    /// The RRF constant k used in the reciprocal rank fusion formula. Defaults to 60.
    #[prost(int32, optional, tag = "1")]
    pub k: ::core::option::Option<i32>,
    /// Weight for embedding (dense) search results. Should be between 0 and 1. Defaults to 0.5.
    #[prost(float, tag = "3")]
    pub embedding_weight: f32,
    /// Weight for keyword (sparse) search results. Should be between 0 and 1. Defaults to 0.5.
    #[prost(float, tag = "4")]
    pub text_weight: f32,
}
/// Configuration for model-based reranking.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RerankerModel {
    /// The model to use for reranking. Defaults to standard reranker model.
    #[prost(string, optional, tag = "1")]
    pub model: ::core::option::Option<::prost::alloc::string::String>,
    /// Instructions for the reranking model. Defaults to generic reranking instructions.
    #[prost(string, optional, tag = "2")]
    pub instructions: ::core::option::Option<::prost::alloc::string::String>,
}
/// Message that contains settings needed to do a document search.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchRequest {
    /// The query to search for which will be embedded using the
    /// same embedding model as the one used for the source to query.
    #[prost(string, tag = "1")]
    pub query: ::prost::alloc::string::String,
    /// The source to query.
    #[prost(message, optional, tag = "2")]
    pub source: ::core::option::Option<DocumentsSource>,
    /// The number of chunks to return.
    /// Will always return the top matching chunks.
    /// Optional, defaults to 10.
    #[prost(int32, optional, tag = "3")]
    pub limit: ::core::option::Option<i32>,
    /// User-defined instructions to be included in the search query. Defaults to generic search instructions.
    #[prost(string, optional, tag = "5")]
    pub instructions: ::core::option::Option<::prost::alloc::string::String>,
    /// Deprecated: Metric now comes from what is set during collection creation.
    #[deprecated]
    #[prost(enumeration = "RankingMetric", optional, tag = "4")]
    pub ranking_metric: ::core::option::Option<i32>,
    /// How to perform the document search. Defaults to HybridRetrieval
    #[prost(oneof = "search_request::RetrievalMode", tags = "11, 12, 13")]
    pub retrieval_mode: ::core::option::Option<search_request::RetrievalMode>,
}
/// Nested message and enum types in `SearchRequest`.
pub mod search_request {
    /// How to perform the document search. Defaults to HybridRetrieval
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum RetrievalMode {
        #[prost(message, tag = "11")]
        HybridRetrieval(super::HybridRetrieval),
        #[prost(message, tag = "12")]
        SemanticRetrieval(super::SemanticRetrieval),
        #[prost(message, tag = "13")]
        KeywordRetrieval(super::KeywordRetrieval),
    }
}
/// SearchResponse message contains the results of a document search operation.
/// It returns a collection of matching document chunks sorted by relevance score.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchResponse {
    /// Collection of document chunks that match the search query, ordered by relevance score
    /// from highest to lowest.
    #[prost(message, repeated, tag = "1")]
    pub matches: ::prost::alloc::vec::Vec<SearchMatch>,
}
/// SearchMatch message represents a single document chunk that matches the search query.
/// It contains the document ID, chunk ID, content text, and a relevance score indicating
/// how well it matches the query.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchMatch {
    /// Unique identifier of the document that contains the matching chunk.
    #[prost(string, tag = "1")]
    pub file_id: ::prost::alloc::string::String,
    /// Unique identifier of the specific chunk within the document that matched the search query.
    #[prost(string, tag = "2")]
    pub chunk_id: ::prost::alloc::string::String,
    /// The actual text content of the matching chunk that can be presented to the user.
    #[prost(string, tag = "3")]
    pub chunk_content: ::prost::alloc::string::String,
    /// Score is the score of the chunk, which is determined by the ranking metric.
    /// For L2 distance, lower scores indicate better matches. Range is \[0, inf).
    /// For cosine similarity, higher scores indicate better matches. Range is \[0, 1\].
    #[prost(float, tag = "4")]
    pub score: f32,
    /// The ID(s) of the collection(s) to which this document belongs.
    #[prost(string, repeated, tag = "5")]
    pub collection_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Configuration for a documents sources in search requests.
///
/// This message configures a source for search content within documents or collections of documents.
/// Those documents must be uploaded through the management API or directly on the xAI console:
/// <https://console.x.ai.>
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DocumentsSource {
    /// IDs of collections to use.
    #[prost(string, repeated, tag = "1")]
    pub collection_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// RankingMetric is the metric to use for the search.
/// Deprecated: Metric now comes from what is set in the collection creation.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum RankingMetric {
    Unknown = 0,
    L2Distance = 1,
    CosineSimilarity = 2,
}
impl RankingMetric {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unknown => "RANKING_METRIC_UNKNOWN",
            Self::L2Distance => "RANKING_METRIC_L2_DISTANCE",
            Self::CosineSimilarity => "RANKING_METRIC_COSINE_SIMILARITY",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "RANKING_METRIC_UNKNOWN" => Some(Self::Unknown),
            "RANKING_METRIC_L2_DISTANCE" => Some(Self::L2Distance),
            "RANKING_METRIC_COSINE_SIMILARITY" => Some(Self::CosineSimilarity),
            _ => None,
        }
    }
}
/// Generated client implementations.
pub mod documents_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    #[derive(Debug, Clone)]
    pub struct DocumentsClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl DocumentsClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> DocumentsClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> DocumentsClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            DocumentsClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        pub async fn search(
            &mut self,
            request: impl tonic::IntoRequest<super::SearchRequest>,
        ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/xai_api.Documents/Search");
            let mut req = request.into_request();
            req.extensions_mut().insert(GrpcMethod::new("xai_api.Documents", "Search"));
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Records the cost associated with a sampling request (both chat and sample
/// endpoints).
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SamplingUsage {
    /// Total number of text completion tokens generated across all choices
    /// (in case of n>1).
    #[prost(int32, tag = "1")]
    pub completion_tokens: i32,
    /// Total number of reasoning tokens generated across all choices.
    #[prost(int32, tag = "6")]
    pub reasoning_tokens: i32,
    /// Total number of prompt tokens (both text and images).
    #[prost(int32, tag = "2")]
    pub prompt_tokens: i32,
    /// Total number of tokens (prompt + completion).
    #[prost(int32, tag = "3")]
    pub total_tokens: i32,
    /// Total number of (uncached) text tokens in the prompt.
    #[prost(int32, tag = "4")]
    pub prompt_text_tokens: i32,
    /// Total number of cached text tokens in the prompt.
    #[prost(int32, tag = "7")]
    pub cached_prompt_text_tokens: i32,
    /// Total number of image tokens in the prompt.
    #[prost(int32, tag = "5")]
    pub prompt_image_tokens: i32,
    /// \[DEPRECATED - live search feature has been deprecated so this field is
    /// redundant\] Number of individual live search sources used. Only applicable
    /// when live search is enabled. e.g. If a live search query returns citations
    /// from both X and Web and news sources, this will be 3. If it returns
    /// citations from only X, this will be 1.
    #[prost(int32, tag = "8")]
    pub num_sources_used: i32,
    /// List of server side tools called.
    #[prost(enumeration = "ServerSideTool", repeated, tag = "9")]
    pub server_side_tools_used: ::prost::alloc::vec::Vec<i32>,
    /// Full price paid by the user for this request, in USD ticks.
    /// For requests with server-side tools, this is the sum of token cost and
    /// server-side tool cost. Also used for image gen, video gen, etc.
    /// 1 USD = 10,000,000,000 ticks (i.e. 1 tick = 1e-10 USD).
    /// To convert to dollars, divide by 10,000,000,000.
    #[prost(int64, optional, tag = "11")]
    pub cost_in_usd_ticks: ::core::option::Option<i64>,
}
/// Usage of embedding models.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct EmbeddingUsage {
    /// The number of feature vectors produced from text inputs.
    #[prost(int32, tag = "1")]
    pub num_text_embeddings: i32,
    /// The number of feature vectors produced from image inputs.
    #[prost(int32, tag = "2")]
    pub num_image_embeddings: i32,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ServerSideTool {
    Invalid = 0,
    WebSearch = 1,
    XSearch = 2,
    CodeExecution = 3,
    ViewImage = 4,
    ViewXVideo = 5,
    CollectionsSearch = 6,
    Mcp = 7,
    AttachmentSearch = 8,
}
impl ServerSideTool {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Invalid => "SERVER_SIDE_TOOL_INVALID",
            Self::WebSearch => "SERVER_SIDE_TOOL_WEB_SEARCH",
            Self::XSearch => "SERVER_SIDE_TOOL_X_SEARCH",
            Self::CodeExecution => "SERVER_SIDE_TOOL_CODE_EXECUTION",
            Self::ViewImage => "SERVER_SIDE_TOOL_VIEW_IMAGE",
            Self::ViewXVideo => "SERVER_SIDE_TOOL_VIEW_X_VIDEO",
            Self::CollectionsSearch => "SERVER_SIDE_TOOL_COLLECTIONS_SEARCH",
            Self::Mcp => "SERVER_SIDE_TOOL_MCP",
            Self::AttachmentSearch => "SERVER_SIDE_TOOL_ATTACHMENT_SEARCH",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SERVER_SIDE_TOOL_INVALID" => Some(Self::Invalid),
            "SERVER_SIDE_TOOL_WEB_SEARCH" => Some(Self::WebSearch),
            "SERVER_SIDE_TOOL_X_SEARCH" => Some(Self::XSearch),
            "SERVER_SIDE_TOOL_CODE_EXECUTION" => Some(Self::CodeExecution),
            "SERVER_SIDE_TOOL_VIEW_IMAGE" => Some(Self::ViewImage),
            "SERVER_SIDE_TOOL_VIEW_X_VIDEO" => Some(Self::ViewXVideo),
            "SERVER_SIDE_TOOL_COLLECTIONS_SEARCH" => Some(Self::CollectionsSearch),
            "SERVER_SIDE_TOOL_MCP" => Some(Self::Mcp),
            "SERVER_SIDE_TOOL_ATTACHMENT_SEARCH" => Some(Self::AttachmentSearch),
            _ => None,
        }
    }
}
/// Request message for generating an image.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GenerateImageRequest {
    /// Input prompt to generate an image from.
    #[prost(string, tag = "1")]
    pub prompt: ::prost::alloc::string::String,
    /// Optional input image to perform generations based on.
    #[prost(message, optional, tag = "5")]
    pub image: ::core::option::Option<ImageUrlContent>,
    /// Name or alias of the image generation model to be used.
    #[prost(string, tag = "2")]
    pub model: ::prost::alloc::string::String,
    /// Number of images to generate. Allowed values are \[1, 10\].
    #[prost(int32, optional, tag = "3")]
    pub n: ::core::option::Option<i32>,
    /// An opaque string supplied by the API client (customer) to identify a user.
    /// The string will be stored in the logs and can be used in customer service
    /// requests to identify certain requests.
    #[prost(string, tag = "4")]
    pub user: ::prost::alloc::string::String,
    /// Optional field to specify the image format to return the generated image(s)
    /// in. See ImageFormat enum for options.
    #[prost(enumeration = "ImageFormat", tag = "11")]
    pub format: i32,
    /// Optional aspect ratio for image generation/editing.
    /// Only supported by grok-imagine models.
    /// Defaults to 1:1 if not specified. Auto is only supported for image generation
    /// with a thinking upsampler.
    #[prost(enumeration = "ImageAspectRatio", optional, tag = "14")]
    pub aspect_ratio: ::core::option::Option<i32>,
    /// Optional resolution for image generation/editing.
    /// Only supported by grok-imagine models.
    /// Defaults to 1k if not specified.
    /// When 2k is selected, the image is generated at 1k and upscaled using super-resolution.
    /// The final output area is capped at approximately 2048x2048 pixels, with dimensions
    /// adjusted to preserve aspect ratio and rounded to multiples of 16.
    #[prost(enumeration = "ImageResolution", optional, tag = "15")]
    pub resolution: ::core::option::Option<i32>,
    /// Optional list of input images for multi-reference image editing.
    /// Each image is either an image URL or a base64-encoded version of the image.
    /// This field cannot be set together with the `image` field.
    #[prost(message, repeated, tag = "17")]
    pub images: ::prost::alloc::vec::Vec<ImageUrlContent>,
}
/// The response from the image generation models containing the generated image(s).
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ImageResponse {
    /// A list of generated images (including relevant metadata).
    #[prost(message, repeated, tag = "1")]
    pub images: ::prost::alloc::vec::Vec<GeneratedImage>,
    /// The model used to generate the image (ignoring aliases).
    #[prost(string, tag = "2")]
    pub model: ::prost::alloc::string::String,
    /// The usage of the request.
    #[prost(message, optional, tag = "3")]
    pub usage: ::core::option::Option<SamplingUsage>,
}
/// Contains all data related to a generated image.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GeneratedImage {
    /// Whether the image generated by the model respects moderation rules.
    /// The field will be true if the image respect moderation rules. Otherwise
    /// the field will be false and the image field is replaced by a placeholder.
    #[prost(bool, tag = "4")]
    pub respect_moderation: bool,
    /// The generated image.
    #[prost(oneof = "generated_image::Image", tags = "1, 3")]
    pub image: ::core::option::Option<generated_image::Image>,
}
/// Nested message and enum types in `GeneratedImage`.
pub mod generated_image {
    /// The generated image.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Image {
        /// A base-64 encoded string of the image. Provided if user specified `IMG_FORMAT_BASE64` in `format` field of the
        /// `GenerateImageRequest` message.
        #[prost(string, tag = "1")]
        Base64(::prost::alloc::string::String),
        /// A url that points to the generated image. Provided if user specified `IMG_FORMAT_URL` in `format` field of the
        /// `GenerateImageRequest` message.
        #[prost(string, tag = "3")]
        Url(::prost::alloc::string::String),
    }
}
/// Contains data relating to an image that is provided to the model.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ImageUrlContent {
    /// This is either an image URL or a base64-encoded version of the image.
    /// The following image formats are supported: PNG, JPG, and WebP.
    /// If an image URL is provided, the image will be downloaded for every API
    /// request without being cached. Images are fetched using
    /// "XaiImageApiFetch/1.0" user agent, and will timeout after 5 seconds.
    /// The image size is limited to 10 MiB. If the image download fails, the API
    /// request will fail as well.
    #[prost(string, tag = "1")]
    pub image_url: ::prost::alloc::string::String,
    /// The level of pre-processing resolution that will be applied to the image.
    #[prost(enumeration = "ImageDetail", tag = "2")]
    pub detail: i32,
}
/// Indicates the level of preprocessing to apply to images that will be fed to
/// the model.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ImageDetail {
    /// Detail level is invalid.
    DetailInvalid = 0,
    /// The system will decide the image resolution to use.
    DetailAuto = 1,
    /// The model will process a low-resolution version of the image. This is
    /// faster and cheaper (i.e. consumes fewer tokens).
    DetailLow = 2,
    /// The model will process a high-resolution of the image. This is slower and
    /// more expensive but will allow the model to attend to more nuanced details
    /// in the image.
    DetailHigh = 3,
}
impl ImageDetail {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::DetailInvalid => "DETAIL_INVALID",
            Self::DetailAuto => "DETAIL_AUTO",
            Self::DetailLow => "DETAIL_LOW",
            Self::DetailHigh => "DETAIL_HIGH",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "DETAIL_INVALID" => Some(Self::DetailInvalid),
            "DETAIL_AUTO" => Some(Self::DetailAuto),
            "DETAIL_LOW" => Some(Self::DetailLow),
            "DETAIL_HIGH" => Some(Self::DetailHigh),
            _ => None,
        }
    }
}
/// The image format to be returned (base-64 encoded string or a url of
/// the image).
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ImageFormat {
    /// Image format is invalid.
    ImgFormatInvalid = 0,
    /// A base-64 encoding of the image.
    ImgFormatBase64 = 1,
    /// An URL at which the user can download the image.
    ImgFormatUrl = 2,
}
impl ImageFormat {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::ImgFormatInvalid => "IMG_FORMAT_INVALID",
            Self::ImgFormatBase64 => "IMG_FORMAT_BASE64",
            Self::ImgFormatUrl => "IMG_FORMAT_URL",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "IMG_FORMAT_INVALID" => Some(Self::ImgFormatInvalid),
            "IMG_FORMAT_BASE64" => Some(Self::ImgFormatBase64),
            "IMG_FORMAT_URL" => Some(Self::ImgFormatUrl),
            _ => None,
        }
    }
}
/// Quality levels for image generation with their corresponding resolutions.
/// Currently only supported by grok-imagine models.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ImageQuality {
    /// Quality is invalid.
    ImgQualityInvalid = 0,
    /// Low quality.
    ImgQualityLow = 1,
    /// Medium quality: (default).
    ImgQualityMedium = 2,
    /// High quality.
    ImgQualityHigh = 3,
}
impl ImageQuality {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::ImgQualityInvalid => "IMG_QUALITY_INVALID",
            Self::ImgQualityLow => "IMG_QUALITY_LOW",
            Self::ImgQualityMedium => "IMG_QUALITY_MEDIUM",
            Self::ImgQualityHigh => "IMG_QUALITY_HIGH",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "IMG_QUALITY_INVALID" => Some(Self::ImgQualityInvalid),
            "IMG_QUALITY_LOW" => Some(Self::ImgQualityLow),
            "IMG_QUALITY_MEDIUM" => Some(Self::ImgQualityMedium),
            "IMG_QUALITY_HIGH" => Some(Self::ImgQualityHigh),
            _ => None,
        }
    }
}
/// Aspect ratio for image generation.
/// Only supported by grok-imagine models.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ImageAspectRatio {
    /// Invalid aspect ratio.
    ImgAspectRatioInvalid = 0,
    /// 1:1 aspect ratio (square).
    ImgAspectRatio11 = 1,
    /// 3:4 aspect ratio (portrait).
    ImgAspectRatio34 = 2,
    /// 4:3 aspect ratio (landscape).
    ImgAspectRatio43 = 3,
    /// 9:16 aspect ratio (tall portrait).
    ImgAspectRatio916 = 4,
    /// 16:9 aspect ratio (wide landscape).
    ImgAspectRatio169 = 5,
    /// 2:3 aspect ratio (photo portrait).
    ImgAspectRatio23 = 6,
    /// 3:2 aspect ratio (photo landscape).
    ImgAspectRatio32 = 7,
    /// Auto aspect ratio (model auto-selects based on prompt).
    /// Only supported for image generation with a thinking upsampler.
    ImgAspectRatioAuto = 8,
    /// 9:19.5 aspect ratio (extra tall portrait - phone screens).
    ImgAspectRatio9195 = 9,
    /// 19.5:9 aspect ratio (extra wide landscape).
    ImgAspectRatio1959 = 10,
    /// 9:20 aspect ratio (tall portrait - modern phone screens).
    ImgAspectRatio920 = 11,
    /// 20:9 aspect ratio (ultra wide landscape).
    ImgAspectRatio209 = 12,
    /// 1:2 aspect ratio (tall portrait).
    ImgAspectRatio12 = 13,
    /// 2:1 aspect ratio (wide landscape).
    ImgAspectRatio21 = 14,
}
impl ImageAspectRatio {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::ImgAspectRatioInvalid => "IMG_ASPECT_RATIO_INVALID",
            Self::ImgAspectRatio11 => "IMG_ASPECT_RATIO_1_1",
            Self::ImgAspectRatio34 => "IMG_ASPECT_RATIO_3_4",
            Self::ImgAspectRatio43 => "IMG_ASPECT_RATIO_4_3",
            Self::ImgAspectRatio916 => "IMG_ASPECT_RATIO_9_16",
            Self::ImgAspectRatio169 => "IMG_ASPECT_RATIO_16_9",
            Self::ImgAspectRatio23 => "IMG_ASPECT_RATIO_2_3",
            Self::ImgAspectRatio32 => "IMG_ASPECT_RATIO_3_2",
            Self::ImgAspectRatioAuto => "IMG_ASPECT_RATIO_AUTO",
            Self::ImgAspectRatio9195 => "IMG_ASPECT_RATIO_9_19_5",
            Self::ImgAspectRatio1959 => "IMG_ASPECT_RATIO_19_5_9",
            Self::ImgAspectRatio920 => "IMG_ASPECT_RATIO_9_20",
            Self::ImgAspectRatio209 => "IMG_ASPECT_RATIO_20_9",
            Self::ImgAspectRatio12 => "IMG_ASPECT_RATIO_1_2",
            Self::ImgAspectRatio21 => "IMG_ASPECT_RATIO_2_1",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "IMG_ASPECT_RATIO_INVALID" => Some(Self::ImgAspectRatioInvalid),
            "IMG_ASPECT_RATIO_1_1" => Some(Self::ImgAspectRatio11),
            "IMG_ASPECT_RATIO_3_4" => Some(Self::ImgAspectRatio34),
            "IMG_ASPECT_RATIO_4_3" => Some(Self::ImgAspectRatio43),
            "IMG_ASPECT_RATIO_9_16" => Some(Self::ImgAspectRatio916),
            "IMG_ASPECT_RATIO_16_9" => Some(Self::ImgAspectRatio169),
            "IMG_ASPECT_RATIO_2_3" => Some(Self::ImgAspectRatio23),
            "IMG_ASPECT_RATIO_3_2" => Some(Self::ImgAspectRatio32),
            "IMG_ASPECT_RATIO_AUTO" => Some(Self::ImgAspectRatioAuto),
            "IMG_ASPECT_RATIO_9_19_5" => Some(Self::ImgAspectRatio9195),
            "IMG_ASPECT_RATIO_19_5_9" => Some(Self::ImgAspectRatio1959),
            "IMG_ASPECT_RATIO_9_20" => Some(Self::ImgAspectRatio920),
            "IMG_ASPECT_RATIO_20_9" => Some(Self::ImgAspectRatio209),
            "IMG_ASPECT_RATIO_1_2" => Some(Self::ImgAspectRatio12),
            "IMG_ASPECT_RATIO_2_1" => Some(Self::ImgAspectRatio21),
            _ => None,
        }
    }
}
/// Resolution for image generation.
/// Only supported by grok-imagine models.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ImageResolution {
    /// Invalid resolution.
    ImgResolutionInvalid = 0,
    /// 1k resolution (~1 megapixel total).
    /// Dimensions vary by aspect ratio.
    ImgResolution1k = 1,
    /// 2k resolution (~4 megapixel total).
    ImgResolution2k = 2,
}
impl ImageResolution {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::ImgResolutionInvalid => "IMG_RESOLUTION_INVALID",
            Self::ImgResolution1k => "IMG_RESOLUTION_1K",
            Self::ImgResolution2k => "IMG_RESOLUTION_2K",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "IMG_RESOLUTION_INVALID" => Some(Self::ImgResolutionInvalid),
            "IMG_RESOLUTION_1K" => Some(Self::ImgResolution1k),
            "IMG_RESOLUTION_2K" => Some(Self::ImgResolution2k),
            _ => None,
        }
    }
}
/// Generated client implementations.
pub mod image_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// An API service for interaction with image generation models.
    #[derive(Debug, Clone)]
    pub struct ImageClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ImageClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> ImageClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> ImageClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            ImageClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Create an image based on a text prompt and optionally another image.
        pub async fn generate_image(
            &mut self,
            request: impl tonic::IntoRequest<super::GenerateImageRequest>,
        ) -> std::result::Result<tonic::Response<super::ImageResponse>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.Image/GenerateImage",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.Image", "GenerateImage"));
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Request to get a text completion response sampling.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SampleTextRequest {
    /// Text prompts to sample on.
    #[prost(string, repeated, tag = "1")]
    pub prompt: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Name or alias of the model to be used.
    #[prost(string, tag = "3")]
    pub model: ::prost::alloc::string::String,
    /// The number of completions to create concurrently. A single completion will
    /// be generated if the parameter is unset. Each completion is charged at the
    /// same rate. You can generate at most 128 concurrent completions.
    #[prost(int32, optional, tag = "8")]
    pub n: ::core::option::Option<i32>,
    /// The maximum number of tokens to sample. If unset, the model samples until
    /// one of the following stop-conditions is reached:
    ///
    /// * The context length of the model is exceeded
    /// * One of the `stop` sequences has been observed.
    ///
    /// We recommend choosing a reasonable value to reduce the risk of accidental
    /// long-generations that consume many tokens.
    #[prost(int32, optional, tag = "7")]
    pub max_tokens: ::core::option::Option<i32>,
    /// A random seed used to make the sampling process deterministic. This is
    /// provided in a best-effort basis without guarantee that sampling is 100%
    /// deterministic given a seed. This is primarily provided for short-lived
    /// testing purposes. Given a fixed request and seed, the answers may change
    /// over time as our systems evolve.
    #[prost(int32, optional, tag = "11")]
    pub seed: ::core::option::Option<i32>,
    /// String patterns that will cause the sampling procedure to stop prematurely
    /// when observed.
    /// Note that the completion is based on individual tokens and sampling can
    /// only terminate at token boundaries. If a stop string is a substring of an
    /// individual token, the completion will include the entire token, which
    /// extends beyond the stop string.
    /// For example, if `stop = \["wor"\]` and we prompt the model with "hello" to
    /// which it responds with "world", then the sampling procedure will stop after
    /// observing the "world" token and the completion will contain
    /// the entire world "world" even though the stop string was just "wor".
    /// You can provide at most 8 stop strings.
    #[prost(string, repeated, tag = "12")]
    pub stop: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// A number between 0 and 2 used to control the variance of completions.
    /// The smaller the value, the more deterministic the model will become. For
    /// example, if we sample 1000 answers to the same prompt at a temperature of
    /// 0.001, then most of the 1000 answers will be identical. Conversely, if we
    /// conduct the same experiment at a temperature of 2, virtually no two answers
    /// will be identical. Note that increasing the temperature will cause
    /// the model to hallucinate more strongly.
    #[prost(float, optional, tag = "14")]
    pub temperature: ::core::option::Option<f32>,
    /// A number between 0 and 1 controlling the likelihood of the model to use
    /// less-common answers. Recall that the model produces a probability for
    /// each token. This means, for any choice of token there are thousands of
    /// possibilities to choose from. This parameter controls the "nucleus sampling
    /// algorithm". Instead of considering every possible token at every step, we
    /// only look at the K tokens who's probabilities exceed `top_p`.
    /// For example, if we set `top_p = 0.9`, then the set of tokens we actually
    /// sample from, will have a probability mass of at least 90%. In practice,
    /// low values will make the model more deterministic.
    #[prost(float, optional, tag = "15")]
    pub top_p: ::core::option::Option<f32>,
    /// Number between -2.0 and 2.0.
    /// Positive values penalize new tokens based on their existing frequency in the text so far,
    /// decreasing the model's likelihood to repeat the same line verbatim.
    #[prost(float, optional, tag = "13")]
    pub frequency_penalty: ::core::option::Option<f32>,
    /// Whether to return log probabilities of the output tokens or not.
    /// If true, returns the log probabilities of each output token returned in the content of message.
    #[prost(bool, tag = "5")]
    pub logprobs: bool,
    /// Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics.
    /// Not supported by grok-3 models.
    #[prost(float, optional, tag = "9")]
    pub presence_penalty: ::core::option::Option<f32>,
    /// An integer between 0 and 8 specifying the number of most likely tokens to return at each token position,
    /// each with an associated log probability.
    /// logprobs must be set to true if this parameter is used.
    #[prost(int32, optional, tag = "6")]
    pub top_logprobs: ::core::option::Option<i32>,
    /// An opaque string supplied by the API client (customer) to identify a user.
    /// The string will be stored in the logs and can be used in customer service
    /// requests to identify certain requests.
    #[prost(string, tag = "17")]
    pub user: ::prost::alloc::string::String,
}
/// Response of a text completion response sampling.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SampleTextResponse {
    /// The ID of this request. This ID will also show up on your billing records
    /// and you can use it when contacting us regarding a specific request.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Completions in response to the input messages. The number of completions is
    /// controlled via the `n` parameter on the request.
    #[prost(message, repeated, tag = "2")]
    pub choices: ::prost::alloc::vec::Vec<SampleChoice>,
    /// A UNIX timestamp (UTC) indicating when the response object was created.
    /// The timestamp is taken when the model starts generating response.
    #[prost(message, optional, tag = "5")]
    pub created: ::core::option::Option<::prost_types::Timestamp>,
    /// The name of the model used for the request. This model name contains
    /// the actual model name used rather than any aliases.
    /// This means the this can be `grok-2-1212` even when the request was
    /// specifying `grok-2-latest`.
    #[prost(string, tag = "6")]
    pub model: ::prost::alloc::string::String,
    /// Note supported yet. Included for compatibility reasons.
    #[prost(string, tag = "7")]
    pub system_fingerprint: ::prost::alloc::string::String,
    /// The number of tokens consumed by this request.
    #[prost(message, optional, tag = "9")]
    pub usage: ::core::option::Option<SamplingUsage>,
}
/// Contains the response generated by the model.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SampleChoice {
    /// Indicating why the model stopped sampling.
    #[prost(enumeration = "FinishReason", tag = "1")]
    pub finish_reason: i32,
    /// The index of this choice in the list of choices. If you set `n > 1` on
    /// your request, you will receive more than one choice in your response.
    #[prost(int32, tag = "2")]
    pub index: i32,
    /// The actual text generated by the model.
    #[prost(string, tag = "3")]
    pub text: ::prost::alloc::string::String,
}
/// Reasons why the model stopped sampling.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum FinishReason {
    /// Invalid reason.
    ReasonInvalid = 0,
    /// The max_len parameter specified on the input is reached.
    ReasonMaxLen = 1,
    /// The maximum context length of the model is reached.
    ReasonMaxContext = 2,
    /// One of the stop words was found.
    ReasonStop = 3,
    /// A tool call is included in the response.
    ReasonToolCalls = 4,
    /// Time limit has been reached.
    ReasonTimeLimit = 5,
}
impl FinishReason {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::ReasonInvalid => "REASON_INVALID",
            Self::ReasonMaxLen => "REASON_MAX_LEN",
            Self::ReasonMaxContext => "REASON_MAX_CONTEXT",
            Self::ReasonStop => "REASON_STOP",
            Self::ReasonToolCalls => "REASON_TOOL_CALLS",
            Self::ReasonTimeLimit => "REASON_TIME_LIMIT",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "REASON_INVALID" => Some(Self::ReasonInvalid),
            "REASON_MAX_LEN" => Some(Self::ReasonMaxLen),
            "REASON_MAX_CONTEXT" => Some(Self::ReasonMaxContext),
            "REASON_STOP" => Some(Self::ReasonStop),
            "REASON_TOOL_CALLS" => Some(Self::ReasonToolCalls),
            "REASON_TIME_LIMIT" => Some(Self::ReasonTimeLimit),
            _ => None,
        }
    }
}
/// Generated client implementations.
pub mod sample_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// An API service for sampling the responses of available language models.
    #[derive(Debug, Clone)]
    pub struct SampleClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl SampleClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> SampleClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> SampleClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            SampleClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Get raw sampling of text response from the model inference.
        pub async fn sample_text(
            &mut self,
            request: impl tonic::IntoRequest<super::SampleTextRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SampleTextResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.Sample/SampleText",
            );
            let mut req = request.into_request();
            req.extensions_mut().insert(GrpcMethod::new("xai_api.Sample", "SampleText"));
            self.inner.unary(req, path, codec).await
        }
        /// Get streaming raw sampling of text response from the model inference.
        pub async fn sample_text_streaming(
            &mut self,
            request: impl tonic::IntoRequest<super::SampleTextRequest>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::SampleTextResponse>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.Sample/SampleTextStreaming",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.Sample", "SampleTextStreaming"));
            self.inner.server_streaming(req, path, codec).await
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetCompletionsRequest {
    /// A sequence of messages in the conversation. There must be at least a single
    /// message that the model can respond to.
    #[prost(message, repeated, tag = "1")]
    pub messages: ::prost::alloc::vec::Vec<Message>,
    /// Name of the model. This is the name as reported by the models API. More
    /// details can be found on your console at <https://console.x.ai.>
    #[prost(string, tag = "2")]
    pub model: ::prost::alloc::string::String,
    /// An opaque string supplied by the API client (customer) to identify a user.
    /// The string will be stored in the logs and can be used in customer service
    /// requests to identify certain requests.
    #[prost(string, tag = "16")]
    pub user: ::prost::alloc::string::String,
    /// The number of completions to create concurrently. A single completion will
    /// be generated if the parameter is unset. Each completion is charged at the
    /// same rate. You can generate at most 128 concurrent completions.
    /// PLEASE NOTE: This field is deprecated and will be removed in the future.
    #[prost(int32, optional, tag = "8")]
    pub n: ::core::option::Option<i32>,
    /// The maximum number of tokens to sample. If unset, the model samples until
    /// one of the following stop-conditions is reached:
    ///
    /// * The context length of the model is exceeded
    /// * One of the `stop` sequences has been observed.
    /// * The time limit exceeds.
    ///
    /// Note that for reasoning models and models that support function calls, the
    /// limit is only applied to the main content and not to the reasoning content
    /// or function calls.
    ///
    /// We recommend choosing a reasonable value to reduce the risk of accidental
    /// long-generations that consume many tokens.
    #[prost(int32, optional, tag = "7")]
    pub max_tokens: ::core::option::Option<i32>,
    /// A random seed used to make the sampling process deterministic. This is
    /// provided in a best-effort basis without guarantee that sampling is 100%
    /// deterministic given a seed. This is primarily provided for short-lived
    /// testing purposes. Given a fixed request and seed, the answers may change
    /// over time as our systems evolve.
    #[prost(int32, optional, tag = "11")]
    pub seed: ::core::option::Option<i32>,
    /// String patterns that will cause the sampling procedure to stop prematurely
    /// when observed.
    /// Note that the completion is based on individual tokens and sampling can
    /// only terminate at token boundaries. If a stop string is a substring of an
    /// individual token, the completion will include the entire token, which
    /// extends beyond the stop string.
    /// For example, if `stop = \["wor"\]` and we prompt the model with "hello" to
    /// which it responds with "world", then the sampling procedure will stop after
    /// observing the "world" token and the completion will contain
    /// the entire world "world" even though the stop string was just "wor".
    /// You can provide at most 8 stop strings.
    #[prost(string, repeated, tag = "12")]
    pub stop: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// A number between 0 and 2 used to control the variance of completions.
    /// The smaller the value, the more deterministic the model will become. For
    /// example, if we sample 1000 answers to the same prompt at a temperature of
    /// 0.001, then most of the 1000 answers will be identical. Conversely, if we
    /// conduct the same experiment at a temperature of 2, virtually no two answers
    /// will be identical. Note that increasing the temperature will cause
    /// the model to hallucinate more strongly.
    #[prost(float, optional, tag = "14")]
    pub temperature: ::core::option::Option<f32>,
    /// A number between 0 and 1 controlling the likelihood of the model to use
    /// less-common answers. Recall that the model produces a probability for
    /// each token. This means, for any choice of token there are thousands of
    /// possibilities to choose from. This parameter controls the "nucleus sampling
    /// algorithm". Instead of considering every possible token at every step, we
    /// only look at the K tokens who's probabilities exceed `top_p`.
    /// For example, if we set `top_p = 0.9`, then the set of tokens we actually
    /// sample from, will have a probability mass of at least 90%. In practice,
    /// low values will make the model more deterministic.
    #[prost(float, optional, tag = "15")]
    pub top_p: ::core::option::Option<f32>,
    /// If set to true, log probabilities of the sampling are returned.
    #[prost(bool, tag = "5")]
    pub logprobs: bool,
    /// Number of top log probabilities to return.
    #[prost(int32, optional, tag = "6")]
    pub top_logprobs: ::core::option::Option<i32>,
    /// A list of tools the model may call. Currently, only functions are supported
    /// as a tool. Use this to provide a list of functions the model may generate
    /// JSON inputs for.
    #[prost(message, repeated, tag = "17")]
    pub tools: ::prost::alloc::vec::Vec<Tool>,
    /// Controls if the model can, should, or must not use tools.
    #[prost(message, optional, tag = "18")]
    pub tool_choice: ::core::option::Option<ToolChoice>,
    /// Formatting constraint on the response.
    #[prost(message, optional, tag = "10")]
    pub response_format: ::core::option::Option<ResponseFormat>,
    /// Positive values penalize new tokens based on their existing frequency in
    /// the text so far, decreasing the model's likelihood to repeat the same line
    /// verbatim.
    #[prost(float, optional, tag = "3")]
    pub frequency_penalty: ::core::option::Option<f32>,
    /// Positive values penalize new tokens based on whether they appear in
    /// the text so far, increasing the model's likelihood to talk about
    /// new topics.
    #[prost(float, optional, tag = "9")]
    pub presence_penalty: ::core::option::Option<f32>,
    /// Constrains effort on reasoning for reasoning models. Default to `EFFORT_MEDIUM`.
    #[prost(enumeration = "ReasoningEffort", optional, tag = "19")]
    pub reasoning_effort: ::core::option::Option<i32>,
    /// Set the parameters to be used for realtime data. If not set, no realtime data will be acquired by the model.
    #[prost(message, optional, tag = "20")]
    pub search_parameters: ::core::option::Option<SearchParameters>,
    /// / If set to false, the model can perform maximum one tool call per response. Default to true.
    #[prost(bool, optional, tag = "21")]
    pub parallel_tool_calls: ::core::option::Option<bool>,
    /// Previous response id. The messages from this response must be chained.
    #[prost(string, optional, tag = "22")]
    pub previous_response_id: ::core::option::Option<::prost::alloc::string::String>,
    /// Whether to store request and responses. Default is false.
    #[prost(bool, tag = "23")]
    pub store_messages: bool,
    /// Whether to use encrypted thinking for thinking trace rehydration.
    #[prost(bool, tag = "24")]
    pub use_encrypted_content: bool,
    /// Maximum number of agentic tool calling turns allowed for this request.
    /// If not set, defaults to the server's global cap.
    /// The effective max_turns will be the min of the server's global cap and the request's max_turns.
    /// This parameter will be ignored for any non-agentic requests.
    /// With parallel tool calls, multiple tool calls can occur within a single turn,
    /// so max_turns does not necessarily equal the total number of tool calls.
    #[prost(int32, optional, tag = "25")]
    pub max_turns: ::core::option::Option<i32>,
    /// Allow the users to control what optional fields to be returned in the response.
    #[prost(enumeration = "IncludeOption", repeated, tag = "26")]
    pub include: ::prost::alloc::vec::Vec<i32>,
    /// Number of agents to use for multi-agent models.
    /// Only valid when model is a `multi-agent` model. Defaults to `AGENT_COUNT_UNSPECIFIED`.
    #[prost(enumeration = "AgentCount", optional, tag = "29")]
    pub agent_count: ::core::option::Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetChatCompletionResponse {
    /// The ID of this request. This ID will also show up on your billing records
    /// and you can use it when contacting us regarding a specific request.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Model-generated outputs/responses to the input messages. Each output contains
    /// the model's response including text content, reasoning traces, tool calls, and
    /// metadata about the generation process.
    #[prost(message, repeated, tag = "2")]
    pub outputs: ::prost::alloc::vec::Vec<CompletionOutput>,
    /// A UNIX timestamp (UTC) indicating when the response object was created.
    /// The timestamp is taken when the model starts generating response.
    #[prost(message, optional, tag = "5")]
    pub created: ::core::option::Option<::prost_types::Timestamp>,
    /// The name of the model used for the request. This model name contains
    /// the actual model name used rather than any aliases.
    /// This means the this can be `grok-2-1212` even when the request was
    /// specifying `grok-2-latest`.
    #[prost(string, tag = "6")]
    pub model: ::prost::alloc::string::String,
    /// This fingerprint represents the backend configuration that the model runs
    /// with.
    #[prost(string, tag = "7")]
    pub system_fingerprint: ::prost::alloc::string::String,
    /// The number of tokens consumed by this request.
    #[prost(message, optional, tag = "9")]
    pub usage: ::core::option::Option<SamplingUsage>,
    /// / List of all the external pages (urls) used by the model to produce its final answer.
    /// This is only present when live search is enabled, (That is `SearchParameters` have been defined in `GetCompletionsRequest`).
    #[prost(string, repeated, tag = "10")]
    pub citations: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Settings used while generating the response.
    #[prost(message, optional, tag = "11")]
    pub settings: ::core::option::Option<RequestSettings>,
    /// Debug output. Only available to trusted testers.
    #[prost(message, optional, tag = "12")]
    pub debug_output: ::core::option::Option<DebugOutput>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetChatCompletionChunk {
    /// The ID of this request. This ID will also show up on your billing records
    /// and you can use it when contacting us regarding a specific request.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Model-generated outputs/responses being streamed as they are generated.
    /// Each output chunk contains incremental updates to the model's response.
    #[prost(message, repeated, tag = "2")]
    pub outputs: ::prost::alloc::vec::Vec<CompletionOutputChunk>,
    /// A UNIX timestamp (UTC) indicating when the response object was created.
    /// The timestamp is taken when the model starts generating response.
    #[prost(message, optional, tag = "3")]
    pub created: ::core::option::Option<::prost_types::Timestamp>,
    /// The name of the model used for the request. This model name contains
    /// the actual model name used rather than any aliases.
    /// This means the this can be `grok-2-1212` even when the request was
    /// specifying `grok-2-latest`.
    #[prost(string, tag = "4")]
    pub model: ::prost::alloc::string::String,
    /// This fingerprint represents the backend configuration that the model runs
    /// with.
    #[prost(string, tag = "5")]
    pub system_fingerprint: ::prost::alloc::string::String,
    /// The total number of tokens consumed when this chunk was streamed. Note that
    /// this is not the final number of tokens billed unless this is the last chunk
    /// in the stream.
    #[prost(message, optional, tag = "6")]
    pub usage: ::core::option::Option<SamplingUsage>,
    /// / List of all the external pages used by the model to answer. Only populated for the last chunk.
    /// This is only present for requests that make use of live search or server-side search tools.
    #[prost(string, repeated, tag = "7")]
    pub citations: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Only available for teams that have debugging privileges.
    #[prost(message, optional, tag = "10")]
    pub debug_output: ::core::option::Option<DebugOutput>,
}
/// Response from GetDeferredCompletion, including the response if the completion
/// request has been processed without error.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetDeferredCompletionResponse {
    /// Current status of the request.
    #[prost(enumeration = "DeferredStatus", tag = "2")]
    pub status: i32,
    /// Response. Only present if `status=DONE`
    #[prost(message, optional, tag = "1")]
    pub response: ::core::option::Option<GetChatCompletionResponse>,
}
/// Contains the response generated by the model.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CompletionOutput {
    /// Indicating why the model stopped sampling.
    #[prost(enumeration = "FinishReason", tag = "1")]
    pub finish_reason: i32,
    /// The index of this output in the list of outputs. When multiple outputs are
    /// generated, each output is assigned a sequential index starting from 0.
    #[prost(int32, tag = "2")]
    pub index: i32,
    /// The actual message generated by the model.
    #[prost(message, optional, tag = "3")]
    pub message: ::core::option::Option<CompletionMessage>,
    /// The log probabilities of the sampling.
    #[prost(message, optional, tag = "4")]
    pub logprobs: ::core::option::Option<LogProbs>,
}
/// Holds the model output (i.e. the result of the sampling process).
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CompletionMessage {
    /// The generated text based on the input prompt.
    #[prost(string, tag = "1")]
    pub content: ::prost::alloc::string::String,
    /// Reasoning trace the model produced before issuing the final answer.
    #[prost(string, tag = "4")]
    pub reasoning_content: ::prost::alloc::string::String,
    /// The role of the message author. Will always default to "assistant".
    #[prost(enumeration = "MessageRole", tag = "2")]
    pub role: i32,
    /// The tools that the assistant wants to call.
    #[prost(message, repeated, tag = "3")]
    pub tool_calls: ::prost::alloc::vec::Vec<ToolCall>,
    /// The encrypted content.
    #[prost(string, tag = "5")]
    pub encrypted_content: ::prost::alloc::string::String,
    /// The citations that the model used to answer the question.
    #[prost(message, repeated, tag = "6")]
    pub citations: ::prost::alloc::vec::Vec<InlineCitation>,
}
/// Holds the differences (deltas) that when concatenated make up the entire
/// agent response.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CompletionOutputChunk {
    /// The actual text differences that need to be accumulated on the client.
    #[prost(message, optional, tag = "1")]
    pub delta: ::core::option::Option<Delta>,
    /// The log probability of the choice.
    #[prost(message, optional, tag = "2")]
    pub logprobs: ::core::option::Option<LogProbs>,
    /// Indicating why the model stopped sampling.
    #[prost(enumeration = "FinishReason", tag = "3")]
    pub finish_reason: i32,
    /// The index of this output chunk in the list of output chunks.
    #[prost(int32, tag = "4")]
    pub index: i32,
}
/// The delta of a streaming response.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Delta {
    /// The main model output/answer.
    #[prost(string, tag = "1")]
    pub content: ::prost::alloc::string::String,
    /// Part of the model's reasoning trace.
    #[prost(string, tag = "4")]
    pub reasoning_content: ::prost::alloc::string::String,
    /// The entity type who sent the message. For example, a message can be sent by
    /// a user or the assistant.
    #[prost(enumeration = "MessageRole", tag = "2")]
    pub role: i32,
    /// A list of tool calls if tool call is requested by the model.
    #[prost(message, repeated, tag = "3")]
    pub tool_calls: ::prost::alloc::vec::Vec<ToolCall>,
    /// The encrypted content.
    #[prost(string, tag = "5")]
    pub encrypted_content: ::prost::alloc::string::String,
    /// The citations that the model used to answer the question.
    #[prost(message, repeated, tag = "6")]
    pub citations: ::prost::alloc::vec::Vec<InlineCitation>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InlineCitation {
    /// The display number for this citation (e.g., "1", "2", "3").
    /// This ID is reused when the same source is cited multiple times in a
    /// response, ensuring consistent numbering (e.g., the same URL always shows as
    /// \[1\]).
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// The character position in the response text where the citation markdown
    /// link begins. This is the index of the first '\[' character in the citation
    /// format [id](id)(url). Uses inclusive indexing (the character at this index is
    /// part of the citation).
    #[prost(int32, tag = "2")]
    pub start_index: i32,
    /// The character position in the response text immediately after the citation
    /// markdown link ends. This is the index after the final '\]' character in the
    /// citation format [id](id)(url). Uses exclusive indexing (the character at this
    /// index is NOT part of the citation). Together with start_index,
    /// text\[start_index:end_index\] extracts the full citation link.
    #[prost(int32, tag = "6")]
    pub end_index: i32,
    /// The citation type.
    #[prost(oneof = "inline_citation::Citation", tags = "3, 4, 5")]
    pub citation: ::core::option::Option<inline_citation::Citation>,
}
/// Nested message and enum types in `InlineCitation`.
pub mod inline_citation {
    /// The citation type.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Citation {
        /// The citation returned from the web search tool.
        #[prost(message, tag = "3")]
        WebCitation(super::WebCitation),
        /// The citation returned from the X search tool.
        #[prost(message, tag = "4")]
        XCitation(super::XCitation),
        /// The citation returned from the collections search tool.
        #[prost(message, tag = "5")]
        CollectionsCitation(super::CollectionsCitation),
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WebCitation {
    /// The url of the web page that the citation is from.
    #[prost(string, tag = "1")]
    pub url: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct XCitation {
    /// The url of the X post or profile that the citation is from.
    /// The url is always a x.com url.
    #[prost(string, tag = "1")]
    pub url: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CollectionsCitation {
    /// The id of the file that the citation is from.
    #[prost(string, tag = "1")]
    pub file_id: ::prost::alloc::string::String,
    /// The id of the chunk that the citation is from.
    #[prost(string, tag = "2")]
    pub chunk_id: ::prost::alloc::string::String,
    /// The content of the chunk that the citation is from.
    #[prost(string, tag = "3")]
    pub chunk_content: ::prost::alloc::string::String,
    /// The relevance score of the citation.
    #[prost(float, tag = "4")]
    pub score: f32,
    /// The ids of the collections that the citation is from.
    #[prost(string, repeated, tag = "5")]
    pub collection_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Holding the log probabilities of the sampling.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LogProbs {
    /// A list of log probability entries, each corresponding to a sampled token
    /// and its associated data.
    #[prost(message, repeated, tag = "1")]
    pub content: ::prost::alloc::vec::Vec<LogProb>,
}
/// Represents the logarithmic probability and metadata for a single sampled
/// token.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LogProb {
    /// The text representation of the sampled token.
    #[prost(string, tag = "1")]
    pub token: ::prost::alloc::string::String,
    /// The logarithmic probability of this token being sampled, given the prior
    /// context.
    #[prost(float, tag = "2")]
    pub logprob: f32,
    /// The raw byte representation of the token, useful for handling non-text or
    /// encoded data.
    #[prost(bytes = "vec", tag = "3")]
    pub bytes: ::prost::alloc::vec::Vec<u8>,
    /// A list of the top alternative tokens and their log probabilities at this
    /// sampling step.
    #[prost(message, repeated, tag = "4")]
    pub top_logprobs: ::prost::alloc::vec::Vec<TopLogProb>,
}
/// Represents an alternative token and its log probability among the top
/// candidates.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TopLogProb {
    /// The text representation of an alternative token considered by the model.
    #[prost(string, tag = "1")]
    pub token: ::prost::alloc::string::String,
    /// The logarithmic probability of this alternative token being sampled.
    #[prost(float, tag = "2")]
    pub logprob: f32,
    /// The raw byte representation of the alternative token.
    #[prost(bytes = "vec", tag = "3")]
    pub bytes: ::prost::alloc::vec::Vec<u8>,
}
/// Holds a single content element that is part of an input message.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Content {
    #[prost(oneof = "content::Content", tags = "1, 2, 3")]
    pub content: ::core::option::Option<content::Content>,
}
/// Nested message and enum types in `Content`.
pub mod content {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Content {
        /// The content is a pure text message.
        #[prost(string, tag = "1")]
        Text(::prost::alloc::string::String),
        /// The content is a single image.
        #[prost(message, tag = "2")]
        ImageUrl(super::ImageUrlContent),
        /// The content is a file attachment (PDF, document, etc.).
        #[prost(message, tag = "3")]
        File(super::FileContent),
    }
}
/// A file attachment in a message.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FileContent {
    /// The file ID from the Files API.
    ///
    /// When set, the file content will be fetched via the Files API.
    #[prost(string, tag = "1")]
    pub file_id: ::prost::alloc::string::String,
    /// Inline file bytes (optional).
    ///
    /// When set, the file content is provided directly in the chat request and does
    /// NOT require uploading to the Files API first.
    ///
    /// Exactly one of `file_id`, `data`, or `url` SHOULD be set.
    #[prost(bytes = "vec", tag = "2")]
    pub data: ::prost::alloc::vec::Vec<u8>,
    /// Filename for inline uploads.
    ///
    /// Recommended when `data` is set. Used for display and may be used by
    /// downstream systems to infer file type.
    #[prost(string, tag = "3")]
    pub filename: ::prost::alloc::string::String,
    /// Optional MIME type for inline uploads (e.g. "application/pdf").
    ///
    /// If unset, downstream systems may attempt to infer the MIME type from the
    /// content and/or filename.
    #[prost(string, tag = "4")]
    pub mime_type: ::prost::alloc::string::String,
    /// Public URL to a file attachment.
    ///
    /// When set, the file will be fetched from this URL as an attachment.
    /// Exactly one of `file_id`, `data`, or `url` SHOULD be set.
    #[prost(string, tag = "5")]
    pub url: ::prost::alloc::string::String,
}
/// A message in a conversation. This message is part of the model input. Each
/// message originates from a "role", which indicates the entity type who sent
/// the message. Messages can contain multiple content elements such as text and
/// images.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Message {
    /// The content of the message. Some model support multi-modal message contents
    /// that consist of text and images. At least one content element must be set
    /// for each message.
    #[prost(message, repeated, tag = "1")]
    pub content: ::prost::alloc::vec::Vec<Content>,
    /// Reasoning trace the model produced before issuing the final answer.
    #[prost(string, optional, tag = "5")]
    pub reasoning_content: ::core::option::Option<::prost::alloc::string::String>,
    /// The entity type who sent the message. For example, a message can be sent by
    /// a user or the assistant.
    #[prost(enumeration = "MessageRole", tag = "2")]
    pub role: i32,
    /// The name of the entity who sent the message. The name can only be set if
    /// the role is ROLE_USER.
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    /// The tools that the assistant wants to call.
    #[prost(message, repeated, tag = "4")]
    pub tool_calls: ::prost::alloc::vec::Vec<ToolCall>,
    /// The encrypted content.
    #[prost(string, tag = "6")]
    pub encrypted_content: ::prost::alloc::string::String,
    /// The ID associating this tool response with a prior invocation (for role = ROLE_TOOL).
    #[prost(string, optional, tag = "7")]
    pub tool_call_id: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ToolChoice {
    #[prost(oneof = "tool_choice::ToolChoice", tags = "1, 2")]
    pub tool_choice: ::core::option::Option<tool_choice::ToolChoice>,
}
/// Nested message and enum types in `ToolChoice`.
pub mod tool_choice {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum ToolChoice {
        /// Force the model to perform in a given mode.
        #[prost(enumeration = "super::ToolMode", tag = "1")]
        Mode(i32),
        /// Force the model to call a particular function.
        #[prost(string, tag = "2")]
        FunctionName(::prost::alloc::string::String),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Tool {
    #[prost(oneof = "tool::Tool", tags = "1, 3, 4, 5, 6, 7, 8")]
    pub tool: ::core::option::Option<tool::Tool>,
}
/// Nested message and enum types in `Tool`.
pub mod tool {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Tool {
        /// Tool Call defined by user
        #[prost(message, tag = "1")]
        Function(super::Function),
        /// Built in web search.
        #[prost(message, tag = "3")]
        WebSearch(super::WebSearch),
        /// Built in X search.
        #[prost(message, tag = "4")]
        XSearch(super::XSearch),
        /// Built in code execution.
        #[prost(message, tag = "5")]
        CodeExecution(super::CodeExecution),
        /// Built in collections search.
        #[prost(message, tag = "6")]
        CollectionsSearch(super::CollectionsSearch),
        /// A remote MCP server to use.
        #[prost(message, tag = "7")]
        Mcp(super::Mcp),
        /// Built in attachment search.
        #[prost(message, tag = "8")]
        AttachmentSearch(super::AttachmentSearch),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Mcp {
    /// A label for the server. if provided, this will be used to prefix tool calls.
    #[prost(string, tag = "1")]
    pub server_label: ::prost::alloc::string::String,
    /// A description of the server.
    #[prost(string, tag = "2")]
    pub server_description: ::prost::alloc::string::String,
    /// The URL of the MCP server.
    #[prost(string, tag = "3")]
    pub server_url: ::prost::alloc::string::String,
    /// A list of tool names that are allowed to be called by the model. If empty, all tools are allowed.
    #[prost(string, repeated, tag = "4")]
    pub allowed_tool_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// An optional authorization token to use when calling the MCP server. This will be set as the Authorization header.
    #[prost(string, optional, tag = "5")]
    pub authorization: ::core::option::Option<::prost::alloc::string::String>,
    /// Extra headers that will be included in the request to the MCP server.
    #[prost(map = "string, string", tag = "6")]
    pub extra_headers: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WebSearch {
    /// List of website domains (without protocol specification or subdomains) to exclude from search results (e.g., \["example.com"\]).
    /// Use this to prevent results from unwanted sites. A maximum of 5 websites can be excluded.
    /// This parameter cannot be set together with `allowed_domains`.
    #[prost(string, repeated, tag = "1")]
    pub excluded_domains: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// List of website domains (without protocol specification or subdomains)
    /// to restrict search results to (e.g., \["example.com"\]). A maximum of 5 websites can be allowed.
    /// Use this as a whitelist to limit results to only these specific sites; no other websites will
    /// be considered. If no relevant information is found on these websites, the number of results
    /// returned might be smaller than `max_search_results` set in `SearchParameters`. Note: This
    /// parameter cannot be set together with `excluded_domains`.
    #[prost(string, repeated, tag = "2")]
    pub allowed_domains: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Enable image understanding in downstream tools (e.g. allow fetching and interpreting images).
    /// When true, the server may add image viewing tools to the active MCP toolset.
    #[prost(bool, optional, tag = "3")]
    pub enable_image_understanding: ::core::option::Option<bool>,
    /// The user location to use for a preference on the search results.
    /// Setting this will make the agentic search results more relevant to the specified location,
    /// which is useful for geolocation-based search results refinement.
    #[prost(message, optional, tag = "4")]
    pub user_location: ::core::option::Option<WebSearchUserLocation>,
}
/// The user location to use for a preference on the search results.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WebSearchUserLocation {
    /// Two-letter ISO 3166-1 alpha-2 country code, like US, GB, etc.
    #[prost(string, optional, tag = "1")]
    pub country: ::core::option::Option<::prost::alloc::string::String>,
    /// Free text string for the city.
    #[prost(string, optional, tag = "2")]
    pub city: ::core::option::Option<::prost::alloc::string::String>,
    /// Free text string for the region.
    #[prost(string, optional, tag = "3")]
    pub region: ::core::option::Option<::prost::alloc::string::String>,
    /// IANA timezone like America/Chicago, Europe/London, etc.
    #[prost(string, optional, tag = "4")]
    pub timezone: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct XSearch {
    /// Optional start date for search results in ISO-8601 YYYY-MM-DD format (e.g., "2024-05-24").
    /// Only content after this date will be considered. Defaults to unset (no start date restriction).
    /// See <https://en.wikipedia.org/wiki/ISO_8601> for format details.
    #[prost(message, optional, tag = "1")]
    pub from_date: ::core::option::Option<::prost_types::Timestamp>,
    /// Optional end date for search results in ISO-8601 YYYY-MM-DD format (e.g., "2024-12-24").
    /// Only content before this date will be considered. Defaults to unset (no end date restriction).
    /// See <https://en.wikipedia.org/wiki/ISO_8601> for format details.
    #[prost(message, optional, tag = "2")]
    pub to_date: ::core::option::Option<::prost_types::Timestamp>,
    /// Optional list of X usernames (without the '@' symbol) to limit search results to posts
    /// from specific accounts (e.g., \["xai"\]). If set, only posts authored by these
    /// handles will be considered in the agentic search.
    /// This field can not be set together with `excluded_x_handles`.
    /// Defaults to unset (no exclusions).
    #[prost(string, repeated, tag = "3")]
    pub allowed_x_handles: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional list of X usernames (without the '@' symbol) used to exclude posts from specific accounts.
    /// If set, posts authored by these handles will be excluded from the agentic search results.
    /// This field can not be set together with `allowed_x_handles`.
    /// Defaults to unset (no exclusions).
    #[prost(string, repeated, tag = "4")]
    pub excluded_x_handles: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Enable image understanding in downstream tools (e.g. allow fetching and interpreting images).
    /// When true, the server may add image viewing tools to the active MCP toolset.
    #[prost(bool, optional, tag = "5")]
    pub enable_image_understanding: ::core::option::Option<bool>,
    /// Enable video understanding in downstream tools (e.g. allow fetching and interpreting videos).
    /// When true, the server may add video viewing tools to the active MCP toolset.
    #[prost(bool, optional, tag = "6")]
    pub enable_video_understanding: ::core::option::Option<bool>,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CodeExecution {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CollectionsSearch {
    /// The ID(s) of the source collection(s) within which the search should be performed.
    /// A maximum of 10 collections IDs can be used for search.
    #[prost(string, repeated, tag = "1")]
    pub collection_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional number of chunks to be returned for each collections search.
    /// Defaults to 10.
    #[prost(int32, optional, tag = "2")]
    pub limit: ::core::option::Option<i32>,
    /// User-defined instructions to be included in the search query. Defaults to generic search
    /// instructions used by the collections search backend if unset.
    #[prost(string, optional, tag = "3")]
    pub instructions: ::core::option::Option<::prost::alloc::string::String>,
    /// How to perform the document search. Defaults to hybrid retrieval when unset.
    #[prost(oneof = "collections_search::RetrievalMode", tags = "4, 5, 6")]
    pub retrieval_mode: ::core::option::Option<collections_search::RetrievalMode>,
}
/// Nested message and enum types in `CollectionsSearch`.
pub mod collections_search {
    /// How to perform the document search. Defaults to hybrid retrieval when unset.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum RetrievalMode {
        /// Perform hybrid retrieval combining keyword and semantic search.
        #[prost(message, tag = "4")]
        HybridRetrieval(super::HybridRetrieval),
        /// Perform pure semantic retrieval using dense embeddings.
        #[prost(message, tag = "5")]
        SemanticRetrieval(super::SemanticRetrieval),
        /// Perform keyword-based retrieval using sparse embeddings.
        #[prost(message, tag = "6")]
        KeywordRetrieval(super::KeywordRetrieval),
    }
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AttachmentSearch {
    /// Optional number of files to limit the search to.
    #[prost(int32, optional, tag = "2")]
    pub limit: ::core::option::Option<i32>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Function {
    /// Name of the function.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Description of the function.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Not supported: Only kept for compatibility reasons.
    #[prost(bool, tag = "3")]
    pub strict: bool,
    /// The parameters the functions accepts, described as a JSON Schema object.
    #[prost(string, tag = "4")]
    pub parameters: ::prost::alloc::string::String,
}
/// Content of a tool call, typically in a response from model.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ToolCall {
    /// The ID of the tool call.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Information to indicate whether the tool call needs to be executed on client side or server side.
    /// By default, it will be a client-side tool call if not specified.
    #[prost(enumeration = "ToolCallType", tag = "2")]
    pub r#type: i32,
    /// Status of the tool call.
    #[prost(enumeration = "ToolCallStatus", tag = "3")]
    pub status: i32,
    /// Error message if the tool call is failed.
    #[prost(string, optional, tag = "4")]
    pub error_message: ::core::option::Option<::prost::alloc::string::String>,
    /// Information regarding invoking the tool call.
    #[prost(oneof = "tool_call::Tool", tags = "10")]
    pub tool: ::core::option::Option<tool_call::Tool>,
}
/// Nested message and enum types in `ToolCall`.
pub mod tool_call {
    /// Information regarding invoking the tool call.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Tool {
        #[prost(message, tag = "10")]
        Function(super::FunctionCall),
    }
}
/// Tool call information.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FunctionCall {
    /// Name of the function to call.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Arguments used to call the function as json string.
    #[prost(string, tag = "2")]
    pub arguments: ::prost::alloc::string::String,
}
/// The response format for structured response.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ResponseFormat {
    /// Type of format expected for the response. Default to `FORMAT_TYPE_TEXT`
    #[prost(enumeration = "FormatType", tag = "1")]
    pub format_type: i32,
    /// The JSON schema that the response should conform to.
    /// Only considered if `format_type` is `FORMAT_TYPE_JSON_SCHEMA`.
    #[prost(string, optional, tag = "2")]
    pub schema: ::core::option::Option<::prost::alloc::string::String>,
}
/// Parameters for configuring search behavior in a chat request.
///
/// This message allows customization of search functionality when using models that support
/// searching external sources for information. You can specify which sources to search,
/// set date ranges for relevant content, control the search mode, and configure how
/// results are returned.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchParameters {
    /// Controls when search is performed. Possible values are:
    ///
    /// * OFF_SEARCH_MODE (default): No search is performed, and no external data will be considered.
    /// * ON_SEARCH_MODE: Search is always performed when sampling from the model and the model will search in every source provided for relevant data.
    /// * AUTO_SEARCH_MODE: The model decides whether to perform a search based on the prompt and which sources to use.
    #[prost(enumeration = "SearchMode", tag = "1")]
    pub mode: i32,
    /// A list of search sources to query, such as web, news, X, or RSS feeds.
    /// Multiple sources can be specified. If no sources are provided, the model will default to
    /// searching the web and X.
    #[prost(message, repeated, tag = "9")]
    pub sources: ::prost::alloc::vec::Vec<Source>,
    /// Optional start date for search results in ISO-8601 YYYY-MM-DD format (e.g., "2024-05-24").
    /// Only content after this date will be considered. Defaults to unset (no start date restriction).
    /// See <https://en.wikipedia.org/wiki/ISO_8601> for format details.
    #[prost(message, optional, tag = "4")]
    pub from_date: ::core::option::Option<::prost_types::Timestamp>,
    /// Optional end date for search results in ISO-8601 YYYY-MM-DD format (e.g., "2024-12-24").
    /// Only content before this date will be considered. Defaults to unset (no end date restriction).
    /// See <https://en.wikipedia.org/wiki/ISO_8601> for format details.
    #[prost(message, optional, tag = "5")]
    pub to_date: ::core::option::Option<::prost_types::Timestamp>,
    /// If set to true, the model will return a list of citations (URLs or references)
    /// to the sources used in generating the response. Defaults to true.
    #[prost(bool, tag = "7")]
    pub return_citations: bool,
    /// Optional limit on the number of search results to consider
    /// when generating a response. Must be in the range \[1, 30\]. Defaults to 15.
    #[prost(int32, optional, tag = "8")]
    pub max_search_results: ::core::option::Option<i32>,
}
/// Defines a source for search requests, specifying the type of content to search.
/// This message acts as a container for different types of search sources. Only one type
/// of source can be specified per instance using the oneof field.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Source {
    #[prost(oneof = "source::Source", tags = "1, 2, 3, 4")]
    pub source: ::core::option::Option<source::Source>,
}
/// Nested message and enum types in `Source`.
pub mod source {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Source {
        /// Configuration for searching online web content. Use this to search general websites
        /// with options to filter by country, exclude specific domains, or only allow specific domains.
        #[prost(message, tag = "1")]
        Web(super::WebSource),
        /// Configuration for searching recent articles and reports from news outlets.
        /// Useful for current events or topic-specific updates.
        #[prost(message, tag = "2")]
        News(super::NewsSource),
        /// Configuration for searching content on X. Allows focusing on
        /// specific user handles for targeted content.
        #[prost(message, tag = "3")]
        X(super::XSource),
        /// Configuration for searching content from RSS feeds. Requires specific feed URLs
        /// to query.
        #[prost(message, tag = "4")]
        Rss(super::RssSource),
    }
}
/// Configuration for a web search source in search requests.
///
/// This message configures a source for searching online web content. It allows specification
/// of regional content through country codes and filtering of results by excluding or allowing
/// specific websites.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WebSource {
    /// List of website domains (without protocol specification or subdomains) to exclude from search results (e.g., \["example.com"\]).
    /// Use this to prevent results from unwanted sites. A maximum of 5 websites can be excluded.
    /// This parameter cannot be set together with `allowed_websites`.
    #[prost(string, repeated, tag = "2")]
    pub excluded_websites: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// List of website domains (without protocol specification or subdomains)
    /// to restrict search results to (e.g., \["example.com"\]). A maximum of 5 websites can be allowed.
    /// Use this as a whitelist to limit results to only these specific sites; no other websites will
    /// be considered. If no relevant information is found on these websites, the number of results
    /// returned might be smaller than `max_search_results` set in `SearchParameters`. Note: This
    /// parameter cannot be set together with `excluded_websites`.
    #[prost(string, repeated, tag = "5")]
    pub allowed_websites: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional ISO alpha-2 country code (e.g., "BE" for Belgium) to limit search results
    /// to content from a specific region or country. Defaults to unset (global search).
    /// See <https://en.wikipedia.org/wiki/ISO_3166-2> for valid codes.
    #[prost(string, optional, tag = "3")]
    pub country: ::core::option::Option<::prost::alloc::string::String>,
    /// Whether to exclude adult content from the search results. Defaults to true.
    #[prost(bool, tag = "4")]
    pub safe_search: bool,
}
/// Configuration for a news search source in search requests.
///
/// This message configures a source for searching recent articles and reports from news outlets.
/// It is useful for obtaining current events or topic-specific updates with regional filtering.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct NewsSource {
    /// List of website domains (without protocol specification or subdomains)
    /// to exclude from search results (e.g., \["example.com"\]). A maximum of 5 websites can be excluded.
    /// Use this to prevent results from specific news sites. Defaults to unset (no exclusions).
    #[prost(string, repeated, tag = "2")]
    pub excluded_websites: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional ISO alpha-2 country code (e.g., "BE" for Belgium) to limit search results
    /// to news from a specific region or country. Defaults to unset (global news).
    /// See <https://en.wikipedia.org/wiki/ISO_3166-2> for valid codes.
    #[prost(string, optional, tag = "3")]
    pub country: ::core::option::Option<::prost::alloc::string::String>,
    /// Whether to exclude adult content from the search results. Defaults to true.
    #[prost(bool, tag = "4")]
    pub safe_search: bool,
}
/// Configuration for an X (formerly Twitter) search source in search requests.
///
/// This message configures a source for searching content on X. It allows focusing the search
/// on specific user handles to retrieve targeted posts and interactions.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct XSource {
    /// Optional list of X usernames (without the '@' symbol) to limit search results to posts
    /// from specific accounts (e.g., \["xai"\]). If set, only posts authored by these
    /// handles will be considered in the live search.
    /// This field can not be set together with `excluded_x_handles`.
    /// Defaults to unset (no exclusions).
    #[prost(string, repeated, tag = "7")]
    pub included_x_handles: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional list of X usernames (without the '@' symbol) used to exclude posts from specific accounts.
    /// If set, posts authored by these handles will be excluded from the live search results.
    /// This field can not be set together with `included_x_handles`.
    /// Defaults to unset (no exclusions).
    #[prost(string, repeated, tag = "8")]
    pub excluded_x_handles: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional post favorite count threshold. Defaults to unset (don't filter posts by post favorite count).
    /// If set, only posts with a favorite count greater than or equal to this threshold will be considered.
    #[prost(int32, optional, tag = "9")]
    pub post_favorite_count: ::core::option::Option<i32>,
    /// Optional post view count threshold. Defaults to unset (don't filter posts by post view count).
    /// If set, only posts with a view count greater than or equal to this threshold will be considered.
    #[prost(int32, optional, tag = "10")]
    pub post_view_count: ::core::option::Option<i32>,
}
/// Configuration for an RSS search source in search requests.
///
/// This message configures a source for searching content from RSS feeds. It requires specific
/// feed URLs to query for content updates.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RssSource {
    /// List of RSS feed URLs to search. Each URL must point to a valid RSS feed.
    /// At least one link must be provided.
    #[prost(string, repeated, tag = "1")]
    pub links: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RequestSettings {
    /// Max number of tokens that can be generated in a response. This includes both output and reasoning tokens.
    #[prost(int32, optional, tag = "1")]
    pub max_tokens: ::core::option::Option<i32>,
    /// / If set to false, the model can perform maximum one tool call. Default to true.
    #[prost(bool, tag = "2")]
    pub parallel_tool_calls: bool,
    /// The ID of the previous response from the model.
    #[prost(string, optional, tag = "3")]
    pub previous_response_id: ::core::option::Option<::prost::alloc::string::String>,
    /// Constrains effort on reasoning for reasoning models. Default to `EFFORT_MEDIUM`.
    #[prost(enumeration = "ReasoningEffort", optional, tag = "4")]
    pub reasoning_effort: ::core::option::Option<i32>,
    /// A number between 0 and 2 used to control the variance of completions.
    /// The smaller the value, the more deterministic the model will become. For
    /// example, if we sample 1000 answers to the same prompt at a temperature of
    /// 0.001, then most of the 1000 answers will be identical. Conversely, if we
    /// conduct the same experiment at a temperature of 2, virtually no two answers
    /// will be identical. Note that increasing the temperature will cause
    /// the model to hallucinate more strongly.
    #[prost(float, optional, tag = "5")]
    pub temperature: ::core::option::Option<f32>,
    /// Formatting constraint on the response.
    #[prost(message, optional, tag = "6")]
    pub response_format: ::core::option::Option<ResponseFormat>,
    /// Controls if the model can, should, or must not use tools.
    #[prost(message, optional, tag = "7")]
    pub tool_choice: ::core::option::Option<ToolChoice>,
    /// A list of tools the model may call. Currently, only functions are supported
    /// as a tool. Use this to provide a list of functions the model may generate
    /// JSON inputs for.
    #[prost(message, repeated, tag = "8")]
    pub tools: ::prost::alloc::vec::Vec<Tool>,
    /// A number between 0 and 1 controlling the likelihood of the model to use
    /// less-common answers. Recall that the model produces a probability for
    /// each token. This means, for any choice of token there are thousands of
    /// possibilities to choose from. This parameter controls the "nucleus sampling
    /// algorithm". Instead of considering every possible token at every step, we
    /// only look at the K tokens who's probabilities exceed `top_p`.
    /// For example, if we set `top_p = 0.9`, then the set of tokens we actually
    /// sample from, will have a probability mass of at least 90%. In practice,
    /// low values will make the model more deterministic.
    #[prost(float, optional, tag = "9")]
    pub top_p: ::core::option::Option<f32>,
    /// An opaque string supplied by the API client (customer) to identify a user.
    /// The string will be stored in the logs and can be used in customer service
    /// requests to identify certain requests.
    #[prost(string, tag = "10")]
    pub user: ::prost::alloc::string::String,
    /// Set the parameters to be used for realtime data. If not set, no realtime data will be acquired by the model.
    #[prost(message, optional, tag = "11")]
    pub search_parameters: ::core::option::Option<SearchParameters>,
    /// Whether to store request and responses. Default is false.
    #[prost(bool, tag = "12")]
    pub store_messages: bool,
    /// Whether to use encrypted thinking for thinking trace rehydration.
    #[prost(bool, tag = "13")]
    pub use_encrypted_content: bool,
    /// Allow the users to control what optional fields to be returned in the response.
    #[prost(enumeration = "IncludeOption", repeated, tag = "14")]
    pub include: ::prost::alloc::vec::Vec<i32>,
}
/// Request to retrieve a stored completion response.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetStoredCompletionRequest {
    /// The response id to be retrieved.
    #[prost(string, tag = "1")]
    pub response_id: ::prost::alloc::string::String,
}
/// Request to delete a stored completion response.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteStoredCompletionRequest {
    /// The response id to be deleted.
    #[prost(string, tag = "1")]
    pub response_id: ::prost::alloc::string::String,
}
/// Response for deleting a stored completion.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteStoredCompletionResponse {
    /// The response id that was deleted.
    #[prost(string, tag = "1")]
    pub response_id: ::prost::alloc::string::String,
}
/// Holds debug information. Only available to trusted testers.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DebugOutput {
    /// Number of attempts made to the model.
    #[prost(int32, tag = "1")]
    pub attempts: i32,
    /// The request received from the user.
    #[prost(string, tag = "2")]
    pub request: ::prost::alloc::string::String,
    /// The prompt sent to the model in text form.
    #[prost(string, tag = "3")]
    pub prompt: ::prost::alloc::string::String,
    /// The JSON-serialized request sent to the inference engine.
    #[prost(string, tag = "9")]
    pub engine_request: ::prost::alloc::string::String,
    /// The response(s) received from the model.
    #[prost(string, repeated, tag = "4")]
    pub responses: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// The raw chunks returned from the pipeline of samplers.
    #[prost(string, repeated, tag = "12")]
    pub chunks: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Number of cache reads
    #[prost(uint32, tag = "5")]
    pub cache_read_count: u32,
    /// Size of cache read
    #[prost(uint64, tag = "6")]
    pub cache_read_input_bytes: u64,
    /// Number of cache writes
    #[prost(uint32, tag = "7")]
    pub cache_write_count: u32,
    /// Size of cache write
    #[prost(uint64, tag = "8")]
    pub cache_write_input_bytes: u64,
    /// The lb address header
    #[prost(string, tag = "10")]
    pub lb_address: ::prost::alloc::string::String,
    /// The tag of the sampler that served this request.
    #[prost(string, tag = "11")]
    pub sampler_tag: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum IncludeOption {
    /// Default value / invalid option.
    Invalid = 0,
    /// Include the encrypted output from the web search tool in the response.
    WebSearchCallOutput = 1,
    /// Include the encrypted output from the X search tool in the response.
    XSearchCallOutput = 2,
    /// Include the plaintext output from the code execution tool in the response.
    CodeExecutionCallOutput = 3,
    /// Include the plaintext output from the collections search tool in the response.
    CollectionsSearchCallOutput = 4,
    /// Include the plaintext output from the attachment search tool in the response.
    AttachmentSearchCallOutput = 5,
    /// Include the plaintext output from the MCP tool in the response.
    McpCallOutput = 6,
    /// Include the inline citations in the final response.
    InlineCitations = 7,
    /// Stream back any chunks that are generated by the model or the agent tools
    /// even if there is no user-visible content in the chunk, e.g. only the usage
    /// statistics are being updated.
    /// The chunks without user-visible content are not streamed to the client when
    /// this option is not included by default.
    /// This option is only available for streaming responses.
    VerboseStreaming = 8,
}
impl IncludeOption {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Invalid => "INCLUDE_OPTION_INVALID",
            Self::WebSearchCallOutput => "INCLUDE_OPTION_WEB_SEARCH_CALL_OUTPUT",
            Self::XSearchCallOutput => "INCLUDE_OPTION_X_SEARCH_CALL_OUTPUT",
            Self::CodeExecutionCallOutput => "INCLUDE_OPTION_CODE_EXECUTION_CALL_OUTPUT",
            Self::CollectionsSearchCallOutput => {
                "INCLUDE_OPTION_COLLECTIONS_SEARCH_CALL_OUTPUT"
            }
            Self::AttachmentSearchCallOutput => {
                "INCLUDE_OPTION_ATTACHMENT_SEARCH_CALL_OUTPUT"
            }
            Self::McpCallOutput => "INCLUDE_OPTION_MCP_CALL_OUTPUT",
            Self::InlineCitations => "INCLUDE_OPTION_INLINE_CITATIONS",
            Self::VerboseStreaming => "INCLUDE_OPTION_VERBOSE_STREAMING",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "INCLUDE_OPTION_INVALID" => Some(Self::Invalid),
            "INCLUDE_OPTION_WEB_SEARCH_CALL_OUTPUT" => Some(Self::WebSearchCallOutput),
            "INCLUDE_OPTION_X_SEARCH_CALL_OUTPUT" => Some(Self::XSearchCallOutput),
            "INCLUDE_OPTION_CODE_EXECUTION_CALL_OUTPUT" => {
                Some(Self::CodeExecutionCallOutput)
            }
            "INCLUDE_OPTION_COLLECTIONS_SEARCH_CALL_OUTPUT" => {
                Some(Self::CollectionsSearchCallOutput)
            }
            "INCLUDE_OPTION_ATTACHMENT_SEARCH_CALL_OUTPUT" => {
                Some(Self::AttachmentSearchCallOutput)
            }
            "INCLUDE_OPTION_MCP_CALL_OUTPUT" => Some(Self::McpCallOutput),
            "INCLUDE_OPTION_INLINE_CITATIONS" => Some(Self::InlineCitations),
            "INCLUDE_OPTION_VERBOSE_STREAMING" => Some(Self::VerboseStreaming),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum MessageRole {
    /// Default value / invalid role.
    InvalidRole = 0,
    /// User role.
    RoleUser = 1,
    /// Assistant role, normally the response from the model.
    RoleAssistant = 2,
    /// System role, typically for system instructions.
    RoleSystem = 3,
    /// Indicates a return from a tool call. Deprecated in favor of ROLE_TOOL.
    #[deprecated]
    RoleFunction = 4,
    /// Indicates a return from a tool call.
    RoleTool = 5,
    /// Developer role, typically for developer instructions, e.g. tool usage instructions.
    RoleDeveloper = 6,
}
impl MessageRole {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::InvalidRole => "INVALID_ROLE",
            Self::RoleUser => "ROLE_USER",
            Self::RoleAssistant => "ROLE_ASSISTANT",
            Self::RoleSystem => "ROLE_SYSTEM",
            #[allow(deprecated)]
            Self::RoleFunction => "ROLE_FUNCTION",
            Self::RoleTool => "ROLE_TOOL",
            Self::RoleDeveloper => "ROLE_DEVELOPER",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "INVALID_ROLE" => Some(Self::InvalidRole),
            "ROLE_USER" => Some(Self::RoleUser),
            "ROLE_ASSISTANT" => Some(Self::RoleAssistant),
            "ROLE_SYSTEM" => Some(Self::RoleSystem),
            "ROLE_FUNCTION" => Some(#[allow(deprecated)] Self::RoleFunction),
            "ROLE_TOOL" => Some(Self::RoleTool),
            "ROLE_DEVELOPER" => Some(Self::RoleDeveloper),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ReasoningEffort {
    InvalidEffort = 0,
    EffortLow = 1,
    EffortMedium = 2,
    EffortHigh = 3,
    EffortNone = 4,
}
impl ReasoningEffort {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::InvalidEffort => "INVALID_EFFORT",
            Self::EffortLow => "EFFORT_LOW",
            Self::EffortMedium => "EFFORT_MEDIUM",
            Self::EffortHigh => "EFFORT_HIGH",
            Self::EffortNone => "EFFORT_NONE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "INVALID_EFFORT" => Some(Self::InvalidEffort),
            "EFFORT_LOW" => Some(Self::EffortLow),
            "EFFORT_MEDIUM" => Some(Self::EffortMedium),
            "EFFORT_HIGH" => Some(Self::EffortHigh),
            "EFFORT_NONE" => Some(Self::EffortNone),
            _ => None,
        }
    }
}
/// Number of agents to use for multi-agent models.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum AgentCount {
    /// Unspecified / unset value.
    Unspecified = 0,
    /// Use 4 agents.
    AgentCount4 = 1,
    /// Use 16 agents.
    AgentCount16 = 2,
}
impl AgentCount {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "AGENT_COUNT_UNSPECIFIED",
            Self::AgentCount4 => "AGENT_COUNT_4",
            Self::AgentCount16 => "AGENT_COUNT_16",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "AGENT_COUNT_UNSPECIFIED" => Some(Self::Unspecified),
            "AGENT_COUNT_4" => Some(Self::AgentCount4),
            "AGENT_COUNT_16" => Some(Self::AgentCount16),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ToolMode {
    /// Invalid tool mode.
    Invalid = 0,
    /// Let the model decide if a tool shall be used.
    Auto = 1,
    /// Force the model to not use tools.
    None = 2,
    /// Force the model to use tools.
    Required = 3,
}
impl ToolMode {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Invalid => "TOOL_MODE_INVALID",
            Self::Auto => "TOOL_MODE_AUTO",
            Self::None => "TOOL_MODE_NONE",
            Self::Required => "TOOL_MODE_REQUIRED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "TOOL_MODE_INVALID" => Some(Self::Invalid),
            "TOOL_MODE_AUTO" => Some(Self::Auto),
            "TOOL_MODE_NONE" => Some(Self::None),
            "TOOL_MODE_REQUIRED" => Some(Self::Required),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum FormatType {
    /// Invalid format type.
    Invalid = 0,
    /// Raw text.
    Text = 1,
    /// Any JSON object.
    JsonObject = 2,
    /// Follow a JSON schema.
    JsonSchema = 3,
}
impl FormatType {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Invalid => "FORMAT_TYPE_INVALID",
            Self::Text => "FORMAT_TYPE_TEXT",
            Self::JsonObject => "FORMAT_TYPE_JSON_OBJECT",
            Self::JsonSchema => "FORMAT_TYPE_JSON_SCHEMA",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "FORMAT_TYPE_INVALID" => Some(Self::Invalid),
            "FORMAT_TYPE_TEXT" => Some(Self::Text),
            "FORMAT_TYPE_JSON_OBJECT" => Some(Self::JsonObject),
            "FORMAT_TYPE_JSON_SCHEMA" => Some(Self::JsonSchema),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ToolCallType {
    Invalid = 0,
    /// Indicates the tool is a client-side tool, and should be executed on client side.
    /// Maps to `function_call` type in OAI Responses API.
    ClientSideTool = 1,
    /// Indicates the tool is a server-side web_search tool, and client side won't need to execute.
    /// Maps to `web_search_call` type in OAI Responses API.
    WebSearchTool = 2,
    /// Indicates the tool is a server-side x_search tool, and client side won't need to execute.
    /// Maps to `x_search_call` type in OAI Responses API.
    XSearchTool = 3,
    /// Indicates the tool is a server-side code_execution tool, and client side won't need to execute.
    /// Maps to `code_interpreter_call` type in OAI Responses API.
    CodeExecutionTool = 4,
    /// Indicates the tool is a server-side collections_search tool, and client side won't need to execute.
    /// Maps to `file_search_call` type in OAI Responses API.
    CollectionsSearchTool = 5,
    /// Indicates the tool is a server-side mcp_tool, and client side won't need to execute.
    /// Maps to `mcp_call` type in OAI Responses API.
    McpTool = 6,
    /// Indicates the tool is a server-side attachment_search tool, and client side won't need to execute.
    /// Maps to `attachment_search_call` type in OAI Responses API.
    AttachmentSearchTool = 7,
}
impl ToolCallType {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Invalid => "TOOL_CALL_TYPE_INVALID",
            Self::ClientSideTool => "TOOL_CALL_TYPE_CLIENT_SIDE_TOOL",
            Self::WebSearchTool => "TOOL_CALL_TYPE_WEB_SEARCH_TOOL",
            Self::XSearchTool => "TOOL_CALL_TYPE_X_SEARCH_TOOL",
            Self::CodeExecutionTool => "TOOL_CALL_TYPE_CODE_EXECUTION_TOOL",
            Self::CollectionsSearchTool => "TOOL_CALL_TYPE_COLLECTIONS_SEARCH_TOOL",
            Self::McpTool => "TOOL_CALL_TYPE_MCP_TOOL",
            Self::AttachmentSearchTool => "TOOL_CALL_TYPE_ATTACHMENT_SEARCH_TOOL",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "TOOL_CALL_TYPE_INVALID" => Some(Self::Invalid),
            "TOOL_CALL_TYPE_CLIENT_SIDE_TOOL" => Some(Self::ClientSideTool),
            "TOOL_CALL_TYPE_WEB_SEARCH_TOOL" => Some(Self::WebSearchTool),
            "TOOL_CALL_TYPE_X_SEARCH_TOOL" => Some(Self::XSearchTool),
            "TOOL_CALL_TYPE_CODE_EXECUTION_TOOL" => Some(Self::CodeExecutionTool),
            "TOOL_CALL_TYPE_COLLECTIONS_SEARCH_TOOL" => Some(Self::CollectionsSearchTool),
            "TOOL_CALL_TYPE_MCP_TOOL" => Some(Self::McpTool),
            "TOOL_CALL_TYPE_ATTACHMENT_SEARCH_TOOL" => Some(Self::AttachmentSearchTool),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ToolCallStatus {
    /// The tool call is in progress.
    InProgress = 0,
    /// The tool call is completed.
    Completed = 1,
    /// The tool call is incomplete.
    Incomplete = 2,
    /// The tool call is failed.
    Failed = 3,
}
impl ToolCallStatus {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::InProgress => "TOOL_CALL_STATUS_IN_PROGRESS",
            Self::Completed => "TOOL_CALL_STATUS_COMPLETED",
            Self::Incomplete => "TOOL_CALL_STATUS_INCOMPLETE",
            Self::Failed => "TOOL_CALL_STATUS_FAILED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "TOOL_CALL_STATUS_IN_PROGRESS" => Some(Self::InProgress),
            "TOOL_CALL_STATUS_COMPLETED" => Some(Self::Completed),
            "TOOL_CALL_STATUS_INCOMPLETE" => Some(Self::Incomplete),
            "TOOL_CALL_STATUS_FAILED" => Some(Self::Failed),
            _ => None,
        }
    }
}
/// Mode to control the web search.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SearchMode {
    InvalidSearchMode = 0,
    OffSearchMode = 1,
    OnSearchMode = 2,
    AutoSearchMode = 3,
}
impl SearchMode {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::InvalidSearchMode => "INVALID_SEARCH_MODE",
            Self::OffSearchMode => "OFF_SEARCH_MODE",
            Self::OnSearchMode => "ON_SEARCH_MODE",
            Self::AutoSearchMode => "AUTO_SEARCH_MODE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "INVALID_SEARCH_MODE" => Some(Self::InvalidSearchMode),
            "OFF_SEARCH_MODE" => Some(Self::OffSearchMode),
            "ON_SEARCH_MODE" => Some(Self::OnSearchMode),
            "AUTO_SEARCH_MODE" => Some(Self::AutoSearchMode),
            _ => None,
        }
    }
}
/// Generated client implementations.
pub mod chat_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// An API that exposes our language models via a Chat interface.
    #[derive(Debug, Clone)]
    pub struct ChatClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ChatClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> ChatClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> ChatClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            ChatClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Samples a response from the model and blocks until the response has been
        /// fully generated.
        pub async fn get_completion(
            &mut self,
            request: impl tonic::IntoRequest<super::GetCompletionsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetChatCompletionResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.Chat/GetCompletion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.Chat", "GetCompletion"));
            self.inner.unary(req, path, codec).await
        }
        /// Samples a response from the model and streams out the model tokens as they
        /// are being generated.
        pub async fn get_completion_chunk(
            &mut self,
            request: impl tonic::IntoRequest<super::GetCompletionsRequest>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::GetChatCompletionChunk>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.Chat/GetCompletionChunk",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.Chat", "GetCompletionChunk"));
            self.inner.server_streaming(req, path, codec).await
        }
        /// Starts sampling of the model and immediately returns a response containing
        /// a request id. The request id may be used to poll
        /// the `GetDeferredCompletion` RPC.
        pub async fn start_deferred_completion(
            &mut self,
            request: impl tonic::IntoRequest<super::GetCompletionsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::StartDeferredResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.Chat/StartDeferredCompletion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.Chat", "StartDeferredCompletion"));
            self.inner.unary(req, path, codec).await
        }
        /// Gets the result of a deferred completion started by calling `StartDeferredCompletion`.
        pub async fn get_deferred_completion(
            &mut self,
            request: impl tonic::IntoRequest<super::GetDeferredRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetDeferredCompletionResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.Chat/GetDeferredCompletion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.Chat", "GetDeferredCompletion"));
            self.inner.unary(req, path, codec).await
        }
        /// Retrieve a stored response using the response ID.
        pub async fn get_stored_completion(
            &mut self,
            request: impl tonic::IntoRequest<super::GetStoredCompletionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetChatCompletionResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.Chat/GetStoredCompletion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.Chat", "GetStoredCompletion"));
            self.inner.unary(req, path, codec).await
        }
        /// Delete a stored response using the response ID.
        pub async fn delete_stored_completion(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteStoredCompletionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::DeleteStoredCompletionResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.Chat/DeleteStoredCompletion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.Chat", "DeleteStoredCompletion"));
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Specifies a video by URL for video editing.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct VideoUrlContent {
    /// Either a URL of the video (e.g., a public URL) or a base64-encoded video
    /// as a data URL (e.g., "data:video/mp4;base64,...").
    #[prost(string, tag = "1")]
    pub url: ::prost::alloc::string::String,
}
/// Request message for generating a video.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GenerateVideoRequest {
    /// Input prompt to generate a video from.
    #[prost(string, tag = "1")]
    pub prompt: ::prost::alloc::string::String,
    /// Optional input image for image-to-video generation.
    /// If provided, generates video with this image as the first frame.
    /// If omitted, generates text-to-video.
    /// Supports the same formats as image generation: URL or base64-encoded image.
    #[prost(message, optional, tag = "2")]
    pub image: ::core::option::Option<ImageUrlContent>,
    /// Name or alias of the video generation model to be used.
    #[prost(string, tag = "3")]
    pub model: ::prost::alloc::string::String,
    /// Duration of the video to be generated in seconds (1-15 seconds).
    #[prost(int32, optional, tag = "4")]
    pub duration: ::core::option::Option<i32>,
    /// Optional input video for video editing.
    /// If provided, the video will be edited based on the prompt.
    /// Supports URL or base64-encoded video data.
    #[prost(message, optional, tag = "6")]
    pub video: ::core::option::Option<VideoUrlContent>,
    /// Optional aspect ratio for video generation.
    /// Defaults to 16:9 if not specified.
    #[prost(enumeration = "VideoAspectRatio", optional, tag = "7")]
    pub aspect_ratio: ::core::option::Option<i32>,
    /// Optional resolution for video generation.
    /// Defaults to 480p if not specified.
    #[prost(enumeration = "VideoResolution", optional, tag = "8")]
    pub resolution: ::core::option::Option<i32>,
    /// Optional reference images for reference-to-video (R2V) generation.
    /// When provided (and `image` is not set), generates video using these images
    /// as style/content references.
    #[prost(message, repeated, tag = "13")]
    pub reference_images: ::prost::alloc::vec::Vec<ImageUrlContent>,
}
/// Request for retrieving deferred video generation results.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetDeferredVideoRequest {
    /// The ID of the request to get.
    #[prost(string, tag = "1")]
    pub request_id: ::prost::alloc::string::String,
}
/// The response from the video generation models containing the generated video.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct VideoResponse {
    /// The generated video.
    #[prost(message, optional, tag = "1")]
    pub video: ::core::option::Option<GeneratedVideo>,
    /// The model used to generate the video (ignoring aliases).
    #[prost(string, tag = "2")]
    pub model: ::prost::alloc::string::String,
    /// Billing and cost information for this request.
    #[prost(message, optional, tag = "3")]
    pub usage: ::core::option::Option<SamplingUsage>,
    /// Structured error describing why video generation failed.
    /// Only present when the background generation encountered a failure
    /// (either client error 4xx or server error 5xx).
    #[prost(message, optional, tag = "6")]
    pub error: ::core::option::Option<VideoError>,
    /// Approximate completion percentage for the video generation task (0-100).
    ///
    /// * When status is `PENDING`: progress is between 0-99, indicating current
    ///   completion.
    /// * When status is `DONE`: progress is 100.
    /// * When status is `FAILED`: progress is 0.
    #[prost(int32, tag = "7")]
    pub progress: i32,
}
/// Contains all data related to a generated video.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GeneratedVideo {
    /// A url that points to the generated video.
    #[prost(string, tag = "1")]
    pub url: ::prost::alloc::string::String,
    /// Duration of the generated video in seconds.
    #[prost(int32, tag = "4")]
    pub duration: i32,
    /// Whether the video generated by the model respects moderation rules.
    /// The field will be true if the video respects moderation rules. Otherwise
    /// the field will be false and the video url field will be empty.
    #[prost(bool, tag = "5")]
    pub respect_moderation: bool,
}
/// Response from GetDeferredVideo, including the response if the video
/// generation request has been processed without error.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetDeferredVideoResponse {
    /// Current status of the request.
    #[prost(enumeration = "DeferredStatus", tag = "1")]
    pub status: i32,
    /// Response. Only present if `status=DONE` or `status=FAILED`.
    /// When failed, the `error` field in VideoResponse describes the failure.
    #[prost(message, optional, tag = "2")]
    pub response: ::core::option::Option<VideoResponse>,
}
/// Structured error returned when video generation fails.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct VideoError {
    /// Machine-readable error code (e.g. "invalid_argument", "internal_error").
    #[prost(string, tag = "1")]
    pub code: ::prost::alloc::string::String,
    /// Human-readable error message describing the failure.
    #[prost(string, tag = "2")]
    pub message: ::prost::alloc::string::String,
}
/// Request message for extending an existing video.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExtendVideoRequest {
    /// Prompt describing what should happen next in the video.
    #[prost(string, tag = "1")]
    pub prompt: ::prost::alloc::string::String,
    /// Input video to extend. The extension continues from the end of this video.
    /// Supports URL or base64-encoded video data.
    /// Input video must be between 2 and 30 seconds long.
    #[prost(message, optional, tag = "2")]
    pub video: ::core::option::Option<VideoUrlContent>,
    /// Name or alias of the video generation model to be used.
    #[prost(string, tag = "3")]
    pub model: ::prost::alloc::string::String,
    /// Duration of the extension segment to generate in seconds (1-10).
    /// Defaults to 6 seconds if not specified.
    #[prost(int32, optional, tag = "4")]
    pub duration: ::core::option::Option<i32>,
}
/// Aspect ratio for video generation.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum VideoAspectRatio {
    /// Invalid/unspecified aspect ratio - defaults to 16:9.
    Unspecified = 0,
    /// 1:1 aspect ratio (square).
    VideoAspectRatio11 = 1,
    /// 16:9 aspect ratio (wide landscape).
    VideoAspectRatio169 = 2,
    /// 9:16 aspect ratio (tall portrait).
    VideoAspectRatio916 = 3,
    /// 4:3 aspect ratio (standard landscape).
    VideoAspectRatio43 = 4,
    /// 3:4 aspect ratio (standard portrait).
    VideoAspectRatio34 = 5,
    /// 3:2 aspect ratio (photo landscape).
    VideoAspectRatio32 = 6,
    /// 2:3 aspect ratio (photo portrait).
    VideoAspectRatio23 = 7,
}
impl VideoAspectRatio {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "VIDEO_ASPECT_RATIO_UNSPECIFIED",
            Self::VideoAspectRatio11 => "VIDEO_ASPECT_RATIO_1_1",
            Self::VideoAspectRatio169 => "VIDEO_ASPECT_RATIO_16_9",
            Self::VideoAspectRatio916 => "VIDEO_ASPECT_RATIO_9_16",
            Self::VideoAspectRatio43 => "VIDEO_ASPECT_RATIO_4_3",
            Self::VideoAspectRatio34 => "VIDEO_ASPECT_RATIO_3_4",
            Self::VideoAspectRatio32 => "VIDEO_ASPECT_RATIO_3_2",
            Self::VideoAspectRatio23 => "VIDEO_ASPECT_RATIO_2_3",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "VIDEO_ASPECT_RATIO_UNSPECIFIED" => Some(Self::Unspecified),
            "VIDEO_ASPECT_RATIO_1_1" => Some(Self::VideoAspectRatio11),
            "VIDEO_ASPECT_RATIO_16_9" => Some(Self::VideoAspectRatio169),
            "VIDEO_ASPECT_RATIO_9_16" => Some(Self::VideoAspectRatio916),
            "VIDEO_ASPECT_RATIO_4_3" => Some(Self::VideoAspectRatio43),
            "VIDEO_ASPECT_RATIO_3_4" => Some(Self::VideoAspectRatio34),
            "VIDEO_ASPECT_RATIO_3_2" => Some(Self::VideoAspectRatio32),
            "VIDEO_ASPECT_RATIO_2_3" => Some(Self::VideoAspectRatio23),
            _ => None,
        }
    }
}
/// Resolution for video generation.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum VideoResolution {
    /// Invalid/unspecified resolution - defaults to 480p.
    Unspecified = 0,
    /// 480p resolution.
    /// Dimensions vary by aspect ratio
    VideoResolution480p = 1,
    /// 720p resolution.
    /// Dimensions vary by aspect ratio
    VideoResolution720p = 2,
}
impl VideoResolution {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "VIDEO_RESOLUTION_UNSPECIFIED",
            Self::VideoResolution480p => "VIDEO_RESOLUTION_480P",
            Self::VideoResolution720p => "VIDEO_RESOLUTION_720P",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "VIDEO_RESOLUTION_UNSPECIFIED" => Some(Self::Unspecified),
            "VIDEO_RESOLUTION_480P" => Some(Self::VideoResolution480p),
            "VIDEO_RESOLUTION_720P" => Some(Self::VideoResolution720p),
            _ => None,
        }
    }
}
/// Generated client implementations.
pub mod video_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// An API service for interaction with video generation models.
    #[derive(Debug, Clone)]
    pub struct VideoClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl VideoClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> VideoClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> VideoClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            VideoClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Create a video based on a text prompt and optionally an image.
        /// If an image is provided, generates video with the image as the first frame
        /// (image-to-video). If no image is provided, generates video from text only
        /// (text-to-video).
        ///
        /// This is an asynchronous operation. The method returns immediately with a
        /// request_id that can be used to poll for the result using GetDeferredVideo.
        pub async fn generate_video(
            &mut self,
            request: impl tonic::IntoRequest<super::GenerateVideoRequest>,
        ) -> std::result::Result<
            tonic::Response<super::StartDeferredResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.Video/GenerateVideo",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.Video", "GenerateVideo"));
            self.inner.unary(req, path, codec).await
        }
        /// Extend an existing video by generating continuation content.
        ///
        /// This is an asynchronous operation. The method returns immediately with a
        /// request_id that can be used to poll for the result using GetDeferredVideo.
        pub async fn extend_video(
            &mut self,
            request: impl tonic::IntoRequest<super::ExtendVideoRequest>,
        ) -> std::result::Result<
            tonic::Response<super::StartDeferredResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.Video/ExtendVideo",
            );
            let mut req = request.into_request();
            req.extensions_mut().insert(GrpcMethod::new("xai_api.Video", "ExtendVideo"));
            self.inner.unary(req, path, codec).await
        }
        /// Gets the result of a video generation started by calling `GenerateVideo` or
        /// `ExtendVideo`.
        pub async fn get_deferred_video(
            &mut self,
            request: impl tonic::IntoRequest<super::GetDeferredVideoRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetDeferredVideoResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.Video/GetDeferredVideo",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.Video", "GetDeferredVideo"));
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Holds basic information about a batch process.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Batch {
    /// The ID of the batch. Can be used to retrieve batch results and metadata, etc.
    #[prost(string, tag = "1")]
    pub batch_id: ::prost::alloc::string::String,
    /// The name of the batch.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// The time when the batch was created.
    #[prost(message, optional, tag = "3")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The time when the batch expires.
    #[prost(message, optional, tag = "4")]
    pub expire_time: ::core::option::Option<::prost_types::Timestamp>,
    /// ID of the API key that was used to create the batch.
    #[prost(string, tag = "5")]
    pub create_api_key_id: ::prost::alloc::string::String,
    /// Time when the batch was cancelled.
    #[prost(message, optional, tag = "6")]
    pub cancel_time: ::core::option::Option<::prost_types::Timestamp>,
    /// If the batch was cancelled by xAI, an error message explaining why.
    #[prost(string, optional, tag = "7")]
    pub cancel_by_xai_message: ::core::option::Option<::prost::alloc::string::String>,
    /// The state information of the batch. Not always populated.
    #[prost(message, optional, tag = "8")]
    pub state: ::core::option::Option<BatchState>,
    /// Cost breakdown for processed requests.
    #[prost(message, optional, tag = "9")]
    pub cost_breakdown: ::core::option::Option<BatchCostBreakdown>,
    /// File ID of the uploaded JSONL input file (from Files API). Only set
    /// when the batch was created via file upload.
    #[prost(string, optional, tag = "10")]
    pub input_file_id: ::core::option::Option<::prost::alloc::string::String>,
}
/// Holds aggregate information about the current state of a batch process.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BatchState {
    /// Total number of requests in the batch.
    #[prost(int64, tag = "1")]
    pub num_requests: i64,
    /// Total number of pending requests.
    #[prost(int64, tag = "2")]
    pub num_pending: i64,
    /// Total number of requests that have finished successfully.
    #[prost(int64, tag = "3")]
    pub num_success: i64,
    /// Total number of requests that finished with an error.
    #[prost(int64, tag = "4")]
    pub num_error: i64,
    /// Total number of requests that have been cancelled.
    #[prost(int64, tag = "5")]
    pub num_cancelled: i64,
}
/// Holds cost information for processed batch requests.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchCostBreakdown {
    /// Total cost across all processed requests of all endpoints in USD ticks ($0.0000000001 / $1e-10).
    #[prost(int64, tag = "1")]
    pub total_cost_usd_ticks: i64,
    /// Cost breakdown by endpoint.
    #[prost(message, repeated, tag = "2")]
    pub endpoint_costs: ::prost::alloc::vec::Vec<EndpointCost>,
    /// Timestamp when the cost was calculated.
    #[prost(message, optional, tag = "3")]
    pub calculation_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Cost breakdown for a specific endpoint.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct EndpointCost {
    /// Endpoint for cost aggregation.
    #[prost(string, tag = "1")]
    pub endpoint: ::prost::alloc::string::String,
    /// Cost for this endpoint in USD ticks ($0.0000000001 / $1e-10).
    #[prost(int64, tag = "2")]
    pub cost_usd_ticks: i64,
    /// Number of requests processed for this endpoint.
    #[prost(int64, tag = "3")]
    pub request_count: i64,
}
/// A request that can be added to a batch for processing.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchRequest {
    /// An optional user-provided identifier for the input request. If provided, it must be unique within the batch.
    /// Used to identify the corresponding result when the response is returned to the user.
    /// This is because the order of the returned results is not guaranteed to be the same as the order of the requests.
    #[prost(string, optional, tag = "1")]
    pub batch_request_id: ::core::option::Option<::prost::alloc::string::String>,
    /// The request to add for processing in the batch.
    #[prost(oneof = "batch_request::Request", tags = "2, 3, 4, 5")]
    pub request: ::core::option::Option<batch_request::Request>,
}
/// Nested message and enum types in `BatchRequest`.
pub mod batch_request {
    /// The request to add for processing in the batch.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Request {
        /// A completion request to send for processing in the batch.
        #[prost(message, tag = "2")]
        CompletionRequest(super::GetCompletionsRequest),
        /// An image generation or editing request to send for processing in the batch.
        #[prost(message, tag = "3")]
        ImageRequest(super::GenerateImageRequest),
        /// A video generation request to send for processing in the batch.
        #[prost(message, tag = "4")]
        VideoRequest(super::GenerateVideoRequest),
        /// A video extension request to send for processing in the batch.
        #[prost(message, tag = "5")]
        VideoExtensionRequest(super::ExtendVideoRequest),
    }
}
/// A container for the response that is returned in a `BatchResult`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchResultData {
    /// The response from the batch request.
    #[prost(oneof = "batch_result_data::Response", tags = "2, 3, 4")]
    pub response: ::core::option::Option<batch_result_data::Response>,
}
/// Nested message and enum types in `BatchResultData`.
pub mod batch_result_data {
    /// The response from the batch request.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Response {
        /// A completion response that has finished processing in the batch.
        #[prost(message, tag = "2")]
        CompletionResponse(super::GetChatCompletionResponse),
        /// An image generation response that has finished processing in the batch.
        #[prost(message, tag = "3")]
        ImageResponse(super::ImageResponse),
        /// A video generation response that has finished processing in the batch.
        #[prost(message, tag = "4")]
        VideoResponse(super::VideoResponse),
    }
}
/// The result corresponding to a `BatchRequest`. Returns the result if processing is successful, or error if processing
/// has failed.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchResult {
    /// User-provided or generated identifier for the batch request. If a user has provided `batch_request_id` in the
    /// `BatchRequest`, the value will match the user-provided value.
    /// The value is unique within the batch.
    #[prost(string, tag = "1")]
    pub batch_request_id: ::prost::alloc::string::String,
    /// The result data, or error status if processing has failed.
    #[prost(oneof = "batch_result::Result", tags = "4, 3")]
    pub result: ::core::option::Option<batch_result::Result>,
}
/// Nested message and enum types in `BatchResult`.
pub mod batch_result {
    /// The result data, or error status if processing has failed.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Result {
        #[prost(message, tag = "4")]
        Response(super::BatchResultData),
        #[prost(message, tag = "3")]
        Error(super::super::google::rpc::Status),
    }
}
/// Metadata about an individual batch request.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BatchRequestMetadata {
    /// User-provided or generated identifier for the batch request. The value is unique within the batch.
    #[prost(string, tag = "1")]
    pub batch_request_id: ::prost::alloc::string::String,
    /// API endpoint to query.
    #[prost(string, tag = "2")]
    pub endpoint: ::prost::alloc::string::String,
    /// Model name to query.
    #[prost(string, tag = "3")]
    pub model: ::prost::alloc::string::String,
    #[prost(enumeration = "batch_request_metadata::State", tag = "4")]
    pub state: i32,
    /// Time when the request was recorded.
    #[prost(message, optional, tag = "5")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Time when the response was recorded.
    #[prost(message, optional, tag = "6")]
    pub finish_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Nested message and enum types in `BatchRequestMetadata`.
pub mod batch_request_metadata {
    /// The processing state of this batch request.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        Unknown = 0,
        Pending = 1,
        Succeeded = 2,
        Cancelled = 3,
        Failed = 4,
    }
    impl State {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unknown => "STATE_UNKNOWN",
                Self::Pending => "STATE_PENDING",
                Self::Succeeded => "STATE_SUCCEEDED",
                Self::Cancelled => "STATE_CANCELLED",
                Self::Failed => "STATE_FAILED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATE_UNKNOWN" => Some(Self::Unknown),
                "STATE_PENDING" => Some(Self::Pending),
                "STATE_SUCCEEDED" => Some(Self::Succeeded),
                "STATE_CANCELLED" => Some(Self::Cancelled),
                "STATE_FAILED" => Some(Self::Failed),
                _ => None,
            }
        }
    }
}
/// Request to create a new batch.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateBatchRequest {
    /// The name of the batch to be created.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional file ID of a JSONL input file (uploaded via the Files API).
    /// When provided, the batch will be populated from the file's contents.
    #[prost(string, tag = "2")]
    pub input_file_id: ::prost::alloc::string::String,
}
/// Request to add `BatchRequest`s to an existing batch for processing.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AddBatchRequestsRequest {
    /// The ID of the batch to add the requests to.
    #[prost(string, tag = "1")]
    pub batch_id: ::prost::alloc::string::String,
    /// The requests to add to the batch.
    #[prost(message, repeated, tag = "2")]
    pub batch_requests: ::prost::alloc::vec::Vec<BatchRequest>,
}
/// Request to get the information of a batch.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetBatchRequest {
    /// The ID of the batch.
    #[prost(string, tag = "1")]
    pub batch_id: ::prost::alloc::string::String,
}
/// Request to list all batches in the team.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListBatchesRequest {
    /// Number of batches to return on a page. Defaults to 100.
    #[prost(int32, tag = "1")]
    pub limit: i32,
    /// Optional pagination token to retrieve a specific page. Provided by `pagination_token` in `ListBatchesResponse`.
    #[prost(string, optional, tag = "2")]
    pub pagination_token: ::core::option::Option<::prost::alloc::string::String>,
}
/// Response containing all the batches on a page.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListBatchesResponse {
    /// The information about the batches.
    #[prost(message, repeated, tag = "1")]
    pub batches: ::prost::alloc::vec::Vec<Batch>,
    /// The pagination token to retrieve batches from the next page. Will be empty if this is the last page.
    #[prost(string, optional, tag = "2")]
    pub pagination_token: ::core::option::Option<::prost::alloc::string::String>,
}
/// Request to cancel processing of all the batch requests in a batch.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CancelBatchRequest {
    /// The ID of the batch that we are cancelling the requests.
    #[prost(string, tag = "1")]
    pub batch_id: ::prost::alloc::string::String,
}
/// Request for the request metadata within a batch.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListBatchRequestMetadataRequest {
    /// ID of the batch whose batch requests' metadata shall be listed.
    #[prost(string, tag = "1")]
    pub batch_id: ::prost::alloc::string::String,
    /// Number of batch request metadata to return on a page. Defaults to 100.
    #[prost(int32, tag = "2")]
    pub limit: i32,
    /// Optional pagination token to retrieve a specific page. Provided by `pagination_token` in `ListBatchRequestMetadataResponse`.
    #[prost(string, optional, tag = "3")]
    pub pagination_token: ::core::option::Option<::prost::alloc::string::String>,
    /// Optional filter by request state. If empty, all states are returned.
    #[prost(enumeration = "batch_request_metadata::State", repeated, tag = "4")]
    pub status: ::prost::alloc::vec::Vec<i32>,
}
/// Response with the metadata of batch requests within a batch.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListBatchRequestMetadataResponse {
    /// The batch requests' metadata for the given batch.
    #[prost(message, repeated, tag = "1")]
    pub batch_request_metadata: ::prost::alloc::vec::Vec<BatchRequestMetadata>,
    /// The pagination token to retrieve results from the next page. Will be empty if this is the last page.
    #[prost(string, optional, tag = "2")]
    pub pagination_token: ::core::option::Option<::prost::alloc::string::String>,
}
/// Request to list a batch's processing results.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListBatchResultsRequest {
    /// The ID of the batch we are retrieving the results from.
    #[prost(string, tag = "1")]
    pub batch_id: ::prost::alloc::string::String,
    /// Number of batch request results to return on a page. Defaults to 100.
    #[prost(int32, tag = "2")]
    pub limit: i32,
    /// Optional pagination token to retrieve a specific page. Provided by `pagination_token` in `ListBatchResultsResponse`.
    #[prost(string, optional, tag = "3")]
    pub pagination_token: ::core::option::Option<::prost::alloc::string::String>,
}
/// Response with the batch's processing results.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListBatchResultsResponse {
    /// The results that has been processed.
    #[prost(message, repeated, tag = "1")]
    pub results: ::prost::alloc::vec::Vec<BatchResult>,
    /// The pagination token to retrieve results from the next page. Will be empty if this is the last page.
    #[prost(string, optional, tag = "2")]
    pub pagination_token: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetBatchRequestResultRequest {
    /// The ID of the batch we are retrieving the request from.
    #[prost(string, tag = "1")]
    pub batch_id: ::prost::alloc::string::String,
    /// The ID of the request we are retrieving.
    #[prost(string, tag = "2")]
    pub batch_request_id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetBatchRequestResultResponse {
    /// The request that was processed.
    #[prost(message, optional, tag = "1")]
    pub request: ::core::option::Option<BatchRequest>,
    /// The response that was returned.
    #[prost(message, optional, tag = "2")]
    pub result: ::core::option::Option<BatchResult>,
}
/// Generated client implementations.
pub mod batch_mgmt_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// An API service for processing batch requests asynchronously at lower priority than chat service.
    #[derive(Debug, Clone)]
    pub struct BatchMgmtClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl BatchMgmtClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> BatchMgmtClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> BatchMgmtClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            BatchMgmtClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Creates a new batch.
        pub async fn create_batch(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateBatchRequest>,
        ) -> std::result::Result<tonic::Response<super::Batch>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.BatchMgmt/CreateBatch",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.BatchMgmt", "CreateBatch"));
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves an individual batch.
        pub async fn get_batch(
            &mut self,
            request: impl tonic::IntoRequest<super::GetBatchRequest>,
        ) -> std::result::Result<tonic::Response<super::Batch>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.BatchMgmt/GetBatch",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.BatchMgmt", "GetBatch"));
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves a list of all batches owned by the team.
        pub async fn list_batches(
            &mut self,
            request: impl tonic::IntoRequest<super::ListBatchesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListBatchesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.BatchMgmt/ListBatches",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.BatchMgmt", "ListBatches"));
            self.inner.unary(req, path, codec).await
        }
        /// Stops processing of all outstanding requests in the batch.
        pub async fn cancel_batch(
            &mut self,
            request: impl tonic::IntoRequest<super::CancelBatchRequest>,
        ) -> std::result::Result<tonic::Response<super::Batch>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.BatchMgmt/CancelBatch",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.BatchMgmt", "CancelBatch"));
            self.inner.unary(req, path, codec).await
        }
        /// Adds requests to a batch.
        pub async fn add_batch_requests(
            &mut self,
            request: impl tonic::IntoRequest<super::AddBatchRequestsRequest>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.BatchMgmt/AddBatchRequests",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.BatchMgmt", "AddBatchRequests"));
            self.inner.unary(req, path, codec).await
        }
        /// Lists metadata about individual requests in a batch.
        pub async fn list_batch_request_metadata(
            &mut self,
            request: impl tonic::IntoRequest<super::ListBatchRequestMetadataRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListBatchRequestMetadataResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.BatchMgmt/ListBatchRequestMetadata",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("xai_api.BatchMgmt", "ListBatchRequestMetadata"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists processing results of a batch.
        pub async fn list_batch_results(
            &mut self,
            request: impl tonic::IntoRequest<super::ListBatchResultsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListBatchResultsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.BatchMgmt/ListBatchResults",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.BatchMgmt", "ListBatchResults"));
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves an individual request in a batch.
        pub async fn get_batch_request_result(
            &mut self,
            request: impl tonic::IntoRequest<super::GetBatchRequestResultRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetBatchRequestResultResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.BatchMgmt/GetBatchRequestResult",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.BatchMgmt", "GetBatchRequestResult"));
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Request message for generating embeddings.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EmbedRequest {
    /// The entities to embed. Note that not every model supports images and text.
    /// Some models are text-only and some are image-only. You can at most embed
    /// 128 inputs in a single request.
    #[prost(message, repeated, tag = "1")]
    pub input: ::prost::alloc::vec::Vec<EmbedInput>,
    /// Name or alias of the embedding model to use.
    #[prost(string, tag = "2")]
    pub model: ::prost::alloc::string::String,
    /// Format of the returned embeddings.
    #[prost(enumeration = "EmbedEncodingFormat", tag = "3")]
    pub encoding_format: i32,
    /// An opaque string supplied by the API client (customer) to identify a user.
    /// The string will be stored in the logs and can be used in customer service
    /// requests to identify certain requests.
    #[prost(string, tag = "4")]
    pub user: ::prost::alloc::string::String,
}
/// Input content to be embedded.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct EmbedInput {
    #[prost(oneof = "embed_input::Input", tags = "1, 2")]
    pub input: ::core::option::Option<embed_input::Input>,
}
/// Nested message and enum types in `EmbedInput`.
pub mod embed_input {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Input {
        /// A string to be embedded.
        #[prost(string, tag = "1")]
        String(::prost::alloc::string::String),
        /// An image to be embedded.
        #[prost(message, tag = "2")]
        ImageUrl(super::ImageUrlContent),
    }
}
/// Response object for the `Embed` RPC.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EmbedResponse {
    /// An identifier of this request. The same ID will be used in your billing
    /// records.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// The embeddings generated from the inputs.
    #[prost(message, repeated, tag = "2")]
    pub embeddings: ::prost::alloc::vec::Vec<Embedding>,
    /// The usage associated with this request.
    #[prost(message, optional, tag = "3")]
    pub usage: ::core::option::Option<EmbeddingUsage>,
    /// The name of the model used for the request. This model name contains
    /// the actual model name used rather than any aliases.
    /// This means it can be `embed-0205` even when the request was specifying
    /// `embed-latest`.
    #[prost(string, tag = "4")]
    pub model: ::prost::alloc::string::String,
    /// This fingerprint represents the backend configuration that the model runs
    /// with.
    #[prost(string, tag = "5")]
    pub system_fingerprint: ::prost::alloc::string::String,
}
/// Holds the embedding vector for a single embedding input.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Embedding {
    /// The index of the input this embedding was produced from.
    #[prost(int32, tag = "1")]
    pub index: i32,
    /// The feature vectors derived from the inputs. Note that some inputs such as
    /// images may produce multiple feature vectors.
    #[prost(message, repeated, tag = "2")]
    pub embeddings: ::prost::alloc::vec::Vec<FeatureVector>,
}
/// A single feature vector.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FeatureVector {
    /// The feature vector encoded as an array of floats. Only populated if
    /// the encoding format is FORMAT_FLOAT.
    #[prost(float, repeated, tag = "1")]
    pub float_array: ::prost::alloc::vec::Vec<f32>,
    /// The feature vector encoded as a base64 string. Only populated if
    /// the encoding format is FORMAT_BASE64.
    #[prost(string, tag = "2")]
    pub base64_array: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum EmbedEncodingFormat {
    /// Invalid format.
    FormatInvalid = 0,
    /// Returns the embeddings as an array of floats.
    FormatFloat = 1,
    /// Returns the embeddings as a base64-encoded string.
    FormatBase64 = 2,
}
impl EmbedEncodingFormat {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::FormatInvalid => "FORMAT_INVALID",
            Self::FormatFloat => "FORMAT_FLOAT",
            Self::FormatBase64 => "FORMAT_BASE64",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "FORMAT_INVALID" => Some(Self::FormatInvalid),
            "FORMAT_FLOAT" => Some(Self::FormatFloat),
            "FORMAT_BASE64" => Some(Self::FormatBase64),
            _ => None,
        }
    }
}
/// Generated client implementations.
pub mod embedder_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// An API service for interaction with available embedding models.
    #[derive(Debug, Clone)]
    pub struct EmbedderClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl EmbedderClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> EmbedderClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> EmbedderClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            EmbedderClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Produces one embedding for each input object. The size of the produced
        /// feature vectors depends on the chosen model.
        pub async fn embed(
            &mut self,
            request: impl tonic::IntoRequest<super::EmbedRequest>,
        ) -> std::result::Result<tonic::Response<super::EmbedResponse>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/xai_api.Embedder/Embed");
            let mut req = request.into_request();
            req.extensions_mut().insert(GrpcMethod::new("xai_api.Embedder", "Embed"));
            self.inner.unary(req, path, codec).await
        }
    }
}
/// First stream message of an `UploadFile` call. Sent exactly once, before
/// any data chunks.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UploadFileInit {
    /// Filename (max 255 Unicode chars). Must not contain ASCII control
    /// chars, line terminators (CR/LF/NEL/U+2028/U+2029), null bytes, `"`,
    /// `;`, or `\` — these would break `Content-Disposition` headers.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional TTL in seconds, measured from upload time. Must be in
    /// \[3600, 2592000\] (1h to 30d) inclusive — 0 and out-of-range values are
    /// rejected. Unset means no expiration.
    #[prost(int64, optional, tag = "2")]
    pub expires_after: ::core::option::Option<i64>,
}
/// One message in an `UploadFile` stream: either `init` (required first) or
/// a `data` chunk.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UploadFileChunk {
    #[prost(oneof = "upload_file_chunk::Chunk", tags = "1, 2")]
    pub chunk: ::core::option::Option<upload_file_chunk::Chunk>,
}
/// Nested message and enum types in `UploadFileChunk`.
pub mod upload_file_chunk {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Chunk {
        /// Information about the file being uploaded.
        #[prost(message, tag = "1")]
        Init(super::UploadFileInit),
        /// Up to ~5 MB per chunk recommended; cumulative size capped at 512 MB.
        #[prost(bytes, tag = "2")]
        Data(::prost::alloc::vec::Vec<u8>),
    }
}
/// Metadata for an uploaded file.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct File {
    /// Size in bytes.
    #[prost(int64, tag = "1")]
    pub size: i64,
    /// UTC timestamp the file was uploaded.
    #[prost(message, optional, tag = "2")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// UTC timestamp the file will be auto-deleted at. Present only if the
    /// upload set `UploadFileInit.expires_after`.
    #[prost(message, optional, tag = "3")]
    pub expires_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Filename as supplied at upload.
    #[prost(string, tag = "4")]
    pub filename: ::prost::alloc::string::String,
    /// Opaque server-assigned ID (e.g. `file_<uuid>`). Use this in
    /// `RetrieveFile`, `DeleteFile`, `RetrieveFileContent`, and other xAI
    /// APIs that accept a file reference.
    #[prost(string, tag = "5")]
    pub id: ::prost::alloc::string::String,
}
/// Request message for `Files.ListFiles`.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListFilesRequest {
    /// Page size, in \[1, 100\]. Values \<= 0 default to 100; values > 100 are
    /// clamped.
    #[prost(int32, tag = "1")]
    pub limit: i32,
    /// Sort direction. Defaults to ASCENDING.
    #[prost(enumeration = "Ordering", tag = "2")]
    pub order: i32,
    /// Opaque token from a prior `ListFilesResponse.pagination_token`, used to
    /// resume listing where the previous page left off. Omit on the first
    /// call. Use the same `order` and `sort_by` as the request that produced
    /// the token; otherwise paging behavior is undefined. Treat as opaque;
    /// format may change.
    #[prost(string, optional, tag = "3")]
    pub pagination_token: ::core::option::Option<::prost::alloc::string::String>,
    /// Sort field. Defaults to `FILES_SORT_BY_CREATED_AT`.
    #[prost(enumeration = "FilesSortBy", optional, tag = "4")]
    pub sort_by: ::core::option::Option<i32>,
}
/// Response message for `Files.ListFiles`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListFilesResponse {
    /// List of file metadata.
    #[prost(message, repeated, tag = "1")]
    pub data: ::prost::alloc::vec::Vec<File>,
    /// Token for the next page; absent on the final page.
    #[prost(string, optional, tag = "2")]
    pub pagination_token: ::core::option::Option<::prost::alloc::string::String>,
}
/// Request message for `Files.RetrieveFile`.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RetrieveFileRequest {
    /// The ID of the file to use for this request.
    #[prost(string, tag = "1")]
    pub file_id: ::prost::alloc::string::String,
}
/// Request message for `Files.DeleteFile`.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteFileRequest {
    /// The ID of the file to use for this request.
    #[prost(string, tag = "1")]
    pub file_id: ::prost::alloc::string::String,
}
/// Response message for `Files.DeleteFile`.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteFileResponse {
    /// Echoes the deleted file's id.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Always true on success (failures surface as gRPC errors).
    #[prost(bool, tag = "2")]
    pub deleted: bool,
}
/// Request message for `Files.RetrieveFileContent`.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RetrieveFileContentRequest {
    /// The ID of the file to download.
    #[prost(string, tag = "1")]
    pub file_id: ::prost::alloc::string::String,
    /// Format of the downloaded content.
    /// ORIGINAL: raw file bytes (default).
    /// TEXT: extracted/converted text content.
    #[prost(enumeration = "DownloadFormat", optional, tag = "2")]
    pub format: ::core::option::Option<i32>,
}
/// One chunk of a `RetrieveFileContent` stream.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FileContentChunk {
    /// Up to 5 MB of file bytes. Final/intermediate chunks may be smaller.
    #[prost(bytes = "vec", tag = "1")]
    pub data: ::prost::alloc::vec::Vec<u8>,
}
/// Sort direction for list-style RPCs.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Ordering {
    Ascending = 0,
    Descending = 1,
}
impl Ordering {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Ascending => "ASCENDING",
            Self::Descending => "DESCENDING",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "ASCENDING" => Some(Self::Ascending),
            "DESCENDING" => Some(Self::Descending),
            _ => None,
        }
    }
}
/// Field to sort `ListFiles` results by.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum FilesSortBy {
    /// Default.
    CreatedAt = 0,
    /// Case-sensitive lexicographic order.
    Filename = 1,
    Size = 2,
}
impl FilesSortBy {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::CreatedAt => "FILES_SORT_BY_CREATED_AT",
            Self::Filename => "FILES_SORT_BY_FILENAME",
            Self::Size => "FILES_SORT_BY_SIZE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "FILES_SORT_BY_CREATED_AT" => Some(Self::CreatedAt),
            "FILES_SORT_BY_FILENAME" => Some(Self::Filename),
            "FILES_SORT_BY_SIZE" => Some(Self::Size),
            _ => None,
        }
    }
}
/// Which representation of a file to download.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum DownloadFormat {
    /// Treated as `DOWNLOAD_FORMAT_ORIGINAL` (the default when `format` is
    /// unset).
    Unknown = 0,
    /// Raw bytes as uploaded.
    Original = 1,
    /// Text extracted from the file (e.g. PDF/DOCX). Only works for file
    /// types with a server-side text-extraction pass; fails otherwise.
    Text = 2,
}
impl DownloadFormat {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unknown => "DOWNLOAD_FORMAT_UNKNOWN",
            Self::Original => "DOWNLOAD_FORMAT_ORIGINAL",
            Self::Text => "DOWNLOAD_FORMAT_TEXT",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "DOWNLOAD_FORMAT_UNKNOWN" => Some(Self::Unknown),
            "DOWNLOAD_FORMAT_ORIGINAL" => Some(Self::Original),
            "DOWNLOAD_FORMAT_TEXT" => Some(Self::Text),
            _ => None,
        }
    }
}
/// Generated client implementations.
pub mod files_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for uploading, listing, retrieving, and deleting files.
    ///
    /// Files are referenced by the `id` returned on upload (e.g. when attaching
    /// to chat completions). Maximum file size is 512 MB.
    #[derive(Debug, Clone)]
    pub struct FilesClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl FilesClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> FilesClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> FilesClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            FilesClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Upload a file. The first stream message MUST set `chunk = init`
        /// (filename + optional TTL); subsequent messages MUST set `chunk = data`
        /// with file bytes in order. Recommended chunk size up to 5 MB; total
        /// size capped at 512 MB. Returns the new file's metadata.
        ///
        /// Errors: INVALID_ARGUMENT (missing/misplaced init, bad filename, bad
        /// TTL), RESOURCE_EXHAUSTED (over 512 MB).
        pub async fn upload_file(
            &mut self,
            request: impl tonic::IntoStreamingRequest<Message = super::UploadFileChunk>,
        ) -> std::result::Result<tonic::Response<super::File>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/xai_api.Files/UploadFile");
            let mut req = request.into_streaming_request();
            req.extensions_mut().insert(GrpcMethod::new("xai_api.Files", "UploadFile"));
            self.inner.client_streaming(req, path, codec).await
        }
        /// List file metadata, paginated and sorted. Returns metadata only — use
        /// `RetrieveFileContent` to download bytes.
        pub async fn list_files(
            &mut self,
            request: impl tonic::IntoRequest<super::ListFilesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListFilesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/xai_api.Files/ListFiles");
            let mut req = request.into_request();
            req.extensions_mut().insert(GrpcMethod::new("xai_api.Files", "ListFiles"));
            self.inner.unary(req, path, codec).await
        }
        /// Get metadata for one file. Returns metadata only — use
        /// `RetrieveFileContent` to download bytes. Errors NOT_FOUND if no
        /// accessible file with that id (including already-deleted).
        pub async fn retrieve_file(
            &mut self,
            request: impl tonic::IntoRequest<super::RetrieveFileRequest>,
        ) -> std::result::Result<tonic::Response<super::File>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.Files/RetrieveFile",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.Files", "RetrieveFile"));
            self.inner.unary(req, path, codec).await
        }
        /// Delete a file. After success it stops appearing in `ListFiles` /
        /// `RetrieveFile` and is no longer downloadable. Errors NOT_FOUND if no
        /// accessible file with that id (including already-deleted).
        pub async fn delete_file(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteFileRequest>,
        ) -> std::result::Result<
            tonic::Response<super::DeleteFileResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/xai_api.Files/DeleteFile");
            let mut req = request.into_request();
            req.extensions_mut().insert(GrpcMethod::new("xai_api.Files", "DeleteFile"));
            self.inner.unary(req, path, codec).await
        }
        /// Stream the file's contents in chunks of up to 5 MB, in order.
        /// Concatenate `data` from every chunk to reconstruct the file.
        pub async fn retrieve_file_content(
            &mut self,
            request: impl tonic::IntoRequest<super::RetrieveFileContentRequest>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::FileContentChunk>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.Files/RetrieveFileContent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.Files", "RetrieveFileContent"));
            self.inner.server_streaming(req, path, codec).await
        }
    }
}
/// Request to get details of a specific model by name.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetModelRequest {
    /// The name of the model to retrieve details about.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Describes a language model available on the platform.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct LanguageModel {
    /// The model name used in API requests/responses.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The aliases of the name, which can also be used in lieu of name in the API
    /// requests.
    #[prost(string, repeated, tag = "11")]
    pub aliases: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// The version number of this model. Used to identify minor updates when
    /// the model name is not changed.
    #[prost(string, tag = "2")]
    pub version: ::prost::alloc::string::String,
    /// The supported input modalities of the model.
    #[prost(enumeration = "Modality", repeated, tag = "3")]
    pub input_modalities: ::prost::alloc::vec::Vec<i32>,
    /// The supported output modalities of the model.
    #[prost(enumeration = "Modality", repeated, tag = "4")]
    pub output_modalities: ::prost::alloc::vec::Vec<i32>,
    /// The price (in 1/100 USD cents) per one million text prompt tokens.
    #[prost(int64, tag = "5")]
    pub prompt_text_token_price: i64,
    /// The price (in 1/100 USD cents) per one million image prompt tokens.
    #[prost(int64, tag = "6")]
    pub prompt_image_token_price: i64,
    /// The price (in USD cents) per 100 million cached text prompt tokens.
    #[prost(int64, tag = "12")]
    pub cached_prompt_token_price: i64,
    /// The price (in 1/100 USD cents) per one million text completion token.
    #[prost(int64, tag = "7")]
    pub completion_text_token_price: i64,
    /// The price (in 1/100 USD cents) per one million searches.
    #[prost(int64, tag = "13")]
    pub search_price: i64,
    /// The creation time of the model.
    #[prost(message, optional, tag = "8")]
    pub created: ::core::option::Option<::prost_types::Timestamp>,
    /// Maximum length of the prompt/input (this includes tokens of all kinds).
    /// This is typically known as the context length of the model.
    #[prost(int32, tag = "9")]
    pub max_prompt_length: i32,
    /// Fingerprint of the unique configuration of the model.
    #[prost(string, tag = "10")]
    pub system_fingerprint: ::prost::alloc::string::String,
}
/// Response from ListLanguageModels including a list of language models.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListLanguageModelsResponse {
    /// A list of language models.
    #[prost(message, repeated, tag = "1")]
    pub models: ::prost::alloc::vec::Vec<LanguageModel>,
}
/// Describes an embedding model available on the platform.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct EmbeddingModel {
    /// The name under which the model is available in the API.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The aliases of the name, which can also be used in lieu of name in the API
    /// requests.
    #[prost(string, repeated, tag = "11")]
    pub aliases: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// The version number of this model. Used to identify minor updates when
    /// the model name is not changed.
    #[prost(string, tag = "2")]
    pub version: ::prost::alloc::string::String,
    /// The supported input modalities of the model.
    #[prost(enumeration = "Modality", repeated, tag = "3")]
    pub input_modalities: ::prost::alloc::vec::Vec<i32>,
    /// The supported output modalities of the model.
    #[prost(enumeration = "Modality", repeated, tag = "4")]
    pub output_modalities: ::prost::alloc::vec::Vec<i32>,
    /// The price (in 1/100 USD cents) per one million text prompt tokens.
    #[prost(int64, tag = "5")]
    pub prompt_text_token_price: i64,
    /// The price (in 1/100 USD cents) per one million image prompt tokens.
    #[prost(int64, tag = "6")]
    pub prompt_image_token_price: i64,
    /// The creation time of the model.
    #[prost(message, optional, tag = "7")]
    pub created: ::core::option::Option<::prost_types::Timestamp>,
    /// Fingerprint of the unique configuration of the model.
    #[prost(string, tag = "8")]
    pub system_fingerprint: ::prost::alloc::string::String,
}
/// Response from ListEmbeddingModels including a list of embedding models.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListEmbeddingModelsResponse {
    /// A list of embedding model(s).
    #[prost(message, repeated, tag = "1")]
    pub models: ::prost::alloc::vec::Vec<EmbeddingModel>,
}
/// Describes a language model available on the platform.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ImageGenerationModel {
    /// The model name used in API requests/responses.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The aliases of the name, which can also be used in lieu of name in the API
    /// requests.
    #[prost(string, repeated, tag = "11")]
    pub aliases: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// The version number of this model. Used to identify minor updates when
    /// the model name is not changed.
    #[prost(string, tag = "2")]
    pub version: ::prost::alloc::string::String,
    /// The supported input modalities of the model.
    #[prost(enumeration = "Modality", repeated, tag = "3")]
    pub input_modalities: ::prost::alloc::vec::Vec<i32>,
    /// The supported output modalities of the model.
    #[prost(enumeration = "Modality", repeated, tag = "6")]
    pub output_modalities: ::prost::alloc::vec::Vec<i32>,
    /// The price (in USD cents) per image.
    #[prost(int64, tag = "12")]
    pub image_price: i64,
    /// When the language model was created.
    #[prost(message, optional, tag = "8")]
    pub created: ::core::option::Option<::prost_types::Timestamp>,
    /// Maximum length of the prompt/input (this includes tokens of all kinds).
    /// This is typically known as the context length of the model.
    #[prost(int32, tag = "9")]
    pub max_prompt_length: i32,
    /// Fingerprint of the unique configuration of the model.
    #[prost(string, tag = "10")]
    pub system_fingerprint: ::prost::alloc::string::String,
}
/// Response from ListImageGenerationModels including a list of image generation
/// models.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListImageGenerationModelsResponse {
    /// A list of image generation models.
    #[prost(message, repeated, tag = "1")]
    pub models: ::prost::alloc::vec::Vec<ImageGenerationModel>,
}
/// Modalities supported by a model input/output.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Modality {
    /// Invalid modality.
    InvalidModality = 0,
    /// Text input/output.
    Text = 1,
    /// Image input/output.
    Image = 2,
    /// Embedding input/output.
    Embedding = 3,
}
impl Modality {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::InvalidModality => "INVALID_MODALITY",
            Self::Text => "TEXT",
            Self::Image => "IMAGE",
            Self::Embedding => "EMBEDDING",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "INVALID_MODALITY" => Some(Self::InvalidModality),
            "TEXT" => Some(Self::Text),
            "IMAGE" => Some(Self::Image),
            "EMBEDDING" => Some(Self::Embedding),
            _ => None,
        }
    }
}
/// Generated client implementations.
pub mod models_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// An API service that let users get details of available models on the
    /// platform.
    #[derive(Debug, Clone)]
    pub struct ModelsClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ModelsClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> ModelsClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> ModelsClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            ModelsClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Lists all language models available to your team (based on the API key).
        pub async fn list_language_models(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<
            tonic::Response<super::ListLanguageModelsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.Models/ListLanguageModels",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.Models", "ListLanguageModels"));
            self.inner.unary(req, path, codec).await
        }
        /// Lists all embedding models available to your team (based on the API key).
        pub async fn list_embedding_models(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<
            tonic::Response<super::ListEmbeddingModelsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.Models/ListEmbeddingModels",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.Models", "ListEmbeddingModels"));
            self.inner.unary(req, path, codec).await
        }
        /// Lists all image generation models available to your team (based on the API key).
        pub async fn list_image_generation_models(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<
            tonic::Response<super::ListImageGenerationModelsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.Models/ListImageGenerationModels",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.Models", "ListImageGenerationModels"));
            self.inner.unary(req, path, codec).await
        }
        /// Get details of a specific language model by model name.
        pub async fn get_language_model(
            &mut self,
            request: impl tonic::IntoRequest<super::GetModelRequest>,
        ) -> std::result::Result<tonic::Response<super::LanguageModel>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.Models/GetLanguageModel",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.Models", "GetLanguageModel"));
            self.inner.unary(req, path, codec).await
        }
        /// Get details of a specific embedding model by model name.
        pub async fn get_embedding_model(
            &mut self,
            request: impl tonic::IntoRequest<super::GetModelRequest>,
        ) -> std::result::Result<tonic::Response<super::EmbeddingModel>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.Models/GetEmbeddingModel",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.Models", "GetEmbeddingModel"));
            self.inner.unary(req, path, codec).await
        }
        /// Get details of a specific image generation model by model name.
        pub async fn get_image_generation_model(
            &mut self,
            request: impl tonic::IntoRequest<super::GetModelRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ImageGenerationModel>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.Models/GetImageGenerationModel",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.Models", "GetImageGenerationModel"));
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Request to convert text to a sequence of tokens.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TokenizeTextRequest {
    /// Text to tokenize.
    #[prost(string, tag = "1")]
    pub text: ::prost::alloc::string::String,
    /// Name or alias of the model used for tokenization.
    #[prost(string, tag = "2")]
    pub model: ::prost::alloc::string::String,
    /// An opaque string supplied by the API client (customer) to identify a user.
    /// The string will be stored in the logs and can be used in customer service
    /// requests to identify certain requests.
    #[prost(string, tag = "3")]
    pub user: ::prost::alloc::string::String,
}
/// Information on a token.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Token {
    /// ID of the token.
    #[prost(uint32, tag = "1")]
    pub token_id: u32,
    /// String snippet of the token.
    #[prost(string, tag = "2")]
    pub string_token: ::prost::alloc::string::String,
    /// Bytes representing the token.
    #[prost(bytes = "vec", tag = "4")]
    pub token_bytes: ::prost::alloc::vec::Vec<u8>,
}
/// Response including the tokenization result.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TokenizeTextResponse {
    /// The sequence of tokens. This is the output of the tokenization process.
    #[prost(message, repeated, tag = "1")]
    pub tokens: ::prost::alloc::vec::Vec<Token>,
    /// The name of the model used for the request. This model name contains
    /// the actual model name used rather than any aliases.
    /// This means the this can be `grok-2-1212` even when the request was
    /// specifying `grok-2-latest`.
    #[prost(string, tag = "2")]
    pub model: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod tokenize_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// An API service to tokenize input prompts.
    #[derive(Debug, Clone)]
    pub struct TokenizeClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl TokenizeClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> TokenizeClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> TokenizeClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            TokenizeClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Convert text to a sequence of tokens.
        pub async fn tokenize_text(
            &mut self,
            request: impl tonic::IntoRequest<super::TokenizeTextRequest>,
        ) -> std::result::Result<
            tonic::Response<super::TokenizeTextResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/xai_api.Tokenize/TokenizeText",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("xai_api.Tokenize", "TokenizeText"));
            self.inner.unary(req, path, codec).await
        }
    }
}