// This file is @generated by prost-build.
/// Expression condition based on session state.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExpressionCondition {
    /// Required. The string representation of cloud.api.Expression condition.
    #[prost(string, tag = "1")]
    pub expression: ::prost::alloc::string::String,
}
/// Python code block to evaluate the condition.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PythonCodeCondition {
    /// Required. The python code to execute.
    #[prost(string, tag = "1")]
    pub python_code: ::prost::alloc::string::String,
}
/// Rule for transferring to a specific agent.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TransferRule {
    /// Required. The resource name of the child agent the rule applies to.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/agents/{agent}`
    #[prost(string, tag = "1")]
    pub child_agent: ::prost::alloc::string::String,
    /// Required. The direction of the transfer.
    #[prost(enumeration = "transfer_rule::Direction", tag = "2")]
    pub direction: i32,
    /// The rule type.
    #[prost(oneof = "transfer_rule::RuleType", tags = "3, 4")]
    pub rule_type: ::core::option::Option<transfer_rule::RuleType>,
}
/// Nested message and enum types in `TransferRule`.
pub mod transfer_rule {
    /// Deterministic transfer rule. When the condition evaluates to true, the
    /// transfer occurs.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct DeterministicTransfer {
        /// The condition to evaluate.
        #[prost(oneof = "deterministic_transfer::ConditionType", tags = "1, 2")]
        pub condition_type: ::core::option::Option<
            deterministic_transfer::ConditionType,
        >,
    }
    /// Nested message and enum types in `DeterministicTransfer`.
    pub mod deterministic_transfer {
        /// The condition to evaluate.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
        pub enum ConditionType {
            /// Optional. A rule that evaluates a session state condition.
            /// If the condition evaluates to true, the transfer occurs.
            #[prost(message, tag = "1")]
            ExpressionCondition(super::super::ExpressionCondition),
            /// Optional. A rule that uses Python code block to evaluate the
            /// conditions. If the condition evaluates to true, the transfer occurs.
            #[prost(message, tag = "2")]
            PythonCodeCondition(super::super::PythonCodeCondition),
        }
    }
    /// A rule that prevents the planner from transferring to the target agent.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct DisablePlannerTransfer {
        /// Required. If the condition evaluates to true, planner will not be allowed
        /// to transfer to the target agent.
        #[prost(message, optional, tag = "1")]
        pub expression_condition: ::core::option::Option<super::ExpressionCondition>,
    }
    /// The direction of the transfer.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Direction {
        /// Unspecified direction.
        Unspecified = 0,
        /// Transfer from the parent agent to the child agent.
        ParentToChild = 1,
        /// Transfer from the child agent to the parent agent.
        ChildToParent = 2,
    }
    impl Direction {
        /// 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 => "DIRECTION_UNSPECIFIED",
                Self::ParentToChild => "PARENT_TO_CHILD",
                Self::ChildToParent => "CHILD_TO_PARENT",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "DIRECTION_UNSPECIFIED" => Some(Self::Unspecified),
                "PARENT_TO_CHILD" => Some(Self::ParentToChild),
                "CHILD_TO_PARENT" => Some(Self::ChildToParent),
                _ => None,
            }
        }
    }
    /// The rule type.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum RuleType {
        /// Optional. A rule that immediately transfers to the target agent when the
        /// condition is met.
        #[prost(message, tag = "3")]
        DeterministicTransfer(DeterministicTransfer),
        /// Optional. Rule that prevents the planner from transferring to the target
        /// agent.
        #[prost(message, tag = "4")]
        DisablePlannerTransfer(DisablePlannerTransfer),
    }
}
/// A callback defines the custom logic to be executed at various stages of
/// agent interaction.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Callback {
    /// Optional. Human-readable description of the callback.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Optional. Whether the callback is disabled. Disabled callbacks are ignored
    /// by the agent.
    #[prost(bool, tag = "2")]
    pub disabled: bool,
    /// Optional. If enabled, the callback will also be executed on intermediate
    /// model outputs. This setting only affects after model callback.
    /// **ENABLE WITH CAUTION**. Typically after model callback only needs to be
    /// executed after receiving all model responses. Enabling proactive execution
    /// may have negative implication on the execution cost and latency, and
    /// should only be enabled in rare situations.
    #[prost(bool, tag = "4")]
    pub proactive_execution_enabled: bool,
    /// The callback to execute.
    #[prost(oneof = "callback::Callback", tags = "1")]
    pub callback: ::core::option::Option<callback::Callback>,
}
/// Nested message and enum types in `Callback`.
pub mod callback {
    /// The callback to execute.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Callback {
        /// Required. The python code to execute for the callback.
        #[prost(string, tag = "1")]
        PythonCode(::prost::alloc::string::String),
    }
}
/// Model settings contains various configurations for the LLM model.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ModelSettings {
    /// Optional. The LLM model that the agent should use.
    /// If not set, the agent will inherit the model from its parent agent.
    #[prost(string, tag = "1")]
    pub model: ::prost::alloc::string::String,
    /// Optional. If set, this temperature will be used for the LLM model.
    /// Temperature controls the randomness of the model's responses. Lower
    /// temperatures produce responses that are more predictable. Higher
    /// temperatures produce responses that are more creative.
    #[prost(double, optional, tag = "2")]
    pub temperature: ::core::option::Option<f64>,
}
/// Action that is taken when a certain precondition is met.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TriggerAction {
    /// The action to take.
    #[prost(oneof = "trigger_action::Action", tags = "1, 2, 3")]
    pub action: ::core::option::Option<trigger_action::Action>,
}
/// Nested message and enum types in `TriggerAction`.
pub mod trigger_action {
    /// Represents a response from the agent.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Response {
        /// Required. Text for the agent to respond with.
        #[prost(string, tag = "1")]
        pub text: ::prost::alloc::string::String,
        /// Optional. Whether the response is disabled. Disabled responses are not
        /// used by the agent.
        #[prost(bool, tag = "2")]
        pub disabled: bool,
    }
    /// The agent will immediately respond with a preconfigured response.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RespondImmediately {
        /// Required. The canned responses for the agent to choose from. The response
        /// is chosen randomly.
        #[prost(message, repeated, tag = "1")]
        pub responses: ::prost::alloc::vec::Vec<Response>,
    }
    /// The agent will immediately respond with a generative answer.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct GenerativeAnswer {
        /// Required. The prompt to use for the generative answer.
        #[prost(string, tag = "1")]
        pub prompt: ::prost::alloc::string::String,
    }
    /// The agent will transfer the conversation to a different agent.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct TransferAgent {
        /// Required. The name of the agent to transfer the conversation to. The
        /// agent must be in the same app as the current agent. Format:
        /// `projects/{project}/locations/{location}/apps/{app}/agents/{agent}`
        #[prost(string, tag = "1")]
        pub agent: ::prost::alloc::string::String,
    }
    /// The action to take.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Action {
        /// Optional. Immediately respond with a preconfigured response.
        #[prost(message, tag = "1")]
        RespondImmediately(RespondImmediately),
        /// Optional. Transfer the conversation to a different agent.
        #[prost(message, tag = "2")]
        TransferAgent(TransferAgent),
        /// Optional. Respond with a generative answer.
        #[prost(message, tag = "3")]
        GenerativeAnswer(GenerativeAnswer),
    }
}
/// The TLS configuration.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TlsConfig {
    /// Required. Specifies a list of allowed custom CA certificates for HTTPS
    /// verification.
    #[prost(message, repeated, tag = "1")]
    pub ca_certs: ::prost::alloc::vec::Vec<tls_config::CaCert>,
}
/// Nested message and enum types in `TlsConfig`.
pub mod tls_config {
    /// The CA certificate.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct CaCert {
        /// Required. The name of the allowed custom CA certificates. This
        /// can be used to disambiguate the custom CA certificates.
        #[prost(string, tag = "1")]
        pub display_name: ::prost::alloc::string::String,
        /// Required. The allowed custom CA certificates (in DER format) for
        /// HTTPS verification. This overrides the default SSL trust store. If this
        /// is empty or unspecified, CES will use Google's default trust
        /// store to verify certificates. N.B. Make sure the HTTPS server
        /// certificates are signed with "subject alt name". For instance a
        /// certificate can be self-signed using the following command:
        ///
        /// ```text,
        ///    openssl x509 -req -days 200 -in example.com.csr \
        ///      -signkey example.com.key \
        ///      -out example.com.crt \
        ///      -extfile <(printf "\nsubjectAltName='DNS:www.example.com'")
        /// ```
        #[prost(bytes = "vec", tag = "2")]
        pub cert: ::prost::alloc::vec::Vec<u8>,
    }
}
/// Configuration for tools using Service Directory.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ServiceDirectoryConfig {
    /// Required. The name of [Service
    /// Directory](<https://cloud.google.com/service-directory>) service.
    /// Format:
    /// `projects/{project}/locations/{location}/namespaces/{namespace}/services/{service}`.
    /// Location of the service directory must be the same as the location of the
    /// app.
    #[prost(string, tag = "1")]
    pub service: ::prost::alloc::string::String,
}
/// A ChannelProfile configures the agent's behavior for a specific communication
/// channel, such as web UI or telephony.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ChannelProfile {
    /// Optional. The unique identifier of the channel profile.
    #[prost(string, tag = "1")]
    pub profile_id: ::prost::alloc::string::String,
    /// Optional. The type of the channel profile.
    #[prost(enumeration = "channel_profile::ChannelType", tag = "3")]
    pub channel_type: i32,
    /// Optional. The persona property of the channel profile.
    #[prost(message, optional, tag = "2")]
    pub persona_property: ::core::option::Option<channel_profile::PersonaProperty>,
    /// Optional. Whether to disable DTMF (dual-tone multi-frequency).
    #[prost(bool, tag = "4")]
    pub disable_dtmf: bool,
    /// Optional. Whether to disable user barge-in control in the conversation.
    ///
    /// * **true**: User interruptions are disabled while the agent is speaking.
    /// * **false**: The agent retains automatic control over when the user can
    ///   interrupt.
    #[prost(bool, tag = "5")]
    pub disable_barge_in_control: bool,
    /// Optional. The configuration for the web widget.
    #[prost(message, optional, tag = "7")]
    pub web_widget_config: ::core::option::Option<channel_profile::WebWidgetConfig>,
    /// Optional. The noise suppression level of the channel profile.
    /// Available values are "low", "moderate", "high", "very_high".
    #[prost(string, tag = "8")]
    pub noise_suppression_level: ::prost::alloc::string::String,
}
/// Nested message and enum types in `ChannelProfile`.
pub mod channel_profile {
    /// Represents the persona property of a channel.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct PersonaProperty {
        /// Optional. The persona of the channel.
        #[prost(enumeration = "persona_property::Persona", tag = "1")]
        pub persona: i32,
    }
    /// Nested message and enum types in `PersonaProperty`.
    pub mod persona_property {
        /// The persona of the channel.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum Persona {
            /// UNKNOWN persona.
            Unknown = 0,
            /// The agent keeps the responses concise and to the point
            Concise = 1,
            /// The agent provides additional context, explanations, and details
            Chatty = 2,
        }
        impl Persona {
            /// 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 => "UNKNOWN",
                    Self::Concise => "CONCISE",
                    Self::Chatty => "CHATTY",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "UNKNOWN" => Some(Self::Unknown),
                    "CONCISE" => Some(Self::Concise),
                    "CHATTY" => Some(Self::Chatty),
                    _ => None,
                }
            }
        }
    }
    /// Message for configuration for the web widget.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct WebWidgetConfig {
        /// Optional. The modality of the web widget.
        #[prost(enumeration = "web_widget_config::Modality", tag = "1")]
        pub modality: i32,
        /// Optional. The theme of the web widget.
        #[prost(enumeration = "web_widget_config::Theme", tag = "2")]
        pub theme: i32,
        /// Optional. The title of the web widget.
        #[prost(string, tag = "3")]
        pub web_widget_title: ::prost::alloc::string::String,
        /// Optional. The security settings of the web widget.
        #[prost(message, optional, tag = "4")]
        pub security_settings: ::core::option::Option<
            web_widget_config::SecuritySettings,
        >,
    }
    /// Nested message and enum types in `WebWidgetConfig`.
    pub mod web_widget_config {
        /// Security settings for the web widget.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct SecuritySettings {
            /// Optional. Indicates whether public access to the web widget is enabled.
            /// If `true`, the web widget will be publicly accessible.
            /// If `false`, the web widget must be integrated with your own
            /// authentication and authorization system to return valid credentials for
            /// accessing the CES agent.
            #[prost(bool, tag = "1")]
            pub enable_public_access: bool,
            /// Optional. Indicates whether origin check for the web widget is enabled.
            /// If `true`, the web widget will check the origin of the website that
            /// loads the web widget and only allow it to be loaded in the same origin
            /// or any of the allowed origins.
            #[prost(bool, tag = "4")]
            pub enable_origin_check: bool,
            /// Optional. The origins that are allowed to host the web widget. An
            /// origin is defined by RFC 6454. If empty, all origins are allowed. A
            /// maximum of 100 origins is allowed. Example: "<https://example.com">
            #[prost(string, repeated, tag = "2")]
            pub allowed_origins: ::prost::alloc::vec::Vec<
                ::prost::alloc::string::String,
            >,
            /// Optional. Indicates whether reCAPTCHA verification for the web widget
            /// is enabled.
            #[prost(bool, tag = "3")]
            pub enable_recaptcha: bool,
        }
        /// Modality of the web widget.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum Modality {
            /// Unknown modality.
            Unspecified = 0,
            /// Widget supports both chat and voice input.
            ChatAndVoice = 1,
            /// Widget supports only voice input.
            VoiceOnly = 2,
            /// Widget supports only chat input.
            ChatOnly = 3,
            /// Widget supports chat, voice, and video input.
            ChatVoiceAndVideo = 4,
        }
        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::Unspecified => "MODALITY_UNSPECIFIED",
                    Self::ChatAndVoice => "CHAT_AND_VOICE",
                    Self::VoiceOnly => "VOICE_ONLY",
                    Self::ChatOnly => "CHAT_ONLY",
                    Self::ChatVoiceAndVideo => "CHAT_VOICE_AND_VIDEO",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "MODALITY_UNSPECIFIED" => Some(Self::Unspecified),
                    "CHAT_AND_VOICE" => Some(Self::ChatAndVoice),
                    "VOICE_ONLY" => Some(Self::VoiceOnly),
                    "CHAT_ONLY" => Some(Self::ChatOnly),
                    "CHAT_VOICE_AND_VIDEO" => Some(Self::ChatVoiceAndVideo),
                    _ => None,
                }
            }
        }
        /// Theme of the web widget.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum Theme {
            /// Unknown theme.
            Unspecified = 0,
            /// Light theme.
            Light = 1,
            /// Dark theme.
            Dark = 2,
        }
        impl Theme {
            /// 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 => "THEME_UNSPECIFIED",
                    Self::Light => "LIGHT",
                    Self::Dark => "DARK",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "THEME_UNSPECIFIED" => Some(Self::Unspecified),
                    "LIGHT" => Some(Self::Light),
                    "DARK" => Some(Self::Dark),
                    _ => None,
                }
            }
        }
    }
    /// The type of the channel profile.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ChannelType {
        /// Unknown channel type.
        Unknown = 0,
        /// Web UI channel.
        WebUi = 2,
        /// API channel.
        Api = 3,
        /// Twilio channel.
        Twilio = 4,
        /// Google Telephony Platform channel.
        GoogleTelephonyPlatform = 5,
        /// Contact Center as a Service (CCaaS) channel.
        ContactCenterAsAService = 6,
        /// Five9 channel.
        Five9 = 7,
        /// Third party contact center integration channel.
        ContactCenterIntegration = 8,
    }
    impl ChannelType {
        /// 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 => "UNKNOWN",
                Self::WebUi => "WEB_UI",
                Self::Api => "API",
                Self::Twilio => "TWILIO",
                Self::GoogleTelephonyPlatform => "GOOGLE_TELEPHONY_PLATFORM",
                Self::ContactCenterAsAService => "CONTACT_CENTER_AS_A_SERVICE",
                Self::Five9 => "FIVE9",
                Self::ContactCenterIntegration => "CONTACT_CENTER_INTEGRATION",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "UNKNOWN" => Some(Self::Unknown),
                "WEB_UI" => Some(Self::WebUi),
                "API" => Some(Self::Api),
                "TWILIO" => Some(Self::Twilio),
                "GOOGLE_TELEPHONY_PLATFORM" => Some(Self::GoogleTelephonyPlatform),
                "CONTACT_CENTER_AS_A_SERVICE" => Some(Self::ContactCenterAsAService),
                "FIVE9" => Some(Self::Five9),
                "CONTACT_CENTER_INTEGRATION" => Some(Self::ContactCenterIntegration),
                _ => None,
            }
        }
    }
}
/// A span is a unit of work or a single operation during the request processing.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Span {
    /// Output only. The name of the span.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. The start time of the span.
    #[prost(message, optional, tag = "2")]
    pub start_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The end time of the span.
    #[prost(message, optional, tag = "3")]
    pub end_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The duration of the span.
    #[prost(message, optional, tag = "6")]
    pub duration: ::core::option::Option<::prost_types::Duration>,
    /// Output only. Key-value attributes associated with the span.
    #[prost(message, optional, tag = "4")]
    pub attributes: ::core::option::Option<::prost_types::Struct>,
    /// Output only. The child spans that are nested under this span.
    #[prost(message, repeated, tag = "5")]
    pub child_spans: ::prost::alloc::vec::Vec<Span>,
}
/// The execution type of the tool or toolset.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ExecutionType {
    /// The execution type is unspecified. Defaults to `SYNCHRONOUS` if
    /// unspecified.
    Unspecified = 0,
    /// The tool is executed synchronously. The session is blocked
    /// until the tool returns.
    Synchronous = 1,
    /// The tool is executed asynchronously. The session will
    /// continue while the tool is executing.
    Asynchronous = 2,
}
impl ExecutionType {
    /// 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 => "EXECUTION_TYPE_UNSPECIFIED",
            Self::Synchronous => "SYNCHRONOUS",
            Self::Asynchronous => "ASYNCHRONOUS",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "EXECUTION_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "SYNCHRONOUS" => Some(Self::Synchronous),
            "ASYNCHRONOUS" => Some(Self::Asynchronous),
            _ => None,
        }
    }
}
/// An agent acts as the fundamental building block that provides instructions to
/// the Large Language Model (LLM) for executing specific tasks.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Agent {
    /// Identifier. The unique identifier of the agent.
    /// Format: `projects/{project}/locations/{location}/apps/{app}/agents/{agent}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. Display name of the agent.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Optional. Human-readable description of the agent.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Optional. Configurations for the LLM model.
    #[prost(message, optional, tag = "4")]
    pub model_settings: ::core::option::Option<ModelSettings>,
    /// Optional. Instructions for the LLM model to guide the agent's behavior.
    #[prost(string, tag = "6")]
    pub instruction: ::prost::alloc::string::String,
    /// Optional. List of available tools for the agent.
    /// Format: `projects/{project}/locations/{location}/apps/{app}/tools/{tool}`
    #[prost(string, repeated, tag = "7")]
    pub tools: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. List of child agents in the agent tree.
    /// Format: `projects/{project}/locations/{location}/apps/{app}/agents/{agent}`
    #[prost(string, repeated, tag = "8")]
    pub child_agents: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. The callbacks to execute before the agent is called.
    /// The provided callbacks are executed sequentially in the exact order they
    /// are given in the list. If a callback returns an overridden response,
    /// execution stops and any remaining callbacks are skipped.
    #[prost(message, repeated, tag = "18")]
    pub before_agent_callbacks: ::prost::alloc::vec::Vec<Callback>,
    /// Optional. The callbacks to execute after the agent is called.
    /// The provided callbacks are executed sequentially in the exact order they
    /// are given in the list. If a callback returns an overridden response,
    /// execution stops and any remaining callbacks are skipped.
    #[prost(message, repeated, tag = "19")]
    pub after_agent_callbacks: ::prost::alloc::vec::Vec<Callback>,
    /// Optional. The callbacks to execute before the model is called. If there are
    /// multiple calls to the model, the callback will be executed multiple times.
    /// The provided callbacks are executed sequentially in the exact order they
    /// are given in the list. If a callback returns an overridden response,
    /// execution stops and any remaining callbacks are skipped.
    #[prost(message, repeated, tag = "20")]
    pub before_model_callbacks: ::prost::alloc::vec::Vec<Callback>,
    /// Optional. The callbacks to execute after the model is called. If there are
    /// multiple calls to the model, the callback will be executed multiple times.
    /// The provided callbacks are executed sequentially in the exact order they
    /// are given in the list. If a callback returns an overridden response,
    /// execution stops and any remaining callbacks are skipped.
    #[prost(message, repeated, tag = "21")]
    pub after_model_callbacks: ::prost::alloc::vec::Vec<Callback>,
    /// Optional. The callbacks to execute before the tool is invoked. If there are
    /// multiple tool invocations, the callback will be executed multiple times.
    /// The provided callbacks are executed sequentially in the exact order they
    /// are given in the list. If a callback returns an overridden response,
    /// execution stops and any remaining callbacks are skipped.
    #[prost(message, repeated, tag = "22")]
    pub before_tool_callbacks: ::prost::alloc::vec::Vec<Callback>,
    /// Optional. The callbacks to execute after the tool is invoked. If there are
    /// multiple tool invocations, the callback will be executed multiple times.
    /// The provided callbacks are executed sequentially in the exact order they
    /// are given in the list. If a callback returns an overridden response,
    /// execution stops and any remaining callbacks are skipped.
    #[prost(message, repeated, tag = "23")]
    pub after_tool_callbacks: ::prost::alloc::vec::Vec<Callback>,
    /// Output only. Timestamp when the agent was created.
    #[prost(message, optional, tag = "15")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Timestamp when the agent was last updated.
    #[prost(message, optional, tag = "16")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Optional. List of guardrails for the agent.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/guardrails/{guardrail}`
    #[prost(string, repeated, tag = "17")]
    pub guardrails: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Etag used to ensure the object hasn't changed during a read-modify-write
    /// operation. If the etag is empty, the update will overwrite any concurrent
    /// changes.
    #[prost(string, tag = "24")]
    pub etag: ::prost::alloc::string::String,
    /// Optional. List of toolsets for the agent.
    #[prost(message, repeated, tag = "28")]
    pub toolsets: ::prost::alloc::vec::Vec<agent::AgentToolset>,
    /// Output only. If the agent is generated by the LLM assistant, this field
    /// contains a descriptive summary of the generation.
    #[prost(string, tag = "29")]
    pub generated_summary: ::prost::alloc::string::String,
    /// Optional. Agent transfer rules.
    /// If multiple rules match, the first one in the list will be used.
    #[prost(message, repeated, tag = "30")]
    pub transfer_rules: ::prost::alloc::vec::Vec<TransferRule>,
    /// The type of agent.
    #[prost(oneof = "agent::AgentType", tags = "26, 27")]
    pub agent_type: ::core::option::Option<agent::AgentType>,
}
/// Nested message and enum types in `Agent`.
pub mod agent {
    /// Default agent type. The agent uses instructions and callbacks specified in
    /// the agent to perform the task using a large language model.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct LlmAgent {}
    /// The agent which will transfer execution to a remote
    /// [Dialogflow
    /// CX](<https://docs.cloud.google.com/dialogflow/cx/docs/concept/agent>) agent.
    /// The Dialogflow agent will process subsequent user queries until the session
    /// ends or flow ends, and the control is transferred back to the parent CES
    /// agent.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RemoteDialogflowAgent {
        /// Required. The
        /// [Dialogflow](<https://docs.cloud.google.com/dialogflow/cx/docs/concept/agent>)
        /// agent resource name.
        /// Format: `projects/{project}/locations/{location}/agents/{agent}`
        #[prost(string, tag = "1")]
        pub agent: ::prost::alloc::string::String,
        /// Optional. The flow ID of the flow in the Dialogflow agent.
        #[prost(string, tag = "2")]
        pub flow_id: ::prost::alloc::string::String,
        /// Optional. The environment ID of the Dialogflow agent to be used for the
        /// agent execution. If not specified, the draft environment will be used.
        #[prost(string, tag = "3")]
        pub environment_id: ::prost::alloc::string::String,
        /// Optional. The mapping of the app variables names to the Dialogflow
        /// session parameters names to be sent to the Dialogflow agent as input.
        #[prost(map = "string, string", tag = "4")]
        pub input_variable_mapping: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            ::prost::alloc::string::String,
        >,
        /// Optional. The mapping of the Dialogflow session parameters names to the
        /// app variables names to be sent back to the CES agent after the Dialogflow
        /// agent execution ends.
        #[prost(map = "string, string", tag = "5")]
        pub output_variable_mapping: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            ::prost::alloc::string::String,
        >,
        /// Optional. Indicates whether to respect the message-level interruption
        /// settings configured in the Dialogflow agent.
        ///
        /// * If false: all response messages from the Dialogflow agent follow the
        ///   app-level barge-in settings.
        /// * If true: only response messages with
        ///   [`allow_playback_interruption`](<https://docs.cloud.google.com/dialogflow/cx/docs/reference/rpc/google.cloud.dialogflow.cx.v3#text>)
        ///   set to true will be interruptable, all other messages follow the
        ///   app-level barge-in settings.
        #[prost(bool, tag = "6")]
        pub respect_response_interruption_settings: bool,
    }
    /// A toolset with a selection of its tools.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct AgentToolset {
        /// Required. The resource name of the toolset.
        /// Format:
        /// `projects/{project}/locations/{location}/apps/{app}/toolsets/{toolset}`
        #[prost(string, tag = "1")]
        pub toolset: ::prost::alloc::string::String,
        /// Optional. The tools IDs to filter the toolset.
        #[prost(string, repeated, tag = "4")]
        pub tool_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    }
    /// The type of agent.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum AgentType {
        /// Optional. The default agent type.
        #[prost(message, tag = "26")]
        LlmAgent(LlmAgent),
        /// Optional. The remote
        /// [Dialogflow](<https://cloud.google.com/dialogflow/cx/docs/concept/console-conversational-agents>)
        /// agent to be used for the agent execution. If this field is set, all other
        /// agent level properties will be ignored.
        ///
        /// Note: If the Dialogflow agent is in a different project from the app, you
        /// should grant `roles/dialogflow.client` to the CES service agent
        /// `service-<PROJECT-NUMBER>@gcp-sa-ces.iam.gserviceaccount.com`.
        #[prost(message, tag = "27")]
        RemoteDialogflowAgent(RemoteDialogflowAgent),
    }
}
/// Settings to describe the BigQuery export behaviors for the app.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BigQueryExportSettings {
    /// Optional. Indicates whether the BigQuery export is enabled.
    #[prost(bool, tag = "1")]
    pub enabled: bool,
    /// Optional. The **project ID** of the BigQuery dataset to export the data to.
    ///
    /// Note: If the BigQuery dataset is in a different project from the app,
    /// you should grant `roles/bigquery.admin` role to the CES service agent
    /// `service-<PROJECT-NUMBER>@gcp-sa-ces.iam.gserviceaccount.com`.
    #[prost(string, tag = "2")]
    pub project: ::prost::alloc::string::String,
    /// Optional. The BigQuery **dataset ID** to export the data to.
    #[prost(string, tag = "3")]
    pub dataset: ::prost::alloc::string::String,
}
/// A code block to be executed instead of a real tool call.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CodeBlock {
    /// Required. Python code which will be invoked in tool fake mode.
    /// Expected Python function signature -
    /// To catch all tool calls:
    /// def fake_tool_call(tool: Tool, input: dict\[str, Any\],
    /// callback_context: CallbackContext) -> Optional\[dict\[str, Any\]\]:
    /// To catch a specific tool call:
    /// def fake\_{tool_id}(tool: Tool, input: dict\[str, Any\],
    /// callback_context: CallbackContext) -> Optional\[dict\[str, Any\]\]:
    /// If the function returns None, the real tool will be invoked instead.
    #[prost(string, tag = "1")]
    pub python_code: ::prost::alloc::string::String,
}
/// Configuration for tool behavior in fake mode.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ToolFakeConfig {
    /// Optional. Whether the tool is using fake mode.
    #[prost(bool, tag = "2")]
    pub enable_fake_mode: bool,
    /// The response is either static or it is provided by a python function.
    #[prost(oneof = "tool_fake_config::ToolResponse", tags = "1")]
    pub tool_response: ::core::option::Option<tool_fake_config::ToolResponse>,
}
/// Nested message and enum types in `ToolFakeConfig`.
pub mod tool_fake_config {
    /// The response is either static or it is provided by a python function.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum ToolResponse {
        /// Optional. Code block which will be executed instead of a real tool call.
        #[prost(message, tag = "1")]
        CodeBlock(super::CodeBlock),
    }
}
/// Configures the tool call behaviour for evaluation runs.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum EvaluationToolCallBehaviour {
    /// Unspecified tool call behavior. Will default to real tool calls.
    Unspecified = 0,
    /// Use real tool calls.
    Real = 1,
    /// Use fake tool calls.
    Fake = 2,
}
impl EvaluationToolCallBehaviour {
    /// 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 => "EVALUATION_TOOL_CALL_BEHAVIOUR_UNSPECIFIED",
            Self::Real => "REAL",
            Self::Fake => "FAKE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "EVALUATION_TOOL_CALL_BEHAVIOUR_UNSPECIFIED" => Some(Self::Unspecified),
            "REAL" => Some(Self::Real),
            "FAKE" => Some(Self::Fake),
            _ => None,
        }
    }
}
/// The method used to run the evaluation.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum GoldenRunMethod {
    /// Run method is not specified.
    Unspecified = 0,
    /// Run the evaluation as stable replay, where each turn is a unique session
    /// with the previous expected turns injected as context.
    Stable = 1,
    /// Run the evaluation as naive replay, where the run is a single
    /// session with no context injected.
    Naive = 2,
}
impl GoldenRunMethod {
    /// 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 => "GOLDEN_RUN_METHOD_UNSPECIFIED",
            Self::Stable => "STABLE",
            Self::Naive => "NAIVE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "GOLDEN_RUN_METHOD_UNSPECIFIED" => Some(Self::Unspecified),
            "STABLE" => Some(Self::Stable),
            "NAIVE" => Some(Self::Naive),
            _ => None,
        }
    }
}
/// Represents a select subset of an OpenAPI 3.0 schema object.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Schema {
    /// Required. The type of the data.
    #[prost(enumeration = "schema::Type", tag = "1")]
    pub r#type: i32,
    /// Optional. Properties of Type.OBJECT.
    #[prost(map = "string, message", tag = "2")]
    pub properties: ::std::collections::HashMap<::prost::alloc::string::String, Schema>,
    /// Optional. Required properties of Type.OBJECT.
    #[prost(string, repeated, tag = "3")]
    pub required: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. The description of the data.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// Optional. Schema of the elements of Type.ARRAY.
    #[prost(message, optional, boxed, tag = "5")]
    pub items: ::core::option::Option<::prost::alloc::boxed::Box<Schema>>,
    /// Optional. Indicates if the value may be null.
    #[prost(bool, tag = "6")]
    pub nullable: bool,
    /// Optional. Indicate the items in the array must be unique. Only applies to
    /// TYPE.ARRAY.
    #[prost(bool, tag = "7")]
    pub unique_items: bool,
    /// Optional. Schemas of initial elements of Type.ARRAY.
    #[prost(message, repeated, tag = "8")]
    pub prefix_items: ::prost::alloc::vec::Vec<Schema>,
    /// Optional. Can either be a boolean or an object, controls the presence of
    /// additional properties.
    #[prost(message, optional, boxed, tag = "9")]
    pub additional_properties: ::core::option::Option<
        ::prost::alloc::boxed::Box<Schema>,
    >,
    /// Optional. The value should be validated against any (one or more) of the
    /// subschemas in the list.
    #[prost(message, repeated, tag = "10")]
    pub any_of: ::prost::alloc::vec::Vec<Schema>,
    /// Optional. Possible values of the element of primitive type with enum
    /// format. Examples:
    ///
    /// 1. We can define direction as :
    ///    {type:STRING, format:enum, enum:\["EAST", NORTH", "SOUTH", "WEST"\]}
    /// 1. We can define apartment number as :
    ///    {type:INTEGER, format:enum, enum:\["101", "201", "301"\]}
    #[prost(string, repeated, tag = "11")]
    pub r#enum: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. Default value of the data.
    #[prost(message, optional, tag = "12")]
    pub default: ::core::option::Option<::prost_types::Value>,
    /// Optional. Allows indirect references between schema nodes. The value should
    /// be a valid reference to a child of the root `defs`.
    ///
    /// For example, the following schema defines a reference to a schema node
    /// named "Pet":
    ///
    /// ```text,
    /// type: object
    /// properties:
    ///   pet:
    ///     ref: #/defs/Pet
    /// defs:
    ///   Pet:
    ///     type: object
    ///     properties:
    ///       name:
    ///         type: string
    /// ```
    ///
    /// The value of the "pet" property is a reference to the schema node
    /// named "Pet".
    /// See details in
    /// <https://json-schema.org/understanding-json-schema/structuring.>
    #[prost(string, tag = "13")]
    pub r#ref: ::prost::alloc::string::String,
    /// Optional. A map of definitions for use by `ref`. Only allowed at the root
    /// of the schema.
    #[prost(map = "string, message", tag = "14")]
    pub defs: ::std::collections::HashMap<::prost::alloc::string::String, Schema>,
    /// Optional. The title of the schema.
    #[prost(string, tag = "15")]
    pub title: ::prost::alloc::string::String,
    /// Optional. Minimum number of the elements for Type.ARRAY.
    #[prost(int64, tag = "16")]
    pub min_items: i64,
    /// Optional. Maximum number of the elements for Type.ARRAY.
    #[prost(int64, tag = "17")]
    pub max_items: i64,
    /// Optional. Minimum value for Type.INTEGER and Type.NUMBER.
    #[prost(double, optional, tag = "18")]
    pub minimum: ::core::option::Option<f64>,
    /// Optional. Maximum value for Type.INTEGER and Type.NUMBER.
    #[prost(double, optional, tag = "19")]
    pub maximum: ::core::option::Option<f64>,
}
/// Nested message and enum types in `Schema`.
pub mod schema {
    /// OpenAPI data types.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Type {
        /// Type unspecified.
        Unspecified = 0,
        /// String type.
        String = 1,
        /// Integer type.
        Integer = 2,
        /// Number type.
        Number = 3,
        /// Boolean type.
        Boolean = 4,
        /// Object type.
        Object = 5,
        /// Array type.
        Array = 6,
    }
    impl Type {
        /// 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 => "TYPE_UNSPECIFIED",
                Self::String => "STRING",
                Self::Integer => "INTEGER",
                Self::Number => "NUMBER",
                Self::Boolean => "BOOLEAN",
                Self::Object => "OBJECT",
                Self::Array => "ARRAY",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "STRING" => Some(Self::String),
                "INTEGER" => Some(Self::Integer),
                "NUMBER" => Some(Self::Number),
                "BOOLEAN" => Some(Self::Boolean),
                "OBJECT" => Some(Self::Object),
                "ARRAY" => Some(Self::Array),
                _ => None,
            }
        }
    }
}
/// An app serves as a top-level container for a group of agents, including the
/// root agent and its sub-agents, along with their associated configurations.
/// These agents work together to achieve specific goals within the app's
/// context.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct App {
    /// Identifier. The unique identifier of the app.
    /// Format: `projects/{project}/locations/{location}/apps/{app}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. Display name of the app.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Optional. Human-readable description of the app.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Optional. Whether the app is pinned in the app list.
    #[prost(bool, tag = "31")]
    pub pinned: bool,
    /// Optional. The root agent is the entry point of the app.
    /// Format: `projects/{project}/locations/{location}/apps/{app}/agents/{agent}`
    #[prost(string, tag = "4")]
    pub root_agent: ::prost::alloc::string::String,
    /// Optional. Language settings of the app.
    #[prost(message, optional, tag = "18")]
    pub language_settings: ::core::option::Option<LanguageSettings>,
    /// Optional. TimeZone settings of the app.
    #[prost(message, optional, tag = "27")]
    pub time_zone_settings: ::core::option::Option<TimeZoneSettings>,
    /// Optional. Audio processing configuration of the app.
    #[prost(message, optional, tag = "7")]
    pub audio_processing_config: ::core::option::Option<AudioProcessingConfig>,
    /// Optional. Logging settings of the app.
    #[prost(message, optional, tag = "8")]
    pub logging_settings: ::core::option::Option<LoggingSettings>,
    /// Optional. Error handling settings of the app.
    #[prost(message, optional, tag = "34")]
    pub error_handling_settings: ::core::option::Option<ErrorHandlingSettings>,
    /// Optional. The default LLM model settings for the app.
    /// Individual resources (e.g. agents, guardrails) can override these
    /// configurations as needed.
    #[prost(message, optional, tag = "13")]
    pub model_settings: ::core::option::Option<ModelSettings>,
    /// Optional. The tool execution mode for the app. If not provided, will
    /// default to PARALLEL.
    #[prost(enumeration = "app::ToolExecutionMode", tag = "32")]
    pub tool_execution_mode: i32,
    /// Optional. The evaluation thresholds for the app.
    #[prost(message, optional, tag = "24")]
    pub evaluation_metrics_thresholds: ::core::option::Option<
        EvaluationMetricsThresholds,
    >,
    /// Optional. The declarations of the variables.
    #[prost(message, repeated, tag = "14")]
    pub variable_declarations: ::prost::alloc::vec::Vec<app::VariableDeclaration>,
    /// Output only. The declarations of predefined variables for the app.
    #[prost(message, repeated, tag = "28")]
    pub predefined_variable_declarations: ::prost::alloc::vec::Vec<
        app::VariableDeclaration,
    >,
    /// Optional. Instructions for all the agents in the app.
    /// You can use this instruction to set up a stable identity or personality
    /// across all the agents.
    #[prost(string, tag = "17")]
    pub global_instruction: ::prost::alloc::string::String,
    /// Optional. List of guardrails for the app.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/guardrails/{guardrail}`
    #[prost(string, repeated, tag = "10")]
    pub guardrails: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. The data store settings for the app.
    #[prost(message, optional, tag = "15")]
    pub data_store_settings: ::core::option::Option<DataStoreSettings>,
    /// Optional. The default channel profile used by the app.
    #[prost(message, optional, tag = "22")]
    pub default_channel_profile: ::core::option::Option<ChannelProfile>,
    /// Optional. Metadata about the app. This field can be used to store
    /// additional information relevant to the app's details or intended usages.
    #[prost(map = "string, string", tag = "11")]
    pub metadata: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Output only. Timestamp when the app was created.
    #[prost(message, optional, tag = "5")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Timestamp when the app was last updated.
    #[prost(message, optional, tag = "6")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Etag used to ensure the object hasn't changed during a
    /// read-modify-write operation. If the etag is empty, the update will
    /// overwrite any concurrent changes.
    #[prost(string, tag = "12")]
    pub etag: ::prost::alloc::string::String,
    /// Output only. Number of deployments in the app.
    #[prost(int32, tag = "23")]
    pub deployment_count: i32,
    /// Optional. The default client certificate settings for the app.
    #[prost(message, optional, tag = "25")]
    pub client_certificate_settings: ::core::option::Option<ClientCertificateSettings>,
    /// Optional. Indicates whether the app is locked for changes. If the app is
    /// locked, modifications to the app resources will be rejected.
    #[prost(bool, tag = "29")]
    pub locked: bool,
    /// Optional. The evaluation personas for the app. This field is used to define
    /// the personas that can be used for evaluation. Maximum of 30 personas can be
    /// defined.
    #[prost(message, repeated, tag = "30")]
    pub evaluation_personas: ::prost::alloc::vec::Vec<EvaluationPersona>,
    /// Optional. The evaluation settings for the app.
    #[prost(message, optional, tag = "33")]
    pub evaluation_settings: ::core::option::Option<EvaluationSettings>,
}
/// Nested message and enum types in `App`.
pub mod app {
    /// Defines the structure and metadata for a variable.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct VariableDeclaration {
        /// Required. The name of the variable. The name must start with a letter or
        /// underscore and contain only letters, numbers, or underscores.
        #[prost(string, tag = "1")]
        pub name: ::prost::alloc::string::String,
        /// Required. The description of the variable.
        #[prost(string, tag = "2")]
        pub description: ::prost::alloc::string::String,
        /// Required. The schema of the variable.
        #[prost(message, optional, tag = "3")]
        pub schema: ::core::option::Option<super::Schema>,
    }
    /// Defines the tool execution behavior if there are **multiple** tools being
    /// selected by the agent **at the same time**.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ToolExecutionMode {
        /// Unspecified tool execution mode. Default to PARALLEL.
        Unspecified = 0,
        /// If there are multiple tools being selected, they will be executed in
        /// parallel, with the same
        /// [ToolContext](<https://google.github.io/adk-docs/context/#the-different-types-of-context>).
        Parallel = 1,
        /// If there are multiple tools being selected, they will be executed
        /// sequentially. The next tool will only be executed after the previous tool
        /// completes and it can see updated
        /// [ToolContext](<https://google.github.io/adk-docs/context/#the-different-types-of-context>)
        /// from the previous tool.
        Sequential = 2,
    }
    impl ToolExecutionMode {
        /// 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 => "TOOL_EXECUTION_MODE_UNSPECIFIED",
                Self::Parallel => "PARALLEL",
                Self::Sequential => "SEQUENTIAL",
            }
        }
        /// 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_EXECUTION_MODE_UNSPECIFIED" => Some(Self::Unspecified),
                "PARALLEL" => Some(Self::Parallel),
                "SEQUENTIAL" => Some(Self::Sequential),
                _ => None,
            }
        }
    }
}
/// TimeZone settings of the app.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TimeZoneSettings {
    /// Optional. The time zone of the app from the [time zone
    /// database](<https://www.iana.org/time-zones>), e.g., America/Los_Angeles,
    /// Europe/Paris.
    #[prost(string, tag = "1")]
    pub time_zone: ::prost::alloc::string::String,
}
/// Language settings of the app.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct LanguageSettings {
    /// Optional. The default language code of the app.
    #[prost(string, tag = "1")]
    pub default_language_code: ::prost::alloc::string::String,
    /// Optional. List of languages codes supported by the app, in addition to the
    /// `default_language_code`.
    #[prost(string, repeated, tag = "2")]
    pub supported_language_codes: ::prost::alloc::vec::Vec<
        ::prost::alloc::string::String,
    >,
    /// Optional. Enables multilingual support. If true, agents in the app will use
    /// pre-built instructions to improve handling of multilingual input.
    #[prost(bool, tag = "3")]
    pub enable_multilingual_support: bool,
    /// Optional. Deprecated: This feature is no longer supported. Use
    /// `enable_multilingual_support` instead to improve handling of multilingual
    /// input.
    /// The action to perform when an agent receives input in an unsupported
    /// language.
    ///
    /// This can be a predefined action or a custom tool call.
    /// Valid values are:
    ///
    /// * A tool's full resource name, which triggers a specific tool execution.
    /// * A predefined system action, such as "escalate" or "exit", which triggers
    ///   an \[EndSession\]\[google.cloud.ces.v1beta.EndSession\] signal with
    ///   corresponding \[metadata\]\[google.cloud.ces.v1beta.EndSession.metadata\] to
    ///   terminate the conversation.
    #[deprecated]
    #[prost(string, tag = "4")]
    pub fallback_action: ::prost::alloc::string::String,
}
/// Configuration for how the input and output audio should be processed and
/// delivered.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AudioProcessingConfig {
    /// Optional. Configuration of how the agent response should be synthesized,
    /// mapping from the language code to
    /// \[SynthesizeSpeechConfig\]\[google.cloud.ces.v1beta.SynthesizeSpeechConfig\].
    ///
    /// If the configuration for the specified language code is not found, the
    /// configuration for the root language code will be used. For example, if the
    /// map contains "en-us" and "en", and the specified language code is "en-gb",
    /// then "en" configuration will be used.
    ///
    /// Note: Language code is case-insensitive.
    #[prost(map = "string, message", tag = "1")]
    pub synthesize_speech_configs: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        SynthesizeSpeechConfig,
    >,
    /// Optional. Configures the agent behavior for the user barge-in activities.
    #[prost(message, optional, tag = "3")]
    pub barge_in_config: ::core::option::Option<BargeInConfig>,
    /// Optional. The duration of user inactivity (no speech or interaction) before
    /// the agent prompts the user for reengagement. If not set, the agent will not
    /// prompt the user for reengagement.
    #[prost(message, optional, tag = "4")]
    pub inactivity_timeout: ::core::option::Option<::prost_types::Duration>,
    /// Optional. Configuration for the ambient sound to be played with the
    /// synthesized agent response, to enhance the naturalness of the conversation.
    #[prost(message, optional, tag = "5")]
    pub ambient_sound_config: ::core::option::Option<AmbientSoundConfig>,
}
/// Configuration for the ambient sound to be played with the synthesized agent
/// response, to enhance the naturalness of the conversation.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AmbientSoundConfig {
    /// Optional. Volume gain (in dB) of the normal native volume supported by
    /// ambient noise, in the range \[-96.0, 16.0\]. If unset, or set to a value of
    /// 0.0 (dB), will play at normal native signal amplitude. A value of -6.0 (dB)
    /// will play at approximately half the amplitude of the normal native signal
    /// amplitude. A value of +6.0 (dB) will play at approximately twice the
    /// amplitude of the normal native signal amplitude. We strongly recommend not
    /// to exceed +10 (dB) as there's usually no effective increase in loudness for
    /// any value greater than that.
    #[prost(double, tag = "3")]
    pub volume_gain_db: f64,
    /// Ambient noise to be played with the synthesized agent response, to
    /// enhance the naturalness of the conversation.
    #[prost(oneof = "ambient_sound_config::Source", tags = "1, 2, 4")]
    pub source: ::core::option::Option<ambient_sound_config::Source>,
}
/// Nested message and enum types in `AmbientSoundConfig`.
pub mod ambient_sound_config {
    /// Prebuilt ambient noise.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum PrebuiltAmbientNoise {
        /// Not specified.
        Unspecified = 0,
        /// Ambient noise of a retail store.
        RetailStore = 1,
        /// Ambient noise of a convention hall.
        ConventionHall = 2,
        /// Ambient noise of a street.
        Outdoor = 3,
    }
    impl PrebuiltAmbientNoise {
        /// 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 => "PREBUILT_AMBIENT_NOISE_UNSPECIFIED",
                Self::RetailStore => "RETAIL_STORE",
                Self::ConventionHall => "CONVENTION_HALL",
                Self::Outdoor => "OUTDOOR",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "PREBUILT_AMBIENT_NOISE_UNSPECIFIED" => Some(Self::Unspecified),
                "RETAIL_STORE" => Some(Self::RetailStore),
                "CONVENTION_HALL" => Some(Self::ConventionHall),
                "OUTDOOR" => Some(Self::Outdoor),
                _ => None,
            }
        }
    }
    /// Ambient noise to be played with the synthesized agent response, to
    /// enhance the naturalness of the conversation.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Source {
        /// Optional. Deprecated: `prebuilt_ambient_noise` is deprecated in favor of
        /// `prebuilt_ambient_sound`.
        #[deprecated]
        #[prost(enumeration = "PrebuiltAmbientNoise", tag = "1")]
        PrebuiltAmbientNoise(i32),
        /// Optional. Ambient noise as a mono-channel, 16kHz WAV file stored in
        /// [Cloud Storage](<https://cloud.google.com/storage>).
        ///
        /// Note: Please make sure the CES service agent
        /// `service-<PROJECT-NUMBER>@gcp-sa-ces.iam.gserviceaccount.com` has
        /// `storage.objects.get` permission to the Cloud Storage object.
        #[prost(string, tag = "2")]
        GcsUri(::prost::alloc::string::String),
        /// Optional. Name of the prebuilt ambient sound.
        /// Valid values are:
        ///
        /// * "coffee_shop"
        /// * "keyboard"
        /// * "keypad"
        /// * "hum"
        /// * "office_1"
        /// * "office_2"
        /// * "office_3"
        /// * "room_1"
        /// * "room_2"
        /// * "room_3"
        /// * "room_4"
        /// * "room_5"
        /// * "air_conditioner"
        #[prost(string, tag = "4")]
        PrebuiltAmbientSound(::prost::alloc::string::String),
    }
}
/// Configuration for how the user barge-in activities should be handled.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BargeInConfig {
    /// Optional. Disables user barge-in while the agent is speaking. If true, user
    /// input during agent response playback will be ignored.
    ///
    /// Deprecated: `disable_barge_in` is deprecated in favor of
    /// \[`disable_barge_in_control`\]\[google.cloud.ces.v1beta.ChannelProfile.disable_barge_in_control\]
    /// in ChannelProfile.
    #[deprecated]
    #[prost(bool, tag = "1")]
    pub disable_barge_in: bool,
    /// Optional. If enabled, the agent will adapt its next response based on the
    /// assumption that the user hasn't heard the full preceding agent message.
    /// This should not be used in scenarios where agent responses are displayed
    /// visually.
    #[prost(bool, tag = "2")]
    pub barge_in_awareness: bool,
}
/// Configuration for how the agent response should be synthesized.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SynthesizeSpeechConfig {
    /// Optional. The name of the voice. If not set, the service will choose a
    /// voice based on the other parameters such as language_code.
    ///
    /// For the list of available voices, please refer to [Supported voices and
    /// languages](<https://cloud.google.com/text-to-speech/docs/voices>) from Cloud
    /// Text-to-Speech.
    #[prost(string, tag = "1")]
    pub voice: ::prost::alloc::string::String,
    /// Optional. The speaking rate/speed in the range \[0.25, 2.0\]. 1.0 is the
    /// normal native speed supported by the specific voice. 2.0 is twice as fast,
    /// and 0.5 is half as fast. Values outside of the range \[0.25, 2.0\] will
    /// return an error.
    #[prost(double, tag = "2")]
    pub speaking_rate: f64,
}
/// Settings to describe the conversation data collection behaviors for LLM
/// analysis metrics pipeline.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct MetricAnalysisSettings {
    /// Optional. Whether to collect conversation data for llm analysis metrics. If
    /// true, conversation data will not be collected for llm analysis metrics;
    /// otherwise, conversation data will be collected.
    #[prost(bool, tag = "1")]
    pub llm_metrics_opted_out: bool,
}
/// Settings to describe the logging behaviors for the app.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct LoggingSettings {
    /// Optional. Configuration for how sensitive data should be redacted.
    #[prost(message, optional, tag = "1")]
    pub redaction_config: ::core::option::Option<RedactionConfig>,
    /// Optional. Configuration for how audio interactions should be recorded.
    #[prost(message, optional, tag = "2")]
    pub audio_recording_config: ::core::option::Option<AudioRecordingConfig>,
    /// Optional. Settings to describe the BigQuery export behaviors for the app.
    /// The conversation data will be exported to BigQuery tables if it is enabled.
    #[prost(message, optional, tag = "3")]
    pub bigquery_export_settings: ::core::option::Option<BigQueryExportSettings>,
    /// Optional. Settings to describe the Cloud Logging behaviors for the app.
    #[prost(message, optional, tag = "4")]
    pub cloud_logging_settings: ::core::option::Option<CloudLoggingSettings>,
    /// Optional. Settings to describe the conversation logging behaviors for the
    /// app.
    #[prost(message, optional, tag = "5")]
    pub conversation_logging_settings: ::core::option::Option<
        ConversationLoggingSettings,
    >,
    /// Optional. Configuration for how audio interactions should be recorded for
    /// the evaluation. By default, audio recording is not enabled for evaluation
    /// sessions.
    #[prost(message, optional, tag = "6")]
    pub evaluation_audio_recording_config: ::core::option::Option<AudioRecordingConfig>,
    /// Optional. Settings to describe the conversation data collection behaviors
    /// for the LLM analysis pipeline for the app.
    #[prost(message, optional, tag = "7")]
    pub metric_analysis_settings: ::core::option::Option<MetricAnalysisSettings>,
}
/// Settings to describe how errors should be handled in the app.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ErrorHandlingSettings {
    /// Optional. The strategy to use for error handling.
    #[prost(enumeration = "error_handling_settings::ErrorHandlingStrategy", tag = "1")]
    pub error_handling_strategy: i32,
    /// Optional. Configuration for handling fallback responses.
    #[prost(message, optional, tag = "2")]
    pub fallback_response_config: ::core::option::Option<
        error_handling_settings::FallbackResponseConfig,
    >,
    /// Optional. Configuration for ending the session in case of system errors
    /// (e.g. LLM errors).
    #[prost(message, optional, tag = "3")]
    pub end_session_config: ::core::option::Option<
        error_handling_settings::EndSessionConfig,
    >,
}
/// Nested message and enum types in `ErrorHandlingSettings`.
pub mod error_handling_settings {
    /// Configuration for handling fallback responses.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct FallbackResponseConfig {
        /// Optional. The fallback messages in case of system errors (e.g. LLM
        /// errors), mapped by [supported language
        /// code](<https://docs.cloud.google.com/customer-engagement-ai/conversational-agents/ps/reference/language>).
        #[prost(map = "string, string", tag = "1")]
        pub custom_fallback_messages: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            ::prost::alloc::string::String,
        >,
        /// Optional. The maximum number of fallback attempts to make before the
        /// agent emitting \[EndSession\]\[google.cloud.ces.v1beta.EndSession\] Signal.
        #[prost(int32, tag = "2")]
        pub max_fallback_attempts: i32,
    }
    /// Configuration for ending the session in case of system errors (e.g. LLM
    /// errors).
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct EndSessionConfig {
        /// Optional. Whether to escalate the session in
        /// \[EndSession\]\[google.cloud.ces.v1beta.EndSession\]. If session is
        /// escalated, \[metadata in
        /// EndSession\]\[google.cloud.ces.v1beta.EndSession.metadata\] will contain
        /// `session_escalated = true`. See
        /// <https://docs.cloud.google.com/customer-engagement-ai/conversational-agents/ps/deploy/google-telephony-platform#transfer_a_call_to_a_human_agent>
        /// for details.
        #[prost(bool, optional, tag = "1")]
        pub escalate_session: ::core::option::Option<bool>,
    }
    /// Defines the strategy for handling errors.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ErrorHandlingStrategy {
        /// Unspecified error handling strategy.
        Unspecified = 0,
        /// No specific handling is enabled.
        None = 1,
        /// A fallback message will be returned to the user in case of
        /// system errors (e.g. LLM errors).
        FallbackResponse = 2,
        /// An \[EndSession\]\[google.cloud.ces.v1beta.EndSession\] signal will be
        /// emitted in case of system errors (e.g. LLM errors).
        EndSession = 3,
    }
    impl ErrorHandlingStrategy {
        /// 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 => "ERROR_HANDLING_STRATEGY_UNSPECIFIED",
                Self::None => "NONE",
                Self::FallbackResponse => "FALLBACK_RESPONSE",
                Self::EndSession => "END_SESSION",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ERROR_HANDLING_STRATEGY_UNSPECIFIED" => Some(Self::Unspecified),
                "NONE" => Some(Self::None),
                "FALLBACK_RESPONSE" => Some(Self::FallbackResponse),
                "END_SESSION" => Some(Self::EndSession),
                _ => None,
            }
        }
    }
}
/// Threshold settings for metrics in an Evaluation.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct EvaluationMetricsThresholds {
    /// Optional. The golden evaluation metrics thresholds.
    #[prost(message, optional, tag = "1")]
    pub golden_evaluation_metrics_thresholds: ::core::option::Option<
        evaluation_metrics_thresholds::GoldenEvaluationMetricsThresholds,
    >,
    /// Optional. Deprecated: Use `golden_hallucination_metric_behavior` instead.
    /// The hallucination metric behavior is currently used for golden evaluations.
    #[deprecated]
    #[prost(
        enumeration = "evaluation_metrics_thresholds::HallucinationMetricBehavior",
        tag = "3"
    )]
    pub hallucination_metric_behavior: i32,
    /// Optional. The hallucination metric behavior for golden evaluations.
    #[prost(
        enumeration = "evaluation_metrics_thresholds::HallucinationMetricBehavior",
        tag = "5"
    )]
    pub golden_hallucination_metric_behavior: i32,
    /// Optional. The hallucination metric behavior for scenario evaluations.
    #[prost(
        enumeration = "evaluation_metrics_thresholds::HallucinationMetricBehavior",
        tag = "4"
    )]
    pub scenario_hallucination_metric_behavior: i32,
}
/// Nested message and enum types in `EvaluationMetricsThresholds`.
pub mod evaluation_metrics_thresholds {
    /// Settings for golden evaluations.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct GoldenEvaluationMetricsThresholds {
        /// Optional. The turn level metrics thresholds.
        #[prost(message, optional, tag = "1")]
        pub turn_level_metrics_thresholds: ::core::option::Option<
            golden_evaluation_metrics_thresholds::TurnLevelMetricsThresholds,
        >,
        /// Optional. The expectation level metrics thresholds.
        #[prost(message, optional, tag = "2")]
        pub expectation_level_metrics_thresholds: ::core::option::Option<
            golden_evaluation_metrics_thresholds::ExpectationLevelMetricsThresholds,
        >,
        /// Optional. The tool matching settings. An
        /// extra tool call is a tool call that is present in the execution but does
        /// not match any tool call in the golden expectation.
        #[prost(message, optional, tag = "3")]
        pub tool_matching_settings: ::core::option::Option<ToolMatchingSettings>,
    }
    /// Nested message and enum types in `GoldenEvaluationMetricsThresholds`.
    pub mod golden_evaluation_metrics_thresholds {
        /// Turn level metrics thresholds.
        #[derive(Clone, Copy, PartialEq, ::prost::Message)]
        pub struct TurnLevelMetricsThresholds {
            /// Optional. The success threshold for semantic similarity. Must be an
            /// integer between 0 and 4. Default is >= 3.
            #[prost(int32, optional, tag = "1")]
            pub semantic_similarity_success_threshold: ::core::option::Option<i32>,
            /// Optional. The success threshold for overall tool invocation
            /// correctness. Must be a float between 0 and 1. Default is 1.0.
            #[prost(float, optional, tag = "2")]
            pub overall_tool_invocation_correctness_threshold: ::core::option::Option<
                f32,
            >,
            /// Optional. The semantic similarity channel to use for evaluation.
            #[prost(
                enumeration = "turn_level_metrics_thresholds::SemanticSimilarityChannel",
                tag = "3"
            )]
            pub semantic_similarity_channel: i32,
        }
        /// Nested message and enum types in `TurnLevelMetricsThresholds`.
        pub mod turn_level_metrics_thresholds {
            /// Semantic similarity channel to use.
            #[derive(
                Clone,
                Copy,
                Debug,
                PartialEq,
                Eq,
                Hash,
                PartialOrd,
                Ord,
                ::prost::Enumeration
            )]
            #[repr(i32)]
            pub enum SemanticSimilarityChannel {
                /// Metric unspecified. Defaults to TEXT.
                Unspecified = 0,
                /// Use text semantic similarity.
                Text = 1,
                /// Use audio semantic similarity.
                Audio = 2,
            }
            impl SemanticSimilarityChannel {
                /// 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 => "SEMANTIC_SIMILARITY_CHANNEL_UNSPECIFIED",
                        Self::Text => "TEXT",
                        Self::Audio => "AUDIO",
                    }
                }
                /// Creates an enum from field names used in the ProtoBuf definition.
                pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                    match value {
                        "SEMANTIC_SIMILARITY_CHANNEL_UNSPECIFIED" => {
                            Some(Self::Unspecified)
                        }
                        "TEXT" => Some(Self::Text),
                        "AUDIO" => Some(Self::Audio),
                        _ => None,
                    }
                }
            }
        }
        /// Expectation level metrics thresholds.
        #[derive(Clone, Copy, PartialEq, ::prost::Message)]
        pub struct ExpectationLevelMetricsThresholds {
            /// Optional. The success threshold for individual tool invocation
            /// parameter correctness. Must be a float between 0 and 1. Default is 1.0.
            #[prost(float, optional, tag = "1")]
            pub tool_invocation_parameter_correctness_threshold: ::core::option::Option<
                f32,
            >,
        }
    }
    /// Settings for matching tool calls.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ToolMatchingSettings {
        /// Optional. Behavior for extra tool calls.
        /// Defaults to FAIL.
        #[prost(
            enumeration = "tool_matching_settings::ExtraToolCallBehavior",
            tag = "1"
        )]
        pub extra_tool_call_behavior: i32,
    }
    /// Nested message and enum types in `ToolMatchingSettings`.
    pub mod tool_matching_settings {
        /// Defines the behavior when an extra tool call is encountered. An extra
        /// tool call is a tool call that is present in the execution but does not
        /// match any tool call in the golden expectation.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum ExtraToolCallBehavior {
            /// Unspecified behavior. Defaults to FAIL.
            Unspecified = 0,
            /// Fail the evaluation if an extra tool call is encountered.
            Fail = 1,
            /// Allow the extra tool call.
            Allow = 2,
        }
        impl ExtraToolCallBehavior {
            /// 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 => "EXTRA_TOOL_CALL_BEHAVIOR_UNSPECIFIED",
                    Self::Fail => "FAIL",
                    Self::Allow => "ALLOW",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "EXTRA_TOOL_CALL_BEHAVIOR_UNSPECIFIED" => Some(Self::Unspecified),
                    "FAIL" => Some(Self::Fail),
                    "ALLOW" => Some(Self::Allow),
                    _ => None,
                }
            }
        }
    }
    /// The hallucination metric behavior. Regardless of the behavior, the metric
    /// will always be calculated. The difference is that when disabled, the
    /// metric is not used to calculate the overall evaluation score.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum HallucinationMetricBehavior {
        /// Unspecified hallucination metric behavior.
        Unspecified = 0,
        /// Disable hallucination metric.
        Disabled = 1,
        /// Enable hallucination metric.
        Enabled = 2,
    }
    impl HallucinationMetricBehavior {
        /// 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 => "HALLUCINATION_METRIC_BEHAVIOR_UNSPECIFIED",
                Self::Disabled => "DISABLED",
                Self::Enabled => "ENABLED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "HALLUCINATION_METRIC_BEHAVIOR_UNSPECIFIED" => Some(Self::Unspecified),
                "DISABLED" => Some(Self::Disabled),
                "ENABLED" => Some(Self::Enabled),
                _ => None,
            }
        }
    }
}
/// Settings for evaluation.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct EvaluationSettings {
    /// Optional. Who starts the conversation in a scenario evaluation.
    #[prost(
        enumeration = "evaluation_settings::ScenarioConversationInitiator",
        tag = "1"
    )]
    pub scenario_conversation_initiator: i32,
    /// Optional. The default method used to run golden evaluations. This will be
    /// used if no golden_run_method is specified in the RunEvaluationRequest.
    #[prost(enumeration = "GoldenRunMethod", tag = "4")]
    pub golden_run_method: i32,
    /// Optional. Configures the default tool call behaviour for golden
    /// evaluations.
    #[prost(enumeration = "EvaluationToolCallBehaviour", tag = "2")]
    pub golden_evaluation_tool_call_behaviour: i32,
    /// Optional. Configures the default tool call behaviour for scenario
    /// evaluations.
    #[prost(enumeration = "EvaluationToolCallBehaviour", tag = "3")]
    pub scenario_evaluation_tool_call_behaviour: i32,
}
/// Nested message and enum types in `EvaluationSettings`.
pub mod evaluation_settings {
    /// Determines who starts the conversation in a scenario evaluation session.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ScenarioConversationInitiator {
        /// Unspecified. Defaults to USER.
        Unspecified = 0,
        /// The user starts the conversation.
        User = 1,
        /// The agent starts the conversation.
        Agent = 2,
    }
    impl ScenarioConversationInitiator {
        /// 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 => "SCENARIO_CONVERSATION_INITIATOR_UNSPECIFIED",
                Self::User => "USER",
                Self::Agent => "AGENT",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "SCENARIO_CONVERSATION_INITIATOR_UNSPECIFIED" => Some(Self::Unspecified),
                "USER" => Some(Self::User),
                "AGENT" => Some(Self::Agent),
                _ => None,
            }
        }
    }
}
/// Settings for custom client certificates.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ClientCertificateSettings {
    /// Required. The TLS certificate encoded in PEM format. This string must
    /// include the begin header and end footer lines.
    #[prost(string, tag = "1")]
    pub tls_certificate: ::prost::alloc::string::String,
    /// Required. The name of the SecretManager secret version resource storing the
    /// private key encoded in PEM format.
    /// Format: `projects/{project}/secrets/{secret}/versions/{version}`
    #[prost(string, tag = "2")]
    pub private_key: ::prost::alloc::string::String,
    /// Optional. The name of the SecretManager secret version resource storing the
    /// passphrase to decrypt the private key. Should be left unset if the private
    /// key is not encrypted.
    /// Format: `projects/{project}/secrets/{secret}/versions/{version}`
    #[prost(string, tag = "3")]
    pub passphrase: ::prost::alloc::string::String,
}
/// Settings to describe the conversation logging behaviors for the app.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ConversationLoggingSettings {
    /// Optional. Whether to disable conversation logging for the sessions.
    #[prost(bool, tag = "1")]
    pub disable_conversation_logging: bool,
    /// Optional. Controls the retention window for the conversation.
    /// If not set, the conversation will be retained for 365 days.
    #[prost(message, optional, tag = "2")]
    pub retention_window: ::core::option::Option<::prost_types::Duration>,
}
/// Settings to describe the Cloud Logging behaviors for the app.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CloudLoggingSettings {
    /// Optional. Whether to enable Cloud Logging for the sessions.
    #[prost(bool, tag = "1")]
    pub enable_cloud_logging: bool,
}
/// Configuration for how the audio interactions should be recorded.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AudioRecordingConfig {
    /// Optional. The [Cloud Storage](<https://cloud.google.com/storage>) bucket to
    /// store the session audio recordings. The URI must start with "gs://".
    ///
    /// Please choose a bucket location that meets your data residency
    /// requirements.
    ///
    /// Note: If the Cloud Storage bucket is in a different project from the app,
    /// you should grant `storage.objects.create` permission to the CES service
    /// agent `service-<PROJECT-NUMBER>@gcp-sa-ces.iam.gserviceaccount.com`.
    #[prost(string, tag = "1")]
    pub gcs_bucket: ::prost::alloc::string::String,
    /// Optional. The Cloud Storage path prefix for audio recordings.
    ///
    /// This prefix can include the following placeholders, which will be
    /// dynamically substituted at serving time:
    ///
    /// * $project:   project ID
    /// * $location:  app location
    /// * $app:       app ID
    /// * $date:      session date in YYYY-MM-DD format
    /// * $session:   session ID
    ///
    /// If the path prefix is not specified, the default prefix
    /// `$project/$location/$app/$date/$session/` will be used.
    #[prost(string, tag = "2")]
    pub gcs_path_prefix: ::prost::alloc::string::String,
}
/// Configuration to instruct how sensitive data should be handled.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RedactionConfig {
    /// Optional. If true, redaction will be applied in various logging scenarios,
    /// including conversation history, Cloud Logging and audio recording.
    #[prost(bool, tag = "1")]
    pub enable_redaction: bool,
    /// Optional. [DLP](<https://cloud.google.com/dlp/docs>) inspect template name to
    /// configure detection of sensitive data types.
    ///
    /// Format:
    /// `projects/{project}/locations/{location}/inspectTemplates/{inspect_template}`
    #[prost(string, tag = "2")]
    pub inspect_template: ::prost::alloc::string::String,
    /// Optional. [DLP](<https://cloud.google.com/dlp/docs>) deidentify template name
    /// to instruct on how to de-identify content.
    ///
    /// Format:
    /// `projects/{project}/locations/{location}/deidentifyTemplates/{deidentify_template}`
    #[prost(string, tag = "3")]
    pub deidentify_template: ::prost::alloc::string::String,
}
/// Data store related settings for the app.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DataStoreSettings {
    /// Output only. The engines for the app.
    #[prost(message, repeated, tag = "3")]
    pub engines: ::prost::alloc::vec::Vec<data_store_settings::Engine>,
}
/// Nested message and enum types in `DataStoreSettings`.
pub mod data_store_settings {
    /// An engine to which the data stores are connected.
    /// See Vertex AI Search:
    /// <https://cloud.google.com/generative-ai-app-builder/docs/enterprise-search-introduction.>
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Engine {
        /// Output only. The resource name of the engine.
        /// Format:
        /// `projects/{project}/locations/{location}/collections/{collection}/engines/{engine}`
        #[prost(string, tag = "1")]
        pub name: ::prost::alloc::string::String,
        /// Output only. The type of the engine.
        #[prost(enumeration = "engine::Type", tag = "2")]
        pub r#type: i32,
    }
    /// Nested message and enum types in `Engine`.
    pub mod engine {
        /// The type of the engine.
        /// See the documentation available at
        /// <https://cloud.google.com/generative-ai-app-builder/docs/reference/rest/v1/SolutionType>
        /// and
        /// <https://cloud.google.com/generative-ai-app-builder/docs/create-datastore-ingest.>
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum Type {
            /// Unspecified engine type.
            Unspecified = 0,
            /// The SOLUTION_TYPE_SEARCH engine for the app. All connector data stores
            /// added to the app will be added to this engine.
            EngineTypeSearch = 1,
            /// Chat engine type.
            /// The SOLUTION_TYPE_CHAT engine for the app. All connector data stores
            /// added to the app will be added to this engine.
            EngineTypeChat = 2,
        }
        impl Type {
            /// 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 => "TYPE_UNSPECIFIED",
                    Self::EngineTypeSearch => "ENGINE_TYPE_SEARCH",
                    Self::EngineTypeChat => "ENGINE_TYPE_CHAT",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                    "ENGINE_TYPE_SEARCH" => Some(Self::EngineTypeSearch),
                    "ENGINE_TYPE_CHAT" => Some(Self::EngineTypeChat),
                    _ => None,
                }
            }
        }
    }
}
/// A persona represents an end user in an evaluation.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EvaluationPersona {
    /// Required. The unique identifier of the persona.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/evaluationPersonas/{evaluationPersona}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The description of the persona.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Required. The display name of the persona. Unique within an app.
    #[prost(string, tag = "3")]
    pub display_name: ::prost::alloc::string::String,
    /// Required. An instruction for the agent on how to behave in the evaluation.
    #[prost(string, tag = "4")]
    pub personality: ::prost::alloc::string::String,
    /// Optional. Configuration for how the persona sounds (TTS settings).
    #[prost(message, optional, tag = "5")]
    pub speech_config: ::core::option::Option<evaluation_persona::SpeechConfig>,
}
/// Nested message and enum types in `EvaluationPersona`.
pub mod evaluation_persona {
    /// Configuration for Text-to-Speech generation.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SpeechConfig {
        /// Optional. The speaking rate. 1.0 is normal.
        /// Lower is slower (e.g., 0.8), higher is faster (e.g., 1.5).
        /// Useful for testing how the agent handles fast talkers.
        #[prost(double, tag = "1")]
        pub speaking_rate: f64,
        /// Optional. The simulated audio environment.
        #[prost(enumeration = "speech_config::BackgroundEnvironment", tag = "2")]
        pub environment: i32,
        /// Optional. The specific voice identifier/accent to use.
        /// Example: "en-US-Wavenet-D" or "en-GB-Standard-A"
        #[prost(string, tag = "3")]
        pub voice_id: ::prost::alloc::string::String,
    }
    /// Nested message and enum types in `SpeechConfig`.
    pub mod speech_config {
        /// Simulated audio environment.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum BackgroundEnvironment {
            /// Background environment unspecified.
            Unspecified = 0,
            /// Call center environment.
            CallCenter = 3,
            /// Traffic noise environment.
            Traffic = 4,
            /// Kids noise environment.
            KidsNoise = 5,
            /// Cafe environment.
            Cafe = 6,
        }
        impl BackgroundEnvironment {
            /// 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 => "BACKGROUND_ENVIRONMENT_UNSPECIFIED",
                    Self::CallCenter => "CALL_CENTER",
                    Self::Traffic => "TRAFFIC",
                    Self::KidsNoise => "KIDS_NOISE",
                    Self::Cafe => "CAFE",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "BACKGROUND_ENVIRONMENT_UNSPECIFIED" => Some(Self::Unspecified),
                    "CALL_CENTER" => Some(Self::CallCenter),
                    "TRAFFIC" => Some(Self::Traffic),
                    "KIDS_NOISE" => Some(Self::KidsNoise),
                    "CAFE" => Some(Self::Cafe),
                    _ => None,
                }
            }
        }
    }
}
/// A tool that is created from a toolset.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ToolsetTool {
    /// Required. The resource name of the Toolset from which this tool is derived.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/toolsets/{toolset}`
    #[prost(string, tag = "1")]
    pub toolset: ::prost::alloc::string::String,
    /// Optional. The tool ID to filter the tools to retrieve the schema for.
    #[prost(string, tag = "3")]
    pub tool_id: ::prost::alloc::string::String,
}
/// An example represents a sample conversation between the user and the
/// agent(s).
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Example {
    /// Identifier. The unique identifier of the example.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/examples/{example}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. Display name of the example.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Optional. Human-readable description of the example.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Optional. The agent that initially handles the conversation. If not
    /// specified, the example represents a conversation that is handled by the
    /// root agent. Format:
    /// `projects/{project}/locations/{location}/apps/{app}/agents/{agent}`
    #[prost(string, tag = "4")]
    pub entry_agent: ::prost::alloc::string::String,
    /// Optional. The collection of messages that make up the conversation.
    #[prost(message, repeated, tag = "5")]
    pub messages: ::prost::alloc::vec::Vec<Message>,
    /// Output only. Timestamp when the example was created.
    #[prost(message, optional, tag = "6")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Timestamp when the example was last updated.
    #[prost(message, optional, tag = "7")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The example may become invalid if referencing resources are
    /// deleted. Invalid examples will not be used as few-shot examples.
    #[prost(bool, tag = "8")]
    pub invalid: bool,
    /// Etag used to ensure the object hasn't changed during a read-modify-write
    /// operation. If the etag is empty, the update will overwrite any concurrent
    /// changes.
    #[prost(string, tag = "9")]
    pub etag: ::prost::alloc::string::String,
}
/// A message within a conversation.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Message {
    /// Optional. The role within the conversation, e.g., user, agent.
    #[prost(string, tag = "1")]
    pub role: ::prost::alloc::string::String,
    /// Optional. Content of the message as a series of chunks.
    #[prost(message, repeated, tag = "2")]
    pub chunks: ::prost::alloc::vec::Vec<Chunk>,
    /// Optional. Timestamp when the message was sent or received. Should not be
    /// used if the message is part of an
    /// \[example\]\[google.cloud.ces.v1beta.Example\].
    #[prost(message, optional, tag = "4")]
    pub event_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// A chunk of content within a message.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Chunk {
    /// Chunk data.
    #[prost(oneof = "chunk::Data", tags = "1, 9, 7, 11, 5, 2, 3, 4, 8, 10")]
    pub data: ::core::option::Option<chunk::Data>,
}
/// Nested message and enum types in `Chunk`.
pub mod chunk {
    /// Chunk data.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Data {
        /// Optional. Text data.
        #[prost(string, tag = "1")]
        Text(::prost::alloc::string::String),
        /// Optional. Transcript associated with the audio.
        #[prost(string, tag = "9")]
        Transcript(::prost::alloc::string::String),
        /// Optional. Blob data.
        #[prost(message, tag = "7")]
        Blob(super::Blob),
        /// Optional. Custom payload data.
        #[prost(message, tag = "11")]
        Payload(::prost_types::Struct),
        /// Optional. Image data.
        #[prost(message, tag = "5")]
        Image(super::Image),
        /// Optional. Tool execution request.
        #[prost(message, tag = "2")]
        ToolCall(super::ToolCall),
        /// Optional. Tool execution response.
        #[prost(message, tag = "3")]
        ToolResponse(super::ToolResponse),
        /// Optional. Agent transfer event.
        #[prost(message, tag = "4")]
        AgentTransfer(super::AgentTransfer),
        /// A struct represents variables that were updated in the conversation,
        /// keyed by variable names.
        #[prost(message, tag = "8")]
        UpdatedVariables(::prost_types::Struct),
        /// A struct represents default variables at the start of the conversation,
        /// keyed by variable names.
        #[prost(message, tag = "10")]
        DefaultVariables(::prost_types::Struct),
    }
}
/// Represents a blob input or output in the conversation.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Blob {
    /// Required. The IANA standard MIME type of the source data.
    #[prost(string, tag = "1")]
    pub mime_type: ::prost::alloc::string::String,
    /// Required. Raw bytes of the blob.
    #[prost(bytes = "vec", tag = "2")]
    pub data: ::prost::alloc::vec::Vec<u8>,
}
/// Represents an image input or output in the conversation.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Image {
    /// Required. The IANA standard MIME type of the source data.
    /// Supported image types includes:
    ///
    /// * image/png
    /// * image/jpeg
    /// * image/webp
    #[prost(string, tag = "1")]
    pub mime_type: ::prost::alloc::string::String,
    /// Required. Raw bytes of the image.
    #[prost(bytes = "vec", tag = "2")]
    pub data: ::prost::alloc::vec::Vec<u8>,
}
/// Request for the client or the agent to execute the specified tool.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ToolCall {
    /// Optional. The unique identifier of the tool call. If populated, the client
    /// should return the execution result with the matching ID in
    /// \[ToolResponse\]\[google.cloud.ces.v1beta.ToolResponse.id\].
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Output only. Display name of the tool.
    #[prost(string, tag = "4")]
    pub display_name: ::prost::alloc::string::String,
    /// Optional. The input parameters and values for the tool in JSON object
    /// format.
    #[prost(message, optional, tag = "3")]
    pub args: ::core::option::Option<::prost_types::Struct>,
    /// The identifier of the tool to execute. It could be either a persisted tool
    /// or a tool from a toolset.
    #[prost(oneof = "tool_call::ToolIdentifier", tags = "2, 5")]
    pub tool_identifier: ::core::option::Option<tool_call::ToolIdentifier>,
}
/// Nested message and enum types in `ToolCall`.
pub mod tool_call {
    /// The identifier of the tool to execute. It could be either a persisted tool
    /// or a tool from a toolset.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum ToolIdentifier {
        /// Optional. The name of the tool to execute.
        /// Format: `projects/{project}/locations/{location}/apps/{app}/tools/{tool}`
        #[prost(string, tag = "2")]
        Tool(::prost::alloc::string::String),
        /// Optional. The toolset tool to execute.
        #[prost(message, tag = "5")]
        ToolsetTool(super::ToolsetTool),
    }
}
/// The execution result of a specific tool from the client or the agent.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ToolResponse {
    /// Optional. The matching ID of the \[tool
    /// call\]\[google.cloud.ces.v1beta.ToolCall\] the response is for.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Output only. Display name of the tool.
    #[prost(string, tag = "4")]
    pub display_name: ::prost::alloc::string::String,
    /// Required. The tool execution result in JSON object format.
    /// Use "output" key to specify tool response and "error" key to specify
    /// error details (if any). If "output" and "error" keys are not specified,
    /// then whole "response" is treated as tool execution result.
    #[prost(message, optional, tag = "3")]
    pub response: ::core::option::Option<::prost_types::Struct>,
    /// The identifier of the tool that got executed. It could be either a
    /// persisted tool or a tool from a toolset.
    #[prost(oneof = "tool_response::ToolIdentifier", tags = "2, 5")]
    pub tool_identifier: ::core::option::Option<tool_response::ToolIdentifier>,
}
/// Nested message and enum types in `ToolResponse`.
pub mod tool_response {
    /// The identifier of the tool that got executed. It could be either a
    /// persisted tool or a tool from a toolset.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum ToolIdentifier {
        /// Optional. The name of the tool to execute.
        /// Format: `projects/{project}/locations/{location}/apps/{app}/tools/{tool}`
        #[prost(string, tag = "2")]
        Tool(::prost::alloc::string::String),
        /// Optional. The toolset tool that got executed.
        #[prost(message, tag = "5")]
        ToolsetTool(super::ToolsetTool),
    }
}
/// Represents an event indicating the transfer of a conversation to a different
/// agent.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AgentTransfer {
    /// Required. The agent to which the conversation is being transferred. The
    /// agent will handle the conversation from this point forward. Format:
    /// `projects/{project}/locations/{location}/apps/{app}/agents/{agent}`
    #[prost(string, tag = "1")]
    pub target_agent: ::prost::alloc::string::String,
    /// Output only. Display name of the agent.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
}
/// Guardrail contains a list of checks and balances to keep the agents safe and
/// secure.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Guardrail {
    /// Identifier. The unique identifier of the guardrail.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/guardrails/{guardrail}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. Display name of the guardrail.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Optional. Description of the guardrail.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Optional. Whether the guardrail is enabled.
    #[prost(bool, tag = "4")]
    pub enabled: bool,
    /// Optional. Action to take when the guardrail is triggered.
    #[prost(message, optional, tag = "5")]
    pub action: ::core::option::Option<TriggerAction>,
    /// Output only. Timestamp when the guardrail was created.
    #[prost(message, optional, tag = "6")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Timestamp when the guardrail was last updated.
    #[prost(message, optional, tag = "7")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Etag used to ensure the object hasn't changed during a read-modify-write
    /// operation. If the etag is empty, the update will overwrite any concurrent
    /// changes.
    #[prost(string, tag = "11")]
    pub etag: ::prost::alloc::string::String,
    /// Guardrail type.
    #[prost(oneof = "guardrail::GuardrailType", tags = "8, 9, 10, 13, 14")]
    pub guardrail_type: ::core::option::Option<guardrail::GuardrailType>,
}
/// Nested message and enum types in `Guardrail`.
pub mod guardrail {
    /// Guardrail that bans certain content from being used in the conversation.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ContentFilter {
        /// Optional. List of banned phrases. Applies to both user inputs and agent
        /// responses.
        #[prost(string, repeated, tag = "1")]
        pub banned_contents: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        /// Optional. List of banned phrases. Applies only to user inputs.
        #[prost(string, repeated, tag = "2")]
        pub banned_contents_in_user_input: ::prost::alloc::vec::Vec<
            ::prost::alloc::string::String,
        >,
        /// Optional. List of banned phrases. Applies only to agent responses.
        #[prost(string, repeated, tag = "3")]
        pub banned_contents_in_agent_response: ::prost::alloc::vec::Vec<
            ::prost::alloc::string::String,
        >,
        /// Required. Match type for the content filter.
        #[prost(enumeration = "content_filter::MatchType", tag = "4")]
        pub match_type: i32,
        /// Optional. If true, diacritics are ignored during matching.
        #[prost(bool, tag = "5")]
        pub disregard_diacritics: bool,
    }
    /// Nested message and enum types in `ContentFilter`.
    pub mod content_filter {
        /// Match type for the content filter.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum MatchType {
            /// Match type is not specified.
            Unspecified = 0,
            /// Content is matched for substrings character by character.
            SimpleStringMatch = 1,
            /// Content only matches if the pattern found in the text is
            /// surrounded by word delimiters. Banned phrases can also contain word
            /// delimiters.
            WordBoundaryStringMatch = 2,
            /// Content is matched using regular expression syntax.
            RegexpMatch = 3,
        }
        impl MatchType {
            /// 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 => "MATCH_TYPE_UNSPECIFIED",
                    Self::SimpleStringMatch => "SIMPLE_STRING_MATCH",
                    Self::WordBoundaryStringMatch => "WORD_BOUNDARY_STRING_MATCH",
                    Self::RegexpMatch => "REGEXP_MATCH",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "MATCH_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                    "SIMPLE_STRING_MATCH" => Some(Self::SimpleStringMatch),
                    "WORD_BOUNDARY_STRING_MATCH" => Some(Self::WordBoundaryStringMatch),
                    "REGEXP_MATCH" => Some(Self::RegexpMatch),
                    _ => None,
                }
            }
        }
    }
    /// Guardrail that blocks the conversation if the input is considered unsafe
    /// based on the LLM classification.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct LlmPromptSecurity {
        /// Optional. Determines the behavior when the guardrail encounters an LLM
        /// error.
        ///
        /// * If true: the guardrail is bypassed.
        /// * If false (default): the guardrail triggers/blocks.
        ///
        /// Note: If a custom policy is provided, this field is ignored in favor
        /// of the policy's 'fail_open' configuration.
        #[prost(bool, tag = "3")]
        pub fail_open: bool,
        /// Defines the security configuration mode.
        /// The user must choose one of the following configurations.
        #[prost(oneof = "llm_prompt_security::SecurityConfig", tags = "1, 2")]
        pub security_config: ::core::option::Option<llm_prompt_security::SecurityConfig>,
    }
    /// Nested message and enum types in `LlmPromptSecurity`.
    pub mod llm_prompt_security {
        /// Configuration for default system security settings.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct DefaultSecuritySettings {
            /// Output only. The default prompt template used by the system.
            /// This field is for display purposes to show the user what prompt
            /// the system uses by default. It is OUTPUT_ONLY.
            #[prost(string, tag = "1")]
            pub default_prompt_template: ::prost::alloc::string::String,
        }
        /// Defines the security configuration mode.
        /// The user must choose one of the following configurations.
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum SecurityConfig {
            /// Optional. Use the system's predefined default security settings.
            /// To select this mode, include an empty 'default_settings' message
            /// in the request. The 'default_prompt_template' field within
            /// will be populated by the server in the response.
            #[prost(message, tag = "1")]
            DefaultSettings(DefaultSecuritySettings),
            /// Optional. Use a user-defined LlmPolicy to configure the security
            /// guardrail.
            #[prost(message, tag = "2")]
            CustomPolicy(super::LlmPolicy),
        }
    }
    /// Guardrail that blocks the conversation if the LLM response is considered
    /// violating the policy based on the LLM classification.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct LlmPolicy {
        /// Optional. When checking this policy, consider the last 'n' messages in
        /// the conversation. When not set a default value of 10 will be used.
        #[prost(int32, tag = "1")]
        pub max_conversation_messages: i32,
        /// Optional. Model settings.
        #[prost(message, optional, tag = "2")]
        pub model_settings: ::core::option::Option<super::ModelSettings>,
        /// Required. Policy prompt.
        #[prost(string, tag = "3")]
        pub prompt: ::prost::alloc::string::String,
        /// Required. Defines when to apply the policy check during the conversation.
        /// If set to `POLICY_SCOPE_UNSPECIFIED`, the policy will be applied to the
        /// user input. When applying the policy to the agent response, additional
        /// latency will be introduced before the agent can respond.
        #[prost(enumeration = "llm_policy::PolicyScope", tag = "4")]
        pub policy_scope: i32,
        /// Optional. If an error occurs during the policy check, fail open and do
        /// not trigger the guardrail.
        #[prost(bool, tag = "5")]
        pub fail_open: bool,
        /// Optional. By default, the LLM policy check is bypassed for short
        /// utterances. Enabling this setting applies the policy check to all
        /// utterances, including those that would normally be skipped.
        #[prost(bool, tag = "6")]
        pub allow_short_utterance: bool,
    }
    /// Nested message and enum types in `LlmPolicy`.
    pub mod llm_policy {
        /// Defines when to apply the policy check during the conversation.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum PolicyScope {
            /// Policy scope is not specified.
            Unspecified = 0,
            /// Policy check is triggered on user input.
            UserQuery = 1,
            /// Policy check is triggered on agent response. Applying this policy
            /// scope will introduce additional latency before the agent can respond.
            AgentResponse = 2,
            /// Policy check is triggered on both user input and agent response.
            /// Applying this policy scope will introduce additional latency before
            /// the agent can respond.
            UserQueryAndAgentResponse = 3,
        }
        impl PolicyScope {
            /// 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 => "POLICY_SCOPE_UNSPECIFIED",
                    Self::UserQuery => "USER_QUERY",
                    Self::AgentResponse => "AGENT_RESPONSE",
                    Self::UserQueryAndAgentResponse => "USER_QUERY_AND_AGENT_RESPONSE",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "POLICY_SCOPE_UNSPECIFIED" => Some(Self::Unspecified),
                    "USER_QUERY" => Some(Self::UserQuery),
                    "AGENT_RESPONSE" => Some(Self::AgentResponse),
                    "USER_QUERY_AND_AGENT_RESPONSE" => {
                        Some(Self::UserQueryAndAgentResponse)
                    }
                    _ => None,
                }
            }
        }
    }
    /// Model safety settings overrides. When this is set, it will override the
    /// default settings and trigger the guardrail if the response is considered
    /// unsafe.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ModelSafety {
        /// Required. List of safety settings.
        #[prost(message, repeated, tag = "1")]
        pub safety_settings: ::prost::alloc::vec::Vec<model_safety::SafetySetting>,
    }
    /// Nested message and enum types in `ModelSafety`.
    pub mod model_safety {
        /// Safety setting.
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct SafetySetting {
            /// Required. The harm category.
            #[prost(enumeration = "HarmCategory", tag = "1")]
            pub category: i32,
            /// Required. The harm block threshold.
            #[prost(enumeration = "HarmBlockThreshold", tag = "2")]
            pub threshold: i32,
        }
        /// Harm category.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum HarmCategory {
            /// The harm category is unspecified.
            Unspecified = 0,
            /// The harm category is hate speech.
            HateSpeech = 1,
            /// The harm category is dangerous content.
            DangerousContent = 2,
            /// The harm category is harassment.
            Harassment = 3,
            /// The harm category is sexually explicit content.
            SexuallyExplicit = 4,
        }
        impl HarmCategory {
            /// 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 => "HARM_CATEGORY_UNSPECIFIED",
                    Self::HateSpeech => "HARM_CATEGORY_HATE_SPEECH",
                    Self::DangerousContent => "HARM_CATEGORY_DANGEROUS_CONTENT",
                    Self::Harassment => "HARM_CATEGORY_HARASSMENT",
                    Self::SexuallyExplicit => "HARM_CATEGORY_SEXUALLY_EXPLICIT",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "HARM_CATEGORY_UNSPECIFIED" => Some(Self::Unspecified),
                    "HARM_CATEGORY_HATE_SPEECH" => Some(Self::HateSpeech),
                    "HARM_CATEGORY_DANGEROUS_CONTENT" => Some(Self::DangerousContent),
                    "HARM_CATEGORY_HARASSMENT" => Some(Self::Harassment),
                    "HARM_CATEGORY_SEXUALLY_EXPLICIT" => Some(Self::SexuallyExplicit),
                    _ => None,
                }
            }
        }
        /// Probability based thresholds levels for blocking.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum HarmBlockThreshold {
            /// Unspecified harm block threshold.
            Unspecified = 0,
            /// Block low threshold and above (i.e. block more).
            BlockLowAndAbove = 1,
            /// Block medium threshold and above.
            BlockMediumAndAbove = 2,
            /// Block only high threshold (i.e. block less).
            BlockOnlyHigh = 3,
            /// Block none.
            BlockNone = 4,
            /// Turn off the safety filter.
            Off = 5,
        }
        impl HarmBlockThreshold {
            /// 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 => "HARM_BLOCK_THRESHOLD_UNSPECIFIED",
                    Self::BlockLowAndAbove => "BLOCK_LOW_AND_ABOVE",
                    Self::BlockMediumAndAbove => "BLOCK_MEDIUM_AND_ABOVE",
                    Self::BlockOnlyHigh => "BLOCK_ONLY_HIGH",
                    Self::BlockNone => "BLOCK_NONE",
                    Self::Off => "OFF",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "HARM_BLOCK_THRESHOLD_UNSPECIFIED" => Some(Self::Unspecified),
                    "BLOCK_LOW_AND_ABOVE" => Some(Self::BlockLowAndAbove),
                    "BLOCK_MEDIUM_AND_ABOVE" => Some(Self::BlockMediumAndAbove),
                    "BLOCK_ONLY_HIGH" => Some(Self::BlockOnlyHigh),
                    "BLOCK_NONE" => Some(Self::BlockNone),
                    "OFF" => Some(Self::Off),
                    _ => None,
                }
            }
        }
    }
    /// Guardrail that blocks the conversation based on the code callbacks
    /// provided.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct CodeCallback {
        /// Optional. The callback to execute before the agent is called.
        /// Each callback function is expected to return a structure (e.g., a dict or
        /// object) containing at least:
        ///
        /// * 'decision': Either 'OK' or 'TRIGGER'.
        /// * 'reason': A string explaining the decision.
        ///   A 'TRIGGER' decision may halt further processing.
        #[prost(message, optional, tag = "1")]
        pub before_agent_callback: ::core::option::Option<super::Callback>,
        /// Optional. The callback to execute after the agent is called.
        /// Each callback function is expected to return a structure (e.g., a dict or
        /// object) containing at least:
        ///
        /// * 'decision': Either 'OK' or 'TRIGGER'.
        /// * 'reason': A string explaining the decision.
        ///   A 'TRIGGER' decision may halt further processing.
        #[prost(message, optional, tag = "2")]
        pub after_agent_callback: ::core::option::Option<super::Callback>,
        /// Optional. The callback to execute before the model is called. If there
        /// are multiple calls to the model, the callback will be executed multiple
        /// times. Each callback function is expected to return a structure (e.g., a
        /// dict or object) containing at least:
        ///
        /// * 'decision': Either 'OK' or 'TRIGGER'.
        /// * 'reason': A string explaining the decision.
        ///   A 'TRIGGER' decision may halt further processing.
        #[prost(message, optional, tag = "3")]
        pub before_model_callback: ::core::option::Option<super::Callback>,
        /// Optional. The callback to execute after the model is called. If there are
        /// multiple calls to the model, the callback will be executed multiple
        /// times. Each callback function is expected to return a structure (e.g., a
        /// dict or object) containing at least:
        ///
        /// * 'decision': Either 'OK' or 'TRIGGER'.
        /// * 'reason': A string explaining the decision.
        ///   A 'TRIGGER' decision may halt further processing.
        #[prost(message, optional, tag = "4")]
        pub after_model_callback: ::core::option::Option<super::Callback>,
    }
    /// Guardrail type.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum GuardrailType {
        /// Optional. Guardrail that bans certain content from being used in the
        /// conversation.
        #[prost(message, tag = "8")]
        ContentFilter(ContentFilter),
        /// Optional. Guardrail that blocks the conversation if the prompt is
        /// considered unsafe based on the LLM classification.
        #[prost(message, tag = "9")]
        LlmPromptSecurity(LlmPromptSecurity),
        /// Optional. Guardrail that blocks the conversation if the LLM response is
        /// considered violating the policy based on the LLM classification.
        #[prost(message, tag = "10")]
        LlmPolicy(LlmPolicy),
        /// Optional. Guardrail that blocks the conversation if the LLM response is
        /// considered unsafe based on the model safety settings.
        #[prost(message, tag = "13")]
        ModelSafety(ModelSafety),
        /// Optional. Guardrail that potentially blocks the conversation based on the
        /// result of the callback execution.
        #[prost(message, tag = "14")]
        CodeCallback(CodeCallback),
    }
}
/// Represents a tool that allows the agent to call another agent.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AgentTool {
    /// Required. The name of the agent tool.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. Description of the tool's purpose.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Optional. Deprecated: Use `agent` instead.
    /// The resource name of the root agent that is the entry point of the tool.
    /// Format: `projects/{project}/locations/{location}/agents/{agent}`
    #[deprecated]
    #[prost(string, tag = "3")]
    pub root_agent: ::prost::alloc::string::String,
    /// Optional. The resource name of the agent that is the entry point of the
    /// tool. Format: `projects/{project}/locations/{location}/agents/{agent}`
    #[prost(string, tag = "4")]
    pub agent: ::prost::alloc::string::String,
}
/// Represents a client-side function that the agent can invoke. When the
/// tool is chosen by the agent, control is handed off to the client.
/// The client is responsible for executing the function and returning the result
/// as a \[ToolResponse\]\[google.cloud.ces.v1beta.ToolResponse\] to continue the
/// interaction with the agent.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ClientFunction {
    /// Required. The function name.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The function description.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Optional. The schema of the function parameters.
    #[prost(message, optional, tag = "3")]
    pub parameters: ::core::option::Option<Schema>,
    /// Optional. The schema of the function response.
    #[prost(message, optional, tag = "4")]
    pub response: ::core::option::Option<Schema>,
}
/// Configurations for authentication with API key.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ApiKeyConfig {
    /// Required. The parameter name or the header name of the API key.
    /// E.g., If the API request is "<https://example.com/act?X-Api-Key=<API>
    /// KEY>", "X-Api-Key" would be the parameter name.
    #[prost(string, tag = "1")]
    pub key_name: ::prost::alloc::string::String,
    /// Required. The name of the SecretManager secret version resource storing the
    /// API key. Format: `projects/{project}/secrets/{secret}/versions/{version}`
    ///
    /// Note: You should grant `roles/secretmanager.secretAccessor` role to the CES
    /// service agent
    /// `service-<PROJECT-NUMBER>@gcp-sa-ces.iam.gserviceaccount.com`.
    #[prost(string, tag = "2")]
    pub api_key_secret_version: ::prost::alloc::string::String,
    /// Required. Key location in the request.
    #[prost(enumeration = "api_key_config::RequestLocation", tag = "3")]
    pub request_location: i32,
}
/// Nested message and enum types in `ApiKeyConfig`.
pub mod api_key_config {
    /// The location of the API key in the request.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum RequestLocation {
        /// Unspecified. This value should not be used.
        Unspecified = 0,
        /// Represents the key in http header.
        Header = 1,
        /// Represents the key in query string.
        QueryString = 2,
    }
    impl RequestLocation {
        /// 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 => "REQUEST_LOCATION_UNSPECIFIED",
                Self::Header => "HEADER",
                Self::QueryString => "QUERY_STRING",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "REQUEST_LOCATION_UNSPECIFIED" => Some(Self::Unspecified),
                "HEADER" => Some(Self::Header),
                "QUERY_STRING" => Some(Self::QueryString),
                _ => None,
            }
        }
    }
}
/// Configurations for authentication with OAuth.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct OAuthConfig {
    /// Required. OAuth grant types.
    #[prost(enumeration = "o_auth_config::OauthGrantType", tag = "1")]
    pub oauth_grant_type: i32,
    /// Required. The client ID from the OAuth provider.
    #[prost(string, tag = "2")]
    pub client_id: ::prost::alloc::string::String,
    /// Required. The name of the SecretManager secret version resource storing the
    /// client secret.
    /// Format: `projects/{project}/secrets/{secret}/versions/{version}`
    ///
    /// Note: You should grant `roles/secretmanager.secretAccessor` role to the CES
    /// service agent
    /// `service-<PROJECT-NUMBER>@gcp-sa-ces.iam.gserviceaccount.com`.
    #[prost(string, tag = "3")]
    pub client_secret_version: ::prost::alloc::string::String,
    /// Required. The token endpoint in the OAuth provider to exchange for an
    /// access token.
    #[prost(string, tag = "4")]
    pub token_endpoint: ::prost::alloc::string::String,
    /// Optional. The OAuth scopes to grant.
    #[prost(string, repeated, tag = "5")]
    pub scopes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Nested message and enum types in `OAuthConfig`.
pub mod o_auth_config {
    /// OAuth grant types. Only [client credential
    /// grant](<https://oauth.net/2/grant-types/client-credentials>) is supported.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum OauthGrantType {
        /// Unspecified. Defaults to CLIENT_CREDENTIAL.
        Unspecified = 0,
        /// Represents the [client credential
        /// flow](<https://oauth.net/2/grant-types/client-credentials>).
        ClientCredential = 1,
    }
    impl OauthGrantType {
        /// 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 => "OAUTH_GRANT_TYPE_UNSPECIFIED",
                Self::ClientCredential => "CLIENT_CREDENTIAL",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "OAUTH_GRANT_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "CLIENT_CREDENTIAL" => Some(Self::ClientCredential),
                _ => None,
            }
        }
    }
}
/// Configurations for authentication with [ID
/// token](<https://cloud.google.com/docs/authentication/token-types#id>) generated
/// from service agent.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ServiceAgentIdTokenAuthConfig {}
/// Configurations for authentication using a custom service account.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ServiceAccountAuthConfig {
    /// Required. The email address of the service account used for authentication.
    /// CES uses this service account to exchange an access token and the access
    /// token is then sent in the `Authorization` header of the request.
    ///
    /// The service account must have the
    /// `roles/iam.serviceAccountTokenCreator` role granted to the
    /// CES service agent
    /// `service-<PROJECT-NUMBER>@gcp-sa-ces.iam.gserviceaccount.com`.
    #[prost(string, tag = "1")]
    pub service_account: ::prost::alloc::string::String,
    /// Optional. The OAuth scopes to grant. If not specified, the default scope
    /// `<https://www.googleapis.com/auth/cloud-platform`> is used.
    #[prost(string, repeated, tag = "2")]
    pub scopes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Configurations for authentication with a bearer token.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BearerTokenConfig {
    /// Required. The bearer token.
    /// Must be in the format `$context.variables.<name_of_variable>`.
    #[prost(string, tag = "1")]
    pub token: ::prost::alloc::string::String,
}
/// End-user authentication configuration used for Connection calls.
/// The field values must be the names of context variables in the format
/// `$context.variables.<name_of_variable>`.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct EndUserAuthConfig {
    /// The auth configuration.
    #[prost(oneof = "end_user_auth_config::AuthConfig", tags = "2, 3")]
    pub auth_config: ::core::option::Option<end_user_auth_config::AuthConfig>,
}
/// Nested message and enum types in `EndUserAuthConfig`.
pub mod end_user_auth_config {
    /// Oauth 2.0 Authorization Code authentication configuration.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Oauth2AuthCodeConfig {
        /// Required. Oauth token parameter name to pass through.
        /// Must be in the format `$context.variables.<name_of_variable>`.
        #[prost(string, tag = "1")]
        pub oauth_token: ::prost::alloc::string::String,
    }
    /// JWT Profile Oauth 2.0 Authorization Grant authentication configuration.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Oauth2JwtBearerConfig {
        /// Required. Issuer parameter name to pass through.
        /// Must be in the format `$context.variables.<name_of_variable>`.
        #[prost(string, tag = "1")]
        pub issuer: ::prost::alloc::string::String,
        /// Required. Subject parameter name to pass through.
        /// Must be in the format `$context.variables.<name_of_variable>`.
        #[prost(string, tag = "2")]
        pub subject: ::prost::alloc::string::String,
        /// Required. Client parameter name to pass through.
        /// Must be in the format `$context.variables.<name_of_variable>`.
        #[prost(string, tag = "3")]
        pub client_key: ::prost::alloc::string::String,
    }
    /// The auth configuration.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum AuthConfig {
        /// Oauth 2.0 Authorization Code authentication.
        #[prost(message, tag = "2")]
        Oauth2AuthCodeConfig(Oauth2AuthCodeConfig),
        /// JWT Profile Oauth 2.0 Authorization Grant authentication.
        #[prost(message, tag = "3")]
        Oauth2JwtBearerConfig(Oauth2JwtBearerConfig),
    }
}
/// Authentication information required for API calls.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ApiAuthentication {
    /// The auth configuration.
    #[prost(oneof = "api_authentication::AuthConfig", tags = "1, 2, 3, 4, 5")]
    pub auth_config: ::core::option::Option<api_authentication::AuthConfig>,
}
/// Nested message and enum types in `ApiAuthentication`.
pub mod api_authentication {
    /// The auth configuration.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum AuthConfig {
        /// Optional. Config for API key auth.
        #[prost(message, tag = "1")]
        ApiKeyConfig(super::ApiKeyConfig),
        /// Optional. Config for OAuth.
        #[prost(message, tag = "2")]
        OauthConfig(super::OAuthConfig),
        /// Optional. Config for ID token auth generated from CES service agent.
        #[prost(message, tag = "3")]
        ServiceAgentIdTokenAuthConfig(super::ServiceAgentIdTokenAuthConfig),
        /// Optional. Config for service account authentication.
        #[prost(message, tag = "4")]
        ServiceAccountAuthConfig(super::ServiceAccountAuthConfig),
        /// Optional. Config for bearer token auth.
        #[prost(message, tag = "5")]
        BearerTokenConfig(super::BearerTokenConfig),
    }
}
/// Configuration of an Action for the tool to use.
/// Note: This can be either an Action or an Operation. See
/// <https://cloud.google.com/integration-connectors/docs/entities-operation-action>
/// for details.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Action {
    /// Optional. Entity fields to use as inputs for the operation.
    /// If no fields are specified, all fields of the Entity will be used.
    #[prost(string, repeated, tag = "2")]
    pub input_fields: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. Entity fields to return from the operation.
    /// If no fields are specified, all fields of the Entity will be returned.
    #[prost(string, repeated, tag = "3")]
    pub output_fields: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Specification for an action to configure for the tool to use.
    #[prost(oneof = "action::ActionSpec", tags = "4, 5")]
    pub action_spec: ::core::option::Option<action::ActionSpec>,
}
/// Nested message and enum types in `Action`.
pub mod action {
    /// Entity CRUD operation specification.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct EntityOperation {
        /// Required. ID of the entity.
        #[prost(string, tag = "1")]
        pub entity_id: ::prost::alloc::string::String,
        /// Required. Operation to perform on the entity.
        #[prost(enumeration = "entity_operation::OperationType", tag = "2")]
        pub operation: i32,
    }
    /// Nested message and enum types in `EntityOperation`.
    pub mod entity_operation {
        /// The operation to perform on the entity.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum OperationType {
            /// Operation type unspecified. Invalid, ConnectorTool create/update
            /// will fail.
            Unspecified = 0,
            /// List operation.
            List = 1,
            /// Get operation.
            Get = 2,
            /// Create operation.
            Create = 3,
            /// Update operation.
            Update = 4,
            /// Delete operation.
            Delete = 5,
        }
        impl OperationType {
            /// 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 => "OPERATION_TYPE_UNSPECIFIED",
                    Self::List => "LIST",
                    Self::Get => "GET",
                    Self::Create => "CREATE",
                    Self::Update => "UPDATE",
                    Self::Delete => "DELETE",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "OPERATION_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                    "LIST" => Some(Self::List),
                    "GET" => Some(Self::Get),
                    "CREATE" => Some(Self::Create),
                    "UPDATE" => Some(Self::Update),
                    "DELETE" => Some(Self::Delete),
                    _ => None,
                }
            }
        }
    }
    /// Specification for an action to configure for the tool to use.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum ActionSpec {
        /// ID of a Connection action for the tool to use.
        #[prost(string, tag = "4")]
        ConnectionActionId(::prost::alloc::string::String),
        /// Entity operation configuration for the tool to use.
        #[prost(message, tag = "5")]
        EntityOperation(EntityOperation),
    }
}
/// A ConnectorTool allows connections to different integrations.
/// See: <https://cloud.google.com/integration-connectors/docs/overview.>
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ConnectorTool {
    /// Required. The full resource name of the referenced Integration Connectors
    /// Connection.
    /// Format:
    /// `projects/{project}/locations/{location}/connections/{connection}`
    #[prost(string, tag = "1")]
    pub connection: ::prost::alloc::string::String,
    /// Required. Action for the tool to use.
    #[prost(message, optional, tag = "2")]
    pub action: ::core::option::Option<Action>,
    /// Optional. Configures how authentication is handled in Integration
    /// Connectors. By default, an admin authentication is passed in the
    /// Integration Connectors API requests. You can override it with a different
    /// end-user authentication config.
    /// **Note**: The Connection must have authentication override enabled in
    /// order to specify an EUC configuration here - otherwise, the ConnectorTool
    /// creation will fail. See
    /// <https://cloud.google.com/application-integration/docs/configure-connectors-task#configure-authentication-override>
    /// for details.
    #[prost(message, optional, tag = "3")]
    pub auth_config: ::core::option::Option<EndUserAuthConfig>,
    /// Optional. The name of the tool that can be used by the Agent to decide
    /// whether to call this ConnectorTool.
    #[prost(string, tag = "4")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The description of the tool that can be used by the Agent to
    /// decide whether to call this ConnectorTool.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
}
/// A DataStore resource in Vertex AI Search.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DataStore {
    /// Required. Full resource name of the DataStore.
    /// Format:
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{dataStore}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. The type of the data store. This field is readonly and
    /// populated by the server.
    #[prost(enumeration = "data_store::DataStoreType", tag = "2")]
    pub r#type: i32,
    /// Output only. The document processing mode for the data store connection.
    /// Only set for PUBLIC_WEB and UNSTRUCTURED data stores.
    #[prost(enumeration = "data_store::DocumentProcessingMode", tag = "4")]
    pub document_processing_mode: i32,
    /// Output only. The display name of the data store.
    #[prost(string, tag = "5")]
    pub display_name: ::prost::alloc::string::String,
    /// Output only. Timestamp when the data store was created.
    #[prost(message, optional, tag = "6")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The connector config for the data store connection.
    #[prost(message, optional, tag = "7")]
    pub connector_config: ::core::option::Option<data_store::ConnectorConfig>,
}
/// Nested message and enum types in `DataStore`.
pub mod data_store {
    /// The connector config for the data store connection.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ConnectorConfig {
        /// Resource name of the collection the data store belongs to.
        #[prost(string, tag = "1")]
        pub collection: ::prost::alloc::string::String,
        /// Display name of the collection the data store belongs to.
        #[prost(string, tag = "2")]
        pub collection_display_name: ::prost::alloc::string::String,
        /// The name of the data source.
        /// Example: `salesforce`, `jira`, `confluence`, `bigquery`.
        #[prost(string, tag = "3")]
        pub data_source: ::prost::alloc::string::String,
    }
    /// The type of the data store.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum DataStoreType {
        /// Not specified. This value indicates that the data store type is not
        /// specified, so it will not be used during search.
        Unspecified = 0,
        /// A data store that contains public web content.
        PublicWeb = 1,
        /// A data store that contains unstructured private data.
        Unstructured = 2,
        /// A data store that contains structured data used as FAQ.
        Faq = 3,
        /// A data store that is a connector to a first-party or a third-party
        /// service.
        Connector = 4,
    }
    impl DataStoreType {
        /// 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 => "DATA_STORE_TYPE_UNSPECIFIED",
                Self::PublicWeb => "PUBLIC_WEB",
                Self::Unstructured => "UNSTRUCTURED",
                Self::Faq => "FAQ",
                Self::Connector => "CONNECTOR",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "DATA_STORE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "PUBLIC_WEB" => Some(Self::PublicWeb),
                "UNSTRUCTURED" => Some(Self::Unstructured),
                "FAQ" => Some(Self::Faq),
                "CONNECTOR" => Some(Self::Connector),
                _ => None,
            }
        }
    }
    /// The document processing mode of the data store.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum DocumentProcessingMode {
        /// Not specified.
        Unspecified = 0,
        /// Documents are processed as documents.
        Documents = 1,
        /// Documents are converted to chunks.
        Chunks = 2,
    }
    impl DocumentProcessingMode {
        /// 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 => "DOCUMENT_PROCESSING_MODE_UNSPECIFIED",
                Self::Documents => "DOCUMENTS",
                Self::Chunks => "CHUNKS",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "DOCUMENT_PROCESSING_MODE_UNSPECIFIED" => Some(Self::Unspecified),
                "DOCUMENTS" => Some(Self::Documents),
                "CHUNKS" => Some(Self::Chunks),
                _ => None,
            }
        }
    }
}
/// Tool to retrieve from Vertex AI Search datastore or engine for grounding.
/// Accepts either a datastore or an engine, but not both.
/// See Vertex AI Search:
/// <https://cloud.google.com/generative-ai-app-builder/docs/enterprise-search-introduction.>
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DataStoreTool {
    /// Required. The data store tool name.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The tool description.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Optional. Boost specification to boost certain documents.
    #[prost(message, repeated, tag = "8")]
    pub boost_specs: ::prost::alloc::vec::Vec<data_store_tool::BoostSpecs>,
    /// Optional. The modality configs for the data store.
    #[prost(message, repeated, tag = "9")]
    pub modality_configs: ::prost::alloc::vec::Vec<data_store_tool::ModalityConfig>,
    /// Optional. The filter parameter behavior.
    #[prost(enumeration = "data_store_tool::FilterParameterBehavior", tag = "10")]
    pub filter_parameter_behavior: i32,
    /// Defines the search source, either a single DataStore or an Engine.
    #[prost(oneof = "data_store_tool::SearchSource", tags = "3, 4")]
    pub search_source: ::core::option::Option<data_store_tool::SearchSource>,
}
/// Nested message and enum types in `DataStoreTool`.
pub mod data_store_tool {
    /// Rewriter configuration.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RewriterConfig {
        /// Required. Configurations for the LLM model.
        #[prost(message, optional, tag = "1")]
        pub model_settings: ::core::option::Option<super::ModelSettings>,
        /// Optional. The prompt definition. If not set, default prompt will be used.
        #[prost(string, tag = "2")]
        pub prompt: ::prost::alloc::string::String,
        /// Optional. Whether the rewriter is disabled.
        #[prost(bool, tag = "3")]
        pub disabled: bool,
    }
    /// Summarization configuration.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SummarizationConfig {
        /// Optional. Configurations for the LLM model.
        #[prost(message, optional, tag = "1")]
        pub model_settings: ::core::option::Option<super::ModelSettings>,
        /// Optional. The prompt definition. If not set, default prompt will be used.
        #[prost(string, tag = "2")]
        pub prompt: ::prost::alloc::string::String,
        /// Optional. Whether summarization is disabled.
        #[prost(bool, tag = "3")]
        pub disabled: bool,
    }
    /// Grounding configuration.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct GroundingConfig {
        /// Optional. The groundedness threshold of the answer based on the retrieved
        /// sources. The value has a configurable range of \[1, 5\]. The level is used
        /// to threshold the groundedness of the answer, meaning that all responses
        /// with a groundedness score below the threshold will fall back to returning
        /// relevant snippets only.
        ///
        /// For example, a level of 3 means that the groundedness score must be
        /// 3 or higher for the response to be returned.
        #[prost(float, tag = "1")]
        pub grounding_level: f32,
        /// Optional. Whether grounding is disabled.
        #[prost(bool, tag = "2")]
        pub disabled: bool,
    }
    /// Configuration for searching within a specific DataStore.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct DataStoreSource {
        /// Optional. Filter specification for the DataStore.
        /// See:
        /// <https://cloud.google.com/generative-ai-app-builder/docs/filter-search-metadata>
        #[prost(string, tag = "2")]
        pub filter: ::prost::alloc::string::String,
        /// Optional. The data store.
        #[prost(message, optional, tag = "4")]
        pub data_store: ::core::option::Option<super::DataStore>,
    }
    /// Configuration for searching within an Engine, potentially targeting
    /// specific DataStores.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct EngineSource {
        /// Required. Full resource name of the Engine.
        /// Format:
        /// `projects/{project}/locations/{location}/collections/{collection}/engines/{engine}`
        #[prost(string, tag = "1")]
        pub engine: ::prost::alloc::string::String,
        /// Optional. Use to target specific DataStores within the Engine.
        /// If empty, the search applies to all DataStores associated with the
        /// Engine.
        #[prost(message, repeated, tag = "2")]
        pub data_store_sources: ::prost::alloc::vec::Vec<DataStoreSource>,
        /// Optional. A filter applied to the search across the Engine. Not relevant
        /// and not used if 'data_store_sources' is provided. See:
        /// <https://cloud.google.com/generative-ai-app-builder/docs/filter-search-metadata>
        #[prost(string, tag = "3")]
        pub filter: ::prost::alloc::string::String,
    }
    /// Boost specifications to boost certain documents.
    /// For more information, please refer to
    /// <https://cloud.google.com/generative-ai-app-builder/docs/boosting.>
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct BoostSpecs {
        /// Required. The Data Store where the boosting configuration is applied.
        /// Full resource name of DataStore, such as
        /// projects/{project}/locations/{location}/collections/{collection}/dataStores/{dataStore}.
        #[prost(string, repeated, tag = "1")]
        pub data_stores: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        /// Required. A list of boosting specifications.
        #[prost(message, repeated, tag = "2")]
        pub spec: ::prost::alloc::vec::Vec<BoostSpec>,
    }
    /// Boost specification to boost certain documents.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct BoostSpec {
        /// Required. A list of boosting specifications.
        #[prost(message, repeated, tag = "1")]
        pub condition_boost_specs: ::prost::alloc::vec::Vec<
            boost_spec::ConditionBoostSpec,
        >,
    }
    /// Nested message and enum types in `BoostSpec`.
    pub mod boost_spec {
        /// Boost specification for a condition.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct ConditionBoostSpec {
            /// Required. An expression which specifies a boost condition. The syntax
            /// is the same as filter expression syntax. Currently, the only supported
            /// condition is a list of BCP-47 lang codes. Example: To boost suggestions
            /// in languages en or fr: (lang_code: ANY("en", "fr"))
            #[prost(string, tag = "1")]
            pub condition: ::prost::alloc::string::String,
            /// Optional. Strength of the boost, which should be in \[-1, 1\]. Negative
            /// boost means demotion. Default is 0.0.
            ///
            /// Setting to 1.0 gives the suggestions a big promotion. However, it does
            /// not necessarily mean that the top result will be a boosted suggestion.
            ///
            /// Setting to -1.0 gives the suggestions a big demotion. However, other
            /// suggestions that are relevant might still be shown.
            ///
            /// Setting to 0.0 means no boost applied. The boosting condition is
            /// ignored.
            #[prost(float, tag = "2")]
            pub boost: f32,
            /// Optional. Complex specification for custom ranking based on customer
            /// defined attribute value.
            #[prost(message, optional, tag = "4")]
            pub boost_control_spec: ::core::option::Option<
                condition_boost_spec::BoostControlSpec,
            >,
        }
        /// Nested message and enum types in `ConditionBoostSpec`.
        pub mod condition_boost_spec {
            /// Specification for custom ranking based on customer specified attribute
            /// value. It provides more controls for customized ranking than the simple
            /// (condition, boost) combination above.
            #[derive(Clone, PartialEq, ::prost::Message)]
            pub struct BoostControlSpec {
                /// Optional. The name of the field whose value will be used to determine
                /// the boost amount.
                #[prost(string, tag = "1")]
                pub field_name: ::prost::alloc::string::String,
                /// Optional. The attribute type to be used to determine the boost
                /// amount. The attribute value can be derived from the field value of
                /// the specified field_name. In the case of numerical it is
                /// straightforward i.e. attribute_value = numerical_field_value. In the
                /// case of freshness however, attribute_value = (time.now() -
                /// datetime_field_value).
                #[prost(enumeration = "boost_control_spec::AttributeType", tag = "2")]
                pub attribute_type: i32,
                /// Optional. The interpolation type to be applied to connect the control
                /// points listed below.
                #[prost(
                    enumeration = "boost_control_spec::InterpolationType",
                    tag = "3"
                )]
                pub interpolation_type: i32,
                /// Optional. The control points used to define the curve. The monotonic
                /// function (defined through the interpolation_type above) passes
                /// through the control points listed here.
                #[prost(message, repeated, tag = "4")]
                pub control_points: ::prost::alloc::vec::Vec<
                    boost_control_spec::ControlPoint,
                >,
            }
            /// Nested message and enum types in `BoostControlSpec`.
            pub mod boost_control_spec {
                /// The control points used to define the curve. The curve defined
                /// through these control points can only be monotonically increasing
                /// or decreasing(constant values are acceptable).
                #[derive(Clone, PartialEq, ::prost::Message)]
                pub struct ControlPoint {
                    /// Optional. Can be one of:
                    ///
                    /// 1. The numerical field value.
                    /// 1. The duration spec for freshness:
                    ///    The value must be formatted as an XSD `dayTimeDuration` value (a
                    ///    restricted subset of an ISO 8601 duration value). The pattern for
                    ///    this is: `[nD][T[nH][nM][nS]]`.
                    #[prost(string, tag = "1")]
                    pub attribute_value: ::prost::alloc::string::String,
                    /// Optional. The value between -1 to 1 by which to boost the score if
                    /// the attribute_value evaluates to the value specified above.
                    #[prost(float, tag = "2")]
                    pub boost_amount: f32,
                }
                /// The attribute(or function) for which the custom ranking is to be
                /// applied.
                #[derive(
                    Clone,
                    Copy,
                    Debug,
                    PartialEq,
                    Eq,
                    Hash,
                    PartialOrd,
                    Ord,
                    ::prost::Enumeration
                )]
                #[repr(i32)]
                pub enum AttributeType {
                    /// Unspecified AttributeType.
                    Unspecified = 0,
                    /// The value of the numerical field will be used to dynamically update
                    /// the boost amount. In this case, the attribute_value (the x value)
                    /// of the control point will be the actual value of the numerical
                    /// field for which the boost_amount is specified.
                    Numerical = 1,
                    /// For the freshness use case the attribute value will be the duration
                    /// between the current time and the date in the datetime field
                    /// specified. The value must be formatted as an XSD `dayTimeDuration`
                    /// value (a restricted subset of an ISO 8601 duration value). The
                    /// pattern for this is: `[nD][T[nH][nM][nS]]`.
                    /// E.g. `5D`, `3DT12H30M`, `T24H`.
                    Freshness = 2,
                }
                impl AttributeType {
                    /// 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 => "ATTRIBUTE_TYPE_UNSPECIFIED",
                            Self::Numerical => "NUMERICAL",
                            Self::Freshness => "FRESHNESS",
                        }
                    }
                    /// Creates an enum from field names used in the ProtoBuf definition.
                    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                        match value {
                            "ATTRIBUTE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                            "NUMERICAL" => Some(Self::Numerical),
                            "FRESHNESS" => Some(Self::Freshness),
                            _ => None,
                        }
                    }
                }
                /// The interpolation type to be applied. Default will be linear
                /// (Piecewise Linear).
                #[derive(
                    Clone,
                    Copy,
                    Debug,
                    PartialEq,
                    Eq,
                    Hash,
                    PartialOrd,
                    Ord,
                    ::prost::Enumeration
                )]
                #[repr(i32)]
                pub enum InterpolationType {
                    /// Interpolation type is unspecified. In this case, it defaults to
                    /// Linear.
                    Unspecified = 0,
                    /// Piecewise linear interpolation will be applied.
                    Linear = 1,
                }
                impl InterpolationType {
                    /// 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 => "INTERPOLATION_TYPE_UNSPECIFIED",
                            Self::Linear => "LINEAR",
                        }
                    }
                    /// Creates an enum from field names used in the ProtoBuf definition.
                    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                        match value {
                            "INTERPOLATION_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                            "LINEAR" => Some(Self::Linear),
                            _ => None,
                        }
                    }
                }
            }
        }
    }
    /// If specified, will apply the given configuration for the specified
    /// modality.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ModalityConfig {
        /// Required. The modality type.
        #[prost(enumeration = "modality_config::ModalityType", tag = "1")]
        pub modality_type: i32,
        /// Optional. The rewriter config.
        #[prost(message, optional, tag = "2")]
        pub rewriter_config: ::core::option::Option<RewriterConfig>,
        /// Optional. The summarization config.
        #[prost(message, optional, tag = "3")]
        pub summarization_config: ::core::option::Option<SummarizationConfig>,
        /// Optional. The grounding configuration.
        #[prost(message, optional, tag = "4")]
        pub grounding_config: ::core::option::Option<GroundingConfig>,
    }
    /// Nested message and enum types in `ModalityConfig`.
    pub mod modality_config {
        /// The modality type.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum ModalityType {
            /// Unspecified modality type.
            Unspecified = 0,
            /// Text modality.
            Text = 1,
            /// Audio modality.
            Audio = 2,
        }
        impl ModalityType {
            /// 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 => "MODALITY_TYPE_UNSPECIFIED",
                    Self::Text => "TEXT",
                    Self::Audio => "AUDIO",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "MODALITY_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                    "TEXT" => Some(Self::Text),
                    "AUDIO" => Some(Self::Audio),
                    _ => None,
                }
            }
        }
    }
    /// Filter parameter behavior.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum FilterParameterBehavior {
        /// Default filter behavior.
        /// Include filter parameter for connector datastores.
        /// For the rest of the datastore types, the filter input parameter is
        /// omitted.
        Unspecified = 0,
        /// Always include filter parameter for all datastore types.
        AlwaysInclude = 2,
        /// The filter parameter is never included in the list of tool parameters,
        /// regardless of the datastore type.
        NeverInclude = 3,
    }
    impl FilterParameterBehavior {
        /// 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 => "FILTER_PARAMETER_BEHAVIOR_UNSPECIFIED",
                Self::AlwaysInclude => "ALWAYS_INCLUDE",
                Self::NeverInclude => "NEVER_INCLUDE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "FILTER_PARAMETER_BEHAVIOR_UNSPECIFIED" => Some(Self::Unspecified),
                "ALWAYS_INCLUDE" => Some(Self::AlwaysInclude),
                "NEVER_INCLUDE" => Some(Self::NeverInclude),
                _ => None,
            }
        }
    }
    /// Defines the search source, either a single DataStore or an Engine.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum SearchSource {
        /// Optional. Search within a single specific DataStore.
        #[prost(message, tag = "3")]
        DataStoreSource(DataStoreSource),
        /// Optional. Search within an Engine (potentially across multiple
        /// DataStores).
        #[prost(message, tag = "4")]
        EngineSource(EngineSource),
    }
}
/// The file search tool allows the agent to search across the files uploaded by
/// the app/agent developer. It has presets to give relatively good quality
/// search over the uploaded files and summarization of the retrieved results.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FileSearchTool {
    /// Optional. The type of the corpus. Default is FULLY_MANAGED.
    #[prost(enumeration = "file_search_tool::CorpusType", tag = "3")]
    pub corpus_type: i32,
    /// Required. The tool name.
    #[prost(string, tag = "4")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The tool description.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
    /// Optional. The corpus where files are stored.
    /// Format:
    /// projects/{project}/locations/{location}/ragCorpora/{rag_corpus}
    #[prost(string, tag = "6")]
    pub file_corpus: ::prost::alloc::string::String,
}
/// Nested message and enum types in `FileSearchTool`.
pub mod file_search_tool {
    /// The type of the Vertex RAG corpus.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum CorpusType {
        /// Unspecified corpus type.
        Unspecified = 0,
        /// The corpus is created and owned by the user.
        UserOwned = 1,
        /// The corpus is created by the agent.
        FullyManaged = 2,
    }
    impl CorpusType {
        /// 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 => "CORPUS_TYPE_UNSPECIFIED",
                Self::UserOwned => "USER_OWNED",
                Self::FullyManaged => "FULLY_MANAGED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "CORPUS_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "USER_OWNED" => Some(Self::UserOwned),
                "FULLY_MANAGED" => Some(Self::FullyManaged),
                _ => None,
            }
        }
    }
}
/// Represents a tool to perform Google web searches for grounding.
/// See
/// <https://cloud.google.com/customer-engagement-ai/conversational-agents/ps/tool#google-search.>
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GoogleSearchTool {
    /// Required. The name of the tool.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. Description of the tool's purpose.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Optional. Content will be fetched directly from these URLs for context and
    /// grounding. Example: "<https://example.com/path.html".> A maximum of 20 URLs
    /// are allowed.
    #[prost(string, repeated, tag = "3")]
    pub context_urls: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. Specifies domains to restrict search results to.
    /// Example: "example.com", "another.site". A maximum of 20 domains can be
    /// specified.
    #[prost(string, repeated, tag = "6")]
    pub preferred_domains: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. List of domains to be excluded from the search results.
    /// Example: "example.com".
    /// A maximum of 2000 domains can be excluded.
    #[prost(string, repeated, tag = "4")]
    pub exclude_domains: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. Prompt instructions passed to planner on how the search results
    /// should be processed for text and voice.
    #[prost(message, optional, tag = "5")]
    pub prompt_config: ::core::option::Option<google_search_tool::PromptConfig>,
}
/// Nested message and enum types in `GoogleSearchTool`.
pub mod google_search_tool {
    /// Prompt settings used by the model when processing or summarizing the
    /// google search results.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct PromptConfig {
        /// Optional. Defines the prompt used for the system instructions when
        /// interacting with the agent in chat conversations. If not set, default
        /// prompt will be used.
        #[prost(string, tag = "1")]
        pub text_prompt: ::prost::alloc::string::String,
        /// Optional. Defines the prompt used for the system instructions when
        /// interacting with the agent in voice conversations. If not set, default
        /// prompt will be used.
        #[prost(string, tag = "2")]
        pub voice_prompt: ::prost::alloc::string::String,
    }
}
/// An MCP tool.
/// See <https://modelcontextprotocol.io/specification/2025-06-18/server/tools> for
/// more details.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct McpTool {
    /// Required. The name of the MCP tool.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The description of the MCP tool.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Optional. The schema of the input arguments of the MCP tool.
    #[prost(message, optional, tag = "3")]
    pub input_schema: ::core::option::Option<Schema>,
    /// Optional. The schema of the output arguments of the MCP tool.
    #[prost(message, optional, tag = "4")]
    pub output_schema: ::core::option::Option<Schema>,
    /// Required. The server address of the MCP server, e.g.,
    /// "<https://example.com/mcp/".> If the server is built with the MCP SDK, the
    /// url should be suffixed with
    /// "/mcp/". Only Streamable HTTP transport based servers are supported. This
    /// is the same as the server_address in the McpToolset. See
    /// <https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http>
    /// for more details.
    #[prost(string, tag = "5")]
    pub server_address: ::prost::alloc::string::String,
    /// Optional. Authentication information required to execute the tool against
    /// the MCP server. For bearer token authentication, the token applies only to
    /// tool execution, not to listing tools. This requires that tools can be
    /// listed without authentication.
    #[prost(message, optional, tag = "6")]
    pub api_authentication: ::core::option::Option<ApiAuthentication>,
    /// Optional. The TLS configuration. Includes the custom server certificates
    /// that the client should trust.
    #[prost(message, optional, tag = "7")]
    pub tls_config: ::core::option::Option<TlsConfig>,
    /// Optional. Service Directory configuration for VPC-SC, used to resolve
    /// service names within a perimeter.
    #[prost(message, optional, tag = "8")]
    pub service_directory_config: ::core::option::Option<ServiceDirectoryConfig>,
    /// Optional. The custom headers to send in the request to the MCP server. The
    /// values must be in the format `$context.variables.<name_of_variable>` and
    /// can be set in the session variables. See
    /// <https://docs.cloud.google.com/customer-engagement-ai/conversational-agents/ps/tool/open-api#openapi-injection>
    /// for more details.
    #[prost(map = "string, string", tag = "9")]
    pub custom_headers: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// A remote API tool defined by an OpenAPI schema.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OpenApiTool {
    /// Required. The OpenAPI schema in JSON or YAML format.
    #[prost(string, tag = "1")]
    pub open_api_schema: ::prost::alloc::string::String,
    /// Optional. The name of the tool. If not provided, the name of the tool will
    /// be derived from the OpenAPI schema, from `operation.operationId`.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The description of the tool. If not provided, the description of
    /// the tool will be derived from the OpenAPI schema, from
    /// `operation.description` or `operation.summary`.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Optional. Authentication information required by the API.
    #[prost(message, optional, tag = "4")]
    pub api_authentication: ::core::option::Option<ApiAuthentication>,
    /// Optional. The TLS configuration. Includes the custom server certificates
    /// that the client will trust.
    #[prost(message, optional, tag = "5")]
    pub tls_config: ::core::option::Option<TlsConfig>,
    /// Optional. Service Directory configuration.
    #[prost(message, optional, tag = "6")]
    pub service_directory_config: ::core::option::Option<ServiceDirectoryConfig>,
    /// Optional. If true, the agent will ignore unknown fields in the API
    /// response.
    #[prost(bool, tag = "7")]
    pub ignore_unknown_fields: bool,
    /// Optional. The server URL of the Open API schema.
    /// This field is only set in tools in the environment dependencies during the
    /// export process if the schema contains a server url. During the import
    /// process, if this url is present in the environment dependencies and the
    /// schema has the $env_var placeholder, it will replace the placeholder in the
    /// schema.
    #[prost(string, tag = "8")]
    pub url: ::prost::alloc::string::String,
}
/// A Python function tool.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PythonFunction {
    /// Optional. The name of the Python function to execute. Must match a Python
    /// function name defined in the python code. Case sensitive. If the name is
    /// not provided, the first function defined in the python code will be used.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The Python code to execute for the tool.
    #[prost(string, tag = "2")]
    pub python_code: ::prost::alloc::string::String,
    /// Output only. The description of the Python function, parsed from the python
    /// code's docstring.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
}
/// Pre-defined system tool.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SystemTool {
    /// Required. The name of the system tool.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. The description of the system tool.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
}
/// Represents a widget tool that the agent can invoke. When the tool is chosen
/// by the agent, agent will return the widget to the client. The client is
/// responsible for processing the widget and generating the next user query to
/// continue the interaction with the agent.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WidgetTool {
    /// Required. The display name of the widget tool.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The description of the widget tool.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Optional. The type of the widget tool. If not specified, the default type
    /// will be CUSTOMIZED.
    #[prost(enumeration = "widget_tool::WidgetType", tag = "3")]
    pub widget_type: i32,
    /// Optional. Configuration for rendering the widget.
    #[prost(message, optional, tag = "5")]
    pub ui_config: ::core::option::Option<::prost_types::Struct>,
    /// Optional. The mapping that defines how data from a source tool is mapped to
    /// the widget's input parameters.
    #[prost(message, optional, tag = "6")]
    pub data_mapping: ::core::option::Option<widget_tool::DataMapping>,
    /// The input of the widget tool.
    #[prost(oneof = "widget_tool::Input", tags = "4")]
    pub input: ::core::option::Option<widget_tool::Input>,
}
/// Nested message and enum types in `WidgetTool`.
pub mod widget_tool {
    /// Configuration for mapping data from a source tool to the widget's input
    /// parameters.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct DataMapping {
        /// Optional. The resource name of the tool that provides the data for the
        /// widget (e.g., a search tool or a custom function). Format:
        /// `projects/{project}/locations/{location}/agents/{agent}/tools/{tool}`
        #[prost(string, tag = "1")]
        pub source_tool_name: ::prost::alloc::string::String,
        /// Optional. A map of widget input parameter fields to the corresponding
        /// output fields of the source tool.
        #[prost(map = "string, string", tag = "2")]
        pub field_mappings: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            ::prost::alloc::string::String,
        >,
        /// Optional. Configuration for a Python function used to transform the
        /// source tool's output into the widget's input format.
        #[prost(message, optional, tag = "5")]
        pub python_function: ::core::option::Option<super::PythonFunction>,
        /// Optional. The mode of the data mapping.
        #[prost(enumeration = "data_mapping::Mode", tag = "4")]
        pub mode: i32,
        /// Deprecated: Use `python_function` instead.
        #[deprecated]
        #[prost(string, tag = "3")]
        pub python_script: ::prost::alloc::string::String,
    }
    /// Nested message and enum types in `DataMapping`.
    pub mod data_mapping {
        /// The strategy used to map data from the source tool to the widget.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum Mode {
            /// Unspecified mode.
            Unspecified = 0,
            /// Use the `field_mappings` map for data transformation.
            FieldMapping = 1,
            /// Use the `python_script` for data transformation.
            PythonScript = 2,
        }
        impl Mode {
            /// 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 => "MODE_UNSPECIFIED",
                    Self::FieldMapping => "FIELD_MAPPING",
                    Self::PythonScript => "PYTHON_SCRIPT",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "MODE_UNSPECIFIED" => Some(Self::Unspecified),
                    "FIELD_MAPPING" => Some(Self::FieldMapping),
                    "PYTHON_SCRIPT" => Some(Self::PythonScript),
                    _ => None,
                }
            }
        }
    }
    /// All available widget types.
    /// New values may be added to this enum in the future.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum WidgetType {
        /// Unspecified widget type.
        Unspecified = 0,
        /// Custom widget type.
        Custom = 1,
        /// Product carousel widget.
        ProductCarousel = 2,
        /// Product details widget.
        ProductDetails = 3,
        /// Quick actions widget.
        QuickActions = 4,
        /// Product comparison widget.
        ProductComparison = 5,
        /// Advanced product details widget.
        AdvancedProductDetails = 6,
        /// Short form widget.
        ShortForm = 7,
        /// Overall satisfaction widget.
        OverallSatisfaction = 8,
        /// Order summary widget.
        OrderSummary = 9,
        /// Appointment details widget.
        AppointmentDetails = 10,
        /// Appointment scheduler widget.
        AppointmentScheduler = 11,
        /// Contact form widget.
        ContactForm = 12,
    }
    impl WidgetType {
        /// 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 => "WIDGET_TYPE_UNSPECIFIED",
                Self::Custom => "CUSTOM",
                Self::ProductCarousel => "PRODUCT_CAROUSEL",
                Self::ProductDetails => "PRODUCT_DETAILS",
                Self::QuickActions => "QUICK_ACTIONS",
                Self::ProductComparison => "PRODUCT_COMPARISON",
                Self::AdvancedProductDetails => "ADVANCED_PRODUCT_DETAILS",
                Self::ShortForm => "SHORT_FORM",
                Self::OverallSatisfaction => "OVERALL_SATISFACTION",
                Self::OrderSummary => "ORDER_SUMMARY",
                Self::AppointmentDetails => "APPOINTMENT_DETAILS",
                Self::AppointmentScheduler => "APPOINTMENT_SCHEDULER",
                Self::ContactForm => "CONTACT_FORM",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "WIDGET_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "CUSTOM" => Some(Self::Custom),
                "PRODUCT_CAROUSEL" => Some(Self::ProductCarousel),
                "PRODUCT_DETAILS" => Some(Self::ProductDetails),
                "QUICK_ACTIONS" => Some(Self::QuickActions),
                "PRODUCT_COMPARISON" => Some(Self::ProductComparison),
                "ADVANCED_PRODUCT_DETAILS" => Some(Self::AdvancedProductDetails),
                "SHORT_FORM" => Some(Self::ShortForm),
                "OVERALL_SATISFACTION" => Some(Self::OverallSatisfaction),
                "ORDER_SUMMARY" => Some(Self::OrderSummary),
                "APPOINTMENT_DETAILS" => Some(Self::AppointmentDetails),
                "APPOINTMENT_SCHEDULER" => Some(Self::AppointmentScheduler),
                "CONTACT_FORM" => Some(Self::ContactForm),
                _ => None,
            }
        }
    }
    /// The input of the widget tool.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Input {
        /// Optional. The input parameters of the widget tool.
        #[prost(message, tag = "4")]
        Parameters(super::Schema),
    }
}
/// A tool represents an action that the CES agent can take to achieve certain
/// goals.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Tool {
    /// Identifier. The resource name of the tool. Format:
    ///
    /// * `projects/{project}/locations/{location}/apps/{app}/tools/{tool}`
    ///   for standalone tools.
    /// * `projects/{project}/locations/{location}/apps/{app}/toolsets/{toolset}/tools/{tool}`
    ///   for tools retrieved from a toolset.
    ///
    /// These tools are dynamic and output-only; they cannot be referenced directly
    /// where a tool is expected.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. The display name of the tool, derived based on the tool's
    /// type. For example, display name of a \[ClientFunction\]\[Tool.ClientFunction\]
    /// is derived from its `name` property.
    #[prost(string, tag = "13")]
    pub display_name: ::prost::alloc::string::String,
    /// Optional. The execution type of the tool.
    #[prost(enumeration = "ExecutionType", tag = "12")]
    pub execution_type: i32,
    /// Output only. Timestamp when the tool was created.
    #[prost(message, optional, tag = "6")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Timestamp when the tool was last updated.
    #[prost(message, optional, tag = "7")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Etag used to ensure the object hasn't changed during a read-modify-write
    /// operation. If the etag is empty, the update will overwrite any concurrent
    /// changes.
    #[prost(string, tag = "14")]
    pub etag: ::prost::alloc::string::String,
    /// Output only. If the tool is generated by the LLM assistant, this field
    /// contains a descriptive summary of the generation.
    #[prost(string, tag = "15")]
    pub generated_summary: ::prost::alloc::string::String,
    /// Optional. Configuration for tool behavior in fake mode.
    #[prost(message, optional, tag = "20")]
    pub tool_fake_config: ::core::option::Option<ToolFakeConfig>,
    /// The type of the tool.
    #[prost(oneof = "tool::ToolType", tags = "2, 3, 5, 8, 10, 11, 16, 17, 18, 23, 24")]
    pub tool_type: ::core::option::Option<tool::ToolType>,
}
/// Nested message and enum types in `Tool`.
pub mod tool {
    /// The type of the tool.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum ToolType {
        /// Optional. The client function.
        #[prost(message, tag = "2")]
        ClientFunction(super::ClientFunction),
        /// Optional. The open API tool.
        #[prost(message, tag = "3")]
        OpenApiTool(super::OpenApiTool),
        /// Optional. The google search tool.
        #[prost(message, tag = "5")]
        GoogleSearchTool(super::GoogleSearchTool),
        /// Optional. The Integration Connector tool.
        #[prost(message, tag = "8")]
        ConnectorTool(super::ConnectorTool),
        /// Optional. The data store tool.
        #[prost(message, tag = "10")]
        DataStoreTool(super::DataStoreTool),
        /// Optional. The python function tool.
        #[prost(message, tag = "11")]
        PythonFunction(super::PythonFunction),
        /// Optional. The MCP tool. An MCP tool cannot be created or updated directly
        /// and is managed by the MCP toolset.
        #[prost(message, tag = "16")]
        McpTool(super::McpTool),
        /// Optional. The file search tool.
        #[prost(message, tag = "17")]
        FileSearchTool(super::FileSearchTool),
        /// Optional. The system tool.
        #[prost(message, tag = "18")]
        SystemTool(super::SystemTool),
        /// Optional. The agent tool.
        #[prost(message, tag = "23")]
        AgentTool(super::AgentTool),
        /// Optional. The widget tool.
        #[prost(message, tag = "24")]
        WidgetTool(super::WidgetTool),
    }
}
/// A toolset that generates tools from an Integration Connectors Connection.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConnectorToolset {
    /// Required. The full resource name of the referenced Integration Connectors
    /// Connection.
    /// Format:
    /// `projects/{project}/locations/{location}/connections/{connection}`
    #[prost(string, tag = "1")]
    pub connection: ::prost::alloc::string::String,
    /// Optional. Configures how authentication is handled in Integration
    /// Connectors. By default, an admin authentication is passed in the
    /// Integration Connectors API requests. You can override it with a different
    /// end-user authentication config.
    /// **Note**: The Connection must have authentication override enabled in
    /// order to specify an EUC configuration here - otherwise, the Toolset
    /// creation will fail. See:
    /// <https://cloud.google.com/application-integration/docs/configure-connectors-task#configure-authentication-override>
    #[prost(message, optional, tag = "2")]
    pub auth_config: ::core::option::Option<EndUserAuthConfig>,
    /// Required. The list of connector actions/entity operations to generate tools
    /// for.
    #[prost(message, repeated, tag = "3")]
    pub connector_actions: ::prost::alloc::vec::Vec<Action>,
}
/// A toolset that contains a list of tools that are offered by the MCP
/// server.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct McpToolset {
    /// Required. The address of the MCP server, for example,
    /// "<https://example.com/mcp/".> If the server is built with the MCP SDK, the
    /// url should be suffixed with
    /// "/mcp/". Only Streamable HTTP transport based servers are supported. See
    /// <https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http>
    /// for more details.
    #[prost(string, tag = "1")]
    pub server_address: ::prost::alloc::string::String,
    /// Optional. Authentication information required to access tools and execute a
    /// tool against the MCP server. For bearer token authentication, the token
    /// applies only to tool execution, not to listing tools. This requires that
    /// tools can be listed without authentication.
    #[prost(message, optional, tag = "2")]
    pub api_authentication: ::core::option::Option<ApiAuthentication>,
    /// Optional. Service Directory configuration for VPC-SC, used to resolve
    /// service names within a perimeter.
    #[prost(message, optional, tag = "3")]
    pub service_directory_config: ::core::option::Option<ServiceDirectoryConfig>,
    /// Optional. The TLS configuration. Includes the custom server certificates
    /// that the client should trust.
    #[prost(message, optional, tag = "4")]
    pub tls_config: ::core::option::Option<TlsConfig>,
    /// Optional. The custom headers to send in the request to the MCP server. The
    /// values must be in the format `$context.variables.<name_of_variable>` and
    /// can be set in the session variables. See
    /// <https://docs.cloud.google.com/customer-engagement-ai/conversational-agents/ps/tool/open-api#openapi-injection>
    /// for more details.
    #[prost(map = "string, string", tag = "5")]
    pub custom_headers: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// A toolset that contains a list of tools that are defined by an OpenAPI
/// schema.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OpenApiToolset {
    /// Required. The OpenAPI schema of the toolset.
    #[prost(string, tag = "1")]
    pub open_api_schema: ::prost::alloc::string::String,
    /// Optional. Authentication information required by the API.
    #[prost(message, optional, tag = "2")]
    pub api_authentication: ::core::option::Option<ApiAuthentication>,
    /// Optional. The TLS configuration. Includes the custom server certificates
    #[prost(message, optional, tag = "3")]
    pub tls_config: ::core::option::Option<TlsConfig>,
    /// Optional. Service Directory configuration.
    #[prost(message, optional, tag = "4")]
    pub service_directory_config: ::core::option::Option<ServiceDirectoryConfig>,
    /// Optional. If true, the agent will ignore unknown fields in the API response
    /// for all operations defined in the OpenAPI schema.
    #[prost(bool, tag = "5")]
    pub ignore_unknown_fields: bool,
    /// Optional. The server URL of the Open API schema.
    /// This field is only set in toolsets in the environment dependencies during
    /// the export process if the schema contains a server url. During the import
    /// process, if this url is present in the environment dependencies and the
    /// schema has the $env_var placeholder, it will replace the placeholder in the
    /// schema.
    #[prost(string, tag = "6")]
    pub url: ::prost::alloc::string::String,
}
/// A toolset represents a group of dynamically managed tools that can be used
/// by the agent.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Toolset {
    /// Identifier. The unique identifier of the toolset.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/toolsets/{toolset}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The display name of the toolset. Must be unique within the same
    /// app.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Optional. The description of the toolset.
    #[prost(string, tag = "10")]
    pub description: ::prost::alloc::string::String,
    /// Output only. Timestamp when the toolset was created.
    #[prost(message, optional, tag = "3")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Timestamp when the toolset was last updated.
    #[prost(message, optional, tag = "4")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// ETag used to ensure the object hasn't changed during a read-modify-write
    /// operation. If the etag is empty, the update will overwrite any concurrent
    /// changes.
    #[prost(string, tag = "5")]
    pub etag: ::prost::alloc::string::String,
    /// Optional. The execution type of the tools in the toolset.
    #[prost(enumeration = "ExecutionType", tag = "9")]
    pub execution_type: i32,
    /// Optional. Configuration for tools behavior in fake mode.
    #[prost(message, optional, tag = "11")]
    pub tool_fake_config: ::core::option::Option<ToolFakeConfig>,
    /// The type of the toolset.
    #[prost(oneof = "toolset::ToolsetType", tags = "6, 7, 8")]
    pub toolset_type: ::core::option::Option<toolset::ToolsetType>,
}
/// Nested message and enum types in `Toolset`.
pub mod toolset {
    /// The type of the toolset.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum ToolsetType {
        /// Optional. A toolset that contains a list of tools that are offered by the
        /// MCP server.
        #[prost(message, tag = "6")]
        McpToolset(super::McpToolset),
        /// Optional. A toolset that contains a list of tools that are defined by an
        /// OpenAPI schema.
        #[prost(message, tag = "7")]
        OpenApiToolset(super::OpenApiToolset),
        /// Optional. A toolset that generates tools from an Integration Connectors
        /// Connection.
        #[prost(message, tag = "8")]
        ConnectorToolset(super::ConnectorToolset),
    }
}
/// A snapshot of the app.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AppSnapshot {
    /// Optional. The basic settings for the app.
    #[prost(message, optional, tag = "1")]
    pub app: ::core::option::Option<App>,
    /// Optional. List of agents in the app.
    #[prost(message, repeated, tag = "2")]
    pub agents: ::prost::alloc::vec::Vec<Agent>,
    /// Optional. List of tools in the app.
    #[prost(message, repeated, tag = "3")]
    pub tools: ::prost::alloc::vec::Vec<Tool>,
    /// Optional. List of examples in the app.
    #[prost(message, repeated, tag = "4")]
    pub examples: ::prost::alloc::vec::Vec<Example>,
    /// Optional. List of guardrails in the app.
    #[prost(message, repeated, tag = "5")]
    pub guardrails: ::prost::alloc::vec::Vec<Guardrail>,
    /// Optional. List of toolsets in the app.
    #[prost(message, repeated, tag = "6")]
    pub toolsets: ::prost::alloc::vec::Vec<Toolset>,
}
/// In Customer Engagement Suite (CES), an app version is a snapshot of the app
/// at a specific point in time. It is immutable and cannot be modified once
/// created.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AppVersion {
    /// Identifier. The unique identifier of the app version.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/versions/{version}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The display name of the app version.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Optional. The description of the app version.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Output only. Email of the user who created the app version.
    #[prost(string, tag = "4")]
    pub creator: ::prost::alloc::string::String,
    /// Output only. Timestamp when the app version was created.
    #[prost(message, optional, tag = "5")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The snapshot of the app when the version is created.
    #[prost(message, optional, tag = "8")]
    pub snapshot: ::core::option::Option<AppSnapshot>,
    /// Output only. Etag used to ensure the object hasn't changed during a
    /// read-modify-write operation. If the etag is empty, the update will
    /// overwrite any concurrent changes.
    #[prost(string, tag = "7")]
    pub etag: ::prost::alloc::string::String,
}
/// Changelogs represent a change made to the app or to an resource within the
/// app.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Changelog {
    /// Identifier. The unique identifier of the changelog.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/changelogs/{changelog}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. Email address of the change author.
    #[prost(string, tag = "2")]
    pub author: ::prost::alloc::string::String,
    /// Output only. Display name of the change. It typically should be the display
    /// name of the resource that was changed.
    #[prost(string, tag = "3")]
    pub display_name: ::prost::alloc::string::String,
    /// Output only. Description of the change. which typically captures the
    /// changed fields in the resource.
    #[prost(string, tag = "11")]
    pub description: ::prost::alloc::string::String,
    /// Output only. The resource that was changed.
    #[prost(string, tag = "4")]
    pub resource: ::prost::alloc::string::String,
    /// Output only. The type of the resource that was changed.
    #[prost(string, tag = "5")]
    pub resource_type: ::prost::alloc::string::String,
    /// Output only. The action that was performed on the resource.
    #[prost(string, tag = "6")]
    pub action: ::prost::alloc::string::String,
    /// Output only. The original resource before the change.
    #[prost(message, optional, tag = "7")]
    pub original_resource: ::core::option::Option<::prost_types::Struct>,
    /// Output only. The new resource after the change.
    #[prost(message, optional, tag = "8")]
    pub new_resource: ::core::option::Option<::prost_types::Struct>,
    /// Output only. The dependent resources that were changed.
    #[prost(message, repeated, tag = "9")]
    pub dependent_resources: ::prost::alloc::vec::Vec<::prost_types::Struct>,
    /// Output only. The time when the change was made.
    #[prost(message, optional, tag = "10")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The monotonically increasing sequence number of the changelog.
    #[prost(int64, tag = "12")]
    pub sequence_number: i64,
}
/// A conversation represents an interaction between an end user and the CES app.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Conversation {
    /// Identifier. The unique identifier of the conversation.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/conversations/{conversation}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. Timestamp when the conversation was created.
    #[prost(message, optional, tag = "3")]
    pub start_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Timestamp when the conversation was completed.
    #[prost(message, optional, tag = "4")]
    pub end_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Required. The turns in the conversation.
    #[prost(message, repeated, tag = "6")]
    pub turns: ::prost::alloc::vec::Vec<conversation::Turn>,
    /// Output only. The number of turns in the conversation.
    #[prost(int32, tag = "7")]
    pub turn_count: i32,
    /// DEPRECATED. Please use
    /// \[input_types\]\[google.cloud.ces.v1beta.Conversation.input_types\] instead.
    #[deprecated]
    #[prost(enumeration = "conversation::ChannelType", tag = "8")]
    pub channel_type: i32,
    /// Output only. Indicate the source of the conversation.
    #[prost(enumeration = "conversation::Source", tag = "9")]
    pub source: i32,
    /// Output only. The input types of the conversation.
    #[prost(
        enumeration = "conversation::InputType",
        repeated,
        packed = "false",
        tag = "10"
    )]
    pub input_types: ::prost::alloc::vec::Vec<i32>,
    /// Output only. The agent that initially handles the conversation. If not
    /// specified, the conversation is handled by the root agent. Format:
    /// `projects/{project}/locations/{location}/apps/{app}/agents/{agent}`
    #[prost(string, tag = "11")]
    pub entry_agent: ::prost::alloc::string::String,
    /// Output only. The deployment of the app used for processing the
    /// conversation. Format:
    /// `projects/{project}/locations/{location}/apps/{app}/deployments/{deployment}`
    #[prost(string, tag = "12")]
    pub deployment: ::prost::alloc::string::String,
    /// Output only. The version of the app used for processing the conversation.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/versions/{version}`
    #[prost(string, tag = "13")]
    pub app_version: ::prost::alloc::string::String,
    /// Output only. The language code of the conversation.
    #[prost(string, tag = "14")]
    pub language_code: ::prost::alloc::string::String,
    /// Deprecated. Use turns instead.
    #[deprecated]
    #[prost(message, repeated, tag = "2")]
    pub messages: ::prost::alloc::vec::Vec<Message>,
}
/// Nested message and enum types in `Conversation`.
pub mod conversation {
    /// All information about a single turn in the conversation.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Turn {
        /// Optional. List of messages in the conversation turn, including user
        /// input, agent responses and intermediate events during the processing.
        #[prost(message, repeated, tag = "1")]
        pub messages: ::prost::alloc::vec::Vec<super::Message>,
        /// Optional. The root span of the action processing.
        #[prost(message, optional, tag = "2")]
        pub root_span: ::core::option::Option<super::Span>,
    }
    /// The channel type of the conversation.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ChannelType {
        /// Unspecified channel type.
        Unspecified = 0,
        /// The conversation only contains text messages between the end user and the
        /// agent.
        Text = 1,
        /// The conversation contains audio messages between the end user and the
        /// agent.
        Audio = 2,
        /// The conversation multi-modal messages (e.g. image) between the end user
        /// and the agent.
        Multimodal = 3,
    }
    impl ChannelType {
        /// 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 => "CHANNEL_TYPE_UNSPECIFIED",
                Self::Text => "TEXT",
                Self::Audio => "AUDIO",
                Self::Multimodal => "MULTIMODAL",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "CHANNEL_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "TEXT" => Some(Self::Text),
                "AUDIO" => Some(Self::Audio),
                "MULTIMODAL" => Some(Self::Multimodal),
                _ => None,
            }
        }
    }
    /// The source of the conversation.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Source {
        /// Unspecified source.
        Unspecified = 0,
        /// The conversation is from the live end user.
        Live = 1,
        /// The conversation is from the simulator.
        Simulator = 2,
        /// The conversation is from the evaluation.
        Eval = 3,
        /// The conversation is from an agent tool. Agent tool runs the agent in a
        /// separate session, which is persisted for testing and debugging purposes.
        AgentTool = 4,
    }
    impl Source {
        /// 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 => "SOURCE_UNSPECIFIED",
                Self::Live => "LIVE",
                Self::Simulator => "SIMULATOR",
                Self::Eval => "EVAL",
                Self::AgentTool => "AGENT_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 {
                "SOURCE_UNSPECIFIED" => Some(Self::Unspecified),
                "LIVE" => Some(Self::Live),
                "SIMULATOR" => Some(Self::Simulator),
                "EVAL" => Some(Self::Eval),
                "AGENT_TOOL" => Some(Self::AgentTool),
                _ => None,
            }
        }
    }
    /// Type of the input message.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum InputType {
        /// Unspecified input type.
        Unspecified = 0,
        /// The input message is text.
        Text = 1,
        /// The input message is audio.
        Audio = 2,
        /// The input message is image.
        Image = 3,
        /// The input message is blob file.
        Blob = 4,
        /// The input message is client function tool response.
        ToolResponse = 5,
        /// The input message are variables.
        Variables = 6,
    }
    impl InputType {
        /// 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 => "INPUT_TYPE_UNSPECIFIED",
                Self::Text => "INPUT_TYPE_TEXT",
                Self::Audio => "INPUT_TYPE_AUDIO",
                Self::Image => "INPUT_TYPE_IMAGE",
                Self::Blob => "INPUT_TYPE_BLOB",
                Self::ToolResponse => "INPUT_TYPE_TOOL_RESPONSE",
                Self::Variables => "INPUT_TYPE_VARIABLES",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "INPUT_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "INPUT_TYPE_TEXT" => Some(Self::Text),
                "INPUT_TYPE_AUDIO" => Some(Self::Audio),
                "INPUT_TYPE_IMAGE" => Some(Self::Image),
                "INPUT_TYPE_BLOB" => Some(Self::Blob),
                "INPUT_TYPE_TOOL_RESPONSE" => Some(Self::ToolResponse),
                "INPUT_TYPE_VARIABLES" => Some(Self::Variables),
                _ => None,
            }
        }
    }
}
/// A deployment represents an immutable, queryable version of the app.
/// It is used to deploy an app version with a specific channel profile.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Deployment {
    /// Identifier. The resource name of the deployment.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/deployments/{deployment}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. Display name of the deployment.
    #[prost(string, tag = "8")]
    pub display_name: ::prost::alloc::string::String,
    /// Optional. The resource name of the app version to deploy.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/versions/{version}`
    /// Use `projects/{project}/locations/{location}/apps/{app}/versions/-` to use
    /// the draft app.
    #[prost(string, tag = "2")]
    pub app_version: ::prost::alloc::string::String,
    /// Required. The channel profile used in the deployment.
    #[prost(message, optional, tag = "3")]
    pub channel_profile: ::core::option::Option<ChannelProfile>,
    /// Output only. Timestamp when this deployment was created.
    #[prost(message, optional, tag = "4")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Timestamp when this deployment was last updated.
    #[prost(message, optional, tag = "5")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Etag used to ensure the object hasn't changed during a
    /// read-modify-write operation. If the etag is empty, the update will
    /// overwrite any concurrent changes.
    #[prost(string, tag = "7")]
    pub etag: ::prost::alloc::string::String,
}
/// A mocked tool call.
///
/// Expresses the target tool + a pattern to match against that tool's
/// args / inputs. If the pattern matches, then the mock response will be
/// returned.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MockedToolCall {
    /// Optional. Deprecated. Use tool_identifier instead.
    #[deprecated]
    #[prost(string, tag = "1")]
    pub tool: ::prost::alloc::string::String,
    /// Required. A pattern to match against the args / inputs of all dispatched
    /// tool calls. If the tool call inputs match this pattern, then mock output
    /// will be returned.
    #[prost(message, optional, tag = "2")]
    pub expected_args_pattern: ::core::option::Option<::prost_types::Struct>,
    /// Optional. The mock response / output to return if the tool call args /
    /// inputs match the pattern.
    #[prost(message, optional, tag = "3")]
    pub mock_response: ::core::option::Option<::prost_types::Struct>,
    /// The identifier of the tool to mock.
    #[prost(oneof = "mocked_tool_call::ToolIdentifier", tags = "4, 5")]
    pub tool_identifier: ::core::option::Option<mocked_tool_call::ToolIdentifier>,
}
/// Nested message and enum types in `MockedToolCall`.
pub mod mocked_tool_call {
    /// The identifier of the tool to mock.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum ToolIdentifier {
        /// Optional. The name of the tool to mock.
        /// Format: `projects/{project}/locations/{location}/apps/{app}/tools/{tool}`
        #[prost(string, tag = "4")]
        ToolId(::prost::alloc::string::String),
        /// Optional. The toolset to mock.
        #[prost(message, tag = "5")]
        Toolset(super::ToolsetTool),
    }
}
/// Search suggestions from \[Google Search
/// Tool\]\[google.cloud.ces.v1beta.GoogleSearchTool\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GoogleSearchSuggestions {
    /// Compliant HTML and CSS styling for search suggestions.
    /// The provided HTML and CSS automatically adapts to your device settings,
    /// displaying in either light or dark mode indicated by
    /// `@media(prefers-color-scheme)`.
    #[prost(string, repeated, tag = "1")]
    pub htmls: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// List of queries used to perform the google search along with the search
    /// result URIs forming the search suggestions.
    #[prost(message, repeated, tag = "2")]
    pub web_search_queries: ::prost::alloc::vec::Vec<WebSearchQuery>,
}
/// Represents a single web search query and its associated search uri.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WebSearchQuery {
    /// The search query text.
    #[prost(string, tag = "1")]
    pub query: ::prost::alloc::string::String,
    /// The URI to the Google Search results page for the query.
    #[prost(string, tag = "2")]
    pub uri: ::prost::alloc::string::String,
}
/// Mock tool calls configuration for the session.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MockConfig {
    /// Optional. All tool calls to mock for the duration of the session.
    #[prost(message, repeated, tag = "1")]
    pub mocked_tool_calls: ::prost::alloc::vec::Vec<MockedToolCall>,
    /// Required. Beavhior for tool calls that don't match any args patterns in
    /// mocked_tool_calls.
    #[prost(enumeration = "mock_config::UnmatchedToolCallBehavior", tag = "2")]
    pub unmatched_tool_call_behavior: i32,
}
/// Nested message and enum types in `MockConfig`.
pub mod mock_config {
    /// What to do when a tool call doesn't match any mocked tool calls.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum UnmatchedToolCallBehavior {
        /// Default value. This value is unused.
        Unspecified = 0,
        /// Throw an error for any tool calls that don't match a mock expected input
        /// pattern.
        Fail = 1,
        /// For unmatched tool calls, pass the tool call through to real tool.
        PassThrough = 2,
    }
    impl UnmatchedToolCallBehavior {
        /// 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 => "UNMATCHED_TOOL_CALL_BEHAVIOR_UNSPECIFIED",
                Self::Fail => "FAIL",
                Self::PassThrough => "PASS_THROUGH",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "UNMATCHED_TOOL_CALL_BEHAVIOR_UNSPECIFIED" => Some(Self::Unspecified),
                "FAIL" => Some(Self::Fail),
                "PASS_THROUGH" => Some(Self::PassThrough),
                _ => None,
            }
        }
    }
}
/// InputAudioConfig configures how the CES agent should interpret the incoming
/// audio data.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct InputAudioConfig {
    /// Required. The encoding of the input audio data.
    #[prost(enumeration = "AudioEncoding", tag = "1")]
    pub audio_encoding: i32,
    /// Required. The sample rate (in Hertz) of the input audio data.
    #[prost(int32, tag = "2")]
    pub sample_rate_hertz: i32,
    /// Optional. Whether to enable noise suppression on the input audio.
    /// Available values are "low", "moderate", "high", "very_high".
    #[prost(string, tag = "6")]
    pub noise_suppression_level: ::prost::alloc::string::String,
}
/// OutputAudioConfig configures how the CES agent should synthesize outgoing
/// audio responses.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct OutputAudioConfig {
    /// Required. The encoding of the output audio data.
    #[prost(enumeration = "AudioEncoding", tag = "1")]
    pub audio_encoding: i32,
    /// Required. The sample rate (in Hertz) of the output audio data.
    #[prost(int32, tag = "2")]
    pub sample_rate_hertz: i32,
}
/// The configuration for the session.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SessionConfig {
    /// Required. The unique identifier of the session.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/sessions/{session}`
    #[prost(string, tag = "1")]
    pub session: ::prost::alloc::string::String,
    /// Optional. Configuration for processing the input audio.
    #[prost(message, optional, tag = "2")]
    pub input_audio_config: ::core::option::Option<InputAudioConfig>,
    /// Optional. Configuration for generating the output audio.
    #[prost(message, optional, tag = "3")]
    pub output_audio_config: ::core::option::Option<OutputAudioConfig>,
    /// Optional. The historical context of the session, including user inputs,
    /// agent responses, and other messages. Typically, CES agent would manage
    /// session automatically so client doesn't need to explicitly populate this
    /// field. However, client can optionally override the historical contexts to
    /// force the session start from certain state.
    #[prost(message, repeated, tag = "5")]
    pub historical_contexts: ::prost::alloc::vec::Vec<Message>,
    /// Optional. The entry agent to handle the session. If not specified, the
    /// session will be handled by the \[root
    /// agent\]\[google.cloud.ces.v1beta.App.root_agent\] of the app. Format:
    /// `projects/{project}/locations/{location}/apps/{app}/agents/{agent}`
    #[prost(string, tag = "12")]
    pub entry_agent: ::prost::alloc::string::String,
    /// Optional. The deployment of the app to use for the session.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/deployments/{deployment}`
    #[prost(string, tag = "8")]
    pub deployment: ::prost::alloc::string::String,
    /// Optional. The time zone of the user. If provided, the agent will use the
    /// time zone for date and time related variables. Otherwise, the agent will
    /// use the time zone specified in the App.time_zone_settings.
    ///
    /// The format is the IANA Time Zone Database time zone, e.g.
    /// "America/Los_Angeles".
    #[prost(string, tag = "11")]
    pub time_zone: ::prost::alloc::string::String,
    /// Optional. Whether to use tool fakes for the session.
    /// If this field is set, the agent will attempt use tool fakes instead of
    /// calling the real tools.
    #[prost(bool, tag = "14")]
    pub use_tool_fakes: bool,
    /// Optional.
    /// [QueryParameters](<https://cloud.google.com/dialogflow/cx/docs/reference/rpc/google.cloud.dialogflow.cx.v3#queryparameters>)
    /// to send to the remote
    /// [Dialogflow](<https://cloud.google.com/dialogflow/cx/docs/concept/console-conversational-agents>)
    /// agent when the session control is transferred to the remote agent.
    #[prost(message, optional, tag = "15")]
    pub remote_dialogflow_query_parameters: ::core::option::Option<
        session_config::RemoteDialogflowQueryParameters,
    >,
    /// Optional. Whether to enable streaming text outputs from the model.
    /// By default, text outputs from the model are collected before sending to the
    /// client.
    /// NOTE: This is only supported for text (non-voice) sessions via
    /// \[StreamRunSession\]\[google.cloud.ces.v1beta.SessionService.StreamRunSession\]
    /// or \[BidiRunSession\]\[google.cloud.ces.v1beta.SessionService.BidiRunSession\].
    #[prost(bool, tag = "18")]
    pub enable_text_streaming: bool,
}
/// Nested message and enum types in `SessionConfig`.
pub mod session_config {
    /// [QueryParameters](<https://cloud.google.com/dialogflow/cx/docs/reference/rpc/google.cloud.dialogflow.cx.v3#queryparameters>)
    /// to send to the remote
    /// [Dialogflow](<https://cloud.google.com/dialogflow/cx/docs/concept/console-conversational-agents>)
    /// agent when the session control is transferred to the remote agent.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RemoteDialogflowQueryParameters {
        /// Optional. The HTTP headers to be sent as webhook_headers in
        /// [QueryParameters](<https://cloud.google.com/dialogflow/cx/docs/reference/rpc/google.cloud.dialogflow.cx.v3#queryparameters>).
        #[prost(map = "string, string", tag = "1")]
        pub webhook_headers: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            ::prost::alloc::string::String,
        >,
        /// Optional. The payload to be sent in
        /// [QueryParameters](<https://cloud.google.com/dialogflow/cx/docs/reference/rpc/google.cloud.dialogflow.cx.v3#queryparameters>).
        #[prost(message, optional, tag = "2")]
        pub payload: ::core::option::Option<::prost_types::Struct>,
        /// Optional. The end user metadata to be sent in
        /// [QueryParameters](<https://cloud.google.com/dialogflow/cx/docs/reference/rpc/google.cloud.dialogflow.cx.v3#queryparameters>).
        #[prost(message, optional, tag = "3")]
        pub end_user_metadata: ::core::option::Option<::prost_types::Struct>,
    }
}
/// Request for the client to execute the tools and return the execution results
/// before continuing the session.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ToolCalls {
    /// Optional. The list of tool calls to execute.
    #[prost(message, repeated, tag = "1")]
    pub tool_calls: ::prost::alloc::vec::Vec<ToolCall>,
}
/// Execution results for the requested tool calls from the client.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ToolResponses {
    /// Optional. The list of tool execution results.
    #[prost(message, repeated, tag = "1")]
    pub tool_responses: ::prost::alloc::vec::Vec<ToolResponse>,
}
/// Citations associated with the agent response.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Citations {
    /// List of cited pieces of information.
    #[prost(message, repeated, tag = "1")]
    pub cited_chunks: ::prost::alloc::vec::Vec<citations::CitedChunk>,
}
/// Nested message and enum types in `Citations`.
pub mod citations {
    /// Piece of cited information.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct CitedChunk {
        /// URI used for citation.
        #[prost(string, tag = "1")]
        pub uri: ::prost::alloc::string::String,
        /// Title of the cited document.
        #[prost(string, tag = "2")]
        pub title: ::prost::alloc::string::String,
        /// Text used for citation.
        #[prost(string, tag = "3")]
        pub text: ::prost::alloc::string::String,
    }
}
/// Event input.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Event {
    /// Required. The name of the event.
    #[prost(string, tag = "1")]
    pub event: ::prost::alloc::string::String,
}
/// Input for the session.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SessionInput {
    /// Optional. A flag to indicate if the current message is a fragment of a
    /// larger input in the bidi streaming session.
    ///
    /// When set to `true`, the agent defers processing until it receives a
    /// subsequent message where `will_continue` is `false`, or until the system
    /// detects an endpoint in the audio input.
    ///
    /// NOTE: This field does not apply to audio and DTMF inputs, as they are
    /// always processed automatically based on the endpointing signal.
    #[prost(bool, tag = "8")]
    pub will_continue: bool,
    /// The type of the input.
    #[prost(oneof = "session_input::InputType", tags = "1, 6, 2, 3, 4, 7, 5, 9")]
    pub input_type: ::core::option::Option<session_input::InputType>,
}
/// Nested message and enum types in `SessionInput`.
pub mod session_input {
    /// The type of the input.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum InputType {
        /// Optional. Text data from the end user.
        #[prost(string, tag = "1")]
        Text(::prost::alloc::string::String),
        /// Optional. DTMF digits from the end user.
        #[prost(string, tag = "6")]
        Dtmf(::prost::alloc::string::String),
        /// Optional. Audio data from the end user.
        #[prost(bytes, tag = "2")]
        Audio(::prost::alloc::vec::Vec<u8>),
        /// Optional. Execution results for the tool calls from the client.
        #[prost(message, tag = "3")]
        ToolResponses(super::ToolResponses),
        /// Optional. Image data from the end user.
        #[prost(message, tag = "4")]
        Image(super::Image),
        /// Optional. Blob data from the end user.
        #[prost(message, tag = "7")]
        Blob(super::Blob),
        /// Optional. Contextual variables for the session, keyed by name. Only
        /// variables declared in the app will be used by the CES agent.
        ///
        /// Unrecognized variables will still be sent to the \[Dialogflow
        /// agent\]\[Agent.RemoteDialogflowAgent\] as additional session parameters.
        #[prost(message, tag = "5")]
        Variables(::prost_types::Struct),
        /// Optional. Event input.
        #[prost(message, tag = "9")]
        Event(super::Event),
    }
}
/// Output for the session.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SessionOutput {
    /// Indicates the sequential order of conversation turn to which this output
    /// belongs to, starting from 1.
    #[prost(int32, tag = "6")]
    pub turn_index: i32,
    /// If true, the CES agent has detected the end of the current conversation
    /// turn and will provide no further output for this turn.
    #[prost(bool, tag = "4")]
    pub turn_completed: bool,
    /// Optional. Diagnostic information contains execution details during the
    /// processing of the input. Only populated in the last SessionOutput (with
    /// `turn_completed=true`) for each turn.
    #[prost(message, optional, tag = "7")]
    pub diagnostic_info: ::core::option::Option<session_output::DiagnosticInfo>,
    /// The type of the output.
    #[prost(oneof = "session_output::OutputType", tags = "1, 2, 3, 8, 10, 9, 11")]
    pub output_type: ::core::option::Option<session_output::OutputType>,
}
/// Nested message and enum types in `SessionOutput`.
pub mod session_output {
    /// Contains execution details during the processing.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct DiagnosticInfo {
        /// List of the messages that happened during the processing.
        #[prost(message, repeated, tag = "1")]
        pub messages: ::prost::alloc::vec::Vec<super::Message>,
        /// A trace of the entire request processing, represented as a root span.
        /// This span can contain nested child spans for specific operations.
        #[prost(message, optional, tag = "3")]
        pub root_span: ::core::option::Option<super::Span>,
    }
    /// The type of the output.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum OutputType {
        /// Output text from the CES agent.
        #[prost(string, tag = "1")]
        Text(::prost::alloc::string::String),
        /// Output audio from the CES agent.
        #[prost(bytes, tag = "2")]
        Audio(::prost::alloc::vec::Vec<u8>),
        /// Request for the client to execute the tools.
        #[prost(message, tag = "3")]
        ToolCalls(super::ToolCalls),
        /// Citations that provide the source information for the agent's generated
        /// text.
        #[prost(message, tag = "8")]
        Citations(super::Citations),
        /// The suggestions returned from Google Search as a result of invoking the
        /// \[GoogleSearchTool\]\[google.cloud.ces.v1beta.GoogleSearchTool\].
        #[prost(message, tag = "10")]
        GoogleSearchSuggestions(super::GoogleSearchSuggestions),
        /// Indicates the session has ended.
        #[prost(message, tag = "9")]
        EndSession(super::EndSession),
        /// Custom payload with structured output from the CES agent.
        #[prost(message, tag = "11")]
        Payload(::prost_types::Struct),
    }
}
/// Speech recognition result for the audio input.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RecognitionResult {
    /// Optional. Concatenated user speech segments captured during the current
    /// turn.
    #[prost(string, tag = "1")]
    pub transcript: ::prost::alloc::string::String,
}
/// Indicates the agent's audio response has been interrupted. The client should
/// immediately stop any current audio playback (e.g., due to user barge-in or
/// a new agent response being generated).
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct InterruptionSignal {
    /// Whether the interruption is caused by a user barge-in event.
    #[prost(bool, tag = "1")]
    pub barge_in: bool,
}
/// Indicates the session has terminated, due to either successful completion
/// (e.g. user says "Good bye!" ) or an agent escalation.
///
/// The agent will not process any further inputs after session is terminated and
/// the client should half-close and disconnect after receiving all remaining
/// responses from the agent.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EndSession {
    /// Optional. Provides additional information about the end session signal,
    /// such as the reason for ending the session.
    #[prost(message, optional, tag = "1")]
    pub metadata: ::core::option::Option<::prost_types::Struct>,
}
/// Indicates that the server will disconnect soon and the client should
/// half-close and restart the connection.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GoAway {}
/// Request message for
/// \[SessionService.RunSession\]\[google.cloud.ces.v1beta.SessionService.RunSession\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RunSessionRequest {
    /// Required. The configuration for the session.
    #[prost(message, optional, tag = "1")]
    pub config: ::core::option::Option<SessionConfig>,
    /// Required. Inputs for the session.
    #[prost(message, repeated, tag = "3")]
    pub inputs: ::prost::alloc::vec::Vec<SessionInput>,
}
/// Response message for
/// \[SessionService.RunSession\]\[google.cloud.ces.v1beta.SessionService.RunSession\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RunSessionResponse {
    /// Outputs for the session.
    #[prost(message, repeated, tag = "1")]
    pub outputs: ::prost::alloc::vec::Vec<SessionOutput>,
}
/// The top-level message sent by the client for the
/// \[SessionService.BidiRunSession\]\[google.cloud.ces.v1beta.SessionService.BidiRunSession\]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BidiSessionClientMessage {
    /// The type of the message.
    #[prost(oneof = "bidi_session_client_message::MessageType", tags = "1, 2")]
    pub message_type: ::core::option::Option<bidi_session_client_message::MessageType>,
}
/// Nested message and enum types in `BidiSessionClientMessage`.
pub mod bidi_session_client_message {
    /// The type of the message.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum MessageType {
        /// Optional. The initial config message for the session.
        #[prost(message, tag = "1")]
        Config(super::SessionConfig),
        /// Optional. Realtime input for the session.
        #[prost(message, tag = "2")]
        RealtimeInput(super::SessionInput),
    }
}
/// The top-level message returned from
/// \[SessionService.BidiRunSession\]\[google.cloud.ces.v1beta.SessionService.BidiRunSession\]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BidiSessionServerMessage {
    /// The type of the message.
    #[prost(oneof = "bidi_session_server_message::MessageType", tags = "1, 2, 3, 5, 6")]
    pub message_type: ::core::option::Option<bidi_session_server_message::MessageType>,
}
/// Nested message and enum types in `BidiSessionServerMessage`.
pub mod bidi_session_server_message {
    /// The type of the message.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum MessageType {
        /// Optional. Processing result from the CES agent.
        #[prost(message, tag = "1")]
        SessionOutput(super::SessionOutput),
        /// Optional. Realtime speech recognition result for the audio input.
        #[prost(message, tag = "2")]
        RecognitionResult(super::RecognitionResult),
        /// Optional. Indicates the agent's audio response has been interrupted.
        #[prost(message, tag = "3")]
        InterruptionSignal(super::InterruptionSignal),
        /// Optional. Indicates that the session has ended.
        #[prost(message, tag = "5")]
        EndSession(super::EndSession),
        /// Optional. Indicates that the server will disconnect soon and the client
        /// should half-close and restart the connection.
        #[prost(message, tag = "6")]
        GoAway(super::GoAway),
    }
}
/// AudioEncoding specifies the encoding format for audio data.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum AudioEncoding {
    /// Unspecified audio encoding.
    Unspecified = 0,
    /// 16-bit linear PCM audio encoding.
    Linear16 = 1,
    /// 8-bit samples that compand 14-bit audio samples using G.711 PCMU/mu-law.
    Mulaw = 2,
    /// 8-bit samples that compand 14-bit audio samples using G.711 PCMU/A-law.
    Alaw = 3,
}
impl AudioEncoding {
    /// 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 => "AUDIO_ENCODING_UNSPECIFIED",
            Self::Linear16 => "LINEAR16",
            Self::Mulaw => "MULAW",
            Self::Alaw => "ALAW",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "AUDIO_ENCODING_UNSPECIFIED" => Some(Self::Unspecified),
            "LINEAR16" => Some(Self::Linear16),
            "MULAW" => Some(Self::Mulaw),
            "ALAW" => Some(Self::Alaw),
            _ => None,
        }
    }
}
/// Generated client implementations.
pub mod session_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Session service provides APIs for interacting with CES agents.
    #[derive(Debug, Clone)]
    pub struct SessionServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl SessionServiceClient<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> SessionServiceClient<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,
        ) -> SessionServiceClient<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,
        {
            SessionServiceClient::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
        }
        /// Initiates a single-turn interaction with the CES agent within a session.
        pub async fn run_session(
            &mut self,
            request: impl tonic::IntoRequest<super::RunSessionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::RunSessionResponse>,
            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(
                "/google.cloud.ces.v1beta.SessionService/RunSession",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.SessionService",
                        "RunSession",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Initiates a single-turn interaction with the CES agent. Uses server-side
        /// streaming to deliver incremental results and partial responses as they are
        /// generated.
        ///
        /// By default, complete responses (e.g., messages from callbacks or full LLM
        /// responses) are sent to the client as soon as they are available. To enable
        /// streaming individual text chunks directly from the model, set
        /// \[enable_text_streaming\]\[google.cloud.ces.v1beta.SessionConfig.enable_text_streaming\]
        /// to true.
        pub async fn stream_run_session(
            &mut self,
            request: impl tonic::IntoRequest<super::RunSessionRequest>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::RunSessionResponse>>,
            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(
                "/google.cloud.ces.v1beta.SessionService/StreamRunSession",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.SessionService",
                        "StreamRunSession",
                    ),
                );
            self.inner.server_streaming(req, path, codec).await
        }
        /// Establishes a bidirectional streaming connection with the CES agent.
        /// The agent processes continuous multimodal inputs (e.g., text, audio) and
        /// generates real-time multimodal output streams.
        ///
        /// --- Client Request Stream ---
        /// The client streams requests in the following order:
        ///
        /// 1. Initialization:
        ///   The first message must contain
        ///   \[SessionConfig\]\[google.cloud.ces.v1beta.BidiSessionClientMessage.config\].
        ///   For audio sessions, this should also include
        ///   \[InputAudioConfig\]\[google.cloud.ces.v1beta.SessionConfig.input_audio_config\]
        ///   and
        ///   \[OutputAudioConfig\]\[google.cloud.ces.v1beta.SessionConfig.output_audio_config\]
        ///   to define audio processing and synthesis parameters.
        ///
        /// 1. Interaction:
        ///   Subsequent messages stream
        ///   \[SessionInput\]\[google.cloud.ces.v1beta.BidiSessionClientMessage.realtime_input\]
        ///   containing real-time user input data.
        ///
        /// 1. Termination:
        ///   The client should half-close the stream when there is no more user
        ///   input. It should also half-close upon receiving
        ///   \[EndSession\]\[google.cloud.ces.v1beta.BidiSessionServerMessage.end_session\]
        ///   or \[GoAway\]\[google.cloud.ces.v1beta.BidiSessionServerMessage.go_away\]
        ///   from the agent.
        ///
        /// --- Server Response Stream ---
        /// For each interaction turn, the agent streams messages in the following
        /// sequence:
        ///
        /// 1. Speech Recognition (First N messages):
        ///   Contains
        ///   \[RecognitionResult\]\[google.cloud.ces.v1beta.BidiSessionServerMessage.recognition_result\]
        ///   representing the concatenated user speech segments captured so far.
        ///   This is only populated for audio sessions.
        ///
        /// 1. Response (Next M messages):
        ///   Contains
        ///   \[SessionOutput\]\[google.cloud.ces.v1beta.BidiSessionServerMessage.session_output\]
        ///   delivering the agent's response in various modalities (e.g., text,
        ///   audio).
        ///
        /// 1. Turn Completion (Final message of the turn):
        ///   Contains
        ///   \[SessionOutput\]\[google.cloud.ces.v1beta.BidiSessionServerMessage.session_output\]
        ///   with
        ///   \[turn_completed\]\[google.cloud.ces.v1beta.SessionOutput.turn_completed\]
        ///   set to true. This signals the end of the current turn and includes
        ///   \[DiagnosticInfo\]\[google.cloud.ces.v1beta.SessionOutput.diagnostic_info\]
        ///   with execution details.
        ///
        /// --- Audio Best Practices ---
        ///
        /// 1. Streaming:
        ///   Stream \[audio data\]\[google.cloud.ces.v1beta.SessionInput.audio\]
        ///   **CONTINUOUSLY**, even during silence. Recommended chunk size: 40-120ms
        ///   (balances latency vs. efficiency).
        ///
        /// 1. Playback & Interruption:
        ///   Play \[audio responses\]\[google.cloud.ces.v1beta.SessionOutput.audio\]
        ///   upon receipt. Stop playback immediately if an
        ///   \[InterruptionSignal\]\[google.cloud.ces.v1beta.BidiSessionServerMessage.interruption_signal\]
        ///   is received (e.g., user barge-in or new agent response).
        pub async fn bidi_run_session(
            &mut self,
            request: impl tonic::IntoStreamingRequest<
                Message = super::BidiSessionClientMessage,
            >,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::BidiSessionServerMessage>>,
            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(
                "/google.cloud.ces.v1beta.SessionService/BidiRunSession",
            );
            let mut req = request.into_streaming_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.SessionService",
                        "BidiRunSession",
                    ),
                );
            self.inner.streaming(req, path, codec).await
        }
    }
}
/// Aggregated metrics for an evaluation or evaluation dataset.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AggregatedMetrics {
    /// Output only. Aggregated metrics, grouped by app version ID.
    #[prost(message, repeated, tag = "3")]
    pub metrics_by_app_version: ::prost::alloc::vec::Vec<
        aggregated_metrics::MetricsByAppVersion,
    >,
}
/// Nested message and enum types in `AggregatedMetrics`.
pub mod aggregated_metrics {
    /// Metrics for a single tool.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ToolMetrics {
        /// Output only. The name of the tool.
        #[prost(string, tag = "1")]
        pub tool: ::prost::alloc::string::String,
        /// Output only. The number of times the tool passed.
        #[prost(int32, tag = "2")]
        pub pass_count: i32,
        /// Output only. The number of times the tool failed.
        #[prost(int32, tag = "3")]
        pub fail_count: i32,
    }
    /// Metrics for turn latency.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct TurnLatencyMetrics {
        /// Output only. The average latency of the turns.
        #[prost(message, optional, tag = "1")]
        pub average_latency: ::core::option::Option<::prost_types::Duration>,
    }
    /// Metrics for tool call latency.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ToolCallLatencyMetrics {
        /// Output only. The name of the tool.
        #[prost(string, tag = "1")]
        pub tool: ::prost::alloc::string::String,
        /// Output only. The average latency of the tool calls.
        #[prost(message, optional, tag = "2")]
        pub average_latency: ::core::option::Option<::prost_types::Duration>,
    }
    /// Metrics for semantic similarity results.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct SemanticSimilarityMetrics {
        /// Output only. The average semantic similarity score (0-4).
        #[prost(float, tag = "1")]
        pub score: f32,
    }
    /// Metrics for hallucination results.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct HallucinationMetrics {
        /// Output only. The average hallucination score (0 to 1).
        #[prost(float, tag = "1")]
        pub score: f32,
    }
    /// Metrics aggregated per app version.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MetricsByAppVersion {
        /// Output only. The app version ID.
        #[prost(string, tag = "1")]
        pub app_version_id: ::prost::alloc::string::String,
        /// Output only. Metrics for each tool within this app version.
        #[prost(message, repeated, tag = "2")]
        pub tool_metrics: ::prost::alloc::vec::Vec<ToolMetrics>,
        /// Output only. Metrics for semantic similarity within this app version.
        #[prost(message, repeated, tag = "3")]
        pub semantic_similarity_metrics: ::prost::alloc::vec::Vec<
            SemanticSimilarityMetrics,
        >,
        /// Output only. Metrics for hallucination within this app version.
        #[prost(message, repeated, tag = "5")]
        pub hallucination_metrics: ::prost::alloc::vec::Vec<HallucinationMetrics>,
        /// Output only. Metrics for tool call latency within this app version.
        #[prost(message, repeated, tag = "6")]
        pub tool_call_latency_metrics: ::prost::alloc::vec::Vec<ToolCallLatencyMetrics>,
        /// Output only. Metrics for turn latency within this app version.
        #[prost(message, repeated, tag = "7")]
        pub turn_latency_metrics: ::prost::alloc::vec::Vec<TurnLatencyMetrics>,
        /// Output only. The number of times the evaluation passed.
        #[prost(int32, tag = "8")]
        pub pass_count: i32,
        /// Output only. The number of times the evaluation failed.
        #[prost(int32, tag = "9")]
        pub fail_count: i32,
        /// Output only. Metrics aggregated per turn within this app version.
        #[prost(message, repeated, tag = "4")]
        pub metrics_by_turn: ::prost::alloc::vec::Vec<MetricsByTurn>,
    }
    /// Metrics aggregated per turn.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MetricsByTurn {
        /// Output only. The turn index (0-based).
        #[prost(int32, tag = "1")]
        pub turn_index: i32,
        /// Output only. Metrics for each tool within this turn.
        #[prost(message, repeated, tag = "2")]
        pub tool_metrics: ::prost::alloc::vec::Vec<ToolMetrics>,
        /// Output only. Metrics for semantic similarity within this turn.
        #[prost(message, repeated, tag = "3")]
        pub semantic_similarity_metrics: ::prost::alloc::vec::Vec<
            SemanticSimilarityMetrics,
        >,
        /// Output only. Metrics for hallucination within this turn.
        #[prost(message, repeated, tag = "4")]
        pub hallucination_metrics: ::prost::alloc::vec::Vec<HallucinationMetrics>,
        /// Output only. Metrics for tool call latency within this turn.
        #[prost(message, repeated, tag = "5")]
        pub tool_call_latency_metrics: ::prost::alloc::vec::Vec<ToolCallLatencyMetrics>,
        /// Output only. Metrics for turn latency within this turn.
        #[prost(message, repeated, tag = "6")]
        pub turn_latency_metrics: ::prost::alloc::vec::Vec<TurnLatencyMetrics>,
    }
}
/// An evaluation represents all of the information needed to simulate and
/// evaluate an agent.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Evaluation {
    /// Identifier. The unique identifier of this evaluation.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/evaluations/{evaluation}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. User-defined display name of the evaluation. Unique within an
    /// App.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Optional. User-defined description of the evaluation.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Optional. User defined tags to categorize the evaluation.
    #[prost(string, repeated, tag = "4")]
    pub tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Output only. List of evaluation datasets the evaluation belongs to.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/evaluationDatasets/{evaluationDataset}`
    #[prost(string, repeated, tag = "5")]
    pub evaluation_datasets: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Output only. Timestamp when the evaluation was created.
    #[prost(message, optional, tag = "8")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The user who created the evaluation.
    #[prost(string, tag = "13")]
    pub created_by: ::prost::alloc::string::String,
    /// Output only. Timestamp when the evaluation was last updated.
    #[prost(message, optional, tag = "9")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The user who last updated the evaluation.
    #[prost(string, tag = "14")]
    pub last_updated_by: ::prost::alloc::string::String,
    /// Output only. The EvaluationRuns that this Evaluation is associated with.
    #[prost(string, repeated, tag = "15")]
    pub evaluation_runs: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Output only. Etag used to ensure the object hasn't changed during a
    /// read-modify-write operation. If the etag is empty, the update will
    /// overwrite any concurrent changes.
    #[prost(string, tag = "10")]
    pub etag: ::prost::alloc::string::String,
    /// Output only. The aggregated metrics for this evaluation across all runs.
    #[prost(message, optional, tag = "16")]
    pub aggregated_metrics: ::core::option::Option<AggregatedMetrics>,
    /// Output only. The latest evaluation result for this evaluation.
    #[prost(message, optional, tag = "17")]
    pub last_completed_result: ::core::option::Option<EvaluationResult>,
    /// Output only. Whether the evaluation is invalid. This can happen if an
    /// evaluation is referencing a tool, toolset, or agent that has since been
    /// deleted.
    #[prost(bool, tag = "18")]
    pub invalid: bool,
    /// Output only. The last 10 evaluation results for this evaluation. This is
    /// only populated if include_last_ten_results is set to true in the
    /// ListEvaluationsRequest or GetEvaluationRequest.
    #[prost(message, repeated, tag = "19")]
    pub last_ten_results: ::prost::alloc::vec::Vec<EvaluationResult>,
    /// The inputs for the evaluation
    #[prost(oneof = "evaluation::Inputs", tags = "11, 12")]
    pub inputs: ::core::option::Option<evaluation::Inputs>,
}
/// Nested message and enum types in `Evaluation`.
pub mod evaluation {
    /// Represents a single, checkable requirement.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct GoldenExpectation {
        /// Optional. A note for this requirement, useful in reporting when specific
        /// checks fail. E.g., "Check_Payment_Tool_Called".
        #[prost(string, tag = "1")]
        pub note: ::prost::alloc::string::String,
        /// The actual check to perform.
        #[prost(oneof = "golden_expectation::Condition", tags = "2, 3, 4, 5, 6, 7")]
        pub condition: ::core::option::Option<golden_expectation::Condition>,
    }
    /// Nested message and enum types in `GoldenExpectation`.
    pub mod golden_expectation {
        /// The actual check to perform.
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Condition {
            /// Optional. Check that a specific tool was called with the parameters.
            #[prost(message, tag = "2")]
            ToolCall(super::super::ToolCall),
            /// Optional. Check that a specific tool had the expected response.
            #[prost(message, tag = "3")]
            ToolResponse(super::super::ToolResponse),
            /// Optional. Check that the agent responded with the correct response. The
            /// role "agent" is implied.
            #[prost(message, tag = "4")]
            AgentResponse(super::super::Message),
            /// Optional. Check that the agent transferred the conversation to a
            /// different agent.
            #[prost(message, tag = "5")]
            AgentTransfer(super::super::AgentTransfer),
            /// Optional. Check that the agent updated the session variables to the
            /// expected values. Used to also capture agent variable updates for golden
            /// evals.
            #[prost(message, tag = "6")]
            UpdatedVariables(::prost_types::Struct),
            /// Optional. The tool response to mock, with the parameters of interest
            /// specified. Any parameters not specified will be hallucinated by the
            /// LLM.
            #[prost(message, tag = "7")]
            MockToolResponse(super::super::ToolResponse),
        }
    }
    /// A step defines a singular action to happen during the evaluation.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Step {
        /// The step to perform.
        #[prost(oneof = "step::Step", tags = "1, 2, 3")]
        pub step: ::core::option::Option<step::Step>,
    }
    /// Nested message and enum types in `Step`.
    pub mod step {
        /// The step to perform.
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Step {
            /// Optional. User input for the conversation.
            #[prost(message, tag = "1")]
            UserInput(super::super::SessionInput),
            /// Optional. Transfer the conversation to a different agent.
            #[prost(message, tag = "2")]
            AgentTransfer(super::super::AgentTransfer),
            /// Optional. Executes an expectation on the current turn.
            #[prost(message, tag = "3")]
            Expectation(super::GoldenExpectation),
        }
    }
    /// A golden turn defines a single turn in a golden conversation.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct GoldenTurn {
        /// Required. The steps required to replay a golden conversation.
        #[prost(message, repeated, tag = "1")]
        pub steps: ::prost::alloc::vec::Vec<Step>,
        /// Optional. The root span of the golden turn for processing and maintaining
        /// audio information.
        #[prost(message, optional, tag = "2")]
        pub root_span: ::core::option::Option<super::Span>,
    }
    /// The steps required to replay a golden conversation.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Golden {
        /// Required. The golden turns required to replay a golden conversation.
        #[prost(message, repeated, tag = "2")]
        pub turns: ::prost::alloc::vec::Vec<GoldenTurn>,
        /// Optional. The evaluation expectations to evaluate the replayed
        /// conversation against. Format:
        /// `projects/{project}/locations/{location}/apps/{app}/evaluationExpectations/{evaluationExpectation}`
        #[prost(string, repeated, tag = "3")]
        pub evaluation_expectations: ::prost::alloc::vec::Vec<
            ::prost::alloc::string::String,
        >,
    }
    /// The expectation to evaluate the conversation produced by the simulation.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ScenarioExpectation {
        /// The expectation to evaluate the conversation produced by the simulation.
        #[prost(oneof = "scenario_expectation::Expectation", tags = "1, 2")]
        pub expectation: ::core::option::Option<scenario_expectation::Expectation>,
    }
    /// Nested message and enum types in `ScenarioExpectation`.
    pub mod scenario_expectation {
        /// The tool call and response pair to be evaluated.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct ToolExpectation {
            /// Required. The expected tool call, with the parameters of interest
            /// specified. Any parameters not specified will be hallucinated by the
            /// LLM.
            #[prost(message, optional, tag = "1")]
            pub expected_tool_call: ::core::option::Option<super::super::ToolCall>,
            /// Required. The tool response to mock, with the parameters of interest
            /// specified. Any parameters not specified will be hallucinated by the
            /// LLM.
            #[prost(message, optional, tag = "2")]
            pub mock_tool_response: ::core::option::Option<super::super::ToolResponse>,
        }
        /// The expectation to evaluate the conversation produced by the simulation.
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Expectation {
            /// Optional. The tool call and response pair to be evaluated.
            #[prost(message, tag = "1")]
            ToolExpectation(ToolExpectation),
            /// Optional. The agent response to be evaluated.
            #[prost(message, tag = "2")]
            AgentResponse(super::super::Message),
        }
    }
    /// The config for a scenario
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Scenario {
        /// Required. The task to be targeted by the scenario.
        #[prost(string, tag = "1")]
        pub task: ::prost::alloc::string::String,
        /// Optional. The user facts to be used by the scenario.
        #[prost(message, repeated, tag = "4")]
        pub user_facts: ::prost::alloc::vec::Vec<scenario::UserFact>,
        /// Optional. The maximum number of turns to simulate. If not specified, the
        /// simulation will continue until the task is complete.
        #[prost(int32, tag = "5")]
        pub max_turns: i32,
        /// Required. The rubrics to score the scenario against.
        #[prost(string, repeated, tag = "2")]
        pub rubrics: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        /// Required. The ScenarioExpectations to evaluate the conversation produced
        /// by the user simulation.
        #[prost(message, repeated, tag = "3")]
        pub scenario_expectations: ::prost::alloc::vec::Vec<ScenarioExpectation>,
        /// Optional. Variables / Session Parameters as context for the session,
        /// keyed by variable names. Members of this struct will override any default
        /// values set by the system.
        ///
        /// Note, these are different from user facts, which are facts known to the
        /// user. Variables are parameters known to the agent: i.e. MDN (phone
        /// number) passed by the telephony system.
        #[prost(message, optional, tag = "6")]
        pub variable_overrides: ::core::option::Option<::prost_types::Struct>,
        /// Optional. Deprecated. Use user_goal_behavior instead.
        #[deprecated]
        #[prost(enumeration = "scenario::TaskCompletionBehavior", tag = "7")]
        pub task_completion_behavior: i32,
        /// Optional. The expected behavior of the user goal.
        #[prost(enumeration = "scenario::UserGoalBehavior", tag = "8")]
        pub user_goal_behavior: i32,
        /// Optional. The evaluation expectations to evaluate the conversation
        /// produced by the simulation against. Format:
        /// `projects/{project}/locations/{location}/apps/{app}/evaluationExpectations/{evaluationExpectation}`
        #[prost(string, repeated, tag = "10")]
        pub evaluation_expectations: ::prost::alloc::vec::Vec<
            ::prost::alloc::string::String,
        >,
    }
    /// Nested message and enum types in `Scenario`.
    pub mod scenario {
        /// Facts about the user as a key value pair.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct UserFact {
            /// Required. The name of the user fact.
            #[prost(string, tag = "1")]
            pub name: ::prost::alloc::string::String,
            /// Required. The value of the user fact.
            #[prost(string, tag = "2")]
            pub value: ::prost::alloc::string::String,
        }
        /// The expected behavior of the user task. This is used to determine whether
        /// the scenario is successful.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum TaskCompletionBehavior {
            /// Behavior unspecified. Will default to TASK_SATISFIED.
            Unspecified = 0,
            /// The user task should be completed successfully.
            TaskSatisfied = 1,
            /// The user task should be rejected.
            TaskRejected = 2,
        }
        impl TaskCompletionBehavior {
            /// 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 => "TASK_COMPLETION_BEHAVIOR_UNSPECIFIED",
                    Self::TaskSatisfied => "TASK_SATISFIED",
                    Self::TaskRejected => "TASK_REJECTED",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "TASK_COMPLETION_BEHAVIOR_UNSPECIFIED" => Some(Self::Unspecified),
                    "TASK_SATISFIED" => Some(Self::TaskSatisfied),
                    "TASK_REJECTED" => Some(Self::TaskRejected),
                    _ => None,
                }
            }
        }
        /// The expected behavior of the user goal. This is used to determine whether
        /// the scenario is successful.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum UserGoalBehavior {
            /// Behavior unspecified. Will default to USER_GOAL_SATISFIED.
            Unspecified = 0,
            /// The user goal should be completed successfully.
            UserGoalSatisfied = 1,
            /// The user goal should be rejected.
            UserGoalRejected = 2,
            /// Ignore the user goal status.
            UserGoalIgnored = 3,
        }
        impl UserGoalBehavior {
            /// 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 => "USER_GOAL_BEHAVIOR_UNSPECIFIED",
                    Self::UserGoalSatisfied => "USER_GOAL_SATISFIED",
                    Self::UserGoalRejected => "USER_GOAL_REJECTED",
                    Self::UserGoalIgnored => "USER_GOAL_IGNORED",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "USER_GOAL_BEHAVIOR_UNSPECIFIED" => Some(Self::Unspecified),
                    "USER_GOAL_SATISFIED" => Some(Self::UserGoalSatisfied),
                    "USER_GOAL_REJECTED" => Some(Self::UserGoalRejected),
                    "USER_GOAL_IGNORED" => Some(Self::UserGoalIgnored),
                    _ => None,
                }
            }
        }
    }
    /// The inputs for the evaluation
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Inputs {
        /// Optional. The golden steps to be evaluated.
        #[prost(message, tag = "11")]
        Golden(Golden),
        /// Optional. The config for a scenario.
        #[prost(message, tag = "12")]
        Scenario(Scenario),
    }
}
/// An evaluation dataset represents a set of evaluations that are grouped
/// together basaed on shared tags.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EvaluationDataset {
    /// Identifier. The unique identifier of this evaluation dataset.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/evaluationDatasets/{evaluationDataset}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. User-defined display name of the evaluation dataset. Unique
    /// within an App.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Optional. Evaluations that are included in this dataset.
    #[prost(string, repeated, tag = "3")]
    pub evaluations: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Output only. Timestamp when the evaluation dataset was created.
    #[prost(message, optional, tag = "4")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Timestamp when the evaluation dataset was last updated.
    #[prost(message, optional, tag = "5")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Etag used to ensure the object hasn't changed during a
    /// read-modify-write operation. If the etag is empty, the update will
    /// overwrite any concurrent changes.
    #[prost(string, tag = "6")]
    pub etag: ::prost::alloc::string::String,
    /// Output only. The user who created the evaluation dataset.
    #[prost(string, tag = "7")]
    pub created_by: ::prost::alloc::string::String,
    /// Output only. The user who last updated the evaluation dataset.
    #[prost(string, tag = "8")]
    pub last_updated_by: ::prost::alloc::string::String,
    /// Output only. The aggregated metrics for this evaluation dataset across all
    /// runs.
    #[prost(message, optional, tag = "9")]
    pub aggregated_metrics: ::core::option::Option<AggregatedMetrics>,
}
/// An evaluation result represents the output of running an Evaluation.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EvaluationResult {
    /// Identifier. The unique identifier of the evaluation result.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/evaluations/{evaluation}/results/{result}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. Display name of the Evaluation Result. Unique within an
    /// Evaluation. By default, it has the following format:
    /// "<evaluation-display-name> result
    ///
    /// * <timestamp>".
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Output only. Timestamp when the evaluation result was created.
    #[prost(message, optional, tag = "5")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The outcome of the evaluation. Only populated if
    /// execution_state is COMPLETE.
    #[prost(enumeration = "evaluation_result::Outcome", tag = "4")]
    pub evaluation_status: i32,
    /// Output only. The evaluation run that produced this result.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/evaluationRuns/{evaluationRun}`
    #[prost(string, tag = "6")]
    pub evaluation_run: ::prost::alloc::string::String,
    /// Output only. The persona used to generate the conversation for the
    /// evaluation result.
    #[prost(message, optional, tag = "17")]
    pub persona: ::core::option::Option<EvaluationPersona>,
    /// Output only. Error information for the evaluation result.
    #[prost(message, optional, tag = "15")]
    pub error_info: ::core::option::Option<EvaluationErrorInfo>,
    /// Output only. Deprecated: Use `error_info` instead. Errors encountered
    /// during execution.
    #[deprecated]
    #[prost(message, optional, tag = "14")]
    pub error: ::core::option::Option<super::super::super::rpc::Status>,
    /// Output only. The user who initiated the evaluation run that resulted in
    /// this result.
    #[prost(string, tag = "9")]
    pub initiated_by: ::prost::alloc::string::String,
    /// Output only. The app version used to generate the conversation that
    /// resulted in this result. Format:
    /// `projects/{project}/locations/{location}/apps/{app}/versions/{version}`
    #[prost(string, tag = "10")]
    pub app_version: ::prost::alloc::string::String,
    /// Output only. The display name of the `app_version` that the evaluation ran
    /// against.
    #[prost(string, tag = "13")]
    pub app_version_display_name: ::prost::alloc::string::String,
    /// Output only. The changelog of the app version that the evaluation ran
    /// against. This is populated if user runs evaluation on latest/draft.
    #[prost(string, tag = "21")]
    pub changelog: ::prost::alloc::string::String,
    /// Output only. The create time of the changelog of the app version that the
    /// evaluation ran against. This is populated if user runs evaluation on
    /// latest/draft.
    #[prost(message, optional, tag = "22")]
    pub changelog_create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The state of the evaluation result execution.
    #[prost(enumeration = "evaluation_result::ExecutionState", tag = "11")]
    pub execution_state: i32,
    /// Output only. The evaluation thresholds for the result.
    #[prost(message, optional, tag = "12")]
    pub evaluation_metrics_thresholds: ::core::option::Option<
        EvaluationMetricsThresholds,
    >,
    /// Output only. The configuration used in the evaluation run that resulted in
    /// this result.
    #[prost(message, optional, tag = "18")]
    pub config: ::core::option::Option<EvaluationConfig>,
    /// Output only. The method used to run the golden evaluation.
    #[prost(enumeration = "GoldenRunMethod", tag = "19")]
    pub golden_run_method: i32,
    /// The result of the evaluation. Only populated when the execution_state is
    /// COMPLETED.
    #[prost(oneof = "evaluation_result::Result", tags = "7, 8")]
    pub result: ::core::option::Option<evaluation_result::Result>,
}
/// Nested message and enum types in `EvaluationResult`.
pub mod evaluation_result {
    /// Specifies the expectation and the result of that expectation.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct GoldenExpectationOutcome {
        /// Output only. The expectation that was evaluated.
        #[prost(message, optional, tag = "1")]
        pub expectation: ::core::option::Option<super::evaluation::GoldenExpectation>,
        /// Output only. The outcome of the expectation.
        #[prost(enumeration = "Outcome", tag = "6")]
        pub outcome: i32,
        /// Output only. The result of the semantic similarity check.
        #[deprecated]
        #[prost(message, optional, tag = "7")]
        pub semantic_similarity_result: ::core::option::Option<SemanticSimilarityResult>,
        /// Output only. The result of the tool invocation check.
        #[prost(message, optional, tag = "8")]
        pub tool_invocation_result: ::core::option::Option<
            golden_expectation_outcome::ToolInvocationResult,
        >,
        /// The result of the expectation.
        #[prost(oneof = "golden_expectation_outcome::Result", tags = "2, 3, 4, 5")]
        pub result: ::core::option::Option<golden_expectation_outcome::Result>,
    }
    /// Nested message and enum types in `GoldenExpectationOutcome`.
    pub mod golden_expectation_outcome {
        /// The result of the tool invocation check.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct ToolInvocationResult {
            /// Output only. The tool invocation parameter correctness score. This
            /// indicates the percent of parameters from the expected tool call that
            /// were also present in the actual tool call.
            #[prost(float, optional, tag = "1")]
            pub parameter_correctness_score: ::core::option::Option<f32>,
            /// Output only. The outcome of the tool invocation check. This is
            /// determined by comparing the parameter_correctness_score to the
            /// threshold. If the score is equal to or above the threshold, the outcome
            /// will be PASS. Otherwise, the outcome will be FAIL.
            #[prost(enumeration = "super::Outcome", tag = "2")]
            pub outcome: i32,
            /// Output only. A free text explanation for the tool invocation result.
            #[prost(string, tag = "3")]
            pub explanation: ::prost::alloc::string::String,
        }
        /// The result of the expectation.
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Result {
            /// Output only. The result of the tool call expectation.
            #[prost(message, tag = "2")]
            ObservedToolCall(super::super::ToolCall),
            /// Output only. The result of the tool response expectation.
            #[prost(message, tag = "3")]
            ObservedToolResponse(super::super::ToolResponse),
            /// Output only. The result of the agent response expectation.
            #[prost(message, tag = "4")]
            ObservedAgentResponse(super::super::Message),
            /// Output only. The result of the agent transfer expectation.
            #[prost(message, tag = "5")]
            ObservedAgentTransfer(super::super::AgentTransfer),
        }
    }
    /// The result of a single evaluation expectation.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct EvaluationExpectationResult {
        /// Output only. The evaluation expectation.
        /// Format:
        /// `projects/{project}/locations/{location}/apps/{app}/evaluationExpectations/{evaluation_expectation}`
        #[prost(string, tag = "1")]
        pub evaluation_expectation: ::prost::alloc::string::String,
        /// Output only. The prompt that was used for the evaluation.
        #[prost(string, tag = "2")]
        pub prompt: ::prost::alloc::string::String,
        /// Output only. The outcome of the evaluation expectation.
        #[prost(enumeration = "Outcome", tag = "3")]
        pub outcome: i32,
        /// Output only. The explanation for the result.
        #[prost(string, tag = "4")]
        pub explanation: ::prost::alloc::string::String,
    }
    /// The result of a golden evaluation.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct GoldenResult {
        /// Output only. The result of running each turn of the golden conversation.
        #[prost(message, repeated, tag = "1")]
        pub turn_replay_results: ::prost::alloc::vec::Vec<
            golden_result::TurnReplayResult,
        >,
        /// Output only. The results of the evaluation expectations.
        #[prost(message, repeated, tag = "2")]
        pub evaluation_expectation_results: ::prost::alloc::vec::Vec<
            EvaluationExpectationResult,
        >,
    }
    /// Nested message and enum types in `GoldenResult`.
    pub mod golden_result {
        /// The result of running a single turn of the golden conversation.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct TurnReplayResult {
            /// Output only. The conversation that was generated for this turn.
            #[prost(string, tag = "1")]
            pub conversation: ::prost::alloc::string::String,
            /// Output only. The outcome of each expectation.
            #[prost(message, repeated, tag = "2")]
            pub expectation_outcome: ::prost::alloc::vec::Vec<
                super::GoldenExpectationOutcome,
            >,
            /// Output only. The result of the hallucination check.
            #[prost(message, optional, tag = "3")]
            pub hallucination_result: ::core::option::Option<super::HallucinationResult>,
            /// Output only. Deprecated. Use OverallToolInvocationResult instead.
            #[deprecated]
            #[prost(float, tag = "4")]
            pub tool_invocation_score: f32,
            /// Output only. The overall tool ordered invocation score for this turn.
            /// This indicates the overall percent of tools from the expected turn that
            /// were actually invoked in the expected order.
            #[prost(float, optional, tag = "5")]
            pub tool_ordered_invocation_score: ::core::option::Option<f32>,
            /// Output only. Duration of the turn.
            #[prost(message, optional, tag = "6")]
            pub turn_latency: ::core::option::Option<::prost_types::Duration>,
            /// Output only. The latency of each tool call in the turn.
            #[prost(message, repeated, tag = "7")]
            pub tool_call_latencies: ::prost::alloc::vec::Vec<super::ToolCallLatency>,
            /// Output only. The result of the semantic similarity check.
            #[prost(message, optional, tag = "8")]
            pub semantic_similarity_result: ::core::option::Option<
                super::SemanticSimilarityResult,
            >,
            /// Output only. The result of the overall tool invocation check.
            #[prost(message, optional, tag = "9")]
            pub overall_tool_invocation_result: ::core::option::Option<
                super::OverallToolInvocationResult,
            >,
            /// Output only. Information about the error that occurred during this
            /// turn.
            #[prost(message, optional, tag = "10")]
            pub error_info: ::core::option::Option<super::super::EvaluationErrorInfo>,
            /// Output only. The latency of spans in the turn.
            #[prost(message, repeated, tag = "11")]
            pub span_latencies: ::prost::alloc::vec::Vec<super::SpanLatency>,
        }
    }
    /// The outcome of the evaluation against the rubric.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ScenarioRubricOutcome {
        /// Output only. The rubric that was used to evaluate the conversation.
        #[prost(string, tag = "1")]
        pub rubric: ::prost::alloc::string::String,
        /// Output only. The score of the conversation against the rubric.
        #[prost(float, optional, tag = "2")]
        pub score: ::core::option::Option<f32>,
        /// Output only. The rater's response to the rubric.
        #[prost(string, tag = "3")]
        pub score_explanation: ::prost::alloc::string::String,
    }
    /// The outcome of a scenario expectation.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ScenarioExpectationOutcome {
        /// Output only. The expectation that was evaluated.
        #[prost(message, optional, tag = "1")]
        pub expectation: ::core::option::Option<super::evaluation::ScenarioExpectation>,
        /// Output only. The outcome of the ScenarioExpectation.
        #[prost(enumeration = "Outcome", tag = "4")]
        pub outcome: i32,
        /// The result of the expectation.
        #[prost(oneof = "scenario_expectation_outcome::Result", tags = "2, 3")]
        pub result: ::core::option::Option<scenario_expectation_outcome::Result>,
    }
    /// Nested message and enum types in `ScenarioExpectationOutcome`.
    pub mod scenario_expectation_outcome {
        /// The observed tool call and response.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct ObservedToolCall {
            /// Output only. The observed tool call.
            #[prost(message, optional, tag = "1")]
            pub tool_call: ::core::option::Option<super::super::ToolCall>,
            /// Output only. The observed tool response.
            #[prost(message, optional, tag = "2")]
            pub tool_response: ::core::option::Option<super::super::ToolResponse>,
        }
        /// The result of the expectation.
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Result {
            /// Output only. The observed tool call.
            #[prost(message, tag = "2")]
            ObservedToolCall(ObservedToolCall),
            /// Output only. The observed agent response.
            #[prost(message, tag = "3")]
            ObservedAgentResponse(super::super::Message),
        }
    }
    /// The outcome of a scenario evaluation.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ScenarioResult {
        /// Output only. The conversation that was generated in the scenario.
        #[prost(string, tag = "1")]
        pub conversation: ::prost::alloc::string::String,
        /// Output only. The task that was used when running the scenario for this
        /// result.
        #[prost(string, tag = "10")]
        pub task: ::prost::alloc::string::String,
        /// Output only. The user facts that were used by the scenario for this
        /// result.
        #[prost(message, repeated, tag = "11")]
        pub user_facts: ::prost::alloc::vec::Vec<super::evaluation::scenario::UserFact>,
        /// Output only. The outcome of each expectation.
        #[prost(message, repeated, tag = "2")]
        pub expectation_outcomes: ::prost::alloc::vec::Vec<ScenarioExpectationOutcome>,
        /// Output only. The outcome of the rubric.
        #[prost(message, repeated, tag = "3")]
        pub rubric_outcomes: ::prost::alloc::vec::Vec<ScenarioRubricOutcome>,
        /// Output only. The result of the hallucination check.
        /// There will be one hallucination result for each turn in the conversation.
        #[prost(message, repeated, tag = "4")]
        pub hallucination_result: ::prost::alloc::vec::Vec<HallucinationResult>,
        /// Output only. The result of the task completion check.
        #[deprecated]
        #[prost(message, optional, tag = "5")]
        pub task_completion_result: ::core::option::Option<TaskCompletionResult>,
        /// Output only. The latency of each tool call execution in the conversation.
        #[prost(message, repeated, tag = "6")]
        pub tool_call_latencies: ::prost::alloc::vec::Vec<ToolCallLatency>,
        /// Output only. The result of the user goal satisfaction check.
        #[prost(message, optional, tag = "7")]
        pub user_goal_satisfaction_result: ::core::option::Option<
            UserGoalSatisfactionResult,
        >,
        /// Output only. Whether all expectations were satisfied for this turn.
        #[prost(bool, optional, tag = "8")]
        pub all_expectations_satisfied: ::core::option::Option<bool>,
        /// Output only. Whether the task was completed for this turn. This is a
        /// composite of all expectations satisfied, no hallucinations, and user goal
        /// satisfaction.
        #[prost(bool, optional, tag = "9")]
        pub task_completed: ::core::option::Option<bool>,
        /// Output only. The latency of spans in the conversation.
        #[prost(message, repeated, tag = "12")]
        pub span_latencies: ::prost::alloc::vec::Vec<SpanLatency>,
        /// Output only. The results of the evaluation expectations.
        #[prost(message, repeated, tag = "13")]
        pub evaluation_expectation_results: ::prost::alloc::vec::Vec<
            EvaluationExpectationResult,
        >,
    }
    /// The latency of a span execution.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct SpanLatency {
        /// Output only. The type of span.
        #[prost(enumeration = "span_latency::Type", tag = "1")]
        pub r#type: i32,
        /// Output only. The display name of the span. Applicable to tool and
        /// guardrail spans.
        #[prost(string, tag = "9")]
        pub display_name: ::prost::alloc::string::String,
        /// Output only. The start time of span.
        #[prost(message, optional, tag = "6")]
        pub start_time: ::core::option::Option<::prost_types::Timestamp>,
        /// Output only. The end time of span.
        #[prost(message, optional, tag = "7")]
        pub end_time: ::core::option::Option<::prost_types::Timestamp>,
        /// Output only. The latency of span.
        #[prost(message, optional, tag = "8")]
        pub execution_latency: ::core::option::Option<::prost_types::Duration>,
        /// The identifier of the specific item based on its type.
        #[prost(oneof = "span_latency::Identifier", tags = "2, 3, 4, 5")]
        pub identifier: ::core::option::Option<span_latency::Identifier>,
    }
    /// Nested message and enum types in `SpanLatency`.
    pub mod span_latency {
        /// The type of span.
        /// Additional values may be added in the future.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum Type {
            /// Default value. This value is unused.
            Unspecified = 0,
            /// Tool call span.
            Tool = 1,
            /// User callback span.
            UserCallback = 2,
            /// Guardrail span.
            Guardrail = 3,
            /// LLM span.
            Llm = 4,
        }
        impl Type {
            /// 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 => "TYPE_UNSPECIFIED",
                    Self::Tool => "TOOL",
                    Self::UserCallback => "USER_CALLBACK",
                    Self::Guardrail => "GUARDRAIL",
                    Self::Llm => "LLM",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                    "TOOL" => Some(Self::Tool),
                    "USER_CALLBACK" => Some(Self::UserCallback),
                    "GUARDRAIL" => Some(Self::Guardrail),
                    "LLM" => Some(Self::Llm),
                    _ => None,
                }
            }
        }
        /// The identifier of the specific item based on its type.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
        pub enum Identifier {
            /// Output only. The resource name of the guardrail or tool spans.
            #[prost(string, tag = "2")]
            Resource(::prost::alloc::string::String),
            /// Output only. The toolset tool identifier.
            #[prost(message, tag = "3")]
            Toolset(super::super::ToolsetTool),
            /// Output only. The name of the LLM span.
            #[prost(string, tag = "4")]
            Model(::prost::alloc::string::String),
            /// Output only. The name of the user callback span.
            #[prost(string, tag = "5")]
            Callback(::prost::alloc::string::String),
        }
    }
    /// The latency of a tool call execution.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ToolCallLatency {
        /// Output only. The name of the tool that got executed.
        /// Format:
        /// `projects/{project}/locations/{location}/apps/{app}/tools/{tool}`.
        #[prost(string, tag = "1")]
        pub tool: ::prost::alloc::string::String,
        /// Output only. The display name of the tool.
        #[prost(string, tag = "2")]
        pub display_name: ::prost::alloc::string::String,
        /// Output only. The start time of the tool call execution.
        #[prost(message, optional, tag = "3")]
        pub start_time: ::core::option::Option<::prost_types::Timestamp>,
        /// Output only. The end time of the tool call execution.
        #[prost(message, optional, tag = "4")]
        pub end_time: ::core::option::Option<::prost_types::Timestamp>,
        /// Output only. The latency of the tool call execution.
        #[prost(message, optional, tag = "5")]
        pub execution_latency: ::core::option::Option<::prost_types::Duration>,
    }
    /// The result of the hallucination check for a single turn.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct HallucinationResult {
        /// Output only. The hallucination score. Can be -1, 0, 1.
        #[prost(int32, optional, tag = "1")]
        pub score: ::core::option::Option<i32>,
        /// Output only. The label associated with each score.
        /// Score 1: Justified
        /// Score 0: Not Justified
        /// Score -1: No Claim To Assess
        #[prost(string, tag = "2")]
        pub label: ::prost::alloc::string::String,
        /// Output only. The explanation for the hallucination score.
        #[prost(string, tag = "3")]
        pub explanation: ::prost::alloc::string::String,
    }
    /// The result of a user goal satisfaction check for a conversation.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct UserGoalSatisfactionResult {
        /// Output only. The user task satisfaction score. Can be -1, 0, 1.
        #[prost(int32, optional, tag = "1")]
        pub score: ::core::option::Option<i32>,
        /// Output only. The label associated with each score.
        /// Score 1: User Task Satisfied
        /// Score 0: User Task Not Satisfied
        /// Score -1: User Task Unspecified
        #[prost(string, tag = "2")]
        pub label: ::prost::alloc::string::String,
        /// Output only. The explanation for the user task satisfaction score.
        #[prost(string, tag = "3")]
        pub explanation: ::prost::alloc::string::String,
    }
    /// The result of the semantic similarity check.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct SemanticSimilarityResult {
        /// Output only. The semantic similarity score. Can be 0, 1, 2, 3, or 4.
        #[prost(int32, optional, tag = "1")]
        pub score: ::core::option::Option<i32>,
        /// Output only. The label associated with each score.
        /// Score 4: Fully Consistent
        /// Score 3: Mostly Consistent
        /// Score 2: Partially Consistent (Minor Omissions)
        /// Score 1: Largely Inconsistent (Major Omissions)
        /// Score 0: Completely Inconsistent / Contradictory
        #[prost(string, tag = "2")]
        pub label: ::prost::alloc::string::String,
        /// Output only. The explanation for the semantic similarity score.
        #[prost(string, tag = "3")]
        pub explanation: ::prost::alloc::string::String,
        /// Output only. The outcome of the semantic similarity check. This is
        /// determined by comparing the score to the
        /// semantic_similarity_success_threshold. If the score is equal to or above
        /// the threshold, the outcome will be PASS. Otherwise, the outcome will be
        /// FAIL.
        #[prost(enumeration = "Outcome", tag = "4")]
        pub outcome: i32,
    }
    /// The result of the overall tool invocation check.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct OverallToolInvocationResult {
        /// The overall tool invocation score for this turn. This indicates the
        /// overall percent of tools from the expected turn that were actually
        /// invoked.
        #[prost(float, optional, tag = "1")]
        pub tool_invocation_score: ::core::option::Option<f32>,
        /// Output only. The outcome of the tool invocation check. This is determined
        /// by comparing the tool_invocation_score to the
        /// overall_tool_invocation_correctness_threshold. If the
        /// score is equal to or above the threshold, the outcome will be PASS.
        /// Otherwise, the outcome will be FAIL.
        #[prost(enumeration = "Outcome", tag = "2")]
        pub outcome: i32,
    }
    /// The result of the task completion check for the conversation.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct TaskCompletionResult {
        /// Output only. The task completion score. Can be -1, 0, 1
        #[prost(int32, optional, tag = "1")]
        pub score: ::core::option::Option<i32>,
        /// Output only. The label associated with each score.
        /// Score 1: Task Completed
        /// Score 0: Task Not Completed
        /// Score -1: User Goal Undefined
        #[prost(string, tag = "2")]
        pub label: ::prost::alloc::string::String,
        /// Output only. The explanation for the task completion score.
        #[prost(string, tag = "3")]
        pub explanation: ::prost::alloc::string::String,
    }
    /// The outcome of the evaluation or expectation.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Outcome {
        /// Evaluation outcome is not specified.
        Unspecified = 0,
        /// Evaluation/Expectation passed. In the case of an evaluation, this means
        /// that all expectations were met.
        Pass = 1,
        /// Evaluation/Expectation failed. In the case of an evaluation, this means
        /// that at least one expectation was not met.
        Fail = 2,
        /// Evaluation/Expectation was skipped.
        Skipped = 3,
    }
    impl Outcome {
        /// 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 => "OUTCOME_UNSPECIFIED",
                Self::Pass => "PASS",
                Self::Fail => "FAIL",
                Self::Skipped => "SKIPPED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "OUTCOME_UNSPECIFIED" => Some(Self::Unspecified),
                "PASS" => Some(Self::Pass),
                "FAIL" => Some(Self::Fail),
                "SKIPPED" => Some(Self::Skipped),
                _ => None,
            }
        }
    }
    /// The state of the evaluation result execution.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ExecutionState {
        /// Evaluation result execution state is not specified.
        Unspecified = 0,
        /// Evaluation result execution is running.
        Running = 1,
        /// Evaluation result execution has completed.
        Completed = 2,
        /// Evaluation result execution failed due to an internal error.
        Error = 3,
    }
    impl ExecutionState {
        /// 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 => "EXECUTION_STATE_UNSPECIFIED",
                Self::Running => "RUNNING",
                Self::Completed => "COMPLETED",
                Self::Error => "ERROR",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "EXECUTION_STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "RUNNING" => Some(Self::Running),
                "COMPLETED" => Some(Self::Completed),
                "ERROR" => Some(Self::Error),
                _ => None,
            }
        }
    }
    /// The result of the evaluation. Only populated when the execution_state is
    /// COMPLETED.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Result {
        /// Output only. The outcome of a golden evaluation.
        #[prost(message, tag = "7")]
        GoldenResult(GoldenResult),
        /// Output only. The outcome of a scenario evaluation.
        #[prost(message, tag = "8")]
        ScenarioResult(ScenarioResult),
    }
}
/// An evaluation run represents an all the evaluation results from an
/// evaluation execution.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EvaluationRun {
    /// Identifier. The unique identifier of the evaluation run.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/evaluationRuns/{evaluationRun}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. User-defined display name of the evaluation run.
    /// default: "<evaluation-dataset-display-name> run - <timestamp>".
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Output only. The evaluation results that are part of this run.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/evaluations/{evaluation}/results/{result}`
    #[prost(string, repeated, tag = "3")]
    pub evaluation_results: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Output only. Timestamp when the evaluation run was created.
    #[prost(message, optional, tag = "4")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The user who initiated the evaluation run.
    #[prost(string, tag = "5")]
    pub initiated_by: ::prost::alloc::string::String,
    /// Output only. The app version to evaluate.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/versions/{version}`
    #[prost(string, tag = "6")]
    pub app_version: ::prost::alloc::string::String,
    /// Output only. The display name of the `app_version` that the evaluation ran
    /// against.
    #[prost(string, tag = "13")]
    pub app_version_display_name: ::prost::alloc::string::String,
    /// Output only. The changelog of the app version that the evaluation ran
    /// against. This is populated if user runs evaluation on latest/draft.
    #[prost(string, tag = "22")]
    pub changelog: ::prost::alloc::string::String,
    /// Output only. The create time of the changelog of the app version that the
    /// evaluation ran against. This is populated if user runs evaluation on
    /// latest/draft.
    #[prost(message, optional, tag = "23")]
    pub changelog_create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The evaluations that are part of this run. The list may
    /// contain evaluations of either type. This field is mutually exclusive with
    /// `evaluation_dataset`.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/evaluations/{evaluation}`
    #[prost(string, repeated, tag = "7")]
    pub evaluations: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Output only. The evaluation dataset that this run is associated with. This
    /// field is mutually exclusive with `evaluations`. Format:
    /// `projects/{project}/locations/{location}/apps/{app}/evaluationDatasets/{evaluationDataset}`
    #[prost(string, tag = "8")]
    pub evaluation_dataset: ::prost::alloc::string::String,
    /// Output only. The type of the evaluations in this run.
    #[prost(enumeration = "evaluation_run::EvaluationType", tag = "9")]
    pub evaluation_type: i32,
    /// Output only. The state of the evaluation run.
    #[prost(enumeration = "evaluation_run::EvaluationRunState", tag = "10")]
    pub state: i32,
    /// Output only. The progress of the evaluation run.
    #[prost(message, optional, tag = "11")]
    pub progress: ::core::option::Option<evaluation_run::Progress>,
    /// Output only. The configuration used in the run.
    #[prost(message, optional, tag = "12")]
    pub config: ::core::option::Option<EvaluationConfig>,
    /// Output only. Deprecated: Use error_info instead. Errors encountered during
    /// execution.
    #[deprecated]
    #[prost(message, optional, tag = "14")]
    pub error: ::core::option::Option<super::super::super::rpc::Status>,
    /// Output only. Error information for the evaluation run.
    #[prost(message, optional, tag = "17")]
    pub error_info: ::core::option::Option<EvaluationErrorInfo>,
    /// Output only. Map of evaluation name to EvaluationRunSummary.
    #[prost(map = "string, message", tag = "15")]
    pub evaluation_run_summaries: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        evaluation_run::EvaluationRunSummary,
    >,
    /// Output only. Latency report for the evaluation run.
    #[prost(message, optional, tag = "25")]
    pub latency_report: ::core::option::Option<LatencyReport>,
    /// Output only. The number of times the evaluations inside the run were run.
    #[prost(int32, tag = "16")]
    pub run_count: i32,
    /// Output only. The configuration to use for the run per persona.
    #[prost(message, repeated, tag = "18")]
    pub persona_run_configs: ::prost::alloc::vec::Vec<PersonaRunConfig>,
    /// Optional. Configuration for running the optimization step after the
    /// evaluation run. If not set, the optimization step will not be run.
    #[prost(message, optional, tag = "19")]
    pub optimization_config: ::core::option::Option<OptimizationConfig>,
    /// Output only. The scheduled evaluation run resource name that created this
    /// evaluation run. This field is only set if the evaluation run was created
    /// by a scheduled evaluation run.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/scheduledEvaluationRuns/{scheduled_evaluation_run}`
    #[prost(string, tag = "20")]
    pub scheduled_evaluation_run: ::prost::alloc::string::String,
    /// Output only. The method used to run the evaluation.
    #[prost(enumeration = "GoldenRunMethod", tag = "21")]
    pub golden_run_method: i32,
}
/// Nested message and enum types in `EvaluationRun`.
pub mod evaluation_run {
    /// The progress of the evaluation run.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Progress {
        /// Output only. Total number of evaluation results in this run.
        #[prost(int32, tag = "1")]
        pub total_count: i32,
        /// Output only. Number of completed evaluation results with an outcome of
        /// FAIL. (EvaluationResult.execution_state is COMPLETED and
        /// EvaluationResult.evaluation_status is FAIL).
        #[prost(int32, tag = "2")]
        pub failed_count: i32,
        /// Output only. Number of evaluation results that failed to execute.
        /// (EvaluationResult.execution_state is ERROR).
        #[prost(int32, tag = "3")]
        pub error_count: i32,
        /// Output only. Number of evaluation results that finished successfully.
        /// (EvaluationResult.execution_state is COMPLETED).
        #[prost(int32, tag = "4")]
        pub completed_count: i32,
        /// Output only. Number of completed evaluation results with an outcome of
        /// PASS. (EvaluationResult.execution_state is COMPLETED and
        /// EvaluationResult.evaluation_status is PASS).
        #[prost(int32, tag = "5")]
        pub passed_count: i32,
    }
    /// Contains the summary of passed and failed result counts for a specific
    /// evaluation in an evaluation run.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct EvaluationRunSummary {
        /// Output only. Number of passed results for the associated Evaluation in
        /// this run.
        #[prost(int32, tag = "1")]
        pub passed_count: i32,
        /// Output only. Number of failed results for the associated Evaluation in
        /// this run.
        #[prost(int32, tag = "2")]
        pub failed_count: i32,
        /// Output only. Number of error results for the associated Evaluation in
        /// this run.
        #[prost(int32, tag = "3")]
        pub error_count: i32,
    }
    /// The type of the evaluations in this run.
    /// Additional values may be added in the future.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum EvaluationType {
        /// Evaluation type is not specified.
        Unspecified = 0,
        /// Golden evaluation.
        Golden = 1,
        /// Scenario evaluation.
        Scenario = 2,
        /// Indicates the run includes a mix of golden and scenario evaluations.
        Mixed = 3,
    }
    impl EvaluationType {
        /// 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 => "EVALUATION_TYPE_UNSPECIFIED",
                Self::Golden => "GOLDEN",
                Self::Scenario => "SCENARIO",
                Self::Mixed => "MIXED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "EVALUATION_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "GOLDEN" => Some(Self::Golden),
                "SCENARIO" => Some(Self::Scenario),
                "MIXED" => Some(Self::Mixed),
                _ => None,
            }
        }
    }
    /// The state of the evaluation run.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum EvaluationRunState {
        /// Evaluation run state is not specified.
        Unspecified = 0,
        /// Evaluation run is running.
        Running = 1,
        /// Evaluation run has completed.
        Completed = 2,
        /// The evaluation run has an error.
        Error = 3,
    }
    impl EvaluationRunState {
        /// 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 => "EVALUATION_RUN_STATE_UNSPECIFIED",
                Self::Running => "RUNNING",
                Self::Completed => "COMPLETED",
                Self::Error => "ERROR",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "EVALUATION_RUN_STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "RUNNING" => Some(Self::Running),
                "COMPLETED" => Some(Self::Completed),
                "ERROR" => Some(Self::Error),
                _ => None,
            }
        }
    }
}
/// Latency report for the evaluation run.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LatencyReport {
    /// Output only. Unordered list. Latency metrics for each tool.
    #[prost(message, repeated, tag = "1")]
    pub tool_latencies: ::prost::alloc::vec::Vec<latency_report::ToolLatency>,
    /// Output only. Unordered list. Latency metrics for each callback.
    #[prost(message, repeated, tag = "2")]
    pub callback_latencies: ::prost::alloc::vec::Vec<latency_report::CallbackLatency>,
    /// Output only. Unordered list. Latency metrics for each guardrail.
    #[prost(message, repeated, tag = "3")]
    pub guardrail_latencies: ::prost::alloc::vec::Vec<latency_report::GuardrailLatency>,
    /// Output only. Unordered list. Latency metrics for each LLM call.
    #[prost(message, repeated, tag = "4")]
    pub llm_call_latencies: ::prost::alloc::vec::Vec<latency_report::LlmCallLatency>,
    /// Output only. The total number of sessions considered in the latency report.
    #[prost(int32, tag = "5")]
    pub session_count: i32,
}
/// Nested message and enum types in `LatencyReport`.
pub mod latency_report {
    /// Latency metrics for a component.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct LatencyMetrics {
        /// Output only. The 50th percentile latency.
        #[prost(message, optional, tag = "1")]
        pub p50_latency: ::core::option::Option<::prost_types::Duration>,
        /// Output only. The 90th percentile latency.
        #[prost(message, optional, tag = "2")]
        pub p90_latency: ::core::option::Option<::prost_types::Duration>,
        /// Output only. The 99th percentile latency.
        #[prost(message, optional, tag = "3")]
        pub p99_latency: ::core::option::Option<::prost_types::Duration>,
        /// Output only. The number of times the resource was called.
        #[prost(int32, tag = "4")]
        pub call_count: i32,
    }
    /// Latency metrics for a single tool.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ToolLatency {
        /// Output only. The display name of the tool.
        #[prost(string, tag = "3")]
        pub tool_display_name: ::prost::alloc::string::String,
        /// Output only. The latency metrics for the tool.
        #[prost(message, optional, tag = "4")]
        pub latency_metrics: ::core::option::Option<LatencyMetrics>,
        /// The identifier of the tool.
        #[prost(oneof = "tool_latency::ToolIdentifier", tags = "1, 2")]
        pub tool_identifier: ::core::option::Option<tool_latency::ToolIdentifier>,
    }
    /// Nested message and enum types in `ToolLatency`.
    pub mod tool_latency {
        /// The identifier of the tool.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
        pub enum ToolIdentifier {
            /// Output only. Format:
            /// `projects/{project}/locations/{location}/apps/{app}/tools/{tool}`.
            #[prost(string, tag = "1")]
            Tool(::prost::alloc::string::String),
            /// Output only. The toolset tool identifier.
            #[prost(message, tag = "2")]
            ToolsetTool(super::super::ToolsetTool),
        }
    }
    /// Latency metrics for a single callback.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct CallbackLatency {
        /// Output only. The stage of the callback.
        #[prost(string, tag = "1")]
        pub stage: ::prost::alloc::string::String,
        /// Output only. The latency metrics for the callback.
        #[prost(message, optional, tag = "2")]
        pub latency_metrics: ::core::option::Option<LatencyMetrics>,
    }
    /// Latency metrics for a single guardrail.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct GuardrailLatency {
        /// Output only. The name of the guardrail.
        /// Format:
        /// `projects/{project}/locations/{location}/apps/{app}/guardrails/{guardrail}`.
        #[prost(string, tag = "1")]
        pub guardrail: ::prost::alloc::string::String,
        /// Output only. The display name of the guardrail.
        #[prost(string, tag = "2")]
        pub guardrail_display_name: ::prost::alloc::string::String,
        /// Output only. The latency metrics for the guardrail.
        #[prost(message, optional, tag = "3")]
        pub latency_metrics: ::core::option::Option<LatencyMetrics>,
    }
    /// Latency metrics for a single LLM call.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct LlmCallLatency {
        /// Output only. The name of the model.
        #[prost(string, tag = "1")]
        pub model: ::prost::alloc::string::String,
        /// Output only. The latency metrics for the LLM call.
        #[prost(message, optional, tag = "2")]
        pub latency_metrics: ::core::option::Option<LatencyMetrics>,
    }
}
/// An evaluation expectation represents a specific criteria to evaluate against.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct EvaluationExpectation {
    /// Identifier. The unique identifier of this evaluation expectation.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/evaluationExpectations/{evaluation_expectation}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. User-defined display name. Must be unique within the app.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Optional. User-defined tags for expectations. Can be used to filter
    /// expectations.
    #[prost(string, repeated, tag = "8")]
    pub tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Output only. Timestamp when the evaluation expectation was created.
    #[prost(message, optional, tag = "4")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Timestamp when the evaluation expectation was last updated.
    #[prost(message, optional, tag = "5")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Etag used to ensure the object hasn't changed during a
    /// read-modify-write operation. If the etag is empty, the update will
    /// overwrite any concurrent changes.
    #[prost(string, tag = "6")]
    pub etag: ::prost::alloc::string::String,
    /// The definition of the criteria used for evaluation.
    #[prost(oneof = "evaluation_expectation::Criteria", tags = "3")]
    pub criteria: ::core::option::Option<evaluation_expectation::Criteria>,
}
/// Nested message and enum types in `EvaluationExpectation`.
pub mod evaluation_expectation {
    /// Configuration for LLM-based evaluation criteria.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct LlmCriteria {
        /// Required. The prompt/instructions provided to the LLM judge.
        #[prost(string, tag = "1")]
        pub prompt: ::prost::alloc::string::String,
    }
    /// The definition of the criteria used for evaluation.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Criteria {
        /// Optional. Evaluation criteria based on an LLM prompt.
        #[prost(message, tag = "3")]
        LlmCriteria(LlmCriteria),
    }
}
/// EvaluationConfig configures settings for running the evaluation.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct EvaluationConfig {
    /// Optional. Configuration for processing the input audio.
    #[deprecated]
    #[prost(message, optional, tag = "1")]
    pub input_audio_config: ::core::option::Option<InputAudioConfig>,
    /// Optional. Configuration for generating the output audio.
    #[deprecated]
    #[prost(message, optional, tag = "2")]
    pub output_audio_config: ::core::option::Option<OutputAudioConfig>,
    /// Optional. The channel to evaluate.
    #[prost(enumeration = "evaluation_config::EvaluationChannel", tag = "3")]
    pub evaluation_channel: i32,
    /// Optional. Specifies whether the evaluation should use real tool calls or
    /// fake tools.
    #[prost(enumeration = "EvaluationToolCallBehaviour", tag = "4")]
    pub tool_call_behaviour: i32,
}
/// Nested message and enum types in `EvaluationConfig`.
pub mod evaluation_config {
    /// The channel to evaluate.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum EvaluationChannel {
        /// Unspecified evaluation channel.
        Unspecified = 0,
        /// Text-only evaluation channel.
        Text = 1,
        /// Audio evaluation channel.
        Audio = 2,
    }
    impl EvaluationChannel {
        /// 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 => "EVALUATION_CHANNEL_UNSPECIFIED",
                Self::Text => "TEXT",
                Self::Audio => "AUDIO",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "EVALUATION_CHANNEL_UNSPECIFIED" => Some(Self::Unspecified),
                "TEXT" => Some(Self::Text),
                "AUDIO" => Some(Self::Audio),
                _ => None,
            }
        }
    }
}
/// Information about an error encountered during an evaluation execution.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct EvaluationErrorInfo {
    /// Output only. The type of error.
    #[prost(enumeration = "evaluation_error_info::ErrorType", tag = "1")]
    pub error_type: i32,
    /// Output only. The error message.
    #[prost(string, tag = "2")]
    pub error_message: ::prost::alloc::string::String,
    /// Output only. The session ID for the conversation that caused the error.
    #[prost(string, tag = "3")]
    pub session_id: ::prost::alloc::string::String,
}
/// Nested message and enum types in `EvaluationErrorInfo`.
pub mod evaluation_error_info {
    /// The type of error
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ErrorType {
        /// Unspecified error type.
        Unspecified = 0,
        /// Failure during runtime execution.
        RuntimeFailure = 1,
        /// Failure to retrieve conversation from CES Runtime.
        ConversationRetrievalFailure = 2,
        /// Failure to calculate a metric / outcome.
        MetricCalculationFailure = 3,
        /// Failure to update the evaluation.
        EvaluationUpdateFailure = 4,
        /// Ran out of quota.
        QuotaExhausted = 5,
        /// Failure during user simulation.
        UserSimulationFailure = 6,
    }
    impl ErrorType {
        /// 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 => "ERROR_TYPE_UNSPECIFIED",
                Self::RuntimeFailure => "RUNTIME_FAILURE",
                Self::ConversationRetrievalFailure => "CONVERSATION_RETRIEVAL_FAILURE",
                Self::MetricCalculationFailure => "METRIC_CALCULATION_FAILURE",
                Self::EvaluationUpdateFailure => "EVALUATION_UPDATE_FAILURE",
                Self::QuotaExhausted => "QUOTA_EXHAUSTED",
                Self::UserSimulationFailure => "USER_SIMULATION_FAILURE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ERROR_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "RUNTIME_FAILURE" => Some(Self::RuntimeFailure),
                "CONVERSATION_RETRIEVAL_FAILURE" => {
                    Some(Self::ConversationRetrievalFailure)
                }
                "METRIC_CALCULATION_FAILURE" => Some(Self::MetricCalculationFailure),
                "EVALUATION_UPDATE_FAILURE" => Some(Self::EvaluationUpdateFailure),
                "QUOTA_EXHAUSTED" => Some(Self::QuotaExhausted),
                "USER_SIMULATION_FAILURE" => Some(Self::UserSimulationFailure),
                _ => None,
            }
        }
    }
}
/// Request message for
/// \[EvaluationService.RunEvaluation\]\[google.cloud.ces.v1beta.EvaluationService.RunEvaluation\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RunEvaluationRequest {
    /// Required. The app to evaluate.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}`
    #[prost(string, tag = "1")]
    pub app: ::prost::alloc::string::String,
    /// Optional. List of evaluations to run.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/evaluations/{evaluation}`
    #[prost(string, repeated, tag = "2")]
    pub evaluations: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. An evaluation dataset to run.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/evaluationDatasets/{evaluationDataset}`
    #[prost(string, tag = "3")]
    pub evaluation_dataset: ::prost::alloc::string::String,
    /// Optional. The display name of the evaluation run.
    #[prost(string, tag = "4")]
    pub display_name: ::prost::alloc::string::String,
    /// Optional. The app version to evaluate.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/versions/{version}`
    #[prost(string, tag = "6")]
    pub app_version: ::prost::alloc::string::String,
    /// Optional. The configuration to use for the run.
    #[prost(message, optional, tag = "8")]
    pub config: ::core::option::Option<EvaluationConfig>,
    /// Optional. The number of times to run the evaluation. If not set, the
    /// default value is 1 per golden, and 5 per scenario.
    #[prost(int32, optional, tag = "9")]
    pub run_count: ::core::option::Option<i32>,
    /// Optional. The configuration to use for the run per persona.
    #[prost(message, repeated, tag = "10")]
    pub persona_run_configs: ::prost::alloc::vec::Vec<PersonaRunConfig>,
    /// Optional. Configuration for running the optimization step after the
    /// evaluation run. If not set, the optimization step will not be run.
    #[prost(message, optional, tag = "11")]
    pub optimization_config: ::core::option::Option<OptimizationConfig>,
    /// Optional. The resource name of the `ScheduledEvaluationRun` that is
    /// triggering this evaluation run.
    ///
    /// If this field is set, the `scheduled_evaluation_run` field on the created
    /// `EvaluationRun` resource will be populated from this value.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/scheduledEvaluationRuns/{scheduled_evaluation_run}`
    #[prost(string, tag = "12")]
    pub scheduled_evaluation_run: ::prost::alloc::string::String,
    /// Optional. The method to run the evaluation if it is a golden evaluation. If
    /// not set, default to STABLE.
    #[prost(enumeration = "GoldenRunMethod", tag = "13")]
    pub golden_run_method: i32,
    /// Optional. Whether to generate a latency report for the evaluation run.
    #[prost(bool, tag = "14")]
    pub generate_latency_report: bool,
}
/// Represents a scheduled evaluation run configuration.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ScheduledEvaluationRun {
    /// Identifier. The unique identifier of the scheduled evaluation run config.
    /// Format:
    /// projects/{projectId}/locations/{locationId}/apps/{appId}/scheduledEvaluationRuns/{scheduledEvaluationRunId}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. User-defined display name of the scheduled evaluation run config.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Required. The RunEvaluationRequest to schedule
    #[prost(message, optional, tag = "3")]
    pub request: ::core::option::Option<RunEvaluationRequest>,
    /// Optional. User-defined description of the scheduled evaluation run.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// Required. Configuration for the timing and frequency with which to execute
    /// the evaluations.
    #[prost(message, optional, tag = "5")]
    pub scheduling_config: ::core::option::Option<
        scheduled_evaluation_run::SchedulingConfig,
    >,
    /// Optional. Whether this config is active
    #[prost(bool, tag = "6")]
    pub active: bool,
    /// Output only. The last successful EvaluationRun of this scheduled execution.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/evaluationRuns/{evaluationRun}`
    #[prost(string, tag = "7")]
    pub last_completed_run: ::prost::alloc::string::String,
    /// Output only. The total number of times this run has been executed
    #[prost(int32, tag = "8")]
    pub total_executions: i32,
    /// Output only. The next time this is scheduled to execute
    #[prost(message, optional, tag = "9")]
    pub next_scheduled_execution_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Timestamp when the scheduled evaluation run was created.
    #[prost(message, optional, tag = "10")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The user who created the scheduled evaluation run.
    #[prost(string, tag = "11")]
    pub created_by: ::prost::alloc::string::String,
    /// Output only. Timestamp when the evaluation was last updated.
    #[prost(message, optional, tag = "12")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The user who last updated the evaluation.
    #[prost(string, tag = "13")]
    pub last_updated_by: ::prost::alloc::string::String,
    /// Output only. Etag used to ensure the object hasn't changed during a
    /// read-modify-write operation. If the etag is empty, the update will
    /// overwrite any concurrent changes.
    #[prost(string, tag = "14")]
    pub etag: ::prost::alloc::string::String,
}
/// Nested message and enum types in `ScheduledEvaluationRun`.
pub mod scheduled_evaluation_run {
    /// Eval scheduling configuration details
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct SchedulingConfig {
        /// Required. The frequency with which to run the eval
        #[prost(enumeration = "scheduling_config::Frequency", tag = "1")]
        pub frequency: i32,
        /// Required. Timestamp when the eval should start.
        #[prost(message, optional, tag = "2")]
        pub start_time: ::core::option::Option<::prost_types::Timestamp>,
        /// Optional. The days of the week to run the eval. Applicable only for
        /// Weekly and Biweekly frequencies. 1 is Monday, 2 is Tuesday, ..., 7 is
        /// Sunday.
        #[prost(int32, repeated, packed = "false", tag = "3")]
        pub days_of_week: ::prost::alloc::vec::Vec<i32>,
    }
    /// Nested message and enum types in `SchedulingConfig`.
    pub mod scheduling_config {
        /// The frequencies evals can be run at
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum Frequency {
            /// The frequency is unspecified.
            Unspecified = 0,
            /// Indicates a one-time scheduled run that should not repeat
            None = 1,
            /// Run the evaluation daily.
            Daily = 2,
            /// Run the evaluation weekly.
            Weekly = 3,
            /// Run the evaluation biweekly.
            Biweekly = 4,
        }
        impl Frequency {
            /// 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 => "FREQUENCY_UNSPECIFIED",
                    Self::None => "NONE",
                    Self::Daily => "DAILY",
                    Self::Weekly => "WEEKLY",
                    Self::Biweekly => "BIWEEKLY",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "FREQUENCY_UNSPECIFIED" => Some(Self::Unspecified),
                    "NONE" => Some(Self::None),
                    "DAILY" => Some(Self::Daily),
                    "WEEKLY" => Some(Self::Weekly),
                    "BIWEEKLY" => Some(Self::Biweekly),
                    _ => None,
                }
            }
        }
    }
}
/// Configuration for running an evaluation for a specific persona.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PersonaRunConfig {
    /// Optional. The persona to use for the evaluation.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/evaluationPersonas/{evaluationPersona}`
    #[prost(string, tag = "1")]
    pub persona: ::prost::alloc::string::String,
    /// Optional. The number of tasks to run for the persona.
    #[prost(int32, tag = "2")]
    pub task_count: i32,
}
/// Configuration for running the optimization step after the evaluation run.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OptimizationConfig {
    /// Optional. Whether to generate a loss report.
    #[prost(bool, tag = "1")]
    pub generate_loss_report: bool,
    /// Output only. The assistant session to use for the optimization based on
    /// this evaluation run. Format:
    /// `projects/{project}/locations/{location}/apps/{app}/assistantSessions/{assistantSession}`
    #[prost(string, tag = "2")]
    pub assistant_session: ::prost::alloc::string::String,
    /// Output only. The summary of the loss report.
    #[prost(string, tag = "3")]
    pub report_summary: ::prost::alloc::string::String,
    /// Output only. Whether to suggest a fix for the losses.
    #[prost(bool, tag = "5")]
    pub should_suggest_fix: bool,
    /// Output only. The status of the optimization run.
    #[prost(enumeration = "optimization_config::OptimizationStatus", tag = "4")]
    pub status: i32,
    /// Output only. The error message if the optimization run failed.
    #[prost(string, tag = "6")]
    pub error_message: ::prost::alloc::string::String,
    /// Output only. The generated loss report.
    #[prost(message, optional, tag = "7")]
    pub loss_report: ::core::option::Option<::prost_types::Struct>,
}
/// Nested message and enum types in `OptimizationConfig`.
pub mod optimization_config {
    /// The status of the optimization run.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum OptimizationStatus {
        /// Optimization status is not specified.
        Unspecified = 0,
        /// Optimization is running.
        Running = 1,
        /// Optimization has completed.
        Completed = 2,
        /// Optimization failed due to an internal error.
        Error = 3,
    }
    impl OptimizationStatus {
        /// 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 => "OPTIMIZATION_STATUS_UNSPECIFIED",
                Self::Running => "RUNNING",
                Self::Completed => "COMPLETED",
                Self::Error => "ERROR",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "OPTIMIZATION_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
                "RUNNING" => Some(Self::Running),
                "COMPLETED" => Some(Self::Completed),
                "ERROR" => Some(Self::Error),
                _ => None,
            }
        }
    }
}
/// Files to be used as context. Files can be provided as raw bytes.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FileContext {
    /// File provided as context.
    #[prost(oneof = "file_context::File", tags = "1")]
    pub file: ::core::option::Option<file_context::File>,
}
/// Nested message and enum types in `FileContext`.
pub mod file_context {
    /// File provided as raw bytes.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct FileBytes {
        /// Required. The name of the file provided as raw bytes.
        #[prost(string, tag = "1")]
        pub file_name: ::prost::alloc::string::String,
        /// Required. The IANA standard MIME type of the source data.
        #[prost(string, tag = "2")]
        pub mime_type: ::prost::alloc::string::String,
        /// Required. Raw bytes of the file.
        #[prost(bytes = "vec", tag = "3")]
        pub data: ::prost::alloc::vec::Vec<u8>,
    }
    /// File provided as context.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum File {
        /// Optional. File provided as raw bytes.
        #[prost(message, tag = "1")]
        FileBytes(FileBytes),
    }
}
/// Project/Location level security settings for CES.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SecuritySettings {
    /// Identifier. The unique identifier of the security settings.
    /// Format: `projects/{project}/locations/{location}/securitySettings`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. Endpoint control related settings.
    #[prost(message, optional, tag = "2")]
    pub endpoint_control_policy: ::core::option::Option<EndpointControlPolicy>,
    /// Output only. Create time of the security settings.
    #[prost(message, optional, tag = "3")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Last update time of the security settings.
    #[prost(message, optional, tag = "4")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Etag of the security settings.
    #[prost(string, tag = "5")]
    pub etag: ::prost::alloc::string::String,
}
/// Defines project/location level endpoint control policy.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct EndpointControlPolicy {
    /// Optional. The scope in which this policy's allowed_origins list is
    /// enforced.
    #[prost(enumeration = "endpoint_control_policy::EnforcementScope", tag = "1")]
    pub enforcement_scope: i32,
    /// Optional. The allowed HTTP(s) origins that tools in the App are able to
    /// directly call. The enforcement depends on the value of
    /// enforcement_scope and the VPC-SC status of the project.
    /// If a port number is not provided, all ports will be allowed. Otherwise,
    /// the port number must match exactly. For example, "<https://example.com">
    /// will match "<https://example.com:443"> and any other port.
    /// "<https://example.com:443"> will only match "<https://example.com:443".>
    #[prost(string, repeated, tag = "2")]
    pub allowed_origins: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Nested message and enum types in `EndpointControlPolicy`.
pub mod endpoint_control_policy {
    /// Defines the scope in which this policy's allowed_origins list is
    /// enforced.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum EnforcementScope {
        /// Unspecified. This policy will be treated as VPCSC_ONLY.
        Unspecified = 0,
        /// This policy applies only when VPC-SC is active.
        VpcscOnly = 1,
        /// This policy ALWAYS applies, regardless of VPC-SC status.
        Always = 2,
    }
    impl EnforcementScope {
        /// 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 => "ENFORCEMENT_SCOPE_UNSPECIFIED",
                Self::VpcscOnly => "VPCSC_ONLY",
                Self::Always => "ALWAYS",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ENFORCEMENT_SCOPE_UNSPECIFIED" => Some(Self::Unspecified),
                "VPCSC_ONLY" => Some(Self::VpcscOnly),
                "ALWAYS" => Some(Self::Always),
                _ => None,
            }
        }
    }
}
/// Request message for
/// \[AgentService.ListApps\]\[google.cloud.ces.v1beta.AgentService.ListApps\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListAppsRequest {
    /// Required. The resource name of the location to list apps from.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Requested page size. Server may return fewer items than
    /// requested. If unspecified, server will pick an appropriate default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. The
    /// \[next_page_token\]\[google.cloud.ces.v1beta.ListAppsResponse.next_page_token\]
    /// value returned from a previous list
    /// \[AgentService.ListApps\]\[google.cloud.ces.v1beta.AgentService.ListApps\]
    /// call.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. Filter to be applied when listing the apps.
    /// See <https://google.aip.dev/160> for more details.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Optional. Field to sort by. Only "name" and "create_time" is supported.
    /// See <https://google.aip.dev/132#ordering> for more details.
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Response message for
/// \[AgentService.ListApps\]\[google.cloud.ces.v1beta.AgentService.ListApps\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListAppsResponse {
    /// The list of apps.
    #[prost(message, repeated, tag = "1")]
    pub apps: ::prost::alloc::vec::Vec<App>,
    /// A token that can be sent as
    /// \[ListAppsRequest.page_token\]\[google.cloud.ces.v1beta.ListAppsRequest.page_token\]
    /// to retrieve the next page. Absence of this field indicates there are no
    /// subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
    /// Unordered list. Locations that could not be reached.
    #[prost(string, repeated, tag = "3")]
    pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Request message for
/// \[AgentService.GetApp\]\[google.cloud.ces.v1beta.AgentService.GetApp\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetAppRequest {
    /// Required. The resource name of the app to retrieve.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// \[AgentService.CreateApp\]\[google.cloud.ces.v1beta.AgentService.CreateApp\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateAppRequest {
    /// Required. The resource name of the location to create an app in.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The ID to use for the app, which will become the final component
    /// of the app's resource name. If not provided, a unique ID will be
    /// automatically assigned for the app.
    #[prost(string, tag = "2")]
    pub app_id: ::prost::alloc::string::String,
    /// Required. The app to create.
    #[prost(message, optional, tag = "3")]
    pub app: ::core::option::Option<App>,
}
/// Request message for
/// \[AgentService.UpdateApp\]\[google.cloud.ces.v1beta.AgentService.UpdateApp\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateAppRequest {
    /// Required. The app to update.
    #[prost(message, optional, tag = "1")]
    pub app: ::core::option::Option<App>,
    /// Optional. Field mask is used to control which fields get updated. If the
    /// mask is not present, all fields will be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for
/// \[AgentService.DeleteApp\]\[google.cloud.ces.v1beta.AgentService.DeleteApp\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteAppRequest {
    /// Required. The resource name of the app to delete.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The current etag of the app. If an etag is not provided, the
    /// deletion will overwrite any concurrent changes. If an etag is provided and
    /// does not match the current etag of the app, deletion will be blocked and an
    /// ABORTED error will be returned.
    #[prost(string, tag = "2")]
    pub etag: ::prost::alloc::string::String,
}
/// Request message for
/// \[AgentService.ExportApp\]\[google.cloud.ces.v1beta.AgentService.ExportApp\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExportAppRequest {
    /// Required. The resource name of the app to export.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. The format to export the app in.
    #[prost(enumeration = "export_app_request::ExportFormat", tag = "2")]
    pub export_format: i32,
    /// Optional. The [Google Cloud
    /// Storage](<https://cloud.google.com/storage/docs/>) URI to which to export the
    /// app. The format of this URI must be `gs://<bucket-name>/<object-name>`. The
    /// exported app archive will be written directly to the specified GCS object.
    #[prost(string, tag = "3")]
    pub gcs_uri: ::prost::alloc::string::String,
    /// Optional. The resource name of the app version to export.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/versions/{version}`.
    #[prost(string, tag = "4")]
    pub app_version: ::prost::alloc::string::String,
}
/// Nested message and enum types in `ExportAppRequest`.
pub mod export_app_request {
    /// Export format for the app.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ExportFormat {
        /// The export format is unspecified.
        Unspecified = 0,
        /// The export format is JSON.
        Json = 1,
        /// The export format is YAML.
        Yaml = 2,
    }
    impl ExportFormat {
        /// 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 => "EXPORT_FORMAT_UNSPECIFIED",
                Self::Json => "JSON",
                Self::Yaml => "YAML",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "EXPORT_FORMAT_UNSPECIFIED" => Some(Self::Unspecified),
                "JSON" => Some(Self::Json),
                "YAML" => Some(Self::Yaml),
                _ => None,
            }
        }
    }
}
/// Response message for
/// \[AgentService.ExportApp\]\[google.cloud.ces.v1beta.AgentService.ExportApp\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExportAppResponse {
    /// The exported app.
    #[prost(oneof = "export_app_response::App", tags = "1, 2")]
    pub app: ::core::option::Option<export_app_response::App>,
}
/// Nested message and enum types in `ExportAppResponse`.
pub mod export_app_response {
    /// The exported app.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum App {
        /// App folder compressed as a zip file.
        #[prost(bytes, tag = "1")]
        AppContent(::prost::alloc::vec::Vec<u8>),
        /// The [Google Cloud Storage](<https://cloud.google.com/storage/docs/>) URI
        /// to which the app was exported.
        #[prost(string, tag = "2")]
        AppUri(::prost::alloc::string::String),
    }
}
/// Request message for
/// \[AgentService.ImportApp\]\[google.cloud.ces.v1beta.AgentService.ImportApp\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ImportAppRequest {
    /// Required. The parent resource name with the location of the app to import.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The display name of the app to import.
    ///
    /// * If the app is created on import, and the display name is specified,
    ///   the imported app will use this display name. If a conflict is detected
    ///   with an existing app, a timestamp will be appended to the display name
    ///   to make it unique.
    /// * If the app is a reimport, this field should not be set. Providing a
    ///   display name during reimport will result in an INVALID_ARGUMENT error.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Optional. The ID to use for the imported app.
    ///
    /// * If not specified, a unique ID will be automatically assigned for
    ///   the app.
    /// * Otherwise, the imported app will use this ID as the final component of
    ///   its resource name. If an app with the same ID already exists at the
    ///   specified location in the project, the content of the existing app will be
    ///   replaced.
    #[prost(string, tag = "3")]
    pub app_id: ::prost::alloc::string::String,
    /// Optional. Options governing the import process for the app.
    #[prost(message, optional, tag = "6")]
    pub import_options: ::core::option::Option<import_app_request::ImportOptions>,
    /// Optional. Flag for overriding the app lock during import.
    /// If set to true, the import process will ignore the app lock.
    #[prost(bool, tag = "7")]
    pub ignore_app_lock: bool,
    /// The app to import.
    #[prost(oneof = "import_app_request::App", tags = "4, 5")]
    pub app: ::core::option::Option<import_app_request::App>,
}
/// Nested message and enum types in `ImportAppRequest`.
pub mod import_app_request {
    /// Configuration options for the app import process.
    /// These options control how the import behaves, particularly when
    /// conflicts arise with existing app data.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ImportOptions {
        /// Optional. The strategy to use when resolving conflicts during import.
        #[prost(enumeration = "import_options::ConflictResolutionStrategy", tag = "1")]
        pub conflict_resolution_strategy: i32,
    }
    /// Nested message and enum types in `ImportOptions`.
    pub mod import_options {
        /// Defines the strategy for handling conflicts when an app with the same ID
        /// already exists, or when imported resources (like Agents, Tools, etc.)
        /// have the same display names as existing resources within that app.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum ConflictResolutionStrategy {
            /// The conflict resolution strategy is unspecified.
            Unspecified = 0,
            /// Replace existing data with imported data.
            /// If an app with the same `app_id` already exists, its content will be
            /// updated based on the imported app.
            ///
            /// * Resources (App, Agents, Tools, Examples, Guardrails, Toolsets) in the
            ///   imported app that have the same display name as existing resources
            ///   will overwrite the existing ones.
            /// * Imported resources with new display names will be created.
            /// * Existing resources that do not have a matching display name in the
            ///   imported app will remain untouched.
            Replace = 1,
            /// Overwrite existing data with imported data.
            /// If an app with the same `app_id` already exists, its content will be
            /// overwritten with the imported app.
            ///
            /// * Existing resources (Agents, Tools, Examples, Guardrails, Toolsets) in
            ///   the app will be deleted.
            /// * Imported resources will be created as new resources.
            Overwrite = 2,
        }
        impl ConflictResolutionStrategy {
            /// 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 => "CONFLICT_RESOLUTION_STRATEGY_UNSPECIFIED",
                    Self::Replace => "REPLACE",
                    Self::Overwrite => "OVERWRITE",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "CONFLICT_RESOLUTION_STRATEGY_UNSPECIFIED" => Some(Self::Unspecified),
                    "REPLACE" => Some(Self::Replace),
                    "OVERWRITE" => Some(Self::Overwrite),
                    _ => None,
                }
            }
        }
    }
    /// The app to import.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum App {
        /// The [Google Cloud Storage](<https://cloud.google.com/storage/docs/>) URI
        /// from which to import app. The format of this URI must be
        /// `gs://<bucket-name>/<object-name>`.
        #[prost(string, tag = "4")]
        GcsUri(::prost::alloc::string::String),
        /// Raw bytes representing the compressed zip file with the app folder
        /// structure.
        #[prost(bytes, tag = "5")]
        AppContent(::prost::alloc::vec::Vec<u8>),
    }
}
/// Response message for
/// \[AgentService.ImportApp\]\[google.cloud.ces.v1beta.AgentService.ImportApp\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ImportAppResponse {
    /// The resource name of the app that was imported.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Warning messages generated during the import process.
    /// If errors occur for specific resources, they will not be included in the
    /// imported app and the error will be mentioned here.
    #[prost(string, repeated, tag = "2")]
    pub warnings: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Request message for
/// \[AgentService.ListAgents\]\[google.cloud.ces.v1beta.AgentService.ListAgents\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListAgentsRequest {
    /// Required. The resource name of the app to list agents from.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Requested page size. Server may return fewer items than
    /// requested. If unspecified, server will pick an appropriate default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. The
    /// \[next_page_token\]\[google.cloud.ces.v1beta.ListAgentsResponse.next_page_token\]
    /// value returned from a previous list
    /// \[AgentService.ListAgents\]\[google.cloud.ces.v1beta.AgentService.ListAgents\]
    /// call.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. Filter to be applied when listing the agents.
    /// See <https://google.aip.dev/160> for more details.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Optional. Field to sort by. Only "name" and "create_time" is supported.
    /// See <https://google.aip.dev/132#ordering> for more details.
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Response message for
/// \[AgentService.ListAgents\]\[google.cloud.ces.v1beta.AgentService.ListAgents\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListAgentsResponse {
    /// The list of agents.
    #[prost(message, repeated, tag = "1")]
    pub agents: ::prost::alloc::vec::Vec<Agent>,
    /// A token that can be sent as
    /// \[ListAgentsRequest.page_token\]\[google.cloud.ces.v1beta.ListAgentsRequest.page_token\]
    /// to retrieve the next page. Absence of this field indicates there are no
    /// subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for
/// \[AgentService.GetAgent\]\[google.cloud.ces.v1beta.AgentService.GetAgent\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetAgentRequest {
    /// Required. The resource name of the agent to retrieve.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// \[AgentService.CreateAgent\]\[google.cloud.ces.v1beta.AgentService.CreateAgent\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateAgentRequest {
    /// Required. The resource name of the app to create an agent in.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The ID to use for the agent, which will become the final
    /// component of the agent's resource name. If not provided, a unique ID will
    /// be automatically assigned for the agent.
    #[prost(string, tag = "2")]
    pub agent_id: ::prost::alloc::string::String,
    /// Required. The agent to create.
    #[prost(message, optional, tag = "3")]
    pub agent: ::core::option::Option<Agent>,
}
/// Request message for
/// \[AgentService.UpdateAgent\]\[google.cloud.ces.v1beta.AgentService.UpdateAgent\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateAgentRequest {
    /// Required. The agent to update.
    #[prost(message, optional, tag = "1")]
    pub agent: ::core::option::Option<Agent>,
    /// Optional. Field mask is used to control which fields get updated. If the
    /// mask is not present, all fields will be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for
/// \[AgentService.DeleteAgent\]\[google.cloud.ces.v1beta.AgentService.DeleteAgent\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteAgentRequest {
    /// Required. The resource name of the agent to delete.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. Indicates whether to forcefully delete the agent, even if it is
    /// still referenced by other app/agents/examples.
    ///
    /// * If `force = false`, the deletion fails if other agents/examples
    ///   reference it.
    /// * If `force = true`, delete the agent and remove it from all referencing
    ///   apps/agents/examples.
    #[prost(bool, tag = "2")]
    pub force: bool,
    /// Optional. The current etag of the agent. If an etag is not provided, the
    /// deletion will overwrite any concurrent changes. If an etag is provided and
    /// does not match the current etag of the agent, deletion will be blocked and
    /// an ABORTED error will be returned.
    #[prost(string, tag = "3")]
    pub etag: ::prost::alloc::string::String,
}
/// Represents the metadata of the long-running operation.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct OperationMetadata {
    /// Output only. The time the operation was created.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The time the operation finished running.
    #[prost(message, optional, tag = "2")]
    pub end_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Human-readable status of the operation, if any.
    #[prost(string, tag = "3")]
    pub status_message: ::prost::alloc::string::String,
    /// Output only. Identifies whether the user has requested cancellation of the
    /// operation. Operations that have been cancelled successfully have
    /// \[google.longrunning.Operation.error\]\[google.longrunning.Operation.error\]
    /// value with a \[google.rpc.Status.code\]\[google.rpc.Status.code\] of `1`,
    /// corresponding to `Code.CANCELLED`.
    #[prost(bool, tag = "4")]
    pub requested_cancellation: bool,
}
/// Request message for
/// \[AgentService.ListExamples\]\[google.cloud.ces.v1beta.AgentService.ListExamples\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListExamplesRequest {
    /// Required. The resource name of the app to list examples from.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Requested page size. Server may return fewer items than
    /// requested. If unspecified, server will pick an appropriate default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. The
    /// \[next_page_token\]\[google.cloud.ces.v1beta.ListExamplesResponse.next_page_token\]
    /// value returned from a previous list
    /// \[AgentService.ListExamples\]\[google.cloud.ces.v1beta.AgentService.ListExamples\]
    /// call.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. Filter to be applied when listing the examples.
    /// See <https://google.aip.dev/160> for more details.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Optional. Field to sort by. Only "name" and "create_time" is supported.
    /// See <https://google.aip.dev/132#ordering> for more details.
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Response message for
/// \[AgentService.ListExamples\]\[google.cloud.ces.v1beta.AgentService.ListExamples\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListExamplesResponse {
    /// The list of examples.
    #[prost(message, repeated, tag = "1")]
    pub examples: ::prost::alloc::vec::Vec<Example>,
    /// A token that can be sent as
    /// \[ListExamplesRequest.page_token\]\[google.cloud.ces.v1beta.ListExamplesRequest.page_token\]
    /// to retrieve the next page. Absence of this field indicates there are no
    /// subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for
/// \[AgentService.GetExample\]\[google.cloud.ces.v1beta.AgentService.GetExample\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetExampleRequest {
    /// Required. The resource name of the example to retrieve.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// \[AgentService.CreateExample\]\[google.cloud.ces.v1beta.AgentService.CreateExample\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateExampleRequest {
    /// Required. The resource name of the app to create an example in.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The ID to use for the example, which will become the final
    /// component of the example's resource name. If not provided, a unique ID will
    /// be automatically assigned for the example.
    #[prost(string, tag = "2")]
    pub example_id: ::prost::alloc::string::String,
    /// Required. The example to create.
    #[prost(message, optional, tag = "3")]
    pub example: ::core::option::Option<Example>,
}
/// Request message for
/// \[AgentService.UpdateExample\]\[google.cloud.ces.v1beta.AgentService.UpdateExample\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateExampleRequest {
    /// Required. The example to update.
    #[prost(message, optional, tag = "1")]
    pub example: ::core::option::Option<Example>,
    /// Optional. Field mask is used to control which fields get updated. If the
    /// mask is not present, all fields will be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for
/// \[AgentService.DeleteExample\]\[google.cloud.ces.v1beta.AgentService.DeleteExample\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteExampleRequest {
    /// Required. The resource name of the example to delete.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The current etag of the example. If an etag is not provided, the
    /// deletion will overwrite any concurrent changes. If an etag is provided and
    /// does not match the current etag of the example, deletion will be blocked
    /// and an ABORTED error will be returned.
    #[prost(string, tag = "2")]
    pub etag: ::prost::alloc::string::String,
}
/// Request message for
/// \[AgentService.ListTools\]\[google.cloud.ces.v1beta.AgentService.ListTools\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListToolsRequest {
    /// Required. The resource name of the app to list tools from.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Requested page size. Server may return fewer items than
    /// requested. If unspecified, server will pick an appropriate default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. The
    /// \[next_page_token\]\[google.cloud.ces.v1beta.ListToolsResponse.next_page_token\]
    /// value returned from a previous list
    /// \[AgentService.ListTools\]\[google.cloud.ces.v1beta.AgentService.ListTools\]
    /// call.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. Filter to be applied when listing the tools. Use
    /// "include_system_tools=true" to include system tools in the response. See
    /// <https://google.aip.dev/160> for more details.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Optional. Field to sort by. Only "name" and "create_time" is supported.
    /// See <https://google.aip.dev/132#ordering> for more details.
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Response message for
/// \[AgentService.ListTools\]\[google.cloud.ces.v1beta.AgentService.ListTools\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListToolsResponse {
    /// The list of tools.
    #[prost(message, repeated, tag = "1")]
    pub tools: ::prost::alloc::vec::Vec<Tool>,
    /// A token that can be sent as
    /// \[ListToolsRequest.page_token\]\[google.cloud.ces.v1beta.ListToolsRequest.page_token\]
    /// to retrieve the next page. Absence of this field indicates there are no
    /// subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for
/// \[AgentService.GetTool\]\[google.cloud.ces.v1beta.AgentService.GetTool\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetToolRequest {
    /// Required. The resource name of the tool to retrieve.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// \[AgentService.CreateTool\]\[google.cloud.ces.v1beta.AgentService.CreateTool\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateToolRequest {
    /// Required. The resource name of the app to create a tool in.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The ID to use for the tool, which will become the final component
    /// of the tool's resource name. If not provided, a unique ID will be
    /// automatically assigned for the tool.
    #[prost(string, tag = "2")]
    pub tool_id: ::prost::alloc::string::String,
    /// Required. The tool to create.
    #[prost(message, optional, tag = "3")]
    pub tool: ::core::option::Option<Tool>,
}
/// Request message for
/// \[AgentService.UpdateTool\]\[google.cloud.ces.v1beta.AgentService.UpdateTool\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateToolRequest {
    /// Required. The tool to update.
    #[prost(message, optional, tag = "1")]
    pub tool: ::core::option::Option<Tool>,
    /// Optional. Field mask is used to control which fields get updated. If the
    /// mask is not present, all fields will be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for
/// \[AgentService.DeleteTool\]\[google.cloud.ces.v1beta.AgentService.DeleteTool\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteToolRequest {
    /// Required. The resource name of the tool to delete.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. Indicates whether to forcefully delete the tool, even if it is
    /// still referenced by agents/examples.
    ///
    /// * If `force = false`, the deletion will fail if any agents still
    ///   reference the tool.
    /// * If `force = true`, all existing references from agents will be removed
    ///   and the tool will be deleted.
    #[prost(bool, tag = "2")]
    pub force: bool,
    /// Optional. The current etag of the tool. If an etag is not provided, the
    /// deletion will overwrite any concurrent changes. If an etag is provided and
    /// does not match the current etag of the tool, deletion will be blocked and
    /// an ABORTED error will be returned.
    #[prost(string, tag = "3")]
    pub etag: ::prost::alloc::string::String,
}
/// Request message for
/// \[AgentService.ListConversations\]\[google.cloud.ces.v1beta.AgentService.ListConversations\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListConversationsRequest {
    /// Required. The resource name of the app to list conversations from.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Requested page size. Server may return fewer items than
    /// requested. If unspecified, server will pick an appropriate default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. The
    /// \[next_page_token\]\[google.cloud.ces.v1beta.ListConversationsResponse.next_page_token\]
    /// value returned from a previous list
    /// \[AgentService.ListConversations\]\[google.cloud.ces.v1beta.AgentService.ListConversations\]
    /// call.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. Filter to be applied when listing the conversations.
    /// See <https://google.aip.dev/160> for more details.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Optional. Indicate the source of the conversation. If not set, Source.Live
    /// will be applied by default. Will be deprecated in favor of `sources` field.
    #[prost(enumeration = "conversation::Source", tag = "5")]
    pub source: i32,
    /// Optional. Indicate the sources of the conversations. If not set, all
    /// available sources will be applied by default.
    #[prost(enumeration = "conversation::Source", repeated, packed = "false", tag = "6")]
    pub sources: ::prost::alloc::vec::Vec<i32>,
}
/// Response message for
/// \[AgentService.ListConversations\]\[google.cloud.ces.v1beta.AgentService.ListConversations\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListConversationsResponse {
    /// The list of conversations.
    #[prost(message, repeated, tag = "1")]
    pub conversations: ::prost::alloc::vec::Vec<Conversation>,
    /// A token that can be sent as
    /// \[ListConversationsRequest.page_token\]\[google.cloud.ces.v1beta.ListConversationsRequest.page_token\]
    /// to retrieve the next page. Absence of this field indicates there are no
    /// subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for
/// \[AgentService.GetConversation\]\[google.cloud.ces.v1beta.AgentService.GetConversation\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetConversationRequest {
    /// Required. The resource name of the conversation to retrieve.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. Indicate the source of the conversation. If not set, all source
    /// will be searched.
    #[deprecated]
    #[prost(enumeration = "conversation::Source", tag = "2")]
    pub source: i32,
}
/// Request message for
/// \[AgentService.DeleteConversation\]\[google.cloud.ces.v1beta.AgentService.DeleteConversation\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteConversationRequest {
    /// Required. The resource name of the conversation to delete.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. Indicate the source of the conversation. If not set, Source.Live
    /// will be applied by default.
    #[deprecated]
    #[prost(enumeration = "conversation::Source", tag = "2")]
    pub source: i32,
}
/// Request message for
/// \[AgentService.BatchDeleteConversations\]\[google.cloud.ces.v1beta.AgentService.BatchDeleteConversations\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BatchDeleteConversationsRequest {
    /// Required. The resource name of the app to delete conversations from.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The resource names of the conversations to delete.
    #[prost(string, repeated, tag = "2")]
    pub conversations: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Response message for
/// \[AgentService.BatchDeleteConversations\]\[google.cloud.ces.v1beta.AgentService.BatchDeleteConversations\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BatchDeleteConversationsResponse {
    /// The list of conversations that were successfully deleted.
    #[prost(string, repeated, tag = "1")]
    pub deleted_conversations: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// The list of conversations that failed to be deleted.
    #[prost(string, repeated, tag = "2")]
    pub failed_conversations: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. A list of error messages associated with conversations that
    /// failed to be deleted.
    #[prost(string, repeated, tag = "3")]
    pub error_messages: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Request message for
/// \[AgentService.ListGuardrails\]\[google.cloud.ces.v1beta.AgentService.ListGuardrails\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListGuardrailsRequest {
    /// Required. The resource name of the app to list guardrails from.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Requested page size. Server may return fewer items than
    /// requested. If unspecified, server will pick an appropriate default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. The
    /// \[next_page_token\]\[google.cloud.ces.v1beta.ListGuardrailsResponse.next_page_token\]
    /// value returned from a previous list
    /// \[AgentService.ListGuardrails\]\[google.cloud.ces.v1beta.AgentService.ListGuardrails\]
    /// call.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. Filter to be applied when listing the guardrails.
    /// See <https://google.aip.dev/160> for more details.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Optional. Field to sort by. Only "name" and "create_time" is supported.
    /// See <https://google.aip.dev/132#ordering> for more details.
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Response message for
/// \[AgentService.ListGuardrails\]\[google.cloud.ces.v1beta.AgentService.ListGuardrails\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListGuardrailsResponse {
    /// The list of guardrails.
    #[prost(message, repeated, tag = "1")]
    pub guardrails: ::prost::alloc::vec::Vec<Guardrail>,
    /// A token that can be sent as
    /// \[ListGuardrailsRequest.page_token\]\[google.cloud.ces.v1beta.ListGuardrailsRequest.page_token\]
    /// to retrieve the next page. Absence of this field indicates there are no
    /// subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for
/// \[AgentService.GetGuardrail\]\[google.cloud.ces.v1beta.AgentService.GetGuardrail\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetGuardrailRequest {
    /// Required. The resource name of the guardrail to retrieve.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// \[AgentService.CreateGuardrail\]\[google.cloud.ces.v1beta.AgentService.CreateGuardrail\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateGuardrailRequest {
    /// Required. The resource name of the app to create a guardrail in.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The ID to use for the guardrail, which will become the final
    /// component of the guardrail's resource name. If not provided, a unique ID
    /// will be automatically assigned for the guardrail.
    #[prost(string, tag = "2")]
    pub guardrail_id: ::prost::alloc::string::String,
    /// Required. The guardrail to create.
    #[prost(message, optional, tag = "3")]
    pub guardrail: ::core::option::Option<Guardrail>,
}
/// Request message for
/// \[AgentService.UpdateGuardrail\]\[google.cloud.ces.v1beta.AgentService.UpdateGuardrail\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateGuardrailRequest {
    /// Required. The guardrail to update.
    #[prost(message, optional, tag = "1")]
    pub guardrail: ::core::option::Option<Guardrail>,
    /// Optional. Field mask is used to control which fields get updated. If the
    /// mask is not present, all fields will be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for
/// \[AgentService.DeleteGuardrail\]\[google.cloud.ces.v1beta.AgentService.DeleteGuardrail\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteGuardrailRequest {
    /// Required. The resource name of the guardrail to delete.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. Indicates whether to forcefully delete the guardrail, even if it
    /// is still referenced by app/agents.
    ///
    /// * If `force = false`, the deletion fails if any apps/agents still
    ///   reference the guardrail.
    /// * If `force = true`, all existing references from apps/agents will be
    ///   removed and the guardrail will be deleted.
    #[prost(bool, tag = "2")]
    pub force: bool,
    /// Optional. The current etag of the guardrail. If an etag is not provided,
    /// the deletion will overwrite any concurrent changes. If an etag is provided
    /// and does not match the current etag of the guardrail, deletion will be
    /// blocked and an ABORTED error will be returned.
    #[prost(string, tag = "3")]
    pub etag: ::prost::alloc::string::String,
}
/// Request message for
/// \[AgentService.ListDeployments\]\[google.cloud.ces.v1beta.AgentService.ListDeployments\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListDeploymentsRequest {
    /// Required. The parent app.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The maximum number of deployments to return. The service may
    /// return fewer than this value. If unspecified, at most 50 deployments will
    /// be returned. The maximum value is 1000; values above 1000 will be coerced
    /// to 1000.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. A page token, received from a previous `ListDeployments` call.
    /// Provide this to retrieve the subsequent page.
    ///
    /// When paginating, all other parameters provided to `ListDeployments` must
    /// match the call that provided the page token.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. Field to sort by. Only "name" and "create_time" is supported.
    /// See <https://google.aip.dev/132#ordering> for more details.
    #[prost(string, tag = "4")]
    pub order_by: ::prost::alloc::string::String,
}
/// Response message for
/// \[AgentService.ListDeployments\]\[google.cloud.ces.v1beta.AgentService.ListDeployments\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListDeploymentsResponse {
    /// The list of deployments.
    #[prost(message, repeated, tag = "1")]
    pub deployments: ::prost::alloc::vec::Vec<Deployment>,
    /// A token, which can be sent as `page_token` to retrieve the next page.
    /// If this field is omitted, there are no subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for
/// \[AgentService.GetDeployment\]\[google.cloud.ces.v1beta.AgentService.GetDeployment\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetDeploymentRequest {
    /// Required. The name of the deployment.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/deployments/{deployment}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// \[AgentService.CreateDeployment\]\[google.cloud.ces.v1beta.AgentService.CreateDeployment\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateDeploymentRequest {
    /// Required. The parent app.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The ID to use for the deployment, which will become the final
    /// component of the deployment's resource name. If not provided, a unique ID
    /// will be automatically assigned for the deployment.
    #[prost(string, tag = "3")]
    pub deployment_id: ::prost::alloc::string::String,
    /// Required. The deployment to create.
    #[prost(message, optional, tag = "2")]
    pub deployment: ::core::option::Option<Deployment>,
}
/// Request message for
/// \[AgentService.UpdateDeployment\]\[google.cloud.ces.v1beta.AgentService.UpdateDeployment\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateDeploymentRequest {
    /// Required. The deployment to update.
    #[prost(message, optional, tag = "1")]
    pub deployment: ::core::option::Option<Deployment>,
    /// Optional. The list of fields to update.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for
/// \[AgentService.DeleteDeployment\]\[google.cloud.ces.v1beta.AgentService.DeleteDeployment\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteDeploymentRequest {
    /// Required. The name of the deployment to delete.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/deployments/{deployment}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The etag of the deployment.
    /// If an etag is provided and does not match the current etag of the
    /// deployment, deletion will be blocked and an ABORTED error will be returned.
    #[prost(string, tag = "2")]
    pub etag: ::prost::alloc::string::String,
}
/// Request message for
/// \[AgentService.ListToolsets\]\[google.cloud.ces.v1beta.AgentService.ListToolsets\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListToolsetsRequest {
    /// Required. The resource name of the app to list toolsets from.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Requested page size. Server may return fewer items than
    /// requested. If unspecified, server will pick an appropriate default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. The
    /// \[next_page_token\]\[google.cloud.ces.v1beta.ListToolsetsResponse.next_page_token\]
    /// value returned from a previous list
    /// \[AgentService.ListToolsets\]\[google.cloud.ces.v1beta.AgentService.ListToolsets\]
    /// call.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. Filter to be applied when listing the toolsets.
    /// See <https://google.aip.dev/160> for more details.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Optional. Field to sort by. Only "name" and "create_time" is supported.
    /// See <https://google.aip.dev/132#ordering> for more details.
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Response message for
/// \[AgentService.ListToolsets\]\[google.cloud.ces.v1beta.AgentService.ListToolsets\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListToolsetsResponse {
    /// The list of toolsets.
    #[prost(message, repeated, tag = "1")]
    pub toolsets: ::prost::alloc::vec::Vec<Toolset>,
    /// A token that can be sent as
    /// \[ListToolsetsRequest.page_token\]\[google.cloud.ces.v1beta.ListToolsetsRequest.page_token\]
    /// to retrieve the next page. Absence of this field indicates there are no
    /// subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for
/// \[AgentService.GetToolset\]\[google.cloud.ces.v1beta.AgentService.GetToolset\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetToolsetRequest {
    /// Required. The resource name of the toolset to retrieve.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// \[AgentService.CreateToolset\]\[google.cloud.ces.v1beta.AgentService.CreateToolset\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateToolsetRequest {
    /// Required. The resource name of the app to create a toolset in.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The ID to use for the toolset, which will become the final
    /// component of the toolset's resource name. If not provided, a unique ID will
    /// be automatically assigned for the toolset.
    #[prost(string, tag = "2")]
    pub toolset_id: ::prost::alloc::string::String,
    /// Required. The toolset to create.
    #[prost(message, optional, tag = "3")]
    pub toolset: ::core::option::Option<Toolset>,
}
/// Request message for
/// \[AgentService.UpdateToolset\]\[google.cloud.ces.v1beta.AgentService.UpdateToolset\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateToolsetRequest {
    /// Required. The toolset to update.
    #[prost(message, optional, tag = "1")]
    pub toolset: ::core::option::Option<Toolset>,
    /// Optional. Field mask is used to control which fields get updated. If the
    /// mask is not present, all fields will be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for
/// \[AgentService.DeleteToolset\]\[google.cloud.ces.v1beta.AgentService.DeleteToolset\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteToolsetRequest {
    /// Required. The resource name of the toolset to delete.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. Indicates whether to forcefully delete the toolset, even if it is
    /// still referenced by app/agents.
    ///
    /// * If `force = false`, the deletion fails if any agents still
    ///   reference the toolset.
    /// * If `force = true`, all existing references from agents will be
    ///   removed and the toolset will be deleted.
    #[prost(bool, tag = "2")]
    pub force: bool,
    /// Optional. The current etag of the toolset. If an etag is not provided, the
    /// deletion will overwrite any concurrent changes. If an etag is provided and
    /// does not match the current etag of the toolset, deletion will be blocked
    /// and an ABORTED error will be returned.
    #[prost(string, tag = "3")]
    pub etag: ::prost::alloc::string::String,
}
/// Request message for
/// \[AgentService.ListAppVersions\]\[google.cloud.ces.v1beta.AgentService.ListAppVersions\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListAppVersionsRequest {
    /// Required. The resource name of the app to list app versions from.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Requested page size. Server may return fewer items than
    /// requested. If unspecified, server will pick an appropriate default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. The
    /// \[next_page_token\]\[google.cloud.ces.v1beta.ListAppVersionsResponse.next_page_token\]
    /// value returned from a previous list
    /// \[AgentService.ListAppVersions\]\[google.cloud.ces.v1beta.AgentService.ListAppVersions\]
    /// call.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. Filter to be applied when listing the app versions.
    /// See <https://google.aip.dev/160> for more details.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Optional. Field to sort by. Only "name" and "create_time" is supported.
    /// See <https://google.aip.dev/132#ordering> for more details.
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Response message for
/// \[AgentService.ListAppVersions\]\[google.cloud.ces.v1beta.AgentService.ListAppVersions\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListAppVersionsResponse {
    /// The list of app versions.
    #[prost(message, repeated, tag = "1")]
    pub app_versions: ::prost::alloc::vec::Vec<AppVersion>,
    /// A token that can be sent as
    /// \[ListAppVersionsRequest.page_token\]\[google.cloud.ces.v1beta.ListAppVersionsRequest.page_token\]
    /// to retrieve the next page. Absence of this field indicates there are no
    /// subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for
/// \[AgentService.GetAppVersion\]\[google.cloud.ces.v1beta.AgentService.GetAppVersion\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetAppVersionRequest {
    /// Required. The resource name of the app version to retrieve.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// \[AgentService.DeleteAppVersion\]\[google.cloud.ces.v1beta.AgentService.DeleteAppVersion\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteAppVersionRequest {
    /// Required. The resource name of the app version to delete.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The current etag of the app version. If an etag is not provided,
    /// the deletion will overwrite any concurrent changes. If an etag is provided
    /// and does not match the current etag of the app version, deletion will be
    /// blocked and an ABORTED error will be returned.
    #[prost(string, tag = "2")]
    pub etag: ::prost::alloc::string::String,
}
/// Request message for
/// \[AgentService.CreateAppVersion\]\[google.cloud.ces.v1beta.AgentService.CreateAppVersion\]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateAppVersionRequest {
    /// Required. The resource name of the app to create an app version in.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The ID to use for the app version, which will become the final
    /// component of the app version's resource name. If not provided, a unique ID
    /// will be automatically assigned for the app version.
    #[prost(string, tag = "2")]
    pub app_version_id: ::prost::alloc::string::String,
    /// Required. The app version to create.
    #[prost(message, optional, tag = "3")]
    pub app_version: ::core::option::Option<AppVersion>,
}
/// Request message for
/// \[AgentService.RestoreAppVersion\]\[google.cloud.ces.v1beta.AgentService.RestoreAppVersion\]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RestoreAppVersionRequest {
    /// Required. The resource name of the app version to restore.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Response message for
/// \[AgentService.RestoreAppVersion\]\[google.cloud.ces.v1beta.AgentService.RestoreAppVersion\]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RestoreAppVersionResponse {}
/// Request message for
/// \[AgentService.GenerateAppResource\]\[google.cloud.ces.v1beta.AgentService.GenerateAppResource\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GenerateAppResourceRequest {
    /// Required. The resource name of the app to generate the resource for.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. List of refine instructions to be used to refine the resource.
    #[prost(message, repeated, tag = "3")]
    pub refine_instructions: ::prost::alloc::vec::Vec<
        generate_app_resource_request::RefineInstructions,
    >,
    /// Optional. The configuration to be used to generate the tool.
    #[prost(message, optional, tag = "5")]
    pub tool_generation_config: ::core::option::Option<
        generate_app_resource_request::ToolGenerationConfig,
    >,
    /// Optional. The configuration to be used to generate the agents and tools.
    #[prost(message, optional, tag = "7")]
    pub app_generation_config: ::core::option::Option<
        generate_app_resource_request::AppGenerationConfig,
    >,
    /// Optional. The configuration to be used to generate the evaluations.
    #[prost(message, optional, tag = "8")]
    pub evaluation_generation_config: ::core::option::Option<
        generate_app_resource_request::EvaluationGenerationConfig,
    >,
    /// Optional. The configuration to be used to generate the evaluation personas.
    #[prost(message, optional, tag = "9")]
    pub evaluation_personas_generation_config: ::core::option::Option<
        generate_app_resource_request::EvaluationPersonasGenerationConfig,
    >,
    /// Optional. The configuration to be used for quality report generation.
    #[prost(message, optional, tag = "10")]
    pub quality_report_generation_config: ::core::option::Option<
        generate_app_resource_request::QualityReportGenerationConfig,
    >,
    /// Optional. The configuration to be used for hill climbing fixes.
    #[prost(message, optional, tag = "11")]
    pub hill_climbing_fix_config: ::core::option::Option<
        generate_app_resource_request::HillClimbingFixConfig,
    >,
    /// The resource to generate.
    #[prost(oneof = "generate_app_resource_request::Resource", tags = "2, 4, 6")]
    pub resource: ::core::option::Option<generate_app_resource_request::Resource>,
}
/// Nested message and enum types in `GenerateAppResourceRequest`.
pub mod generate_app_resource_request {
    /// The instructions to be used to refine a part of the resource. The part of
    /// the resource can be specified  with a start index, end index and a field
    /// mask. For example, if you want to refine a part of the agent instructions
    /// you can specify the index of the first character of the instructions, the
    /// index of the last character of the instructions and the field mask as
    /// "instructions".
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct RefineInstructions {
        /// Required. The first character (inclusive) of the text to refine.
        #[prost(int64, tag = "1")]
        pub start_index: i64,
        /// Required. The last character (inclusive) of the text to refine.
        #[prost(int64, tag = "2")]
        pub end_index: i64,
        /// Required. The field of the resource being refined. Only one field is
        /// allowed per RefineInstructions. If refining agent instructions, the field
        /// mask should be "instructions".
        #[prost(message, optional, tag = "3")]
        pub field_mask: ::core::option::Option<::prost_types::FieldMask>,
        /// Required. The instructions to refine the resource.
        #[prost(string, tag = "4")]
        pub instructions: ::prost::alloc::string::String,
    }
    /// The configuration to be used to generate a tool.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ToolGenerationConfig {
        /// Optional. The context which describes the tool to be generated. This can
        /// be empty if the tool request & response are provided.
        #[prost(string, tag = "1")]
        pub context: ::prost::alloc::string::String,
        /// Optional. The files to be used as context.
        #[prost(message, repeated, tag = "3")]
        pub file_contexts: ::prost::alloc::vec::Vec<super::FileContext>,
        /// Optional. The configuration to be used to generate an Open API schema.
        #[prost(message, optional, tag = "2")]
        pub open_api_toolset_generation_config: ::core::option::Option<
            tool_generation_config::OpenApiToolsetGenerationConfig,
        >,
    }
    /// Nested message and enum types in `ToolGenerationConfig`.
    pub mod tool_generation_config {
        /// The configuration to be used to generate an Open API schema.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct OpenApiToolsetGenerationConfig {
            /// Required. The base uri of the tool.
            #[prost(string, tag = "1")]
            pub uri: ::prost::alloc::string::String,
            /// Required. The list of operations to be added to the Open API schema.
            #[prost(message, repeated, tag = "2")]
            pub operation_generation_configs: ::prost::alloc::vec::Vec<
                open_api_toolset_generation_config::OperationGenerationConfig,
            >,
        }
        /// Nested message and enum types in `OpenApiToolsetGenerationConfig`.
        pub mod open_api_toolset_generation_config {
            /// The configuration to be used to generate an operation in the Open API
            /// schema.
            #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
            pub struct OperationGenerationConfig {
                /// Required. The uri of the tool. This should include query and path
                /// parameters if any.
                #[prost(string, tag = "1")]
                pub method: ::prost::alloc::string::String,
                /// Required. The path of the tool to be appended to the base uri. This
                /// should include query and path parameters if any.
                #[prost(string, tag = "2")]
                pub path: ::prost::alloc::string::String,
                /// Required. A sample request to the tool in JSON format. Skip if the
                /// tool does not support request body.
                #[prost(string, tag = "3")]
                pub request_json: ::prost::alloc::string::String,
                /// Required. A sample response from the tool in JSON format.
                #[prost(string, tag = "4")]
                pub response_json: ::prost::alloc::string::String,
            }
        }
    }
    /// The configuration to be used to generate the app.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct AppGenerationConfig {
        /// Optional. The context which describes the requirements of the agents &
        /// tools to be generated.
        #[prost(string, tag = "1")]
        pub context: ::prost::alloc::string::String,
        /// Optional. The files to be used as context.
        #[prost(message, repeated, tag = "2")]
        pub file_contexts: ::prost::alloc::vec::Vec<super::FileContext>,
        /// Optional. The insights dataset to be used to fetch conversation data for
        /// generating the agents & tools.
        /// Format:
        /// `projects/{project}/locations/{location}/datasets/{dataset}`.
        #[prost(string, tag = "3")]
        pub dataset_id: ::prost::alloc::string::String,
        /// Optional. Whether to generate the evaluations for the app. If true, the
        /// provided context will be used to generate the evaluations data.
        #[prost(bool, tag = "4")]
        pub generate_evaluations: bool,
        /// Optional. The Cloud Storage location to store the generated question
        /// answer data to be used by the Datastore tool. This data is generated only
        /// when using conversation data as an input source. The location must be
        /// in the same project as the app.
        /// Format: `gs://...`.
        #[prost(string, tag = "5")]
        pub gcs_location: ::prost::alloc::string::String,
    }
    /// The configuration to be used to generate the evaluations.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct EvaluationGenerationConfig {
        /// Optional. The insights dataset to be used to fetch conversation data for
        /// generating the evaluations.
        /// Format:
        /// `projects/{project}/locations/{location}/datasets/{dataset}`.
        #[prost(string, tag = "1")]
        pub dataset_id: ::prost::alloc::string::String,
    }
    /// The configuration to be used to generate the evaluation personas.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct EvaluationPersonasGenerationConfig {}
    /// The configuration to be used for quality report generation.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct QualityReportGenerationConfig {
        /// Required. The evaluation run used to inform quality report analysis.
        #[prost(string, tag = "1")]
        pub evaluation_run: ::prost::alloc::string::String,
    }
    /// The configuration to be used for hill climbing fixes.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct HillClimbingFixConfig {
        /// Required. The quality report used to inform the instruction following
        /// fix.
        #[prost(message, optional, tag = "1")]
        pub quality_report: ::core::option::Option<super::QualityReport>,
    }
    /// The resource to generate.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Resource {
        /// The agent resource to be used by the LLM assistant, can be empty for
        /// generating a new agent.
        #[prost(message, tag = "2")]
        Agent(super::Agent),
        /// The tool resource to be used by the LLM assistant, can be empty for
        /// generating a new tool.
        #[prost(message, tag = "4")]
        Tool(super::Tool),
        /// The toolset resource to be used by the LLM assistant, can be empty for
        /// generating a new toolset.
        #[prost(message, tag = "6")]
        Toolset(super::Toolset),
    }
}
/// Response message for
/// \[AgentService.GenerateAppResource\]\[google.cloud.ces.v1beta.AgentService.GenerateAppResource\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GenerateAppResourceResponse {
    /// Additional information about the generated result.
    #[prost(message, optional, tag = "2")]
    pub generate_result_info: ::core::option::Option<
        generate_app_resource_response::GenerateResultInfo,
    >,
    /// The generated resource.
    #[prost(
        oneof = "generate_app_resource_response::GeneratedResource",
        tags = "1, 3, 4, 5, 6, 7, 8"
    )]
    pub generated_resource: ::core::option::Option<
        generate_app_resource_response::GeneratedResource,
    >,
}
/// Nested message and enum types in `GenerateAppResourceResponse`.
pub mod generate_app_resource_response {
    /// The list of evaluations generated by the LLM assistant.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Evaluations {
        /// The list of generated evaluations.
        #[prost(message, repeated, tag = "1")]
        pub evaluations: ::prost::alloc::vec::Vec<super::Evaluation>,
    }
    /// The list of tools generated by the LLM assistant.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Tools {
        /// The list of tools generated by the LLM assistant.
        #[prost(message, repeated, tag = "1")]
        pub tools: ::prost::alloc::vec::Vec<super::Tool>,
    }
    /// The list of app resources generated by the LLM assistant.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct AppResources {
        /// The app snapshot generated by the LLM assistant. This snapshot contains
        /// the app, agents & tools generated by the LLM assistant.
        #[prost(message, optional, tag = "1")]
        pub app_snapshot: ::core::option::Option<super::AppSnapshot>,
        /// The list of evaluations generated by the LLM assistant.
        #[prost(message, repeated, tag = "2")]
        pub evaluations: ::prost::alloc::vec::Vec<super::Evaluation>,
    }
    /// This provides additional information about the generated result.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct GenerateResultInfo {
        /// An explanation of the changes in the generated resource.
        #[prost(string, tag = "1")]
        pub explanation: ::prost::alloc::string::String,
    }
    /// The generated resource.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum GeneratedResource {
        /// Agent generated by the LLM assistant.
        #[prost(message, tag = "1")]
        Agent(super::Agent),
        /// Toolset generated by the LLM assistant. Supports Open API toolset schema
        /// generation.
        #[prost(message, tag = "3")]
        Toolset(super::Toolset),
        /// App snapshot generated by the LLM assistant. This snapshot contains the
        /// app, agents & tools generated by the LLM assistant.
        #[prost(message, tag = "4")]
        AppSnapshot(super::AppSnapshot),
        /// The list of tools generated by the LLM assistant.
        #[prost(message, tag = "5")]
        Tools(Tools),
        /// Evaluations generated by the LLM assistant.
        #[prost(message, tag = "6")]
        Evaluations(Evaluations),
        /// The app resources generated by the LLM assistant.
        #[prost(message, tag = "7")]
        AppResources(AppResources),
        /// The quality report generated by the LLM assistant.
        #[prost(message, tag = "8")]
        QualityReport(super::QualityReport),
    }
}
/// The report describing any identified quality issues in the app.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QualityReport {
    /// Optional. The issues grouped by agent.
    #[prost(message, repeated, tag = "1")]
    pub issues: ::prost::alloc::vec::Vec<quality_report::AgentIssues>,
    /// Optional. A list of evaluation runs used to generate the quality report.
    /// Format:
    /// `projects/{project}/locations/{location}/evaluationRuns/{evaluationRun}`.
    #[prost(string, repeated, tag = "2")]
    pub evaluation_runs: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. General issues not specific to any agent.
    #[prost(message, repeated, tag = "3")]
    pub general_issues: ::prost::alloc::vec::Vec<quality_report::Issue>,
}
/// Nested message and enum types in `QualityReport`.
pub mod quality_report {
    /// The issue identified.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Issue {
        /// Optional. Description of the issue found.
        #[prost(string, tag = "1")]
        pub description: ::prost::alloc::string::String,
        /// Optional. How many times this issue occurred.
        #[prost(int32, tag = "2")]
        pub occurrence_count: i32,
        /// Optional. Proposed solution to fix the issue by modifying instructions or
        /// tools.
        #[prost(string, tag = "3")]
        pub proposed_solution: ::prost::alloc::string::String,
    }
    /// Issues identified for a single agent.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct AgentIssues {
        /// Optional. The name of the agent to which the issues are related.
        /// Format:
        /// `projects/{project}/locations/{location}/apps/{app}/agents/{agent}`
        #[prost(string, tag = "1")]
        pub agent: ::prost::alloc::string::String,
        /// Optional. List of issues found for this agent.
        #[prost(message, repeated, tag = "2")]
        pub issues: ::prost::alloc::vec::Vec<Issue>,
    }
}
/// Operation metadata for
/// \[AgentService.GenerateAppResource\]\[google.cloud.ces.v1beta.AgentService.GenerateAppResource\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GenerateAppResourceOperationMetadata {
    /// Output only. The type of the operation.
    #[prost(
        enumeration = "generate_app_resource_operation_metadata::GenerationType",
        tag = "1"
    )]
    pub generation_type: i32,
    /// Output only. Human-readable status of the operation, if any.
    #[prost(string, tag = "2")]
    pub message: ::prost::alloc::string::String,
    /// Output only. The time the operation was created.
    #[prost(message, optional, tag = "3")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The time the operation finished running.
    #[prost(message, optional, tag = "4")]
    pub end_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The resource name of the app that the operation is associated
    /// with. Format: `projects/{project}/locations/{location}/apps/{app}`.
    #[prost(string, tag = "5")]
    pub target: ::prost::alloc::string::String,
    /// Output only. Error messages from the resource generation process.
    #[prost(message, repeated, tag = "6")]
    pub partial_errors: ::prost::alloc::vec::Vec<super::super::super::rpc::Status>,
}
/// Nested message and enum types in `GenerateAppResourceOperationMetadata`.
pub mod generate_app_resource_operation_metadata {
    /// The type of the generation operation.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum GenerationType {
        /// Unspecified operation type.
        Unspecified = 0,
        /// Agent instruction restructure type.
        AgentRestructure = 1,
        /// Agent instruction refinement type.
        AgentRefine = 2,
        /// Agent creation from type.
        AgentCreate = 3,
        /// Tool creation type.
        ToolCreate = 4,
        /// Scenario creation type.
        ScenarioCreate = 5,
        /// Scenario creation from transcripts type.
        ScenarioCreateFromTranscripts = 7,
        /// Evaluation persona generation type.
        EvaluationPersonaCreate = 6,
        /// Quality report generation type.
        QualityReportCreate = 8,
        /// Instruction following fix type (used for hill climbing fixes).
        InstructionFollowingFix = 9,
    }
    impl GenerationType {
        /// 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 => "GENERATION_TYPE_UNSPECIFIED",
                Self::AgentRestructure => "AGENT_RESTRUCTURE",
                Self::AgentRefine => "AGENT_REFINE",
                Self::AgentCreate => "AGENT_CREATE",
                Self::ToolCreate => "TOOL_CREATE",
                Self::ScenarioCreate => "SCENARIO_CREATE",
                Self::ScenarioCreateFromTranscripts => "SCENARIO_CREATE_FROM_TRANSCRIPTS",
                Self::EvaluationPersonaCreate => "EVALUATION_PERSONA_CREATE",
                Self::QualityReportCreate => "QUALITY_REPORT_CREATE",
                Self::InstructionFollowingFix => "INSTRUCTION_FOLLOWING_FIX",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "GENERATION_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "AGENT_RESTRUCTURE" => Some(Self::AgentRestructure),
                "AGENT_REFINE" => Some(Self::AgentRefine),
                "AGENT_CREATE" => Some(Self::AgentCreate),
                "TOOL_CREATE" => Some(Self::ToolCreate),
                "SCENARIO_CREATE" => Some(Self::ScenarioCreate),
                "SCENARIO_CREATE_FROM_TRANSCRIPTS" => {
                    Some(Self::ScenarioCreateFromTranscripts)
                }
                "EVALUATION_PERSONA_CREATE" => Some(Self::EvaluationPersonaCreate),
                "QUALITY_REPORT_CREATE" => Some(Self::QualityReportCreate),
                "INSTRUCTION_FOLLOWING_FIX" => Some(Self::InstructionFollowingFix),
                _ => None,
            }
        }
    }
}
/// Request message for
/// \[AgentService.ListChangelogs\]\[google.cloud.ces.v1beta.AgentService.ListChangelogs\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListChangelogsRequest {
    /// Required. The resource name of the app to list changelogs from.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Requested page size. Server may return fewer items than
    /// requested. If unspecified, server will pick an appropriate default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. The
    /// \[next_page_token\]\[google.cloud.ces.v1beta.ListChangelogsResponse.next_page_token\]
    /// value returned from a previous list
    /// \[AgentService.ListChangelogs\]\[google.cloud.ces.v1beta.AgentService.ListChangelogs\]
    /// call.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. Filter to be applied when listing the changelogs.
    /// See <https://google.aip.dev/160> for more details.
    ///
    /// The filter string can be used to filter by `action`, `resource_type`,
    /// `resource_name`, `author`, and `create_time`.
    /// The `:` comparator can be used for case-insensitive partial matching on
    /// string fields, while `=` performs an exact case-sensitive match.
    ///
    /// Examples:
    ///
    /// * `action:update` (case-insensitive partial match)
    /// * `action="Create"` (case-sensitive exact match)
    /// * `resource_type:agent`
    /// * `resource_name:my-agent`
    /// * `author:me@example.com`
    /// * `create_time > "2025-01-01T00:00:00Z"`
    /// * `create_time <= "2025-01-01T00:00:00Z" AND resource_type:tool`
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Optional. Field to sort by. Only "name" and "create_time" is supported.
    /// See <https://google.aip.dev/132#ordering> for more details.
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Response message for
/// \[AgentService.ListChangelogs\]\[google.cloud.ces.v1beta.AgentService.ListChangelogs\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListChangelogsResponse {
    /// The list of changelogs.
    #[prost(message, repeated, tag = "1")]
    pub changelogs: ::prost::alloc::vec::Vec<Changelog>,
    /// A token that can be sent as
    /// \[ListChangelogsRequest.page_token\]\[google.cloud.ces.v1beta.ListChangelogsRequest.page_token\]
    /// to retrieve the next page. Absence of this field indicates there are no
    /// subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for
/// \[AgentService.GetChangelog\]\[google.cloud.ces.v1beta.AgentService.GetChangelog\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetChangelogRequest {
    /// Required. The resource name of the changelog to retrieve.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// \[AgentService.GetSecuritySettings\]\[google.cloud.ces.v1beta.AgentService.GetSecuritySettings\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetSecuritySettingsRequest {
    /// Required. The resource name of the security settings to retrieve.
    /// Format: `projects/{project}/locations/{location}/securitySettings`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// \[AgentService.UpdateSecuritySettings\]\[google.cloud.ces.v1beta.AgentService.UpdateSecuritySettings\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateSecuritySettingsRequest {
    /// Required. The security settings to update.
    #[prost(message, optional, tag = "1")]
    pub security_settings: ::core::option::Option<SecuritySettings>,
    /// Optional. Field mask is used to control which fields get updated. If the
    /// mask is not present, all fields will be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Generated client implementations.
pub mod agent_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// The service that manages agent-related resources in Gemini Enterprise for
    /// Customer Engagement (CES).
    #[derive(Debug, Clone)]
    pub struct AgentServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl AgentServiceClient<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> AgentServiceClient<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,
        ) -> AgentServiceClient<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,
        {
            AgentServiceClient::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 apps in the given project and location.
        pub async fn list_apps(
            &mut self,
            request: impl tonic::IntoRequest<super::ListAppsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListAppsResponse>,
            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(
                "/google.cloud.ces.v1beta.AgentService/ListApps",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.ces.v1beta.AgentService", "ListApps"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets details of the specified app.
        pub async fn get_app(
            &mut self,
            request: impl tonic::IntoRequest<super::GetAppRequest>,
        ) -> std::result::Result<tonic::Response<super::App>, 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(
                "/google.cloud.ces.v1beta.AgentService/GetApp",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.ces.v1beta.AgentService", "GetApp"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a new app in the given project and location.
        pub async fn create_app(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateAppRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            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(
                "/google.cloud.ces.v1beta.AgentService/CreateApp",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.ces.v1beta.AgentService", "CreateApp"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified app.
        pub async fn update_app(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateAppRequest>,
        ) -> std::result::Result<tonic::Response<super::App>, 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(
                "/google.cloud.ces.v1beta.AgentService/UpdateApp",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.ces.v1beta.AgentService", "UpdateApp"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified app.
        pub async fn delete_app(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteAppRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            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(
                "/google.cloud.ces.v1beta.AgentService/DeleteApp",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.ces.v1beta.AgentService", "DeleteApp"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Exports the specified app.
        pub async fn export_app(
            &mut self,
            request: impl tonic::IntoRequest<super::ExportAppRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            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(
                "/google.cloud.ces.v1beta.AgentService/ExportApp",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.ces.v1beta.AgentService", "ExportApp"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Imports the specified app.
        pub async fn import_app(
            &mut self,
            request: impl tonic::IntoRequest<super::ImportAppRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            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(
                "/google.cloud.ces.v1beta.AgentService/ImportApp",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.ces.v1beta.AgentService", "ImportApp"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the security settings for the project and location.
        pub async fn get_security_settings(
            &mut self,
            request: impl tonic::IntoRequest<super::GetSecuritySettingsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SecuritySettings>,
            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(
                "/google.cloud.ces.v1beta.AgentService/GetSecuritySettings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "GetSecuritySettings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the security settings for the project and location.
        pub async fn update_security_settings(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateSecuritySettingsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SecuritySettings>,
            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(
                "/google.cloud.ces.v1beta.AgentService/UpdateSecuritySettings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "UpdateSecuritySettings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists agents in the given app.
        pub async fn list_agents(
            &mut self,
            request: impl tonic::IntoRequest<super::ListAgentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListAgentsResponse>,
            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(
                "/google.cloud.ces.v1beta.AgentService/ListAgents",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.ces.v1beta.AgentService", "ListAgents"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets details of the specified agent.
        pub async fn get_agent(
            &mut self,
            request: impl tonic::IntoRequest<super::GetAgentRequest>,
        ) -> std::result::Result<tonic::Response<super::Agent>, 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(
                "/google.cloud.ces.v1beta.AgentService/GetAgent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.ces.v1beta.AgentService", "GetAgent"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a new agent in the given app.
        pub async fn create_agent(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateAgentRequest>,
        ) -> std::result::Result<tonic::Response<super::Agent>, 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(
                "/google.cloud.ces.v1beta.AgentService/CreateAgent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "CreateAgent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified agent.
        pub async fn update_agent(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateAgentRequest>,
        ) -> std::result::Result<tonic::Response<super::Agent>, 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(
                "/google.cloud.ces.v1beta.AgentService/UpdateAgent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "UpdateAgent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified agent.
        pub async fn delete_agent(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteAgentRequest>,
        ) -> 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(
                "/google.cloud.ces.v1beta.AgentService/DeleteAgent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "DeleteAgent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists examples in the given app.
        pub async fn list_examples(
            &mut self,
            request: impl tonic::IntoRequest<super::ListExamplesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListExamplesResponse>,
            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(
                "/google.cloud.ces.v1beta.AgentService/ListExamples",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "ListExamples",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets details of the specified example.
        pub async fn get_example(
            &mut self,
            request: impl tonic::IntoRequest<super::GetExampleRequest>,
        ) -> std::result::Result<tonic::Response<super::Example>, 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(
                "/google.cloud.ces.v1beta.AgentService/GetExample",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.ces.v1beta.AgentService", "GetExample"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a new example in the given app.
        pub async fn create_example(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateExampleRequest>,
        ) -> std::result::Result<tonic::Response<super::Example>, 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(
                "/google.cloud.ces.v1beta.AgentService/CreateExample",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "CreateExample",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified example.
        pub async fn update_example(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateExampleRequest>,
        ) -> std::result::Result<tonic::Response<super::Example>, 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(
                "/google.cloud.ces.v1beta.AgentService/UpdateExample",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "UpdateExample",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified example.
        pub async fn delete_example(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteExampleRequest>,
        ) -> 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(
                "/google.cloud.ces.v1beta.AgentService/DeleteExample",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "DeleteExample",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists tools in the given app.
        pub async fn list_tools(
            &mut self,
            request: impl tonic::IntoRequest<super::ListToolsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListToolsResponse>,
            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(
                "/google.cloud.ces.v1beta.AgentService/ListTools",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.ces.v1beta.AgentService", "ListTools"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets details of the specified tool.
        pub async fn get_tool(
            &mut self,
            request: impl tonic::IntoRequest<super::GetToolRequest>,
        ) -> std::result::Result<tonic::Response<super::Tool>, 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(
                "/google.cloud.ces.v1beta.AgentService/GetTool",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.ces.v1beta.AgentService", "GetTool"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists conversations in the given app.
        pub async fn list_conversations(
            &mut self,
            request: impl tonic::IntoRequest<super::ListConversationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListConversationsResponse>,
            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(
                "/google.cloud.ces.v1beta.AgentService/ListConversations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "ListConversations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets details of the specified conversation.
        pub async fn get_conversation(
            &mut self,
            request: impl tonic::IntoRequest<super::GetConversationRequest>,
        ) -> std::result::Result<tonic::Response<super::Conversation>, 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(
                "/google.cloud.ces.v1beta.AgentService/GetConversation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "GetConversation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified conversation.
        pub async fn delete_conversation(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteConversationRequest>,
        ) -> 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(
                "/google.cloud.ces.v1beta.AgentService/DeleteConversation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "DeleteConversation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Batch deletes the specified conversations.
        pub async fn batch_delete_conversations(
            &mut self,
            request: impl tonic::IntoRequest<super::BatchDeleteConversationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            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(
                "/google.cloud.ces.v1beta.AgentService/BatchDeleteConversations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "BatchDeleteConversations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a new tool in the given app.
        pub async fn create_tool(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateToolRequest>,
        ) -> std::result::Result<tonic::Response<super::Tool>, 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(
                "/google.cloud.ces.v1beta.AgentService/CreateTool",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.ces.v1beta.AgentService", "CreateTool"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified tool.
        pub async fn update_tool(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateToolRequest>,
        ) -> std::result::Result<tonic::Response<super::Tool>, 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(
                "/google.cloud.ces.v1beta.AgentService/UpdateTool",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.ces.v1beta.AgentService", "UpdateTool"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified tool.
        pub async fn delete_tool(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteToolRequest>,
        ) -> 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(
                "/google.cloud.ces.v1beta.AgentService/DeleteTool",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.ces.v1beta.AgentService", "DeleteTool"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists guardrails in the given app.
        pub async fn list_guardrails(
            &mut self,
            request: impl tonic::IntoRequest<super::ListGuardrailsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListGuardrailsResponse>,
            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(
                "/google.cloud.ces.v1beta.AgentService/ListGuardrails",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "ListGuardrails",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets details of the specified guardrail.
        pub async fn get_guardrail(
            &mut self,
            request: impl tonic::IntoRequest<super::GetGuardrailRequest>,
        ) -> std::result::Result<tonic::Response<super::Guardrail>, 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(
                "/google.cloud.ces.v1beta.AgentService/GetGuardrail",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "GetGuardrail",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a new guardrail in the given app.
        pub async fn create_guardrail(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateGuardrailRequest>,
        ) -> std::result::Result<tonic::Response<super::Guardrail>, 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(
                "/google.cloud.ces.v1beta.AgentService/CreateGuardrail",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "CreateGuardrail",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified guardrail.
        pub async fn update_guardrail(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateGuardrailRequest>,
        ) -> std::result::Result<tonic::Response<super::Guardrail>, 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(
                "/google.cloud.ces.v1beta.AgentService/UpdateGuardrail",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "UpdateGuardrail",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified guardrail.
        pub async fn delete_guardrail(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteGuardrailRequest>,
        ) -> 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(
                "/google.cloud.ces.v1beta.AgentService/DeleteGuardrail",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "DeleteGuardrail",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists deployments in the given app.
        pub async fn list_deployments(
            &mut self,
            request: impl tonic::IntoRequest<super::ListDeploymentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListDeploymentsResponse>,
            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(
                "/google.cloud.ces.v1beta.AgentService/ListDeployments",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "ListDeployments",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets details of the specified deployment.
        pub async fn get_deployment(
            &mut self,
            request: impl tonic::IntoRequest<super::GetDeploymentRequest>,
        ) -> std::result::Result<tonic::Response<super::Deployment>, 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(
                "/google.cloud.ces.v1beta.AgentService/GetDeployment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "GetDeployment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a new deployment in the given app.
        pub async fn create_deployment(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateDeploymentRequest>,
        ) -> std::result::Result<tonic::Response<super::Deployment>, 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(
                "/google.cloud.ces.v1beta.AgentService/CreateDeployment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "CreateDeployment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified deployment.
        pub async fn update_deployment(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateDeploymentRequest>,
        ) -> std::result::Result<tonic::Response<super::Deployment>, 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(
                "/google.cloud.ces.v1beta.AgentService/UpdateDeployment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "UpdateDeployment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified deployment.
        pub async fn delete_deployment(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteDeploymentRequest>,
        ) -> 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(
                "/google.cloud.ces.v1beta.AgentService/DeleteDeployment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "DeleteDeployment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists toolsets in the given app.
        pub async fn list_toolsets(
            &mut self,
            request: impl tonic::IntoRequest<super::ListToolsetsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListToolsetsResponse>,
            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(
                "/google.cloud.ces.v1beta.AgentService/ListToolsets",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "ListToolsets",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets details of the specified toolset.
        pub async fn get_toolset(
            &mut self,
            request: impl tonic::IntoRequest<super::GetToolsetRequest>,
        ) -> std::result::Result<tonic::Response<super::Toolset>, 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(
                "/google.cloud.ces.v1beta.AgentService/GetToolset",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.ces.v1beta.AgentService", "GetToolset"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a new toolset in the given app.
        pub async fn create_toolset(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateToolsetRequest>,
        ) -> std::result::Result<tonic::Response<super::Toolset>, 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(
                "/google.cloud.ces.v1beta.AgentService/CreateToolset",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "CreateToolset",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified toolset.
        pub async fn update_toolset(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateToolsetRequest>,
        ) -> std::result::Result<tonic::Response<super::Toolset>, 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(
                "/google.cloud.ces.v1beta.AgentService/UpdateToolset",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "UpdateToolset",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified toolset.
        pub async fn delete_toolset(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteToolsetRequest>,
        ) -> 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(
                "/google.cloud.ces.v1beta.AgentService/DeleteToolset",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "DeleteToolset",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists all app versions in the given app.
        pub async fn list_app_versions(
            &mut self,
            request: impl tonic::IntoRequest<super::ListAppVersionsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListAppVersionsResponse>,
            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(
                "/google.cloud.ces.v1beta.AgentService/ListAppVersions",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "ListAppVersions",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets details of the specified app version.
        pub async fn get_app_version(
            &mut self,
            request: impl tonic::IntoRequest<super::GetAppVersionRequest>,
        ) -> std::result::Result<tonic::Response<super::AppVersion>, 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(
                "/google.cloud.ces.v1beta.AgentService/GetAppVersion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "GetAppVersion",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a new app version in the given app.
        pub async fn create_app_version(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateAppVersionRequest>,
        ) -> std::result::Result<tonic::Response<super::AppVersion>, 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(
                "/google.cloud.ces.v1beta.AgentService/CreateAppVersion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "CreateAppVersion",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified app version.
        pub async fn delete_app_version(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteAppVersionRequest>,
        ) -> 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(
                "/google.cloud.ces.v1beta.AgentService/DeleteAppVersion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "DeleteAppVersion",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Restores the specified app version.
        /// This will create a new app version from the current draft app and overwrite
        /// the current draft with the specified app version.
        pub async fn restore_app_version(
            &mut self,
            request: impl tonic::IntoRequest<super::RestoreAppVersionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            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(
                "/google.cloud.ces.v1beta.AgentService/RestoreAppVersion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "RestoreAppVersion",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Generates specific resources (e.g. agent) in the app using LLM assistant.
        pub async fn generate_app_resource(
            &mut self,
            request: impl tonic::IntoRequest<super::GenerateAppResourceRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            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(
                "/google.cloud.ces.v1beta.AgentService/GenerateAppResource",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "GenerateAppResource",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists the changelogs of the specified app.
        pub async fn list_changelogs(
            &mut self,
            request: impl tonic::IntoRequest<super::ListChangelogsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListChangelogsResponse>,
            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(
                "/google.cloud.ces.v1beta.AgentService/ListChangelogs",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "ListChangelogs",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets the specified changelog.
        pub async fn get_changelog(
            &mut self,
            request: impl tonic::IntoRequest<super::GetChangelogRequest>,
        ) -> std::result::Result<tonic::Response<super::Changelog>, 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(
                "/google.cloud.ces.v1beta.AgentService/GetChangelog",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.AgentService",
                        "GetChangelog",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Response message for
/// \[EvaluationService.RunEvaluation\]\[google.cloud.ces.v1beta.EvaluationService.RunEvaluation\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RunEvaluationResponse {
    /// The name of the evaluation run that was created.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/evaluationRuns/{evaluation_run}`
    #[prost(string, tag = "1")]
    pub evaluation_run: ::prost::alloc::string::String,
}
/// Operation metadata for
/// \[EvaluationService.RunEvaluation\]\[google.cloud.ces.v1beta.EvaluationService.RunEvaluation\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RunEvaluationOperationMetadata {
    /// Output only. The list of evaluations that were run.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/evaluations/{evaluation}`
    #[prost(string, repeated, tag = "1")]
    pub evaluations: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Output only. The evaluation run that was created.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/evaluationRuns/{evaluation_run}`
    #[prost(string, tag = "2")]
    pub evaluation_run: ::prost::alloc::string::String,
    /// Output only. The time the operation was created.
    #[prost(message, optional, tag = "3")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The time the operation completed.
    #[prost(message, optional, tag = "4")]
    pub end_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The verb of the operation.
    #[prost(string, tag = "5")]
    pub verb: ::prost::alloc::string::String,
    /// Output only. Identifies whether the user has requested cancellation of the
    /// operation. Operations that have been cancelled successfully have
    /// \[google.longrunning.Operation.error\]\[google.longrunning.Operation.error\]
    /// value with a \[google.rpc.Status.code\]\[google.rpc.Status.code\] of `1`,
    /// corresponding to `Code.CANCELLED`.
    #[prost(bool, tag = "6")]
    pub cancel_requested: bool,
}
/// Operation metadata for
/// \[EvaluationService.GenerateEvaluation\]\[google.cloud.ces.v1beta.EvaluationService.GenerateEvaluation\].
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GenerateEvaluationOperationMetadata {}
/// Operation metadata for
/// \[EvaluationService.DeleteEvaluationRun\]\[google.cloud.ces.v1beta.EvaluationService.DeleteEvaluationRun\].
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteEvaluationRunOperationMetadata {}
/// Request message for
/// \[EvaluationService.CreateEvaluation\]\[google.cloud.ces.v1beta.EvaluationService.CreateEvaluation\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateEvaluationRequest {
    /// Required. The app to create the evaluation for.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The ID to use for the evaluation, which will become the final
    /// component of the evaluation's resource name. If not provided, a unique ID
    /// will be automatically assigned for the evaluation.
    #[prost(string, tag = "2")]
    pub evaluation_id: ::prost::alloc::string::String,
    /// Required. The evaluation to create.
    #[prost(message, optional, tag = "3")]
    pub evaluation: ::core::option::Option<Evaluation>,
}
/// Request message for
/// \[EvaluationService.GenerateEvaluation\]\[google.cloud.ces.v1beta.EvaluationService.GenerateEvaluation\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GenerateEvaluationRequest {
    /// Required. The conversation to create the golden evaluation for.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/conversations/{conversation}`
    #[prost(string, tag = "1")]
    pub conversation: ::prost::alloc::string::String,
    /// Optional. Indicate the source of the conversation. If not set, all sources
    /// will be searched.
    #[deprecated]
    #[prost(enumeration = "conversation::Source", tag = "2")]
    pub source: i32,
}
/// Request message for
/// \[EvaluationService.ImportEvaluations\]\[google.cloud.ces.v1beta.EvaluationService.ImportEvaluations\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ImportEvaluationsRequest {
    /// Required. The app to import the evaluations into.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Options governing the import process for the evaluations.
    #[prost(message, optional, tag = "5")]
    pub import_options: ::core::option::Option<
        import_evaluations_request::ImportOptions,
    >,
    /// The source of the evaluations to import from.
    #[prost(oneof = "import_evaluations_request::Source", tags = "2, 3, 4")]
    pub source: ::core::option::Option<import_evaluations_request::Source>,
}
/// Nested message and enum types in `ImportEvaluationsRequest`.
pub mod import_evaluations_request {
    /// A list of conversation resource names.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ConversationList {
        /// Optional. Conversation resource names.
        #[prost(string, repeated, tag = "1")]
        pub conversations: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    }
    /// Configuration options for the evaluation import process.
    /// These options control how the import behaves, particularly when
    /// conflicts arise with existing evaluations data.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ImportOptions {
        /// Optional. The strategy to use when resolving conflicts during import.
        #[prost(enumeration = "import_options::ConflictResolutionStrategy", tag = "1")]
        pub conflict_resolution_strategy: i32,
    }
    /// Nested message and enum types in `ImportOptions`.
    pub mod import_options {
        /// Defines the strategy for handling conflicts when an evaluation with the
        /// same evaluation ID already exists in the app.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum ConflictResolutionStrategy {
            /// The conflict resolution strategy is unspecified.
            Unspecified = 0,
            /// Overwrite the existing evaluation with the new one.
            Overwrite = 1,
            /// Keep the existing evaluation and skip the new one.
            Skip = 2,
            /// Keep the existing evaluation and duplicate the new one as a new
            /// evaluation.
            Duplicate = 3,
        }
        impl ConflictResolutionStrategy {
            /// 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 => "CONFLICT_RESOLUTION_STRATEGY_UNSPECIFIED",
                    Self::Overwrite => "OVERWRITE",
                    Self::Skip => "SKIP",
                    Self::Duplicate => "DUPLICATE",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "CONFLICT_RESOLUTION_STRATEGY_UNSPECIFIED" => Some(Self::Unspecified),
                    "OVERWRITE" => Some(Self::Overwrite),
                    "SKIP" => Some(Self::Skip),
                    "DUPLICATE" => Some(Self::Duplicate),
                    _ => None,
                }
            }
        }
    }
    /// The source of the evaluations to import from.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Source {
        /// The conversations to import the evaluations from.
        #[prost(message, tag = "2")]
        ConversationList(ConversationList),
        /// The [Google Cloud Storage](<https://cloud.google.com/storage/docs/>) URI
        /// from which to import evaluations. The format of this URI must be
        /// `gs://<bucket-name>/<object-name>`.
        #[prost(string, tag = "3")]
        GcsUri(::prost::alloc::string::String),
        /// Raw bytes representing the csv file with the evaluations structure.
        #[prost(bytes, tag = "4")]
        CsvContent(::prost::alloc::vec::Vec<u8>),
    }
}
/// Response message for
/// \[EvaluationService.ImportEvaluations\]\[google.cloud.ces.v1beta.EvaluationService.ImportEvaluations\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ImportEvaluationsResponse {
    /// The list of evaluations that were imported into the app.
    #[prost(message, repeated, tag = "1")]
    pub evaluations: ::prost::alloc::vec::Vec<Evaluation>,
    /// The list of evaluation results that were imported into the app.
    #[prost(message, repeated, tag = "4")]
    pub evaluation_results: ::prost::alloc::vec::Vec<EvaluationResult>,
    /// The list of evaluation runs that were imported into the app.
    #[prost(message, repeated, tag = "5")]
    pub evaluation_runs: ::prost::alloc::vec::Vec<EvaluationRun>,
    /// Optional. A list of error messages associated with evaluations that failed
    /// to be imported.
    #[prost(string, repeated, tag = "2")]
    pub error_messages: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// The number of evaluations that either failed to import entirely or
    /// completed import with one or more errors.
    #[prost(int32, tag = "3")]
    pub import_failure_count: i32,
    /// The number of evaluation results that either failed to import entirely or
    /// completed import with one or more errors.
    #[prost(int32, tag = "6")]
    pub evaluation_result_import_failure_count: i32,
    /// The number of evaluation runs that either failed to import entirely or
    /// completed import with one or more errors.
    #[prost(int32, tag = "7")]
    pub evaluation_run_import_failure_count: i32,
}
/// Represents the metadata of the long-running operation for
/// \[EvaluationService.ImportEvaluations\]\[google.cloud.ces.v1beta.EvaluationService.ImportEvaluations\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ImportEvaluationsOperationMetadata {
    /// Output only. The time the operation was created.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The time the operation finished running.
    #[prost(message, optional, tag = "2")]
    pub end_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Human-readable status of the operation, if any.
    #[prost(string, tag = "3")]
    pub status_message: ::prost::alloc::string::String,
}
/// Request message for
/// \[EvaluationService.CreateEvaluationDataset\]\[google.cloud.ces.v1beta.EvaluationService.CreateEvaluationDataset\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateEvaluationDatasetRequest {
    /// Required. The app to create the evaluation for.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The ID to use for the evaluation dataset, which will become the
    /// final component of the evaluation dataset's resource name. If not provided,
    /// a unique ID will be automatically assigned for the evaluation.
    #[prost(string, tag = "2")]
    pub evaluation_dataset_id: ::prost::alloc::string::String,
    /// Required. The evaluation dataset to create.
    #[prost(message, optional, tag = "3")]
    pub evaluation_dataset: ::core::option::Option<EvaluationDataset>,
}
/// Request message for
/// \[EvaluationService.UpdateEvaluation\]\[google.cloud.ces.v1beta.EvaluationService.UpdateEvaluation\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateEvaluationRequest {
    /// Required. The evaluation to update.
    #[prost(message, optional, tag = "1")]
    pub evaluation: ::core::option::Option<Evaluation>,
    /// Optional. Field mask is used to control which fields get updated. If the
    /// mask is not present, all fields will be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for
/// \[EvaluationService.UpdateEvaluationDataset\]\[google.cloud.ces.v1beta.EvaluationService.UpdateEvaluationDataset\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateEvaluationDatasetRequest {
    /// Required. The evaluation dataset to update.
    #[prost(message, optional, tag = "1")]
    pub evaluation_dataset: ::core::option::Option<EvaluationDataset>,
    /// Optional. Field mask is used to control which fields get updated. If the
    /// mask is not present, all fields will be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for
/// \[EvaluationService.DeleteEvaluation\]\[google.cloud.ces.v1beta.EvaluationService.DeleteEvaluation\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteEvaluationRequest {
    /// Required. The resource name of the evaluation to delete.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. Indicates whether to forcefully delete the evaluation, even if it
    /// is still referenced by evaluation datasets.
    ///
    /// * If `force = false`, the deletion will fail if any datasets still
    ///   reference the evaluation.
    /// * If `force = true`, all existing references from datasets will be removed
    ///   and the evaluation will be deleted.
    #[prost(bool, tag = "2")]
    pub force: bool,
    /// Optional. The current etag of the evaluation. If an etag is not provided,
    /// the deletion will overwrite any concurrent changes. If an etag is provided
    /// and does not match the current etag of the evaluation, deletion will be
    /// blocked and an ABORTED error will be returned.
    #[prost(string, tag = "3")]
    pub etag: ::prost::alloc::string::String,
}
/// Request message for
/// \[EvaluationService.DeleteEvaluationResult\]\[google.cloud.ces.v1beta.EvaluationService.DeleteEvaluationResult\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteEvaluationResultRequest {
    /// Required. The resource name of the evaluation result to delete.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// \[EvaluationService.DeleteEvaluationDataset\]\[google.cloud.ces.v1beta.EvaluationService.DeleteEvaluationDataset\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteEvaluationDatasetRequest {
    /// Required. The resource name of the evaluation dataset to delete.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The current etag of the evaluation dataset. If an etag is not
    /// provided, the deletion will overwrite any concurrent changes. If an etag is
    /// provided and does not match the current etag of the evaluation dataset,
    /// deletion will be blocked and an ABORTED error will be returned.
    #[prost(string, tag = "2")]
    pub etag: ::prost::alloc::string::String,
}
/// Request message for
/// \[EvaluationService.DeleteEvaluationRun\]\[google.cloud.ces.v1beta.EvaluationService.DeleteEvaluationRun\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteEvaluationRunRequest {
    /// Required. The resource name of the evaluation run to delete.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// \[EvaluationService.GetEvaluation\]\[google.cloud.ces.v1beta.EvaluationService.GetEvaluation\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetEvaluationRequest {
    /// Required. The resource name of the evaluation to retrieve.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// \[EvaluationService.GetEvaluationResult\]\[google.cloud.ces.v1beta.EvaluationService.GetEvaluationResult\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetEvaluationResultRequest {
    /// Required. The resource name of the evaluation result to retrieve.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// \[EvaluationService.GetEvaluationDataset\]\[google.cloud.ces.v1beta.EvaluationService.GetEvaluationDataset\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetEvaluationDatasetRequest {
    /// Required. The resource name of the evaluation dataset to retrieve.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// \[EvaluationService.GetEvaluationRun\]\[google.cloud.ces.v1beta.EvaluationService.GetEvaluationRun\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetEvaluationRunRequest {
    /// Required. The resource name of the evaluation run to retrieve.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// \[EvaluationService.ListEvaluations\]\[google.cloud.ces.v1beta.EvaluationService.ListEvaluations\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListEvaluationsRequest {
    /// Required. The resource name of the app to list evaluations from.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Requested page size. Server may return fewer items than
    /// requested. If unspecified, server will pick an appropriate default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. The
    /// \[next_page_token\]\[google.cloud.ces.v1beta.ListEvaluationsResponse.next_page_token\]
    /// value returned from a previous list
    /// \[EvaluationService.ListEvaluations\]\[google.cloud.ces.v1beta.EvaluationService.ListEvaluations\]
    /// call.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. Deprecated: Use evaluation_filter and evaluation_run_filter
    /// instead.
    #[deprecated]
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Optional. Filter to be applied on the evaluation when listing the
    /// evaluations. See <https://google.aip.dev/160> for more details. Supported
    /// fields: evaluation_datasets
    #[prost(string, tag = "7")]
    pub evaluation_filter: ::prost::alloc::string::String,
    /// Optional. Filter string for fields on the associated EvaluationRun
    /// resources. See <https://google.aip.dev/160> for more details. Supported
    /// fields: create_time, initiated_by, app_version_display_name
    #[prost(string, tag = "8")]
    pub evaluation_run_filter: ::prost::alloc::string::String,
    /// Optional. Field to sort by. Only "name" and "create_time", and
    /// "update_time" are supported. Time fields are ordered in descending order,
    /// and the name field is ordered in ascending order. If not included,
    /// "update_time" will be the default. See <https://google.aip.dev/132#ordering>
    /// for more details.
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
    /// Optional. Whether to include the last 10 evaluation results for each
    /// evaluation in the response.
    #[prost(bool, tag = "6")]
    pub last_ten_results: bool,
}
/// Request message for
/// \[EvaluationService.ListEvaluationResults\]\[google.cloud.ces.v1beta.EvaluationService.ListEvaluationResults\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListEvaluationResultsRequest {
    /// Required. The resource name of the evaluation to list evaluation results
    /// from. To filter by evaluation run, use `-` as the evaluation ID and specify
    /// the evaluation run ID in the filter. For example:
    /// `projects/{project}/locations/{location}/apps/{app}/evaluations/-`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Requested page size. Server may return fewer items than
    /// requested. If unspecified, server will pick an appropriate default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. The
    /// \[next_page_token\]\[google.cloud.ces.v1beta.ListEvaluationResultsResponse.next_page_token\]
    /// value returned from a previous list
    /// \[EvaluationService.ListEvaluationResults\]\[google.cloud.ces.v1beta.EvaluationService.ListEvaluationResults\]
    /// call.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. Filter to be applied when listing the evaluation results.
    /// See <https://google.aip.dev/160> for more details.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Optional. Field to sort by. Only "name" and "create_time", and
    /// "update_time" are supported. Time fields are ordered in descending order,
    /// and the name field is ordered in ascending order. If not included,
    /// "update_time" will be the default. See <https://google.aip.dev/132#ordering>
    /// for more details.
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Request message for
/// \[EvaluationService.ListEvaluationDatasets\]\[google.cloud.ces.v1beta.EvaluationService.ListEvaluationDatasets\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListEvaluationDatasetsRequest {
    /// Required. The resource name of the app to list evaluation datasets from.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Requested page size. Server may return fewer items than
    /// requested. If unspecified, server will pick an appropriate default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. The
    /// \[next_page_token\]\[google.cloud.ces.v1beta.ListEvaluationDatasetsResponse.next_page_token\]
    /// value returned from a previous list
    /// \[EvaluationService.ListEvaluationDatasets\]\[google.cloud.ces.v1beta.EvaluationService.ListEvaluationDatasets\]
    /// call.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. Filter to be applied when listing the evaluation datasets.
    /// See <https://google.aip.dev/160> for more details.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Optional. Field to sort by. Only "name" and "create_time", and
    /// "update_time" are supported. Time fields are ordered in descending order,
    /// and the name field is ordered in ascending order. If not included,
    /// "update_time" will be the default. See <https://google.aip.dev/132#ordering>
    /// for more details.
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Request message for
/// \[EvaluationService.ListEvaluationRuns\]\[google.cloud.ces.v1beta.EvaluationService.ListEvaluationRuns\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListEvaluationRunsRequest {
    /// Required. The resource name of the app to list evaluation runs from.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Requested page size. Server may return fewer items than
    /// requested. If unspecified, server will pick an appropriate default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. The
    /// \[next_page_token\]\[google.cloud.ces.v1beta.ListEvaluationRunsResponse.next_page_token\]
    /// value returned from a previous list
    /// \[EvaluationService.ListEvaluationRuns\]\[google.cloud.ces.v1beta.EvaluationService.ListEvaluationRuns\]
    /// call.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. Filter to be applied when listing the evaluation runs.
    /// See <https://google.aip.dev/160> for more details.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Optional. Field to sort by. Only "name" and "create_time", and
    /// "update_time" are supported. Time fields are ordered in descending order,
    /// and the name field is ordered in ascending order. If not included,
    /// "update_time" will be the default. See <https://google.aip.dev/132#ordering>
    /// for more details.
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Response message for
/// \[EvaluationService.ListEvaluations\]\[google.cloud.ces.v1beta.EvaluationService.ListEvaluations\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListEvaluationsResponse {
    /// The list of evaluations.
    #[prost(message, repeated, tag = "1")]
    pub evaluations: ::prost::alloc::vec::Vec<Evaluation>,
    /// A token that can be sent as
    /// \[ListEvaluationsRequest.page_token\]\[google.cloud.ces.v1beta.ListEvaluationsRequest.page_token\]
    /// to retrieve the next page. Absence of this field indicates there are no
    /// subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Response message for
/// \[EvaluationService.ListEvaluationResults\]\[google.cloud.ces.v1beta.EvaluationService.ListEvaluationResults\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListEvaluationResultsResponse {
    /// The list of evaluation results.
    #[prost(message, repeated, tag = "1")]
    pub evaluation_results: ::prost::alloc::vec::Vec<EvaluationResult>,
    /// A token that can be sent as
    /// \[ListEvaluationResultsRequest.page_token\]\[google.cloud.ces.v1beta.ListEvaluationResultsRequest.page_token\]
    /// to retrieve the next page. Absence of this field indicates there are no
    /// subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Response message for
/// \[EvaluationService.ListEvaluationDatasets\]\[google.cloud.ces.v1beta.EvaluationService.ListEvaluationDatasets\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListEvaluationDatasetsResponse {
    /// The list of evaluation datasets.
    #[prost(message, repeated, tag = "1")]
    pub evaluation_datasets: ::prost::alloc::vec::Vec<EvaluationDataset>,
    /// A token that can be sent as
    /// \[ListEvaluationDatasetsRequest.page_token\]\[google.cloud.ces.v1beta.ListEvaluationDatasetsRequest.page_token\]
    /// to retrieve the next page. Absence of this field indicates there are no
    /// subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Response message for
/// \[EvaluationService.ListEvaluationRuns\]\[google.cloud.ces.v1beta.EvaluationService.ListEvaluationRuns\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListEvaluationRunsResponse {
    /// The list of evaluation runs.
    #[prost(message, repeated, tag = "1")]
    pub evaluation_runs: ::prost::alloc::vec::Vec<EvaluationRun>,
    /// A token that can be sent as
    /// \[ListEvaluationRunsRequest.page_token\]\[google.cloud.ces.v1beta.ListEvaluationRunsRequest.page_token\]
    /// to retrieve the next page. Absence of this field indicates there are no
    /// subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for
/// \[EvaluationService.CreateScheduledEvaluationRun\]\[google.cloud.ces.v1beta.EvaluationService.CreateScheduledEvaluationRun\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateScheduledEvaluationRunRequest {
    /// Required. The app to create the scheduled evaluation run for.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The ID to use for the scheduled evaluation run, which will become
    /// the final component of the scheduled evaluation run's resource name. If not
    /// provided, a unique ID will be automatically assigned.
    #[prost(string, tag = "2")]
    pub scheduled_evaluation_run_id: ::prost::alloc::string::String,
    /// Required. The scheduled evaluation run to create.
    #[prost(message, optional, tag = "3")]
    pub scheduled_evaluation_run: ::core::option::Option<ScheduledEvaluationRun>,
}
/// Request message for
/// \[EvaluationService.GetScheduledEvaluationRun\]\[google.cloud.ces.v1beta.EvaluationService.GetScheduledEvaluationRun\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetScheduledEvaluationRunRequest {
    /// Required. The resource name of the scheduled evaluation run to retrieve.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// \[EvaluationService.ListScheduledEvaluationRuns\]\[google.cloud.ces.v1beta.EvaluationService.ListScheduledEvaluationRuns\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListScheduledEvaluationRunsRequest {
    /// Required. The resource name of the app to list scheduled evaluation runs
    /// from.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Requested page size. Server may return fewer items than
    /// requested. If unspecified, server will pick an appropriate default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. The
    /// \[next_page_token\]\[google.cloud.ces.v1beta.ListScheduledEvaluationRunsResponse.next_page_token\]
    /// value returned from a previous list
    /// \[EvaluationService.ListScheduledEvaluationRuns\]\[google.cloud.ces.v1beta.EvaluationService.ListScheduledEvaluationRuns\]
    /// call.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. Filter to be applied when listing the scheduled evaluation runs.
    /// See <https://google.aip.dev/160> for more details.
    /// Currently supports filtering by:
    ///
    /// * request.evaluations:evaluation_id
    /// * request.evaluation_dataset:evaluation_dataset_id
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Optional. Field to sort by. Supported fields are:
    /// "name" (ascending), "create_time" (descending), "update_time" (descending),
    /// "next_scheduled_execution" (ascending), and
    /// "last_completed_run.create_time" (descending).
    /// If not included, "update_time" will be the default.
    /// See <https://google.aip.dev/132#ordering> for more details.
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Response message for
/// \[EvaluationService.ListScheduledEvaluationRuns\]\[google.cloud.ces.v1beta.EvaluationService.ListScheduledEvaluationRuns\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListScheduledEvaluationRunsResponse {
    /// The list of scheduled evaluation runs.
    #[prost(message, repeated, tag = "1")]
    pub scheduled_evaluation_runs: ::prost::alloc::vec::Vec<ScheduledEvaluationRun>,
    /// A token that can be sent as
    /// \[ListScheduledEvaluationRunsRequest.page_token\]\[google.cloud.ces.v1beta.ListScheduledEvaluationRunsRequest.page_token\]
    /// to retrieve the next page. Absence of this field indicates there are no
    /// subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for
/// \[EvaluationService.UpdateScheduledEvaluationRun\]\[google.cloud.ces.v1beta.EvaluationService.UpdateScheduledEvaluationRun\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateScheduledEvaluationRunRequest {
    /// Required. The scheduled evaluation run to update.
    #[prost(message, optional, tag = "1")]
    pub scheduled_evaluation_run: ::core::option::Option<ScheduledEvaluationRun>,
    /// Optional. Field mask is used to control which fields get updated. If the
    /// mask is not present, all fields will be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for
/// \[EvaluationService.DeleteScheduledEvaluationRun\]\[google.cloud.ces.v1beta.EvaluationService.DeleteScheduledEvaluationRun\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteScheduledEvaluationRunRequest {
    /// Required. The resource name of the scheduled evaluation run to delete.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The etag of the ScheduledEvaluationRun.
    /// If provided, it must match the server's etag.
    #[prost(string, tag = "2")]
    pub etag: ::prost::alloc::string::String,
}
/// Request message for
/// \[EvaluationService.TestPersonaVoice\]\[google.cloud.ces.v1beta.EvaluationService.TestPersonaVoice\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TestPersonaVoiceRequest {
    /// Required. the resource name of the app to test the persona voice for.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}`
    #[prost(string, tag = "1")]
    pub app: ::prost::alloc::string::String,
    /// Required. The persona ID to test the voice for. Also accepts "default".
    #[prost(string, tag = "2")]
    pub persona_id: ::prost::alloc::string::String,
    /// Required. The text to test the voice for.
    #[prost(string, tag = "3")]
    pub text: ::prost::alloc::string::String,
}
/// Request message for
/// \[EvaluationService.UploadEvaluationAudio\]\[google.cloud.ces.v1beta.EvaluationService.UploadEvaluationAudio\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UploadEvaluationAudioRequest {
    /// Required. The resource name of the Evaluation for which to upload the
    /// evaluation audio. Format:
    /// `projects/{project}/locations/{location}/apps/{app}/evaluations/{evaluation}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. The raw audio bytes.
    /// The format of the audio must be single-channel LINEAR16 with a sample
    /// rate of 16kHz (default InputAudioConfig).
    #[prost(bytes = "vec", tag = "2")]
    pub audio_content: ::prost::alloc::vec::Vec<u8>,
    /// Optional. The Google Cloud Storage URI of the previously uploaded audio
    /// file to be deleted. Format: `gs://<bucket-name>/<object-name>`
    #[prost(string, tag = "3")]
    pub previous_audio_gcs_uri: ::prost::alloc::string::String,
}
/// Response message for
/// \[EvaluationService.UploadEvaluationAudio\]\[google.cloud.ces.v1beta.EvaluationService.UploadEvaluationAudio\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UploadEvaluationAudioResponse {
    /// The Google Cloud Storage URI where the uploaded audio file is stored.
    /// Format: `gs://<bucket-name>/<object-name>`
    #[prost(string, tag = "1")]
    pub audio_gcs_uri: ::prost::alloc::string::String,
    /// The transcript of the audio, generated by Cloud Speech-to-Text.
    #[prost(string, tag = "2")]
    pub transcript: ::prost::alloc::string::String,
    /// The duration of the audio.
    #[prost(message, optional, tag = "3")]
    pub duration: ::core::option::Option<::prost_types::Duration>,
}
/// Response message for
/// \[EvaluationService.TestPersonaVoice\]\[google.cloud.ces.v1beta.EvaluationService.TestPersonaVoice\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TestPersonaVoiceResponse {
    /// The audio data bytes of the synthesized voice.
    #[prost(bytes = "vec", tag = "1")]
    pub audio: ::prost::alloc::vec::Vec<u8>,
}
/// Request message for
/// \[EvaluationService.CreateEvaluationExpectation\]\[google.cloud.ces.v1beta.EvaluationService.CreateEvaluationExpectation\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateEvaluationExpectationRequest {
    /// Required. The app to create the evaluation expectation for.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The ID to use for the evaluation expectation, which will become
    /// the final component of the evaluation expectation's resource name. If not
    /// provided, a unique ID will be automatically assigned for the evaluation
    /// expectation.
    #[prost(string, tag = "2")]
    pub evaluation_expectation_id: ::prost::alloc::string::String,
    /// Required. The evaluation expectation to create.
    #[prost(message, optional, tag = "3")]
    pub evaluation_expectation: ::core::option::Option<EvaluationExpectation>,
}
/// Request message for
/// \[EvaluationService.UpdateEvaluationExpectation\]\[google.cloud.ces.v1beta.EvaluationService.UpdateEvaluationExpectation\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateEvaluationExpectationRequest {
    /// Required. The evaluation expectation to update.
    #[prost(message, optional, tag = "1")]
    pub evaluation_expectation: ::core::option::Option<EvaluationExpectation>,
    /// Optional. Field mask is used to control which fields get updated. If the
    /// mask is not present, all fields will be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for
/// \[EvaluationService.DeleteEvaluationExpectation\]\[google.cloud.ces.v1beta.EvaluationService.DeleteEvaluationExpectation\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteEvaluationExpectationRequest {
    /// Required. The resource name of the evaluation expectation to delete.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The current etag of the evaluation expectation. If an etag is not
    /// provided, the deletion will overwrite any concurrent changes. If an etag is
    /// provided and does not match the current etag of the evaluation expectation,
    /// deletion will be blocked and an ABORTED error will be returned.
    #[prost(string, tag = "2")]
    pub etag: ::prost::alloc::string::String,
}
/// Request message for
/// \[EvaluationService.GetEvaluationExpectation\]\[google.cloud.ces.v1beta.EvaluationService.GetEvaluationExpectation\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetEvaluationExpectationRequest {
    /// Required. The resource name of the evaluation expectation to retrieve.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// \[EvaluationService.ListEvaluationExpectations\]\[google.cloud.ces.v1beta.EvaluationService.ListEvaluationExpectations\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListEvaluationExpectationsRequest {
    /// Required. The resource name of the app to list evaluation expectations
    /// from.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Requested page size. Server may return fewer items than
    /// requested. If unspecified, server will pick an appropriate default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. The
    /// \[next_page_token\]\[google.cloud.ces.v1beta.ListEvaluationExpectationsResponse.next_page_token\]
    /// value returned from a previous list
    /// \[EvaluationService.ListEvaluationExpectations\]\[google.cloud.ces.v1beta.EvaluationService.ListEvaluationExpectations\]
    /// call.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. Filter to be applied when listing the evaluation expectations.
    /// See <https://google.aip.dev/160> for more details.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Optional. Field to sort by. Only "name" and "create_time", and
    /// "update_time" are supported. Time fields are ordered in descending order,
    /// and the name field is ordered in ascending order. If not included,
    /// "update_time" will be the default. See <https://google.aip.dev/132#ordering>
    /// for more details.
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Response message for
/// \[EvaluationService.ListEvaluationExpectations\]\[google.cloud.ces.v1beta.EvaluationService.ListEvaluationExpectations\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListEvaluationExpectationsResponse {
    /// The list of evaluation expectations.
    #[prost(message, repeated, tag = "1")]
    pub evaluation_expectations: ::prost::alloc::vec::Vec<EvaluationExpectation>,
    /// A token that can be sent as
    /// \[ListEvaluationExpectationsRequest.page_token\]\[google.cloud.ces.v1beta.ListEvaluationExpectationsRequest.page_token\]
    /// to retrieve the next page. Absence of this field indicates there are no
    /// subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Options for exporting CES evaluation resources.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExportOptions {
    /// Optional. The format to export the evaluation results in. Defaults to JSON
    /// if not specified.
    #[prost(enumeration = "export_options::ExportFormat", tag = "1")]
    pub export_format: i32,
    /// Optional. The Google Cloud Storage URI to write the exported Evaluation
    /// Results to.
    #[prost(string, tag = "2")]
    pub gcs_uri: ::prost::alloc::string::String,
}
/// Nested message and enum types in `ExportOptions`.
pub mod export_options {
    /// The format to export the items in. Defaults to JSON if not
    /// specified.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ExportFormat {
        /// Unspecified format.
        Unspecified = 0,
        /// JSON format.
        Json = 1,
        /// YAML format.
        Yaml = 2,
    }
    impl ExportFormat {
        /// 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 => "EXPORT_FORMAT_UNSPECIFIED",
                Self::Json => "JSON",
                Self::Yaml => "YAML",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "EXPORT_FORMAT_UNSPECIFIED" => Some(Self::Unspecified),
                "JSON" => Some(Self::Json),
                "YAML" => Some(Self::Yaml),
                _ => None,
            }
        }
    }
}
/// Request message for
/// \[EvaluationService.ExportEvaluations\]\[google.cloud.ces.v1beta.EvaluationService.ExportEvaluations\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExportEvaluationsRequest {
    /// Required. The resource name of the app to export evaluations from.
    /// Format: `projects/{project}/locations/{location}/apps/{app}`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The resource names of the evaluations to export.
    #[prost(string, repeated, tag = "2")]
    pub names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. The export options for the evaluations.
    #[prost(message, optional, tag = "3")]
    pub export_options: ::core::option::Option<ExportOptions>,
    /// Optional. Includes evaluation results in the export. At least one of
    /// include_evaluation_results or include_evaluations must be set.
    #[prost(bool, tag = "4")]
    pub include_evaluation_results: bool,
    /// Optional. Includes evaluations in the export. At least one of
    /// include_evaluation_results or include_evaluations must be set.
    #[prost(bool, tag = "5")]
    pub include_evaluations: bool,
}
/// Response message for
/// \[EvaluationService.ExportEvaluations\]\[google.cloud.ces.v1beta.EvaluationService.ExportEvaluations\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExportEvaluationsResponse {
    /// Output only. A map of evaluation resource names that could not be exported,
    /// to the reason why they failed.
    #[prost(map = "string, string", tag = "3")]
    pub failed_evaluations: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// The exported evaluations.
    #[prost(oneof = "export_evaluations_response::Evaluations", tags = "1, 2")]
    pub evaluations: ::core::option::Option<export_evaluations_response::Evaluations>,
}
/// Nested message and enum types in `ExportEvaluationsResponse`.
pub mod export_evaluations_response {
    /// The exported evaluations.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Evaluations {
        /// The content of the exported Evaluations. This will be populated if
        /// gcs_uri was not specified in the request.
        #[prost(bytes, tag = "1")]
        EvaluationsContent(::prost::alloc::vec::Vec<u8>),
        /// The Google Cloud Storage URI folder where the exported evaluations were
        /// written. This will be populated if gcs_uri was specified in the request.
        #[prost(string, tag = "2")]
        EvaluationsUri(::prost::alloc::string::String),
    }
}
/// Response message for
/// \[EvaluationService.ExportEvaluationResults\]\[google.cloud.ces.v1beta.EvaluationService.ExportEvaluationResults\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExportEvaluationResultsResponse {
    /// The exported evaluation results.
    #[prost(
        oneof = "export_evaluation_results_response::EvaluationResults",
        tags = "1, 2"
    )]
    pub evaluation_results: ::core::option::Option<
        export_evaluation_results_response::EvaluationResults,
    >,
}
/// Nested message and enum types in `ExportEvaluationResultsResponse`.
pub mod export_evaluation_results_response {
    /// The exported evaluation results.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum EvaluationResults {
        /// The content of the exported Evaluation Results. This will be populated if
        /// gcs_uri was not specified in the request.
        #[prost(bytes, tag = "1")]
        EvaluationResultsContent(::prost::alloc::vec::Vec<u8>),
        /// The Google Cloud Storage URI folder where the exported Evaluation Results
        /// were written. This will be populated if gcs_uri was specified in the
        /// request.
        #[prost(string, tag = "2")]
        EvaluationResultsUri(::prost::alloc::string::String),
    }
}
/// Response message for
/// \[EvaluationService.ExportEvaluationRuns\]\[google.cloud.ces.v1beta.EvaluationService.ExportEvaluationRuns\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExportEvaluationRunsResponse {
    /// The exported evaluation runs.
    #[prost(oneof = "export_evaluation_runs_response::EvaluationRuns", tags = "1, 2")]
    pub evaluation_runs: ::core::option::Option<
        export_evaluation_runs_response::EvaluationRuns,
    >,
}
/// Nested message and enum types in `ExportEvaluationRunsResponse`.
pub mod export_evaluation_runs_response {
    /// The exported evaluation runs.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum EvaluationRuns {
        /// The content of the exported Evaluation Runs. This will be populated if
        /// gcs_uri was not specified in the request.
        #[prost(bytes, tag = "1")]
        EvaluationRunsContent(::prost::alloc::vec::Vec<u8>),
        /// The Google Cloud Storage URI folder where the exported Evaluation Runs
        /// were written. This will be populated if gcs_uri was specified in the
        /// request.
        #[prost(string, tag = "2")]
        EvaluationRunsUri(::prost::alloc::string::String),
    }
}
/// Generated client implementations.
pub mod evaluation_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// EvaluationService exposes methods to perform evaluation for the CES app.
    #[derive(Debug, Clone)]
    pub struct EvaluationServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl EvaluationServiceClient<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> EvaluationServiceClient<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,
        ) -> EvaluationServiceClient<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,
        {
            EvaluationServiceClient::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
        }
        /// Runs an evaluation of the app.
        pub async fn run_evaluation(
            &mut self,
            request: impl tonic::IntoRequest<super::RunEvaluationRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            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(
                "/google.cloud.ces.v1beta.EvaluationService/RunEvaluation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "RunEvaluation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Uploads audio for use in Golden Evaluations. Stores the audio in the Cloud
        /// Storage bucket defined in
        /// 'App.logging_settings.evaluation_audio_recording_config.gcs_bucket' and
        /// returns a transcript.
        pub async fn upload_evaluation_audio(
            &mut self,
            request: impl tonic::IntoRequest<super::UploadEvaluationAudioRequest>,
        ) -> std::result::Result<
            tonic::Response<super::UploadEvaluationAudioResponse>,
            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(
                "/google.cloud.ces.v1beta.EvaluationService/UploadEvaluationAudio",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "UploadEvaluationAudio",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates an evaluation.
        pub async fn create_evaluation(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateEvaluationRequest>,
        ) -> std::result::Result<tonic::Response<super::Evaluation>, 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(
                "/google.cloud.ces.v1beta.EvaluationService/CreateEvaluation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "CreateEvaluation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a golden evaluation from a conversation.
        pub async fn generate_evaluation(
            &mut self,
            request: impl tonic::IntoRequest<super::GenerateEvaluationRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            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(
                "/google.cloud.ces.v1beta.EvaluationService/GenerateEvaluation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "GenerateEvaluation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Imports evaluations into the app.
        pub async fn import_evaluations(
            &mut self,
            request: impl tonic::IntoRequest<super::ImportEvaluationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            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(
                "/google.cloud.ces.v1beta.EvaluationService/ImportEvaluations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "ImportEvaluations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates an evaluation dataset.
        pub async fn create_evaluation_dataset(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateEvaluationDatasetRequest>,
        ) -> std::result::Result<
            tonic::Response<super::EvaluationDataset>,
            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(
                "/google.cloud.ces.v1beta.EvaluationService/CreateEvaluationDataset",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "CreateEvaluationDataset",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates an evaluation.
        pub async fn update_evaluation(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateEvaluationRequest>,
        ) -> std::result::Result<tonic::Response<super::Evaluation>, 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(
                "/google.cloud.ces.v1beta.EvaluationService/UpdateEvaluation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "UpdateEvaluation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates an evaluation dataset.
        pub async fn update_evaluation_dataset(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateEvaluationDatasetRequest>,
        ) -> std::result::Result<
            tonic::Response<super::EvaluationDataset>,
            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(
                "/google.cloud.ces.v1beta.EvaluationService/UpdateEvaluationDataset",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "UpdateEvaluationDataset",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes an evaluation.
        pub async fn delete_evaluation(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteEvaluationRequest>,
        ) -> 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(
                "/google.cloud.ces.v1beta.EvaluationService/DeleteEvaluation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "DeleteEvaluation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes an evaluation result.
        pub async fn delete_evaluation_result(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteEvaluationResultRequest>,
        ) -> 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(
                "/google.cloud.ces.v1beta.EvaluationService/DeleteEvaluationResult",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "DeleteEvaluationResult",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes an evaluation dataset.
        pub async fn delete_evaluation_dataset(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteEvaluationDatasetRequest>,
        ) -> 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(
                "/google.cloud.ces.v1beta.EvaluationService/DeleteEvaluationDataset",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "DeleteEvaluationDataset",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes an evaluation run.
        pub async fn delete_evaluation_run(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteEvaluationRunRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            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(
                "/google.cloud.ces.v1beta.EvaluationService/DeleteEvaluationRun",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "DeleteEvaluationRun",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets details of the specified evaluation.
        pub async fn get_evaluation(
            &mut self,
            request: impl tonic::IntoRequest<super::GetEvaluationRequest>,
        ) -> std::result::Result<tonic::Response<super::Evaluation>, 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(
                "/google.cloud.ces.v1beta.EvaluationService/GetEvaluation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "GetEvaluation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets details of the specified evaluation result.
        pub async fn get_evaluation_result(
            &mut self,
            request: impl tonic::IntoRequest<super::GetEvaluationResultRequest>,
        ) -> std::result::Result<
            tonic::Response<super::EvaluationResult>,
            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(
                "/google.cloud.ces.v1beta.EvaluationService/GetEvaluationResult",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "GetEvaluationResult",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets details of the specified evaluation dataset.
        pub async fn get_evaluation_dataset(
            &mut self,
            request: impl tonic::IntoRequest<super::GetEvaluationDatasetRequest>,
        ) -> std::result::Result<
            tonic::Response<super::EvaluationDataset>,
            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(
                "/google.cloud.ces.v1beta.EvaluationService/GetEvaluationDataset",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "GetEvaluationDataset",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets details of the specified evaluation run.
        pub async fn get_evaluation_run(
            &mut self,
            request: impl tonic::IntoRequest<super::GetEvaluationRunRequest>,
        ) -> std::result::Result<tonic::Response<super::EvaluationRun>, 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(
                "/google.cloud.ces.v1beta.EvaluationService/GetEvaluationRun",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "GetEvaluationRun",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists all evaluations in the given app.
        pub async fn list_evaluations(
            &mut self,
            request: impl tonic::IntoRequest<super::ListEvaluationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListEvaluationsResponse>,
            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(
                "/google.cloud.ces.v1beta.EvaluationService/ListEvaluations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "ListEvaluations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists all evaluation results for a given evaluation.
        pub async fn list_evaluation_results(
            &mut self,
            request: impl tonic::IntoRequest<super::ListEvaluationResultsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListEvaluationResultsResponse>,
            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(
                "/google.cloud.ces.v1beta.EvaluationService/ListEvaluationResults",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "ListEvaluationResults",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists all evaluation datasets in the given app.
        pub async fn list_evaluation_datasets(
            &mut self,
            request: impl tonic::IntoRequest<super::ListEvaluationDatasetsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListEvaluationDatasetsResponse>,
            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(
                "/google.cloud.ces.v1beta.EvaluationService/ListEvaluationDatasets",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "ListEvaluationDatasets",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists all evaluation runs in the given app.
        pub async fn list_evaluation_runs(
            &mut self,
            request: impl tonic::IntoRequest<super::ListEvaluationRunsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListEvaluationRunsResponse>,
            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(
                "/google.cloud.ces.v1beta.EvaluationService/ListEvaluationRuns",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "ListEvaluationRuns",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists all evaluation expectations in the given app.
        pub async fn list_evaluation_expectations(
            &mut self,
            request: impl tonic::IntoRequest<super::ListEvaluationExpectationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListEvaluationExpectationsResponse>,
            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(
                "/google.cloud.ces.v1beta.EvaluationService/ListEvaluationExpectations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "ListEvaluationExpectations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets details of the specified evaluation expectation.
        pub async fn get_evaluation_expectation(
            &mut self,
            request: impl tonic::IntoRequest<super::GetEvaluationExpectationRequest>,
        ) -> std::result::Result<
            tonic::Response<super::EvaluationExpectation>,
            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(
                "/google.cloud.ces.v1beta.EvaluationService/GetEvaluationExpectation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "GetEvaluationExpectation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates an evaluation expectation.
        pub async fn create_evaluation_expectation(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateEvaluationExpectationRequest>,
        ) -> std::result::Result<
            tonic::Response<super::EvaluationExpectation>,
            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(
                "/google.cloud.ces.v1beta.EvaluationService/CreateEvaluationExpectation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "CreateEvaluationExpectation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates an evaluation expectation.
        pub async fn update_evaluation_expectation(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateEvaluationExpectationRequest>,
        ) -> std::result::Result<
            tonic::Response<super::EvaluationExpectation>,
            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(
                "/google.cloud.ces.v1beta.EvaluationService/UpdateEvaluationExpectation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "UpdateEvaluationExpectation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes an evaluation expectation.
        pub async fn delete_evaluation_expectation(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteEvaluationExpectationRequest>,
        ) -> 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(
                "/google.cloud.ces.v1beta.EvaluationService/DeleteEvaluationExpectation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "DeleteEvaluationExpectation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a scheduled evaluation run.
        pub async fn create_scheduled_evaluation_run(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateScheduledEvaluationRunRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ScheduledEvaluationRun>,
            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(
                "/google.cloud.ces.v1beta.EvaluationService/CreateScheduledEvaluationRun",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "CreateScheduledEvaluationRun",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets details of the specified scheduled evaluation run.
        pub async fn get_scheduled_evaluation_run(
            &mut self,
            request: impl tonic::IntoRequest<super::GetScheduledEvaluationRunRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ScheduledEvaluationRun>,
            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(
                "/google.cloud.ces.v1beta.EvaluationService/GetScheduledEvaluationRun",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "GetScheduledEvaluationRun",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists all scheduled evaluation runs in the given app.
        pub async fn list_scheduled_evaluation_runs(
            &mut self,
            request: impl tonic::IntoRequest<super::ListScheduledEvaluationRunsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListScheduledEvaluationRunsResponse>,
            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(
                "/google.cloud.ces.v1beta.EvaluationService/ListScheduledEvaluationRuns",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "ListScheduledEvaluationRuns",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates a scheduled evaluation run.
        pub async fn update_scheduled_evaluation_run(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateScheduledEvaluationRunRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ScheduledEvaluationRun>,
            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(
                "/google.cloud.ces.v1beta.EvaluationService/UpdateScheduledEvaluationRun",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "UpdateScheduledEvaluationRun",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a scheduled evaluation run.
        pub async fn delete_scheduled_evaluation_run(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteScheduledEvaluationRunRequest>,
        ) -> 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(
                "/google.cloud.ces.v1beta.EvaluationService/DeleteScheduledEvaluationRun",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "DeleteScheduledEvaluationRun",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Tests the voice of a persona. Also accepts a default persona.
        pub async fn test_persona_voice(
            &mut self,
            request: impl tonic::IntoRequest<super::TestPersonaVoiceRequest>,
        ) -> std::result::Result<
            tonic::Response<super::TestPersonaVoiceResponse>,
            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(
                "/google.cloud.ces.v1beta.EvaluationService/TestPersonaVoice",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "TestPersonaVoice",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Exports evaluations.
        pub async fn export_evaluations(
            &mut self,
            request: impl tonic::IntoRequest<super::ExportEvaluationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            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(
                "/google.cloud.ces.v1beta.EvaluationService/ExportEvaluations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.EvaluationService",
                        "ExportEvaluations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Represents an Omnichannel resource.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Omnichannel {
    /// Identifier. The unique identifier of the omnichannel resource.
    /// Format:
    /// `projects/{project}/locations/{location}/omnichannels/{omnichannel}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. Display name of the omnichannel resource.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Optional. Human-readable description of the omnichannel resource.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Output only. Timestamp when the omnichannel resource was created.
    #[prost(message, optional, tag = "4")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Timestamp when the omnichannel resource was last updated.
    #[prost(message, optional, tag = "5")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Etag used to ensure the object hasn't changed during a
    /// read-modify-write operation.
    #[prost(string, tag = "6")]
    pub etag: ::prost::alloc::string::String,
    /// Optional. The integration config for the omnichannel resource.
    #[prost(message, optional, tag = "7")]
    pub integration_config: ::core::option::Option<OmnichannelIntegrationConfig>,
}
/// OmnichannelIntegrationConfig contains all App integration configs.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OmnichannelIntegrationConfig {
    /// Optional. Various of configuration for handling App events.
    #[prost(map = "string, message", tag = "1")]
    pub channel_configs: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        omnichannel_integration_config::ChannelConfig,
    >,
    /// Optional. Various of subscribers configs.
    #[prost(map = "string, message", tag = "2")]
    pub subscriber_configs: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        omnichannel_integration_config::SubscriberConfig,
    >,
    /// Optional. The key of routing_configs is a key of `app_configs`, value is a
    /// `RoutingConfig`, which contains subscriber's key.
    #[prost(map = "string, message", tag = "3")]
    pub routing_configs: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        omnichannel_integration_config::RoutingConfig,
    >,
}
/// Nested message and enum types in `OmnichannelIntegrationConfig`.
pub mod omnichannel_integration_config {
    /// ChannelConfig contains config for various of app integration.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ChannelConfig {
        /// The config for the app.
        #[prost(oneof = "channel_config::ChannelConfig", tags = "1")]
        pub channel_config: ::core::option::Option<channel_config::ChannelConfig>,
    }
    /// Nested message and enum types in `ChannelConfig`.
    pub mod channel_config {
        /// The config for the app.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
        pub enum ChannelConfig {
            /// WhatsApp config.
            #[prost(message, tag = "1")]
            WhatsappConfig(super::WhatsappConfig),
        }
    }
    /// How Omnichannel should receive/reply events from WhatsApp.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct WhatsappConfig {
        /// The Phone Number ID associated with the WhatsApp Business Account.
        #[prost(string, tag = "1")]
        pub phone_number_id: ::prost::alloc::string::String,
        /// The phone number used for sending/receiving messages.
        #[prost(string, tag = "2")]
        pub phone_number: ::prost::alloc::string::String,
        /// The customer's WhatsApp Business Account (WABA) ID.
        #[prost(string, tag = "3")]
        pub whatsapp_business_account_id: ::prost::alloc::string::String,
        /// The verify token configured in the Meta App Dashboard for webhook
        /// verification.
        #[prost(string, tag = "4")]
        pub webhook_verify_token: ::prost::alloc::string::String,
        /// The access token for authenticating API calls to the WhatsApp Cloud API.
        /// <https://developers.facebook.com/docs/whatsapp/business-management-api/get-started/#business-integration-system-user-access-tokens>
        #[prost(string, tag = "5")]
        pub whatsapp_business_token: ::prost::alloc::string::String,
        /// The Meta Business Portfolio (MBP) ID.
        /// <https://www.facebook.com/business/help/1710077379203657>
        #[prost(string, tag = "6")]
        pub meta_business_portfolio_id: ::prost::alloc::string::String,
    }
    /// Configs of subscribers.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct SubscriberConfig {
        /// The config for the subscriber.
        #[prost(oneof = "subscriber_config::SubscriberConfig", tags = "1")]
        pub subscriber_config: ::core::option::Option<
            subscriber_config::SubscriberConfig,
        >,
    }
    /// Nested message and enum types in `SubscriberConfig`.
    pub mod subscriber_config {
        /// The config for the subscriber.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
        pub enum SubscriberConfig {
            /// Ces app config.
            #[prost(message, tag = "1")]
            CesAppConfig(super::CesAppConfig),
        }
    }
    /// Configs for CES app.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct CesAppConfig {
        /// The unique identifier of the CES app.
        /// Format: `projects/{project}/locations/{location}/apps/{app}`
        #[prost(string, tag = "1")]
        pub app: ::prost::alloc::string::String,
    }
    /// Routing config specify how/who to route app events to a subscriber.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct RoutingConfig {
        /// The key of the subscriber.
        #[prost(string, tag = "1")]
        pub subscriber_key: ::prost::alloc::string::String,
    }
}
/// Represents the metadata of the long-running operation.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct OmnichannelOperationMetadata {
    /// Output only. The time the operation was created.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The time the operation finished running.
    #[prost(message, optional, tag = "2")]
    pub end_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Human-readable status of the operation, if any.
    #[prost(string, tag = "3")]
    pub status_message: ::prost::alloc::string::String,
    /// Output only. Identifies whether the user has requested cancellation of the
    /// operation.
    #[prost(bool, tag = "4")]
    pub requested_cancellation: bool,
}
/// Request message for
/// \[ToolService.ExecuteTool\]\[google.cloud.ces.v1beta.ToolService.ExecuteTool\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecuteToolRequest {
    /// Required. The resource name of the app which the tool/toolset belongs to.
    /// Format: `projects/{project}/locations/{location}/apps/{app}`
    #[prost(string, tag = "4")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The input parameters and values for the tool in JSON object
    /// format.
    #[prost(message, optional, tag = "2")]
    pub args: ::core::option::Option<::prost_types::Struct>,
    /// Optional. Mock configuration for the tool execution.
    /// If this field is set, tools that call other tools will be
    /// mocked based on the provided patterns and responses.
    #[prost(message, optional, tag = "7")]
    pub mock_config: ::core::option::Option<MockConfig>,
    /// The identifier of the tool to execute. It could be either a persisted tool
    /// or a tool from a toolset.
    #[prost(oneof = "execute_tool_request::ToolIdentifier", tags = "1, 3")]
    pub tool_identifier: ::core::option::Option<execute_tool_request::ToolIdentifier>,
    /// Additional context to be provided for the tool execution
    #[prost(oneof = "execute_tool_request::ToolExecutionContext", tags = "5, 6")]
    pub tool_execution_context: ::core::option::Option<
        execute_tool_request::ToolExecutionContext,
    >,
}
/// Nested message and enum types in `ExecuteToolRequest`.
pub mod execute_tool_request {
    /// The identifier of the tool to execute. It could be either a persisted tool
    /// or a tool from a toolset.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum ToolIdentifier {
        /// Optional. The name of the tool to execute.
        /// Format:
        /// projects/{project}/locations/{location}/apps/{app}/tools/{tool}
        #[prost(string, tag = "1")]
        Tool(::prost::alloc::string::String),
        /// Optional. The toolset tool to execute. Only one tool should match the
        /// predicate from the toolset. Otherwise, an error will be returned.
        #[prost(message, tag = "3")]
        ToolsetTool(super::ToolsetTool),
    }
    /// Additional context to be provided for the tool execution
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum ToolExecutionContext {
        /// Optional. The variables that are available for the tool execution.
        #[prost(message, tag = "5")]
        Variables(::prost_types::Struct),
        /// Optional. The
        /// \[ToolCallContext\](<https://docs.cloud.google.com/customer-engagement-ai/conversational-agents/ps/tool/python#environment>
        /// for details) to be passed to the Python tool.
        #[prost(message, tag = "6")]
        Context(::prost_types::Struct),
    }
}
/// Response message for
/// \[ToolService.ExecuteTool\]\[google.cloud.ces.v1beta.ToolService.ExecuteTool\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecuteToolResponse {
    /// The tool execution result in JSON object format.
    /// Use "output" key to specify tool response and "error" key to specify
    /// error details (if any). If "output" and "error" keys are not specified,
    /// then whole "response" is treated as tool execution result.
    #[prost(message, optional, tag = "2")]
    pub response: ::core::option::Option<::prost_types::Struct>,
    /// The variable values at the end of the tool execution.
    #[prost(message, optional, tag = "4")]
    pub variables: ::core::option::Option<::prost_types::Struct>,
    /// The identifier of the tool that got executed.
    #[prost(oneof = "execute_tool_response::ToolIdentifier", tags = "1, 3")]
    pub tool_identifier: ::core::option::Option<execute_tool_response::ToolIdentifier>,
}
/// Nested message and enum types in `ExecuteToolResponse`.
pub mod execute_tool_response {
    /// The identifier of the tool that got executed.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum ToolIdentifier {
        /// The name of the tool that got executed.
        /// Format: `projects/{project}/locations/{location}/apps/{app}/tools/{tool}`
        #[prost(string, tag = "1")]
        Tool(::prost::alloc::string::String),
        /// The toolset tool that got executed.
        #[prost(message, tag = "3")]
        ToolsetTool(super::ToolsetTool),
    }
}
/// Request message for
/// \[ToolService.RetrieveToolSchema\]\[google.cloud.ces.v1beta.ToolService.RetrieveToolSchema\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RetrieveToolSchemaRequest {
    /// Required. The resource name of the app which the tool/toolset belongs to.
    /// Format: `projects/{project}/locations/{location}/apps/{app}`
    #[prost(string, tag = "3")]
    pub parent: ::prost::alloc::string::String,
    /// The identifier of the tool to retrieve the schema for. It could be either a
    /// persisted tool or a tool from a toolset.
    #[prost(oneof = "retrieve_tool_schema_request::ToolIdentifier", tags = "1, 2")]
    pub tool_identifier: ::core::option::Option<
        retrieve_tool_schema_request::ToolIdentifier,
    >,
}
/// Nested message and enum types in `RetrieveToolSchemaRequest`.
pub mod retrieve_tool_schema_request {
    /// The identifier of the tool to retrieve the schema for. It could be either a
    /// persisted tool or a tool from a toolset.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum ToolIdentifier {
        /// Optional. The name of the tool to retrieve the schema for.
        /// Format:
        /// projects/{project}/locations/{location}/apps/{app}/tools/{tool}
        #[prost(string, tag = "1")]
        Tool(::prost::alloc::string::String),
        /// Optional. The toolset tool to retrieve the schema for. Only one tool
        /// should match the predicate from the toolset. Otherwise, an error will be
        /// returned.
        #[prost(message, tag = "2")]
        ToolsetTool(super::ToolsetTool),
    }
}
/// Response message for
/// \[ToolService.RetrieveToolSchema\]\[google.cloud.ces.v1beta.ToolService.RetrieveToolSchema\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RetrieveToolSchemaResponse {
    /// The schema of the tool input parameters.
    #[prost(message, optional, tag = "3")]
    pub input_schema: ::core::option::Option<Schema>,
    /// The schema of the tool output parameters.
    #[prost(message, optional, tag = "4")]
    pub output_schema: ::core::option::Option<Schema>,
    /// The identifier of the tool that the schema is for.
    #[prost(oneof = "retrieve_tool_schema_response::ToolIdentifier", tags = "1, 2")]
    pub tool_identifier: ::core::option::Option<
        retrieve_tool_schema_response::ToolIdentifier,
    >,
}
/// Nested message and enum types in `RetrieveToolSchemaResponse`.
pub mod retrieve_tool_schema_response {
    /// The identifier of the tool that the schema is for.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum ToolIdentifier {
        /// The name of the tool that the schema is for.
        /// Format: `projects/{project}/locations/{location}/apps/{app}/tools/{tool}`
        #[prost(string, tag = "1")]
        Tool(::prost::alloc::string::String),
        /// The toolset tool that the schema is for.
        #[prost(message, tag = "2")]
        ToolsetTool(super::ToolsetTool),
    }
}
/// Request message for
/// \[ToolService.RetrieveTools\]\[google.cloud.ces.v1beta.ToolService.RetrieveTools\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RetrieveToolsRequest {
    /// Required. The name of the toolset to retrieve the tools for.
    /// Format:
    /// `projects/{project}/locations/{location}/apps/{app}/toolsets/{toolset}`
    #[prost(string, tag = "1")]
    pub toolset: ::prost::alloc::string::String,
    /// Optional. The identifiers of the tools to retrieve from the toolset.
    /// If empty, all tools in the toolset will be returned.
    #[prost(string, repeated, tag = "3")]
    pub tool_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Response message for
/// \[ToolService.RetrieveTools\]\[google.cloud.ces.v1beta.ToolService.RetrieveTools\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RetrieveToolsResponse {
    /// The list of tools that are included in the specified toolset.
    #[prost(message, repeated, tag = "1")]
    pub tools: ::prost::alloc::vec::Vec<Tool>,
}
/// Generated client implementations.
pub mod tool_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Tool service provides APIs for interacting with CES tools.
    #[derive(Debug, Clone)]
    pub struct ToolServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ToolServiceClient<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> ToolServiceClient<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,
        ) -> ToolServiceClient<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,
        {
            ToolServiceClient::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
        }
        /// Executes the given tool with the given arguments.
        pub async fn execute_tool(
            &mut self,
            request: impl tonic::IntoRequest<super::ExecuteToolRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ExecuteToolResponse>,
            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(
                "/google.cloud.ces.v1beta.ToolService/ExecuteTool",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.ces.v1beta.ToolService", "ExecuteTool"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieve the schema of the given tool. The schema is computed on the fly
        /// for the given instance of the tool.
        pub async fn retrieve_tool_schema(
            &mut self,
            request: impl tonic::IntoRequest<super::RetrieveToolSchemaRequest>,
        ) -> std::result::Result<
            tonic::Response<super::RetrieveToolSchemaResponse>,
            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(
                "/google.cloud.ces.v1beta.ToolService/RetrieveToolSchema",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.ToolService",
                        "RetrieveToolSchema",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieve the list of tools included in the specified toolset.
        pub async fn retrieve_tools(
            &mut self,
            request: impl tonic::IntoRequest<super::RetrieveToolsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::RetrieveToolsResponse>,
            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(
                "/google.cloud.ces.v1beta.ToolService/RetrieveTools",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.ToolService",
                        "RetrieveTools",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Request message for
/// \[WidgetService.GenerateChatToken\]\[google.cloud.ces.v1beta.WidgetService.GenerateChatToken\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GenerateChatTokenRequest {
    /// Required. The session name to generate the chat token for.
    /// Format:
    /// projects/{project}/locations/{location}/apps/{app}/sessions/{session}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. The deployment of the app to use for the session.
    /// Format:
    /// projects/{project}/locations/{location}/apps/{app}/deployments/{deployment}
    #[prost(string, tag = "2")]
    pub deployment: ::prost::alloc::string::String,
    /// Optional. The reCAPTCHA token generated by the client-side chat widget.
    #[prost(string, tag = "3")]
    pub recaptcha_token: ::prost::alloc::string::String,
    /// Optional. Indicates if live handoff is enabled for the session.
    #[prost(bool, tag = "4")]
    pub live_handoff_enabled: bool,
}
/// Response message for
/// \[WidgetService.GenerateChatToken\]\[google.cloud.ces.v1beta.WidgetService.GenerateChatToken\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GenerateChatTokenResponse {
    /// The session scoped token for chat widget to authenticate with Session APIs.
    #[prost(string, tag = "1")]
    pub chat_token: ::prost::alloc::string::String,
    /// The time at which the chat token expires.
    #[prost(message, optional, tag = "2")]
    pub expire_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Generated client implementations.
pub mod widget_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Provides APIs for widgets to interact with CES APIs.
    #[derive(Debug, Clone)]
    pub struct WidgetServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl WidgetServiceClient<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> WidgetServiceClient<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,
        ) -> WidgetServiceClient<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,
        {
            WidgetServiceClient::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
        }
        /// Generates a session scoped token for chat widget to authenticate with
        /// Session APIs.
        pub async fn generate_chat_token(
            &mut self,
            request: impl tonic::IntoRequest<super::GenerateChatTokenRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GenerateChatTokenResponse>,
            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(
                "/google.cloud.ces.v1beta.WidgetService/GenerateChatToken",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.ces.v1beta.WidgetService",
                        "GenerateChatToken",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
