// This file is @generated by prost-build.
/// Google Cloud Storage location for a Dialogflow operation that writes or
/// exports objects (e.g. exported agent or transcripts) outside of Dialogflow.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GcsDestination {
    /// Required. The Google Cloud Storage URI for the exported objects. A URI is
    /// of the form: `gs://bucket/object-name-or-prefix` Whether a full object
    /// name, or just a prefix, its usage depends on the Dialogflow operation.
    #[prost(string, tag = "1")]
    pub uri: ::prost::alloc::string::String,
}
/// Hierarchical advanced settings for agent/flow/page/fulfillment/parameter.
/// Settings exposed at lower level overrides the settings exposed at higher
/// level. Overriding occurs at the sub-setting level. For example, the
/// playback_interruption_settings at fulfillment level only overrides the
/// playback_interruption_settings at the agent level, leaving other settings
/// at the agent level unchanged.
///
/// DTMF settings does not override each other. DTMF settings set at different
/// levels define DTMF detections running in parallel.
///
/// Hierarchy: Agent->Flow->Page->Fulfillment/Parameter.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AdvancedSettings {
    /// If present, incoming audio is exported by Dialogflow to the configured
    /// Google Cloud Storage destination.
    /// Exposed at the following levels:
    ///
    /// * Agent level
    /// * Flow level
    #[prost(message, optional, tag = "2")]
    pub audio_export_gcs_destination: ::core::option::Option<GcsDestination>,
    /// Settings for speech to text detection.
    /// Exposed at the following levels:
    ///
    /// * Agent level
    /// * Flow level
    /// * Page level
    /// * Parameter level
    #[prost(message, optional, tag = "3")]
    pub speech_settings: ::core::option::Option<advanced_settings::SpeechSettings>,
    /// Settings for DTMF.
    /// Exposed at the following levels:
    ///
    /// * Agent level
    /// * Flow level
    /// * Page level
    /// * Parameter level.
    #[prost(message, optional, tag = "5")]
    pub dtmf_settings: ::core::option::Option<advanced_settings::DtmfSettings>,
    /// Settings for logging.
    /// Settings for Dialogflow History, Contact Center messages, StackDriver logs,
    /// and speech logging.
    /// Exposed at the following levels:
    ///
    /// * Agent level.
    #[prost(message, optional, tag = "6")]
    pub logging_settings: ::core::option::Option<advanced_settings::LoggingSettings>,
}
/// Nested message and enum types in `AdvancedSettings`.
pub mod advanced_settings {
    /// Define behaviors of speech to text detection.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SpeechSettings {
        /// Sensitivity of the speech model that detects the end of speech.
        /// Scale from 0 to 100.
        #[prost(int32, tag = "1")]
        pub endpointer_sensitivity: i32,
        /// Timeout before detecting no speech.
        #[prost(message, optional, tag = "2")]
        pub no_speech_timeout: ::core::option::Option<::prost_types::Duration>,
        /// Use timeout based endpointing, interpreting endpointer sensitivity as
        /// seconds of timeout value.
        #[prost(bool, tag = "3")]
        pub use_timeout_based_endpointing: bool,
        /// Mapping from language to Speech-to-Text model. The mapped Speech-to-Text
        /// model will be selected for requests from its corresponding language.
        /// For more information, see
        /// [Speech
        /// models](<https://cloud.google.com/dialogflow/cx/docs/concept/speech-models>).
        #[prost(map = "string, string", tag = "5")]
        pub models: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            ::prost::alloc::string::String,
        >,
    }
    /// Define behaviors for DTMF (dual tone multi frequency).
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct DtmfSettings {
        /// If true, incoming audio is processed for DTMF (dual tone multi frequency)
        /// events. For example, if the caller presses a button on their telephone
        /// keypad and DTMF processing is enabled, Dialogflow will detect the
        /// event (e.g. a "3" was pressed) in the incoming audio and pass the event
        /// to the bot to drive business logic (e.g. when 3 is pressed, return the
        /// account balance).
        #[prost(bool, tag = "1")]
        pub enabled: bool,
        /// Max length of DTMF digits.
        #[prost(int32, tag = "2")]
        pub max_digits: i32,
        /// The digit that terminates a DTMF digit sequence.
        #[prost(string, tag = "3")]
        pub finish_digit: ::prost::alloc::string::String,
        /// Interdigit timeout setting for matching dtmf input to regex.
        #[prost(message, optional, tag = "6")]
        pub interdigit_timeout_duration: ::core::option::Option<::prost_types::Duration>,
        /// Endpoint timeout setting for matching dtmf input to regex.
        #[prost(message, optional, tag = "7")]
        pub endpointing_timeout_duration: ::core::option::Option<
            ::prost_types::Duration,
        >,
    }
    /// Define behaviors on logging.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct LoggingSettings {
        /// Enables Google Cloud Logging.
        #[prost(bool, tag = "2")]
        pub enable_stackdriver_logging: bool,
        /// Enables DF Interaction logging.
        #[prost(bool, tag = "3")]
        pub enable_interaction_logging: bool,
        /// Enables consent-based end-user input redaction, if true, a pre-defined
        /// session parameter `$session.params.conversation-redaction` will be
        /// used to determine if the utterance should be redacted.
        #[prost(bool, tag = "4")]
        pub enable_consent_based_redaction: bool,
    }
}
/// Information for a word recognized by the speech recognizer.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SpeechWordInfo {
    /// The word this info is for.
    #[prost(string, tag = "3")]
    pub word: ::prost::alloc::string::String,
    /// Time offset relative to the beginning of the audio that corresponds to the
    /// start of the spoken word. This is an experimental feature and the accuracy
    /// of the time offset can vary.
    #[prost(message, optional, tag = "1")]
    pub start_offset: ::core::option::Option<::prost_types::Duration>,
    /// Time offset relative to the beginning of the audio that corresponds to the
    /// end of the spoken word. This is an experimental feature and the accuracy of
    /// the time offset can vary.
    #[prost(message, optional, tag = "2")]
    pub end_offset: ::core::option::Option<::prost_types::Duration>,
    /// The Speech confidence between 0.0 and 1.0 for this word. A higher number
    /// indicates an estimated greater likelihood that the recognized word is
    /// correct. The default of 0.0 is a sentinel value indicating that confidence
    /// was not set.
    ///
    /// This field is not guaranteed to be fully stable over time for the same
    /// audio input. Users should also not rely on it to always be provided.
    #[prost(float, tag = "4")]
    pub confidence: f32,
}
/// Configuration of the barge-in behavior. Barge-in instructs the API to return
/// a detected utterance at a proper time while the client is playing back the
/// response audio from a previous request. When the client sees the
/// utterance, it should stop the playback and immediately get ready for
/// receiving the responses for the current request.
///
/// The barge-in handling requires the client to start streaming audio input
/// as soon as it starts playing back the audio from the previous response. The
/// playback is modeled into two phases:
///
/// * No barge-in phase: which goes first and during which speech detection
///   should not be carried out.
///
/// * Barge-in phase: which follows the no barge-in phase and during which
///   the API starts speech detection and may inform the client that an utterance
///   has been detected. Note that no-speech event is not expected in this
///   phase.
///
/// The client provides this configuration in terms of the durations of those
/// two phases. The durations are measured in terms of the audio length from the
/// start of the input audio.
///
/// No-speech event is a response with END_OF_UTTERANCE without any transcript
/// following up.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BargeInConfig {
    /// Duration that is not eligible for barge-in at the beginning of the input
    /// audio.
    #[prost(message, optional, tag = "1")]
    pub no_barge_in_duration: ::core::option::Option<::prost_types::Duration>,
    /// Total duration for the playback at the beginning of the input audio.
    #[prost(message, optional, tag = "2")]
    pub total_duration: ::core::option::Option<::prost_types::Duration>,
}
/// Instructs the speech recognizer on how to process the audio content.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct InputAudioConfig {
    /// Required. Audio encoding of the audio content to process.
    #[prost(enumeration = "AudioEncoding", tag = "1")]
    pub audio_encoding: i32,
    /// Sample rate (in Hertz) of the audio content sent in the query.
    /// Refer to
    /// [Cloud Speech API
    /// documentation](<https://cloud.google.com/speech-to-text/docs/basics>) for
    /// more details.
    #[prost(int32, tag = "2")]
    pub sample_rate_hertz: i32,
    /// Optional. If `true`, Dialogflow returns
    /// \[SpeechWordInfo\]\[google.cloud.dialogflow.cx.v3.SpeechWordInfo\] in
    /// \[StreamingRecognitionResult\]\[google.cloud.dialogflow.cx.v3.StreamingRecognitionResult\]
    /// with information about the recognized speech words, e.g. start and end time
    /// offsets. If false or unspecified, Speech doesn't return any word-level
    /// information.
    #[prost(bool, tag = "13")]
    pub enable_word_info: bool,
    /// Optional. A list of strings containing words and phrases that the speech
    /// recognizer should recognize with higher likelihood.
    ///
    /// See [the Cloud Speech
    /// documentation](<https://cloud.google.com/speech-to-text/docs/basics#phrase-hints>)
    /// for more details.
    #[prost(string, repeated, tag = "4")]
    pub phrase_hints: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. Which Speech model to select for the given request.
    /// For more information, see
    /// [Speech
    /// models](<https://cloud.google.com/dialogflow/cx/docs/concept/speech-models>).
    #[prost(string, tag = "7")]
    pub model: ::prost::alloc::string::String,
    /// Optional. Which variant of the \[Speech
    /// model\]\[google.cloud.dialogflow.cx.v3.InputAudioConfig.model\] to use.
    #[prost(enumeration = "SpeechModelVariant", tag = "10")]
    pub model_variant: i32,
    /// Optional. If `false` (default), recognition does not cease until the
    /// client closes the stream.
    /// If `true`, the recognizer will detect a single spoken utterance in input
    /// audio. Recognition ceases when it detects the audio's voice has
    /// stopped or paused. In this case, once a detected intent is received, the
    /// client should close the stream and start a new request with a new stream as
    /// needed.
    /// Note: This setting is relevant only for streaming methods.
    #[prost(bool, tag = "8")]
    pub single_utterance: bool,
    /// Configuration of barge-in behavior during the streaming of input audio.
    #[prost(message, optional, tag = "15")]
    pub barge_in_config: ::core::option::Option<BargeInConfig>,
    /// If `true`, the request will opt out for STT conformer model migration.
    /// This field will be deprecated once force migration takes place in June
    /// 2024. Please refer to [Dialogflow CX Speech model
    /// migration](<https://cloud.google.com/dialogflow/cx/docs/concept/speech-model-migration>).
    #[prost(bool, tag = "26")]
    pub opt_out_conformer_model_migration: bool,
}
/// Description of which voice to use for speech synthesis.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct VoiceSelectionParams {
    /// Optional. The name of the voice. If not set, the service will choose a
    /// voice based on the other parameters such as language_code and
    /// \[ssml_gender\]\[google.cloud.dialogflow.cx.v3.VoiceSelectionParams.ssml_gender\].
    ///
    /// For the list of available voices, please refer to [Supported voices and
    /// languages](<https://cloud.google.com/text-to-speech/docs/voices>).
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The preferred gender of the voice. If not set, the service will
    /// choose a voice based on the other parameters such as language_code and
    /// \[name\]\[google.cloud.dialogflow.cx.v3.VoiceSelectionParams.name\]. Note that
    /// this is only a preference, not requirement. If a voice of the appropriate
    /// gender is not available, the synthesizer substitutes a voice with a
    /// different gender rather than failing the request.
    #[prost(enumeration = "SsmlVoiceGender", tag = "2")]
    pub ssml_gender: i32,
}
/// Configuration of how speech should be synthesized.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SynthesizeSpeechConfig {
    /// Optional. Speaking rate/speed, in the range \[0.25, 4.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. If unset(0.0), defaults to the native 1.0 speed. Any
    /// other values \< 0.25 or > 4.0 will return an error.
    #[prost(double, tag = "1")]
    pub speaking_rate: f64,
    /// Optional. Speaking pitch, in the range \[-20.0, 20.0\]. 20 means increase 20
    /// semitones from the original pitch. -20 means decrease 20 semitones from the
    /// original pitch.
    #[prost(double, tag = "2")]
    pub pitch: f64,
    /// Optional. Volume gain (in dB) of the normal native volume supported by the
    /// specific voice, 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,
    /// Optional. An identifier which selects 'audio effects' profiles that are
    /// applied on (post synthesized) text to speech. Effects are applied on top of
    /// each other in the order they are given.
    #[prost(string, repeated, tag = "5")]
    pub effects_profile_id: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. The desired voice of the synthesized audio.
    #[prost(message, optional, tag = "4")]
    pub voice: ::core::option::Option<VoiceSelectionParams>,
}
/// Instructs the speech synthesizer how to generate the output audio content.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OutputAudioConfig {
    /// Required. Audio encoding of the synthesized audio content.
    #[prost(enumeration = "OutputAudioEncoding", tag = "1")]
    pub audio_encoding: i32,
    /// Optional. The synthesis sample rate (in hertz) for this audio. If not
    /// provided, then the synthesizer will use the default sample rate based on
    /// the audio encoding. If this is different from the voice's natural sample
    /// rate, then the synthesizer will honor this request by converting to the
    /// desired sample rate (which might result in worse audio quality).
    #[prost(int32, tag = "2")]
    pub sample_rate_hertz: i32,
    /// Optional. Configuration of how speech should be synthesized.
    /// If not specified,
    /// \[Agent.text_to_speech_settings\]\[google.cloud.dialogflow.cx.v3.Agent.text_to_speech_settings\]
    /// is applied.
    #[prost(message, optional, tag = "3")]
    pub synthesize_speech_config: ::core::option::Option<SynthesizeSpeechConfig>,
}
/// Settings related to speech synthesizing.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TextToSpeechSettings {
    /// Configuration of how speech should be synthesized, mapping from language
    /// (<https://cloud.google.com/dialogflow/cx/docs/reference/language>) to
    /// SynthesizeSpeechConfig.
    ///
    /// These settings affect:
    ///
    /// * The [phone
    ///   gateway](<https://cloud.google.com/dialogflow/cx/docs/concept/integration/phone-gateway>)
    ///   synthesize configuration set via
    ///   \[Agent.text_to_speech_settings\]\[google.cloud.dialogflow.cx.v3.Agent.text_to_speech_settings\].
    ///
    /// * How speech is synthesized when invoking
    ///   \[session\]\[google.cloud.dialogflow.cx.v3.Sessions\] APIs.
    ///   \[Agent.text_to_speech_settings\]\[google.cloud.dialogflow.cx.v3.Agent.text_to_speech_settings\]
    ///   only applies if
    ///   \[OutputAudioConfig.synthesize_speech_config\]\[google.cloud.dialogflow.cx.v3.OutputAudioConfig.synthesize_speech_config\]
    ///   is not specified.
    #[prost(map = "string, message", tag = "1")]
    pub synthesize_speech_configs: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        SynthesizeSpeechConfig,
    >,
}
/// Audio encoding of the audio content sent in the conversational query request.
/// Refer to the
/// [Cloud Speech API
/// documentation](<https://cloud.google.com/speech-to-text/docs/basics>) for more
/// details.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum AudioEncoding {
    /// Not specified.
    Unspecified = 0,
    /// Uncompressed 16-bit signed little-endian samples (Linear PCM).
    /// LINT: LEGACY_NAMES
    Linear16 = 1,
    /// [`FLAC`](<https://xiph.org/flac/documentation.html>) (Free Lossless Audio
    /// Codec) is the recommended encoding because it is lossless (therefore
    /// recognition is not compromised) and requires only about half the
    /// bandwidth of `LINEAR16`. `FLAC` stream encoding supports 16-bit and
    /// 24-bit samples, however, not all fields in `STREAMINFO` are supported.
    Flac = 2,
    /// 8-bit samples that compand 14-bit audio samples using G.711 PCMU/mu-law.
    Mulaw = 3,
    /// Adaptive Multi-Rate Narrowband codec. `sample_rate_hertz` must be 8000.
    Amr = 4,
    /// Adaptive Multi-Rate Wideband codec. `sample_rate_hertz` must be 16000.
    AmrWb = 5,
    /// Opus encoded audio frames in Ogg container
    /// ([OggOpus](<https://wiki.xiph.org/OggOpus>)).
    /// `sample_rate_hertz` must be 16000.
    OggOpus = 6,
    /// Although the use of lossy encodings is not recommended, if a very low
    /// bitrate encoding is required, `OGG_OPUS` is highly preferred over
    /// Speex encoding. The [Speex](<https://speex.org/>) encoding supported by
    /// Dialogflow API has a header byte in each block, as in MIME type
    /// `audio/x-speex-with-header-byte`.
    /// It is a variant of the RTP Speex encoding defined in
    /// [RFC 5574](<https://tools.ietf.org/html/rfc5574>).
    /// The stream is a sequence of blocks, one block per RTP packet. Each block
    /// starts with a byte containing the length of the block, in bytes, followed
    /// by one or more frames of Speex data, padded to an integral number of
    /// bytes (octets) as specified in RFC 5574. In other words, each RTP header
    /// is replaced with a single byte containing the block length. Only Speex
    /// wideband is supported. `sample_rate_hertz` must be 16000.
    SpeexWithHeaderByte = 7,
    /// 8-bit samples that compand 13-bit audio samples using G.711 PCMU/a-law.
    Alaw = 8,
}
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 => "AUDIO_ENCODING_LINEAR_16",
            Self::Flac => "AUDIO_ENCODING_FLAC",
            Self::Mulaw => "AUDIO_ENCODING_MULAW",
            Self::Amr => "AUDIO_ENCODING_AMR",
            Self::AmrWb => "AUDIO_ENCODING_AMR_WB",
            Self::OggOpus => "AUDIO_ENCODING_OGG_OPUS",
            Self::SpeexWithHeaderByte => "AUDIO_ENCODING_SPEEX_WITH_HEADER_BYTE",
            Self::Alaw => "AUDIO_ENCODING_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),
            "AUDIO_ENCODING_LINEAR_16" => Some(Self::Linear16),
            "AUDIO_ENCODING_FLAC" => Some(Self::Flac),
            "AUDIO_ENCODING_MULAW" => Some(Self::Mulaw),
            "AUDIO_ENCODING_AMR" => Some(Self::Amr),
            "AUDIO_ENCODING_AMR_WB" => Some(Self::AmrWb),
            "AUDIO_ENCODING_OGG_OPUS" => Some(Self::OggOpus),
            "AUDIO_ENCODING_SPEEX_WITH_HEADER_BYTE" => Some(Self::SpeexWithHeaderByte),
            "AUDIO_ENCODING_ALAW" => Some(Self::Alaw),
            _ => None,
        }
    }
}
/// Variant of the specified \[Speech
/// model\]\[google.cloud.dialogflow.cx.v3.InputAudioConfig.model\] to use.
///
/// See the [Cloud Speech
/// documentation](<https://cloud.google.com/speech-to-text/docs/enhanced-models>)
/// for which models have different variants. For example, the "phone_call" model
/// has both a standard and an enhanced variant. When you use an enhanced model,
/// you will generally receive higher quality results than for a standard model.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SpeechModelVariant {
    /// No model variant specified. In this case Dialogflow defaults to
    /// USE_BEST_AVAILABLE.
    Unspecified = 0,
    /// Use the best available variant of the \[Speech
    /// model\]\[InputAudioConfig.model\] that the caller is eligible for.
    UseBestAvailable = 1,
    /// Use standard model variant even if an enhanced model is available.  See the
    /// [Cloud Speech
    /// documentation](<https://cloud.google.com/speech-to-text/docs/enhanced-models>)
    /// for details about enhanced models.
    UseStandard = 2,
    /// Use an enhanced model variant:
    ///
    /// * If an enhanced variant does not exist for the given
    ///   \[model\]\[google.cloud.dialogflow.cx.v3.InputAudioConfig.model\] and request
    ///   language, Dialogflow falls back to the standard variant.
    ///
    ///   The [Cloud Speech
    ///   documentation](<https://cloud.google.com/speech-to-text/docs/enhanced-models>)
    ///   describes which models have enhanced variants.
    UseEnhanced = 3,
}
impl SpeechModelVariant {
    /// 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 => "SPEECH_MODEL_VARIANT_UNSPECIFIED",
            Self::UseBestAvailable => "USE_BEST_AVAILABLE",
            Self::UseStandard => "USE_STANDARD",
            Self::UseEnhanced => "USE_ENHANCED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SPEECH_MODEL_VARIANT_UNSPECIFIED" => Some(Self::Unspecified),
            "USE_BEST_AVAILABLE" => Some(Self::UseBestAvailable),
            "USE_STANDARD" => Some(Self::UseStandard),
            "USE_ENHANCED" => Some(Self::UseEnhanced),
            _ => None,
        }
    }
}
/// Gender of the voice as described in
/// [SSML voice element](<https://www.w3.org/TR/speech-synthesis11/#edef_voice>).
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SsmlVoiceGender {
    /// An unspecified gender, which means that the client doesn't care which
    /// gender the selected voice will have.
    Unspecified = 0,
    /// A male voice.
    Male = 1,
    /// A female voice.
    Female = 2,
    /// A gender-neutral voice.
    Neutral = 3,
}
impl SsmlVoiceGender {
    /// 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 => "SSML_VOICE_GENDER_UNSPECIFIED",
            Self::Male => "SSML_VOICE_GENDER_MALE",
            Self::Female => "SSML_VOICE_GENDER_FEMALE",
            Self::Neutral => "SSML_VOICE_GENDER_NEUTRAL",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SSML_VOICE_GENDER_UNSPECIFIED" => Some(Self::Unspecified),
            "SSML_VOICE_GENDER_MALE" => Some(Self::Male),
            "SSML_VOICE_GENDER_FEMALE" => Some(Self::Female),
            "SSML_VOICE_GENDER_NEUTRAL" => Some(Self::Neutral),
            _ => None,
        }
    }
}
/// Audio encoding of the output audio format in Text-To-Speech.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum OutputAudioEncoding {
    /// Not specified.
    Unspecified = 0,
    /// Uncompressed 16-bit signed little-endian samples (Linear PCM).
    /// Audio content returned as LINEAR16 also contains a WAV header.
    /// LINT: LEGACY_NAMES
    Linear16 = 1,
    /// MP3 audio at 32kbps.
    Mp3 = 2,
    /// MP3 audio at 64kbps.
    /// LINT: LEGACY_NAMES
    Mp364Kbps = 4,
    /// Opus encoded audio wrapped in an ogg container. The result will be a
    /// file which can be played natively on Android, and in browsers (at least
    /// Chrome and Firefox). The quality of the encoding is considerably higher
    /// than MP3 while using approximately the same bitrate.
    OggOpus = 3,
    /// 8-bit samples that compand 14-bit audio samples using G.711 PCMU/mu-law.
    Mulaw = 5,
    /// 8-bit samples that compand 13-bit audio samples using G.711 PCMU/a-law.
    Alaw = 6,
}
impl OutputAudioEncoding {
    /// 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 => "OUTPUT_AUDIO_ENCODING_UNSPECIFIED",
            Self::Linear16 => "OUTPUT_AUDIO_ENCODING_LINEAR_16",
            Self::Mp3 => "OUTPUT_AUDIO_ENCODING_MP3",
            Self::Mp364Kbps => "OUTPUT_AUDIO_ENCODING_MP3_64_KBPS",
            Self::OggOpus => "OUTPUT_AUDIO_ENCODING_OGG_OPUS",
            Self::Mulaw => "OUTPUT_AUDIO_ENCODING_MULAW",
            Self::Alaw => "OUTPUT_AUDIO_ENCODING_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 {
            "OUTPUT_AUDIO_ENCODING_UNSPECIFIED" => Some(Self::Unspecified),
            "OUTPUT_AUDIO_ENCODING_LINEAR_16" => Some(Self::Linear16),
            "OUTPUT_AUDIO_ENCODING_MP3" => Some(Self::Mp3),
            "OUTPUT_AUDIO_ENCODING_MP3_64_KBPS" => Some(Self::Mp364Kbps),
            "OUTPUT_AUDIO_ENCODING_OGG_OPUS" => Some(Self::OggOpus),
            "OUTPUT_AUDIO_ENCODING_MULAW" => Some(Self::Mulaw),
            "OUTPUT_AUDIO_ENCODING_ALAW" => Some(Self::Alaw),
            _ => None,
        }
    }
}
/// Import strategies for the conflict resolution of resources (i.e. intents,
/// entities, and webhooks) with identical display names during import
/// operations.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ImportStrategy {
    /// Unspecified. Treated as 'CREATE_NEW'.
    Unspecified = 0,
    /// Create a new resource with a numeric suffix appended to the end of the
    /// existing display name.
    CreateNew = 1,
    /// Replace existing resource with incoming resource in the content to be
    /// imported.
    Replace = 2,
    /// Keep existing resource and discard incoming resource in the content to be
    /// imported.
    Keep = 3,
    /// Combine existing and incoming resources when a conflict is encountered.
    Merge = 4,
    /// Throw error if a conflict is encountered.
    ThrowError = 5,
}
impl ImportStrategy {
    /// 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 => "IMPORT_STRATEGY_UNSPECIFIED",
            Self::CreateNew => "IMPORT_STRATEGY_CREATE_NEW",
            Self::Replace => "IMPORT_STRATEGY_REPLACE",
            Self::Keep => "IMPORT_STRATEGY_KEEP",
            Self::Merge => "IMPORT_STRATEGY_MERGE",
            Self::ThrowError => "IMPORT_STRATEGY_THROW_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 {
            "IMPORT_STRATEGY_UNSPECIFIED" => Some(Self::Unspecified),
            "IMPORT_STRATEGY_CREATE_NEW" => Some(Self::CreateNew),
            "IMPORT_STRATEGY_REPLACE" => Some(Self::Replace),
            "IMPORT_STRATEGY_KEEP" => Some(Self::Keep),
            "IMPORT_STRATEGY_MERGE" => Some(Self::Merge),
            "IMPORT_STRATEGY_THROW_ERROR" => Some(Self::ThrowError),
            _ => None,
        }
    }
}
/// A data store connection. It represents a data store in Discovery Engine and
/// the type of the contents it contains.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DataStoreConnection {
    /// The type of the connected data store.
    #[prost(enumeration = "DataStoreType", tag = "1")]
    pub data_store_type: i32,
    /// The full name of the referenced data store.
    /// Formats:
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}`
    /// `projects/{project}/locations/{location}/dataStores/{data_store}`
    #[prost(string, tag = "2")]
    pub data_store: ::prost::alloc::string::String,
    /// The document processing mode for the data store connection. Should only be
    /// set for PUBLIC_WEB and UNSTRUCTURED data stores. If not set it is
    /// considered as DOCUMENTS, as this is the legacy mode.
    #[prost(enumeration = "DocumentProcessingMode", tag = "4")]
    pub document_processing_mode: i32,
}
/// Data store connection feature output signals.
/// Might be only partially field if processing stop before the final answer.
/// Reasons for this can be, but are not limited to: empty UCS search results,
/// positive RAI check outcome, grounding failure, ...
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DataStoreConnectionSignals {
    /// Optional. Diagnostic info related to the rewriter model call.
    #[prost(message, optional, tag = "1")]
    pub rewriter_model_call_signals: ::core::option::Option<
        data_store_connection_signals::RewriterModelCallSignals,
    >,
    /// Optional. Rewritten string query used for search.
    #[prost(string, tag = "2")]
    pub rewritten_query: ::prost::alloc::string::String,
    /// Optional. Search snippets included in the answer generation prompt.
    #[prost(message, repeated, tag = "3")]
    pub search_snippets: ::prost::alloc::vec::Vec<
        data_store_connection_signals::SearchSnippet,
    >,
    /// Optional. Diagnostic info related to the answer generation model call.
    #[prost(message, optional, tag = "4")]
    pub answer_generation_model_call_signals: ::core::option::Option<
        data_store_connection_signals::AnswerGenerationModelCallSignals,
    >,
    /// Optional. The final compiled answer.
    #[prost(string, tag = "5")]
    pub answer: ::prost::alloc::string::String,
    /// Optional. Answer parts with relevant citations.
    /// Concatenation of texts should add up the `answer` (not counting
    /// whitespaces).
    #[prost(message, repeated, tag = "6")]
    pub answer_parts: ::prost::alloc::vec::Vec<
        data_store_connection_signals::AnswerPart,
    >,
    /// Optional. Snippets cited by the answer generation model from the most to
    /// least relevant.
    #[prost(message, repeated, tag = "7")]
    pub cited_snippets: ::prost::alloc::vec::Vec<
        data_store_connection_signals::CitedSnippet,
    >,
    /// Optional. Grounding signals.
    #[prost(message, optional, tag = "8")]
    pub grounding_signals: ::core::option::Option<
        data_store_connection_signals::GroundingSignals,
    >,
    /// Optional. Safety check result.
    #[prost(message, optional, tag = "9")]
    pub safety_signals: ::core::option::Option<
        data_store_connection_signals::SafetySignals,
    >,
}
/// Nested message and enum types in `DataStoreConnectionSignals`.
pub mod data_store_connection_signals {
    /// Diagnostic info related to the rewriter model call.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct RewriterModelCallSignals {
        /// Prompt as sent to the model.
        #[prost(string, tag = "1")]
        pub rendered_prompt: ::prost::alloc::string::String,
        /// Output of the generative model.
        #[prost(string, tag = "2")]
        pub model_output: ::prost::alloc::string::String,
        /// Name of the generative model. For example, "gemini-ultra", "gemini-pro",
        /// "gemini-1.5-flash" etc. Defaults to "Other" if the model is unknown.
        #[prost(string, tag = "3")]
        pub model: ::prost::alloc::string::String,
    }
    /// Search snippet details.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SearchSnippet {
        /// Title of the enclosing document.
        #[prost(string, tag = "1")]
        pub document_title: ::prost::alloc::string::String,
        /// Uri for the document. Present if specified for the document.
        #[prost(string, tag = "2")]
        pub document_uri: ::prost::alloc::string::String,
        /// Text included in the prompt.
        #[prost(string, tag = "3")]
        pub text: ::prost::alloc::string::String,
        /// Metadata associated with the document.
        #[prost(message, optional, tag = "5")]
        pub metadata: ::core::option::Option<::prost_types::Struct>,
    }
    /// Diagnostic info related to the answer generation model call.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct AnswerGenerationModelCallSignals {
        /// Prompt as sent to the model.
        #[prost(string, tag = "1")]
        pub rendered_prompt: ::prost::alloc::string::String,
        /// Output of the generative model.
        #[prost(string, tag = "2")]
        pub model_output: ::prost::alloc::string::String,
        /// Name of the generative model. For example, "gemini-ultra", "gemini-pro",
        /// "gemini-1.5-flash" etc. Defaults to "Other" if the model is unknown.
        #[prost(string, tag = "3")]
        pub model: ::prost::alloc::string::String,
    }
    /// Answer part with citation.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct AnswerPart {
        /// Substring of the answer.
        #[prost(string, tag = "1")]
        pub text: ::prost::alloc::string::String,
        /// Citations for this answer part. Indices of `search_snippets`.
        #[prost(int32, repeated, tag = "2")]
        pub supporting_indices: ::prost::alloc::vec::Vec<i32>,
    }
    /// Snippet cited by the answer generation model.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct CitedSnippet {
        /// Details of the snippet.
        #[prost(message, optional, tag = "1")]
        pub search_snippet: ::core::option::Option<SearchSnippet>,
        /// Index of the snippet in `search_snippets` field.
        #[prost(int32, tag = "2")]
        pub snippet_index: i32,
    }
    /// Grounding signals.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct GroundingSignals {
        /// Represents the decision of the grounding check.
        #[prost(enumeration = "grounding_signals::GroundingDecision", tag = "1")]
        pub decision: i32,
        /// Grounding score bucket setting.
        #[prost(enumeration = "grounding_signals::GroundingScoreBucket", tag = "2")]
        pub score: i32,
    }
    /// Nested message and enum types in `GroundingSignals`.
    pub mod grounding_signals {
        /// Represents the decision of the grounding check.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum GroundingDecision {
            /// Decision not specified.
            Unspecified = 0,
            /// Grounding have accepted the answer.
            AcceptedByGrounding = 1,
            /// Grounding have rejected the answer.
            RejectedByGrounding = 2,
        }
        impl GroundingDecision {
            /// 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 => "GROUNDING_DECISION_UNSPECIFIED",
                    Self::AcceptedByGrounding => "ACCEPTED_BY_GROUNDING",
                    Self::RejectedByGrounding => "REJECTED_BY_GROUNDING",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "GROUNDING_DECISION_UNSPECIFIED" => Some(Self::Unspecified),
                    "ACCEPTED_BY_GROUNDING" => Some(Self::AcceptedByGrounding),
                    "REJECTED_BY_GROUNDING" => Some(Self::RejectedByGrounding),
                    _ => None,
                }
            }
        }
        /// Grounding score buckets.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum GroundingScoreBucket {
            /// Score not specified.
            Unspecified = 0,
            /// We have very low confidence that the answer is grounded.
            VeryLow = 1,
            /// We have low confidence that the answer is grounded.
            Low = 3,
            /// We have medium confidence that the answer is grounded.
            Medium = 4,
            /// We have high confidence that the answer is grounded.
            High = 5,
            /// We have very high confidence that the answer is grounded.
            VeryHigh = 6,
        }
        impl GroundingScoreBucket {
            /// 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 => "GROUNDING_SCORE_BUCKET_UNSPECIFIED",
                    Self::VeryLow => "VERY_LOW",
                    Self::Low => "LOW",
                    Self::Medium => "MEDIUM",
                    Self::High => "HIGH",
                    Self::VeryHigh => "VERY_HIGH",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "GROUNDING_SCORE_BUCKET_UNSPECIFIED" => Some(Self::Unspecified),
                    "VERY_LOW" => Some(Self::VeryLow),
                    "LOW" => Some(Self::Low),
                    "MEDIUM" => Some(Self::Medium),
                    "HIGH" => Some(Self::High),
                    "VERY_HIGH" => Some(Self::VeryHigh),
                    _ => None,
                }
            }
        }
    }
    /// Safety check results.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct SafetySignals {
        /// Safety decision.
        #[prost(enumeration = "safety_signals::SafetyDecision", tag = "1")]
        pub decision: i32,
        /// Specifies banned phrase match subject.
        #[prost(enumeration = "safety_signals::BannedPhraseMatch", tag = "2")]
        pub banned_phrase_match: i32,
        /// The matched banned phrase if there was a match.
        #[prost(string, tag = "3")]
        pub matched_banned_phrase: ::prost::alloc::string::String,
    }
    /// Nested message and enum types in `SafetySignals`.
    pub mod safety_signals {
        /// Safety decision.
        /// All kinds of check are incorporated into this final decision, including
        /// banned phrases check.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum SafetyDecision {
            /// Decision not specified.
            Unspecified = 0,
            /// No manual or automatic safety check fired.
            AcceptedBySafetyCheck = 1,
            /// One ore more safety checks fired.
            RejectedBySafetyCheck = 2,
        }
        impl SafetyDecision {
            /// 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 => "SAFETY_DECISION_UNSPECIFIED",
                    Self::AcceptedBySafetyCheck => "ACCEPTED_BY_SAFETY_CHECK",
                    Self::RejectedBySafetyCheck => "REJECTED_BY_SAFETY_CHECK",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "SAFETY_DECISION_UNSPECIFIED" => Some(Self::Unspecified),
                    "ACCEPTED_BY_SAFETY_CHECK" => Some(Self::AcceptedBySafetyCheck),
                    "REJECTED_BY_SAFETY_CHECK" => Some(Self::RejectedBySafetyCheck),
                    _ => None,
                }
            }
        }
        /// Specifies banned phrase match subject.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum BannedPhraseMatch {
            /// No banned phrase check was executed.
            Unspecified = 0,
            /// All banned phrase checks led to no match.
            None = 1,
            /// A banned phrase matched the query.
            Query = 2,
            /// A banned phrase matched the response.
            Response = 3,
        }
        impl BannedPhraseMatch {
            /// 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 => "BANNED_PHRASE_MATCH_UNSPECIFIED",
                    Self::None => "BANNED_PHRASE_MATCH_NONE",
                    Self::Query => "BANNED_PHRASE_MATCH_QUERY",
                    Self::Response => "BANNED_PHRASE_MATCH_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 {
                    "BANNED_PHRASE_MATCH_UNSPECIFIED" => Some(Self::Unspecified),
                    "BANNED_PHRASE_MATCH_NONE" => Some(Self::None),
                    "BANNED_PHRASE_MATCH_QUERY" => Some(Self::Query),
                    "BANNED_PHRASE_MATCH_RESPONSE" => Some(Self::Response),
                    _ => None,
                }
            }
        }
    }
}
/// Type of a data store.
/// Determines how search is performed in 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 (for example FAQ).
    Structured = 3,
}
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::Structured => "STRUCTURED",
        }
    }
    /// 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),
            "STRUCTURED" => Some(Self::Structured),
            _ => 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. This should be set for STRUCTURED type data stores. Due to
    /// legacy reasons this is considered as DOCUMENTS for STRUCTURED and
    /// PUBLIC_WEB data stores.
    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,
        }
    }
}
/// Represents a call of a specific tool's action with the specified inputs.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ToolCall {
    /// Required. The \[tool\]\[google.cloud.dialogflow.cx.v3.Tool\] associated with
    /// this call. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/tools/<ToolID>`.
    #[prost(string, tag = "1")]
    pub tool: ::prost::alloc::string::String,
    /// Required. The name of the tool's action associated with this call.
    #[prost(string, tag = "2")]
    pub action: ::prost::alloc::string::String,
    /// Optional. The action's input parameters.
    #[prost(message, optional, tag = "3")]
    pub input_parameters: ::core::option::Option<::prost_types::Struct>,
}
/// The result of calling a tool's action that has been executed by the client.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ToolCallResult {
    /// Required. The \[tool\]\[google.cloud.dialogflow.cx.v3.Tool\] associated with
    /// this call. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/tools/<ToolID>`.
    #[prost(string, tag = "1")]
    pub tool: ::prost::alloc::string::String,
    /// Required. The name of the tool's action associated with this call.
    #[prost(string, tag = "2")]
    pub action: ::prost::alloc::string::String,
    /// The tool call's result.
    #[prost(oneof = "tool_call_result::Result", tags = "3, 4")]
    pub result: ::core::option::Option<tool_call_result::Result>,
}
/// Nested message and enum types in `ToolCallResult`.
pub mod tool_call_result {
    /// An error produced by the tool call.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Error {
        /// Optional. The error message of the function.
        #[prost(string, tag = "1")]
        pub message: ::prost::alloc::string::String,
    }
    /// The tool call's result.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Result {
        /// The tool call's error.
        #[prost(message, tag = "3")]
        Error(Error),
        /// The tool call's output parameters.
        #[prost(message, tag = "4")]
        OutputParameters(::prost_types::Struct),
    }
}
/// Represents a response message that can be returned by a conversational agent.
///
/// Response messages are also used for output audio synthesis. The approach is
/// as follows:
///
/// * If at least one OutputAudioText response is present, then all
///   OutputAudioText responses are linearly concatenated, and the result is used
///   for output audio synthesis.
/// * If the OutputAudioText responses are a mixture of text and SSML, then the
///   concatenated result is treated as SSML; otherwise, the result is treated as
///   either text or SSML as appropriate. The agent designer should ideally use
///   either text or SSML consistently throughout the bot design.
/// * Otherwise, all Text responses are linearly concatenated, and the result is
///   used for output audio synthesis.
///
/// This approach allows for more sophisticated user experience scenarios, where
/// the text displayed to the user may differ from what is heard.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResponseMessage {
    /// Response type.
    #[prost(enumeration = "response_message::ResponseType", tag = "4")]
    pub response_type: i32,
    /// The channel which the response is associated with. Clients can specify the
    /// channel via
    /// \[QueryParameters.channel\]\[google.cloud.dialogflow.cx.v3.QueryParameters.channel\],
    /// and only associated channel response will be returned.
    #[prost(string, tag = "19")]
    pub channel: ::prost::alloc::string::String,
    /// Required. The rich response message.
    #[prost(
        oneof = "response_message::Message",
        tags = "1, 2, 9, 8, 10, 11, 12, 13, 18, 20, 22"
    )]
    pub message: ::core::option::Option<response_message::Message>,
}
/// Nested message and enum types in `ResponseMessage`.
pub mod response_message {
    /// The text response message.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Text {
        /// Required. A collection of text response variants. If multiple variants
        /// are defined, only one text response variant is returned at runtime.
        #[prost(string, repeated, tag = "1")]
        pub text: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        /// Output only. Whether the playback of this message can be interrupted by
        /// the end user's speech and the client can then starts the next Dialogflow
        /// request.
        #[prost(bool, tag = "2")]
        pub allow_playback_interruption: bool,
    }
    /// Indicates that the conversation should be handed off to a live agent.
    ///
    /// Dialogflow only uses this to determine which conversations were handed off
    /// to a human agent for measurement purposes. What else to do with this signal
    /// is up to you and your handoff procedures.
    ///
    /// You may set this, for example:
    ///
    /// * In the
    ///   \[entry_fulfillment\]\[google.cloud.dialogflow.cx.v3.Page.entry_fulfillment\]
    ///   of a \[Page\]\[google.cloud.dialogflow.cx.v3.Page\] if
    ///   entering the page indicates something went extremely wrong in the
    ///   conversation.
    /// * In a webhook response when you determine that the customer issue can only
    ///   be handled by a human.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct LiveAgentHandoff {
        /// Custom metadata for your handoff procedure. Dialogflow doesn't impose
        /// any structure on this.
        #[prost(message, optional, tag = "1")]
        pub metadata: ::core::option::Option<::prost_types::Struct>,
    }
    /// Indicates that the conversation succeeded, i.e., the bot handled the issue
    /// that the customer talked to it about.
    ///
    /// Dialogflow only uses this to determine which conversations should be
    /// counted as successful and doesn't process the metadata in this message in
    /// any way. Note that Dialogflow also considers conversations that get to the
    /// conversation end page as successful even if they don't return
    /// \[ConversationSuccess\]\[google.cloud.dialogflow.cx.v3.ResponseMessage.ConversationSuccess\].
    ///
    /// You may set this, for example:
    ///
    /// * In the
    ///   \[entry_fulfillment\]\[google.cloud.dialogflow.cx.v3.Page.entry_fulfillment\]
    ///   of a \[Page\]\[google.cloud.dialogflow.cx.v3.Page\] if
    ///   entering the page indicates that the conversation succeeded.
    /// * In a webhook response when you determine that you handled the customer
    ///   issue.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ConversationSuccess {
        /// Custom metadata. Dialogflow doesn't impose any structure on this.
        #[prost(message, optional, tag = "1")]
        pub metadata: ::core::option::Option<::prost_types::Struct>,
    }
    /// A text or ssml response that is preferentially used for TTS output audio
    /// synthesis, as described in the comment on the ResponseMessage message.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct OutputAudioText {
        /// Output only. Whether the playback of this message can be interrupted by
        /// the end user's speech and the client can then starts the next Dialogflow
        /// request.
        #[prost(bool, tag = "3")]
        pub allow_playback_interruption: bool,
        /// The source, which is either plain text or SSML.
        #[prost(oneof = "output_audio_text::Source", tags = "1, 2")]
        pub source: ::core::option::Option<output_audio_text::Source>,
    }
    /// Nested message and enum types in `OutputAudioText`.
    pub mod output_audio_text {
        /// The source, which is either plain text or SSML.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
        pub enum Source {
            /// The raw text to be synthesized.
            #[prost(string, tag = "1")]
            Text(::prost::alloc::string::String),
            /// The SSML text to be synthesized. For more information, see
            /// [SSML](/speech/text-to-speech/docs/ssml).
            #[prost(string, tag = "2")]
            Ssml(::prost::alloc::string::String),
        }
    }
    /// Indicates that interaction with the Dialogflow agent has ended.
    /// This message is generated by Dialogflow only and not supposed to be
    /// defined by the user.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct EndInteraction {}
    /// Specifies an audio clip to be played by the client as part of the response.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct PlayAudio {
        /// Required. URI of the audio clip. Dialogflow does not impose any
        /// validation on this value. It is specific to the client that reads it.
        #[prost(string, tag = "1")]
        pub audio_uri: ::prost::alloc::string::String,
        /// Output only. Whether the playback of this message can be interrupted by
        /// the end user's speech and the client can then starts the next Dialogflow
        /// request.
        #[prost(bool, tag = "2")]
        pub allow_playback_interruption: bool,
    }
    /// Represents an audio message that is composed of both segments
    /// synthesized from the Dialogflow agent prompts and ones hosted externally
    /// at the specified URIs.
    /// The external URIs are specified via
    /// \[play_audio\]\[google.cloud.dialogflow.cx.v3.ResponseMessage.play_audio\].
    /// This message is generated by Dialogflow only and not supposed to be
    /// defined by the user.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MixedAudio {
        /// Segments this audio response is composed of.
        #[prost(message, repeated, tag = "1")]
        pub segments: ::prost::alloc::vec::Vec<mixed_audio::Segment>,
    }
    /// Nested message and enum types in `MixedAudio`.
    pub mod mixed_audio {
        /// Represents one segment of audio.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Segment {
            /// Output only. Whether the playback of this segment can be interrupted by
            /// the end user's speech and the client should then start the next
            /// Dialogflow request.
            #[prost(bool, tag = "3")]
            pub allow_playback_interruption: bool,
            /// Content of the segment.
            #[prost(oneof = "segment::Content", tags = "1, 2")]
            pub content: ::core::option::Option<segment::Content>,
        }
        /// Nested message and enum types in `Segment`.
        pub mod segment {
            /// Content of the segment.
            #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
            pub enum Content {
                /// Raw audio synthesized from the Dialogflow agent's response using
                /// the output config specified in the request.
                #[prost(bytes, tag = "1")]
                Audio(::prost::alloc::vec::Vec<u8>),
                /// Client-specific URI that points to an audio clip accessible to the
                /// client. Dialogflow does not impose any validation on it.
                #[prost(string, tag = "2")]
                Uri(::prost::alloc::string::String),
            }
        }
    }
    /// Represents the signal that telles the client to transfer the phone call
    /// connected to the agent to a third-party endpoint.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct TelephonyTransferCall {
        /// Endpoint to transfer the call to.
        #[prost(oneof = "telephony_transfer_call::Endpoint", tags = "1")]
        pub endpoint: ::core::option::Option<telephony_transfer_call::Endpoint>,
    }
    /// Nested message and enum types in `TelephonyTransferCall`.
    pub mod telephony_transfer_call {
        /// Endpoint to transfer the call to.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
        pub enum Endpoint {
            /// Transfer the call to a phone number
            /// in [E.164 format](<https://en.wikipedia.org/wiki/E.164>).
            #[prost(string, tag = "1")]
            PhoneNumber(::prost::alloc::string::String),
        }
    }
    /// Represents info card response. If the response contains generative
    /// knowledge prediction, Dialogflow will return a payload with Infobot
    /// Messenger compatible info card.
    ///
    /// Otherwise, the info card response is skipped.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct KnowledgeInfoCard {}
    /// Represents different response types.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ResponseType {
        /// Not specified.
        Unspecified = 0,
        /// The response is from an \[entry
        /// prompt\]\[google.cloud.dialogflow.cx.v3.Page.entry_fulfillment\] in the
        /// page.
        EntryPrompt = 1,
        /// The response is from \[form-filling
        /// prompt\]\[google.cloud.dialogflow.cx.v3.Form.Parameter.fill_behavior\] in
        /// the page.
        ParameterPrompt = 2,
        /// The response is from a \[transition
        /// route\]\[google.cloud.dialogflow.cx.v3.TransitionRoute\] or an \[event
        /// handler\]\[EventHandler\] in the page or flow or transition route group.
        HandlerPrompt = 3,
    }
    impl ResponseType {
        /// 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 => "RESPONSE_TYPE_UNSPECIFIED",
                Self::EntryPrompt => "ENTRY_PROMPT",
                Self::ParameterPrompt => "PARAMETER_PROMPT",
                Self::HandlerPrompt => "HANDLER_PROMPT",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "RESPONSE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "ENTRY_PROMPT" => Some(Self::EntryPrompt),
                "PARAMETER_PROMPT" => Some(Self::ParameterPrompt),
                "HANDLER_PROMPT" => Some(Self::HandlerPrompt),
                _ => None,
            }
        }
    }
    /// Required. The rich response message.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Message {
        /// Returns a text response.
        #[prost(message, tag = "1")]
        Text(Text),
        /// Returns a response containing a custom, platform-specific payload.
        #[prost(message, tag = "2")]
        Payload(::prost_types::Struct),
        /// Indicates that the conversation succeeded.
        #[prost(message, tag = "9")]
        ConversationSuccess(ConversationSuccess),
        /// A text or ssml response that is preferentially used for TTS output audio
        /// synthesis, as described in the comment on the ResponseMessage message.
        #[prost(message, tag = "8")]
        OutputAudioText(OutputAudioText),
        /// Hands off conversation to a human agent.
        #[prost(message, tag = "10")]
        LiveAgentHandoff(LiveAgentHandoff),
        /// Output only. A signal that indicates the interaction with the Dialogflow
        /// agent has ended. This message is generated by Dialogflow only when the
        /// conversation reaches `END_SESSION` page. It is not supposed to be defined
        /// by the user.
        ///
        /// It's guaranteed that there is at most one such message in each response.
        #[prost(message, tag = "11")]
        EndInteraction(EndInteraction),
        /// Signal that the client should play an audio clip hosted at a
        /// client-specific URI. Dialogflow uses this to construct
        /// \[mixed_audio\]\[google.cloud.dialogflow.cx.v3.ResponseMessage.mixed_audio\].
        /// However, Dialogflow itself does not try to read or process the URI in any
        /// way.
        #[prost(message, tag = "12")]
        PlayAudio(PlayAudio),
        /// Output only. An audio response message composed of both the synthesized
        /// Dialogflow agent responses and responses defined via
        /// \[play_audio\]\[google.cloud.dialogflow.cx.v3.ResponseMessage.play_audio\].
        /// This message is generated by Dialogflow only and not supposed to be
        /// defined by the user.
        #[prost(message, tag = "13")]
        MixedAudio(MixedAudio),
        /// A signal that the client should transfer the phone call connected to
        /// this agent to a third-party endpoint.
        #[prost(message, tag = "18")]
        TelephonyTransferCall(TelephonyTransferCall),
        /// Represents info card for knowledge answers, to be better rendered in
        /// Dialogflow Messenger.
        #[prost(message, tag = "20")]
        KnowledgeInfoCard(KnowledgeInfoCard),
        /// Returns the definition of a tool call that should be executed by the
        /// client.
        #[prost(message, tag = "22")]
        ToolCall(super::ToolCall),
    }
}
/// A fulfillment can do one or more of the following actions at the same time:
///
/// * Generate rich message responses.
/// * Set parameter values.
/// * Call the webhook.
///
/// Fulfillments can be called at various stages in the
/// \[Page\]\[google.cloud.dialogflow.cx.v3.Page\] or
/// \[Form\]\[google.cloud.dialogflow.cx.v3.Form\] lifecycle. For example, when a
/// \[DetectIntentRequest\]\[google.cloud.dialogflow.cx.v3.DetectIntentRequest\]
/// drives a session to enter a new page, the page's entry fulfillment can add a
/// static response to the
/// \[QueryResult\]\[google.cloud.dialogflow.cx.v3.QueryResult\] in the returning
/// \[DetectIntentResponse\]\[google.cloud.dialogflow.cx.v3.DetectIntentResponse\],
/// call the webhook (for example, to load user data from a database), or both.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Fulfillment {
    /// The list of rich message responses to present to the user.
    #[prost(message, repeated, tag = "1")]
    pub messages: ::prost::alloc::vec::Vec<ResponseMessage>,
    /// The webhook to call.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/webhooks/<WebhookID>`.
    #[prost(string, tag = "2")]
    pub webhook: ::prost::alloc::string::String,
    /// Whether Dialogflow should return currently queued fulfillment response
    /// messages in streaming APIs. If a webhook is specified, it happens before
    /// Dialogflow invokes webhook.
    /// Warning:
    ///
    /// 1. This flag only affects streaming API. Responses are still queued
    ///    and returned once in non-streaming API.
    /// 1. The flag can be enabled in any fulfillment but only the first 3 partial
    ///    responses will be returned. You may only want to apply it to fulfillments
    ///    that have slow webhooks.
    #[prost(bool, tag = "8")]
    pub return_partial_responses: bool,
    /// The value of this field will be populated in the
    /// \[WebhookRequest\]\[google.cloud.dialogflow.cx.v3.WebhookRequest\]
    /// `fulfillmentInfo.tag` field by Dialogflow when the associated webhook is
    /// called.
    /// The tag is typically used by the webhook service to identify which
    /// fulfillment is being called, but it could be used for other purposes.
    /// This field is required if `webhook` is specified.
    #[prost(string, tag = "3")]
    pub tag: ::prost::alloc::string::String,
    /// Set parameter values before executing the webhook.
    #[prost(message, repeated, tag = "4")]
    pub set_parameter_actions: ::prost::alloc::vec::Vec<fulfillment::SetParameterAction>,
    /// Conditional cases for this fulfillment.
    #[prost(message, repeated, tag = "5")]
    pub conditional_cases: ::prost::alloc::vec::Vec<fulfillment::ConditionalCases>,
    /// Hierarchical advanced settings for this fulfillment. The settings exposed
    /// at the lower level overrides the settings exposed at the higher level.
    #[prost(message, optional, tag = "7")]
    pub advanced_settings: ::core::option::Option<AdvancedSettings>,
    /// If the flag is true, the agent will utilize LLM to generate a text
    /// response. If LLM generation fails, the defined
    /// \[responses\]\[google.cloud.dialogflow.cx.v3.Fulfillment.messages\] in the
    /// fulfillment will be respected. This flag is only useful for fulfillments
    /// associated with no-match event handlers.
    #[prost(bool, tag = "12")]
    pub enable_generative_fallback: bool,
    /// A list of Generators to be called during this fulfillment.
    #[prost(message, repeated, tag = "13")]
    pub generators: ::prost::alloc::vec::Vec<fulfillment::GeneratorSettings>,
}
/// Nested message and enum types in `Fulfillment`.
pub mod fulfillment {
    /// Setting a parameter value.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SetParameterAction {
        /// Display name of the parameter.
        #[prost(string, tag = "1")]
        pub parameter: ::prost::alloc::string::String,
        /// The new value of the parameter. A null value clears the parameter.
        #[prost(message, optional, tag = "2")]
        pub value: ::core::option::Option<::prost_types::Value>,
    }
    /// A list of cascading if-else conditions. Cases are mutually exclusive.
    /// The first one with a matching condition is selected, all the rest ignored.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ConditionalCases {
        /// A list of cascading if-else conditions.
        #[prost(message, repeated, tag = "1")]
        pub cases: ::prost::alloc::vec::Vec<conditional_cases::Case>,
    }
    /// Nested message and enum types in `ConditionalCases`.
    pub mod conditional_cases {
        /// Each case has a Boolean condition. When it is evaluated to be True, the
        /// corresponding messages will be selected and evaluated recursively.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct Case {
            /// The condition to activate and select this case. Empty means the
            /// condition is always true. The condition is evaluated against \[form
            /// parameters\]\[Form.parameters\] or \[session
            /// parameters\]\[SessionInfo.parameters\].
            ///
            /// See the [conditions
            /// reference](<https://cloud.google.com/dialogflow/cx/docs/reference/condition>).
            #[prost(string, tag = "1")]
            pub condition: ::prost::alloc::string::String,
            /// A list of case content.
            #[prost(message, repeated, tag = "2")]
            pub case_content: ::prost::alloc::vec::Vec<case::CaseContent>,
        }
        /// Nested message and enum types in `Case`.
        pub mod case {
            /// The list of messages or conditional cases to activate for this case.
            #[derive(Clone, PartialEq, ::prost::Message)]
            pub struct CaseContent {
                /// Either a message is returned or additional cases to be evaluated.
                #[prost(oneof = "case_content::CasesOrMessage", tags = "1, 2")]
                pub cases_or_message: ::core::option::Option<
                    case_content::CasesOrMessage,
                >,
            }
            /// Nested message and enum types in `CaseContent`.
            pub mod case_content {
                /// Either a message is returned or additional cases to be evaluated.
                #[derive(Clone, PartialEq, ::prost::Oneof)]
                pub enum CasesOrMessage {
                    /// Returned message.
                    #[prost(message, tag = "1")]
                    Message(super::super::super::super::ResponseMessage),
                    /// Additional cases to be evaluated.
                    #[prost(message, tag = "2")]
                    AdditionalCases(super::super::super::ConditionalCases),
                }
            }
        }
    }
    /// Generator settings used by the LLM to generate a text response.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct GeneratorSettings {
        /// Required. The generator to call.
        /// Format:
        /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/generators/<GeneratorID>`.
        #[prost(string, tag = "1")]
        pub generator: ::prost::alloc::string::String,
        /// Map from \[placeholder parameter\]\[Generator.Parameter.id\] in the
        /// \[Generator\]\[google.cloud.dialogflow.cx.v3.Generator\] to corresponding
        /// session parameters. By default, Dialogflow uses the session parameter
        /// with the same name to fill in the generator template. e.g. If there is a
        /// placeholder parameter `city` in the Generator, Dialogflow default to fill
        /// in the `$city` with
        /// `$session.params.city`. However, you may choose to fill `$city` with
        /// `$session.params.desination-city`.
        ///
        /// * Map key: \[parameter ID\]\[Genrator.Parameter.id\]
        /// * Map value: session parameter name
        #[prost(map = "string, string", tag = "2")]
        pub input_parameters: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            ::prost::alloc::string::String,
        >,
        /// Required. Output parameter which should contain the generator response.
        #[prost(string, tag = "3")]
        pub output_parameter: ::prost::alloc::string::String,
    }
}
/// A Dialogflow CX conversation (session) can be described and visualized as a
/// state machine. The states of a CX session are represented by pages.
///
/// For each flow, you define many pages, where your combined pages can handle a
/// complete conversation on the topics the flow is designed for. At any given
/// moment, exactly one page is the current page, the current page is considered
/// active, and the flow associated with that page is considered active. Every
/// flow has a special start page. When a flow initially becomes active, the
/// start page page becomes the current page. For each conversational turn, the
/// current page will either stay the same or transition to another page.
///
/// You configure each page to collect information from the end-user that is
/// relevant for the conversational state represented by the page.
///
/// For more information, see the
/// [Page guide](<https://cloud.google.com/dialogflow/cx/docs/concept/page>).
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Page {
    /// The unique identifier of the page.
    /// Required for the
    /// \[Pages.UpdatePage\]\[google.cloud.dialogflow.cx.v3.Pages.UpdatePage\] method.
    /// \[Pages.CreatePage\]\[google.cloud.dialogflow.cx.v3.Pages.CreatePage\]
    /// populates the name automatically.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/pages/<PageID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. The human-readable name of the page, unique within the flow.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// The description of the page. The maximum length is 500 characters.
    #[prost(string, tag = "19")]
    pub description: ::prost::alloc::string::String,
    /// The fulfillment to call when the session is entering the page.
    #[prost(message, optional, tag = "7")]
    pub entry_fulfillment: ::core::option::Option<Fulfillment>,
    /// The form associated with the page, used for collecting parameters
    /// relevant to the page.
    #[prost(message, optional, tag = "4")]
    pub form: ::core::option::Option<Form>,
    /// Ordered list of
    /// \[`TransitionRouteGroups`\]\[google.cloud.dialogflow.cx.v3.TransitionRouteGroup\]
    /// added to the page. Transition route groups must be unique within a page. If
    /// the page links both flow-level transition route groups and agent-level
    /// transition route groups, the flow-level ones will have higher priority and
    /// will be put before the agent-level ones.
    ///
    /// * If multiple transition routes within a page scope refer to the same
    ///   intent, then the precedence order is: page's transition route -> page's
    ///   transition route group -> flow's transition routes.
    ///
    /// * If multiple transition route groups within a page contain the same
    ///   intent, then the first group in the ordered list takes precedence.
    ///
    /// Format:`projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/transitionRouteGroups/<TransitionRouteGroupID>`
    /// or
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/transitionRouteGroups/<TransitionRouteGroupID>`
    /// for agent-level groups.
    #[prost(string, repeated, tag = "11")]
    pub transition_route_groups: ::prost::alloc::vec::Vec<
        ::prost::alloc::string::String,
    >,
    /// A list of transitions for the transition rules of this page.
    /// They route the conversation to another page in the same flow, or another
    /// flow.
    ///
    /// When we are in a certain page, the TransitionRoutes are evaluated in the
    /// following order:
    ///
    /// * TransitionRoutes defined in the page with intent specified.
    /// * TransitionRoutes defined in the
    ///   \[transition route
    ///   groups\]\[google.cloud.dialogflow.cx.v3.Page.transition_route_groups\]
    ///   with intent specified.
    /// * TransitionRoutes defined in flow with intent specified.
    /// * TransitionRoutes defined in the
    ///   \[transition route
    ///   groups\]\[google.cloud.dialogflow.cx.v3.Flow.transition_route_groups\]
    ///   with intent specified.
    /// * TransitionRoutes defined in the page with only condition specified.
    /// * TransitionRoutes defined in the
    ///   \[transition route
    ///   groups\]\[google.cloud.dialogflow.cx.v3.Page.transition_route_groups\]
    ///   with only condition specified.
    #[prost(message, repeated, tag = "9")]
    pub transition_routes: ::prost::alloc::vec::Vec<TransitionRoute>,
    /// Handlers associated with the page to handle events such as webhook errors,
    /// no match or no input.
    #[prost(message, repeated, tag = "10")]
    pub event_handlers: ::prost::alloc::vec::Vec<EventHandler>,
    /// Hierarchical advanced settings for this page. The settings exposed at the
    /// lower level overrides the settings exposed at the higher level.
    #[prost(message, optional, tag = "13")]
    pub advanced_settings: ::core::option::Option<AdvancedSettings>,
    /// Optional. Knowledge connector configuration.
    #[prost(message, optional, tag = "18")]
    pub knowledge_connector_settings: ::core::option::Option<KnowledgeConnectorSettings>,
}
/// A form is a data model that groups related parameters that can be collected
/// from the user. The process in which the agent prompts the user and collects
/// parameter values from the user is called form filling. A form can be added to
/// a \[page\]\[google.cloud.dialogflow.cx.v3.Page\]. When form filling is done, the
/// filled parameters will be written to the
/// \[session\]\[google.cloud.dialogflow.cx.v3.SessionInfo.parameters\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Form {
    /// Parameters to collect from the user.
    #[prost(message, repeated, tag = "1")]
    pub parameters: ::prost::alloc::vec::Vec<form::Parameter>,
}
/// Nested message and enum types in `Form`.
pub mod form {
    /// Represents a form parameter.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Parameter {
        /// Required. The human-readable name of the parameter, unique within the
        /// form.
        #[prost(string, tag = "1")]
        pub display_name: ::prost::alloc::string::String,
        /// Indicates whether the parameter is required. Optional parameters will not
        /// trigger prompts; however, they are filled if the user specifies them.
        /// Required parameters must be filled before form filling concludes.
        #[prost(bool, tag = "2")]
        pub required: bool,
        /// Required. The entity type of the parameter.
        /// Format:
        /// `projects/-/locations/-/agents/-/entityTypes/<SystemEntityTypeID>` for
        /// system entity types (for example,
        /// `projects/-/locations/-/agents/-/entityTypes/sys.date`), or
        /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/entityTypes/<EntityTypeID>`
        /// for developer entity types.
        #[prost(string, tag = "3")]
        pub entity_type: ::prost::alloc::string::String,
        /// Indicates whether the parameter represents a list of values.
        #[prost(bool, tag = "4")]
        pub is_list: bool,
        /// Required. Defines fill behavior for the parameter.
        #[prost(message, optional, tag = "7")]
        pub fill_behavior: ::core::option::Option<parameter::FillBehavior>,
        /// The default value of an optional parameter. If the parameter is required,
        /// the default value will be ignored.
        #[prost(message, optional, tag = "9")]
        pub default_value: ::core::option::Option<::prost_types::Value>,
        /// Indicates whether the parameter content should be redacted in log.  If
        /// redaction is enabled, the parameter content will be replaced by parameter
        /// name during logging.
        /// Note: the parameter content is subject to redaction if either parameter
        /// level redaction or \[entity type level
        /// redaction\]\[google.cloud.dialogflow.cx.v3.EntityType.redact\] is enabled.
        #[prost(bool, tag = "11")]
        pub redact: bool,
        /// Hierarchical advanced settings for this parameter. The settings exposed
        /// at the lower level overrides the settings exposed at the higher level.
        #[prost(message, optional, tag = "12")]
        pub advanced_settings: ::core::option::Option<super::AdvancedSettings>,
    }
    /// Nested message and enum types in `Parameter`.
    pub mod parameter {
        /// Configuration for how the filling of a parameter should be handled.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct FillBehavior {
            /// Required. The fulfillment to provide the initial prompt that the agent
            /// can present to the user in order to fill the parameter.
            #[prost(message, optional, tag = "3")]
            pub initial_prompt_fulfillment: ::core::option::Option<
                super::super::Fulfillment,
            >,
            /// The handlers for parameter-level events, used to provide reprompt for
            /// the parameter or transition to a different page/flow. The supported
            /// events are:
            ///
            /// * `sys.no-match-<N>`, where N can be from 1 to 6
            /// * `sys.no-match-default`
            /// * `sys.no-input-<N>`, where N can be from 1 to 6
            /// * `sys.no-input-default`
            /// * `sys.invalid-parameter`
            ///
            /// `initial_prompt_fulfillment` provides the first prompt for the
            /// parameter.
            ///
            /// If the user's response does not fill the parameter, a
            /// no-match/no-input event will be triggered, and the fulfillment
            /// associated with the `sys.no-match-1`/`sys.no-input-1` handler (if
            /// defined) will be called to provide a prompt. The
            /// `sys.no-match-2`/`sys.no-input-2` handler (if defined) will respond to
            /// the next no-match/no-input event, and so on.
            ///
            /// A `sys.no-match-default` or `sys.no-input-default` handler will be used
            /// to handle all following no-match/no-input events after all numbered
            /// no-match/no-input handlers for the parameter are consumed.
            ///
            /// A `sys.invalid-parameter` handler can be defined to handle the case
            /// where the parameter values have been `invalidated` by webhook. For
            /// example, if the user's response fill the parameter, however the
            /// parameter was invalidated by webhook, the fulfillment associated with
            /// the `sys.invalid-parameter` handler (if defined) will be called to
            /// provide a prompt.
            ///
            /// If the event handler for the corresponding event can't be found on the
            /// parameter, `initial_prompt_fulfillment` will be re-prompted.
            #[prost(message, repeated, tag = "5")]
            pub reprompt_event_handlers: ::prost::alloc::vec::Vec<
                super::super::EventHandler,
            >,
        }
    }
}
/// An event handler specifies an
/// \[event\]\[google.cloud.dialogflow.cx.v3.EventHandler.event\] that can be handled
/// during a session. When the specified event happens, the following actions are
/// taken in order:
///
/// * If there is a
///   \[`trigger_fulfillment`\]\[google.cloud.dialogflow.cx.v3.EventHandler.trigger_fulfillment\]
///   associated with the event, it will be called.
/// * If there is a
///   \[`target_page`\]\[google.cloud.dialogflow.cx.v3.EventHandler.target_page\]
///   associated with the event, the session will transition into the specified
///   page.
/// * If there is a
///   \[`target_flow`\]\[google.cloud.dialogflow.cx.v3.EventHandler.target_flow\]
///   associated with the event, the session will transition into the specified
///   flow.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EventHandler {
    /// Output only. The unique identifier of this event handler.
    #[prost(string, tag = "6")]
    pub name: ::prost::alloc::string::String,
    /// Required. The name of the event to handle.
    #[prost(string, tag = "4")]
    pub event: ::prost::alloc::string::String,
    /// The fulfillment to call when the event occurs.
    /// Handling webhook errors with a fulfillment enabled with webhook could
    /// cause infinite loop. It is invalid to specify such fulfillment for a
    /// handler handling webhooks.
    #[prost(message, optional, tag = "5")]
    pub trigger_fulfillment: ::core::option::Option<Fulfillment>,
    /// The target to transition to, either a page in the same host flow (the flow
    /// that owns this
    /// \[TransitionRoute\]\[google.cloud.dialogflow.cx.v3.TransitionRoute\]), or
    /// another flow in the same agent.
    #[prost(oneof = "event_handler::Target", tags = "2, 3, 7")]
    pub target: ::core::option::Option<event_handler::Target>,
}
/// Nested message and enum types in `EventHandler`.
pub mod event_handler {
    /// The target to transition to, either a page in the same host flow (the flow
    /// that owns this
    /// \[TransitionRoute\]\[google.cloud.dialogflow.cx.v3.TransitionRoute\]), or
    /// another flow in the same agent.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Target {
        /// The target page to transition to.
        /// Format:
        /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/pages/<PageID>`.
        #[prost(string, tag = "2")]
        TargetPage(::prost::alloc::string::String),
        /// The target flow to transition to.
        /// Format:
        /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>`.
        #[prost(string, tag = "3")]
        TargetFlow(::prost::alloc::string::String),
        /// The target playbook to transition to.
        /// Format:
        /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/playbooks/<PlaybookID>`.
        #[prost(string, tag = "7")]
        TargetPlaybook(::prost::alloc::string::String),
    }
}
/// A transition route specifies a \[intent\]\[google.cloud.dialogflow.cx.v3.Intent\]
/// that can be matched and/or a data condition that can be evaluated during a
/// session. When a specified transition is matched, the following actions are
/// taken in order:
///
/// * If there is a
///   \[`trigger_fulfillment`\]\[google.cloud.dialogflow.cx.v3.TransitionRoute.trigger_fulfillment\]
///   associated with the transition, it will be called.
/// * If there is a
///   \[`target_page`\]\[google.cloud.dialogflow.cx.v3.TransitionRoute.target_page\]
///   associated with the transition, the session will transition into the
///   specified page.
/// * If there is a
///   \[`target_flow`\]\[google.cloud.dialogflow.cx.v3.TransitionRoute.target_flow\]
///   associated with the transition, the session will transition into the
///   specified flow.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TransitionRoute {
    /// Output only. The unique identifier of this transition route.
    #[prost(string, tag = "6")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The description of the transition route. The maximum length is
    /// 500 characters.
    #[prost(string, tag = "8")]
    pub description: ::prost::alloc::string::String,
    /// The unique identifier of an \[Intent\]\[google.cloud.dialogflow.cx.v3.Intent\].
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/intents/<IntentID>`.
    /// Indicates that the transition can only happen when the given intent is
    /// matched.
    /// At least one of `intent` or `condition` must be specified. When both
    /// `intent` and `condition` are specified, the transition can only happen
    /// when both are fulfilled.
    #[prost(string, tag = "1")]
    pub intent: ::prost::alloc::string::String,
    /// The condition to evaluate against \[form
    /// parameters\]\[google.cloud.dialogflow.cx.v3.Form.parameters\] or \[session
    /// parameters\]\[google.cloud.dialogflow.cx.v3.SessionInfo.parameters\].
    ///
    /// See the [conditions
    /// reference](<https://cloud.google.com/dialogflow/cx/docs/reference/condition>).
    /// At least one of `intent` or `condition` must be specified. When both
    /// `intent` and `condition` are specified, the transition can only happen
    /// when both are fulfilled.
    #[prost(string, tag = "2")]
    pub condition: ::prost::alloc::string::String,
    /// The fulfillment to call when the condition is satisfied. At least one of
    /// `trigger_fulfillment` and `target` must be specified. When both are
    /// defined, `trigger_fulfillment` is executed first.
    #[prost(message, optional, tag = "3")]
    pub trigger_fulfillment: ::core::option::Option<Fulfillment>,
    /// The target to transition to, either a page in the same host flow (the flow
    /// that owns this
    /// \[TransitionRoute\]\[google.cloud.dialogflow.cx.v3.TransitionRoute\]), or
    /// another flow in the same agent.
    #[prost(oneof = "transition_route::Target", tags = "4, 5")]
    pub target: ::core::option::Option<transition_route::Target>,
}
/// Nested message and enum types in `TransitionRoute`.
pub mod transition_route {
    /// The target to transition to, either a page in the same host flow (the flow
    /// that owns this
    /// \[TransitionRoute\]\[google.cloud.dialogflow.cx.v3.TransitionRoute\]), or
    /// another flow in the same agent.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Target {
        /// The target page to transition to.
        /// Format:
        /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/pages/<PageID>`.
        #[prost(string, tag = "4")]
        TargetPage(::prost::alloc::string::String),
        /// The target flow to transition to.
        /// Format:
        /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>`.
        #[prost(string, tag = "5")]
        TargetFlow(::prost::alloc::string::String),
    }
}
/// The request message for
/// \[Pages.ListPages\]\[google.cloud.dialogflow.cx.v3.Pages.ListPages\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListPagesRequest {
    /// Required. The flow to list all pages for.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The language to list pages for. The following fields are language
    /// dependent:
    ///
    /// * `Page.entry_fulfillment.messages`
    /// * `Page.entry_fulfillment.conditional_cases`
    /// * `Page.event_handlers.trigger_fulfillment.messages`
    /// * `Page.event_handlers.trigger_fulfillment.conditional_cases`
    /// * `Page.form.parameters.fill_behavior.initial_prompt_fulfillment.messages`
    /// *
    ///
    /// `Page.form.parameters.fill_behavior.initial_prompt_fulfillment.conditional_cases`
    ///
    /// * `Page.form.parameters.fill_behavior.reprompt_event_handlers.messages`
    /// *
    ///
    /// `Page.form.parameters.fill_behavior.reprompt_event_handlers.conditional_cases`
    ///
    /// * `Page.transition_routes.trigger_fulfillment.messages`
    /// * `Page.transition_routes.trigger_fulfillment.conditional_cases`
    ///
    /// If not specified, the agent's default language is used.
    /// [Many
    /// languages](<https://cloud.google.com/dialogflow/cx/docs/reference/language>)
    /// are supported.
    /// Note: languages must be enabled in the agent before they can be used.
    #[prost(string, tag = "2")]
    pub language_code: ::prost::alloc::string::String,
    /// The maximum number of items to return in a single page. By default 100 and
    /// at most 1000.
    #[prost(int32, tag = "3")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous list request.
    #[prost(string, tag = "4")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response message for
/// \[Pages.ListPages\]\[google.cloud.dialogflow.cx.v3.Pages.ListPages\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListPagesResponse {
    /// The list of pages. There will be a maximum number of items returned based
    /// on the page_size field in the request.
    #[prost(message, repeated, tag = "1")]
    pub pages: ::prost::alloc::vec::Vec<Page>,
    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request message for
/// \[Pages.GetPage\]\[google.cloud.dialogflow.cx.v3.Pages.GetPage\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetPageRequest {
    /// Required. The name of the page.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/pages/<PageID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The language to retrieve the page for. The following fields are language
    /// dependent:
    ///
    /// * `Page.entry_fulfillment.messages`
    /// * `Page.entry_fulfillment.conditional_cases`
    /// * `Page.event_handlers.trigger_fulfillment.messages`
    /// * `Page.event_handlers.trigger_fulfillment.conditional_cases`
    /// * `Page.form.parameters.fill_behavior.initial_prompt_fulfillment.messages`
    /// *
    ///
    /// `Page.form.parameters.fill_behavior.initial_prompt_fulfillment.conditional_cases`
    ///
    /// * `Page.form.parameters.fill_behavior.reprompt_event_handlers.messages`
    /// *
    ///
    /// `Page.form.parameters.fill_behavior.reprompt_event_handlers.conditional_cases`
    ///
    /// * `Page.transition_routes.trigger_fulfillment.messages`
    /// * `Page.transition_routes.trigger_fulfillment.conditional_cases`
    ///
    /// If not specified, the agent's default language is used.
    /// [Many
    /// languages](<https://cloud.google.com/dialogflow/cx/docs/reference/language>)
    /// are supported.
    /// Note: languages must be enabled in the agent before they can be used.
    #[prost(string, tag = "2")]
    pub language_code: ::prost::alloc::string::String,
}
/// The request message for
/// \[Pages.CreatePage\]\[google.cloud.dialogflow.cx.v3.Pages.CreatePage\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreatePageRequest {
    /// Required. The flow to create a page for.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The page to create.
    #[prost(message, optional, tag = "2")]
    pub page: ::core::option::Option<Page>,
    /// The language of the following fields in `page`:
    ///
    /// * `Page.entry_fulfillment.messages`
    /// * `Page.entry_fulfillment.conditional_cases`
    /// * `Page.event_handlers.trigger_fulfillment.messages`
    /// * `Page.event_handlers.trigger_fulfillment.conditional_cases`
    /// * `Page.form.parameters.fill_behavior.initial_prompt_fulfillment.messages`
    /// *
    ///
    /// `Page.form.parameters.fill_behavior.initial_prompt_fulfillment.conditional_cases`
    ///
    /// * `Page.form.parameters.fill_behavior.reprompt_event_handlers.messages`
    /// *
    ///
    /// `Page.form.parameters.fill_behavior.reprompt_event_handlers.conditional_cases`
    ///
    /// * `Page.transition_routes.trigger_fulfillment.messages`
    /// * `Page.transition_routes.trigger_fulfillment.conditional_cases`
    ///
    /// If not specified, the agent's default language is used.
    /// [Many
    /// languages](<https://cloud.google.com/dialogflow/cx/docs/reference/language>)
    /// are supported.
    /// Note: languages must be enabled in the agent before they can be used.
    #[prost(string, tag = "3")]
    pub language_code: ::prost::alloc::string::String,
}
/// The request message for
/// \[Pages.UpdatePage\]\[google.cloud.dialogflow.cx.v3.Pages.UpdatePage\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdatePageRequest {
    /// Required. The page to update.
    #[prost(message, optional, tag = "1")]
    pub page: ::core::option::Option<Page>,
    /// The language of the following fields in `page`:
    ///
    /// * `Page.entry_fulfillment.messages`
    /// * `Page.entry_fulfillment.conditional_cases`
    /// * `Page.event_handlers.trigger_fulfillment.messages`
    /// * `Page.event_handlers.trigger_fulfillment.conditional_cases`
    /// * `Page.form.parameters.fill_behavior.initial_prompt_fulfillment.messages`
    /// *
    ///
    /// `Page.form.parameters.fill_behavior.initial_prompt_fulfillment.conditional_cases`
    ///
    /// * `Page.form.parameters.fill_behavior.reprompt_event_handlers.messages`
    /// *
    ///
    /// `Page.form.parameters.fill_behavior.reprompt_event_handlers.conditional_cases`
    ///
    /// * `Page.transition_routes.trigger_fulfillment.messages`
    /// * `Page.transition_routes.trigger_fulfillment.conditional_cases`
    ///
    /// If not specified, the agent's default language is used.
    /// [Many
    /// languages](<https://cloud.google.com/dialogflow/cx/docs/reference/language>)
    /// are supported.
    /// Note: languages must be enabled in the agent before they can be used.
    #[prost(string, tag = "2")]
    pub language_code: ::prost::alloc::string::String,
    /// The mask to control which fields get updated. If the mask is not present,
    /// all fields will be updated.
    #[prost(message, optional, tag = "3")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// The request message for
/// \[Pages.DeletePage\]\[google.cloud.dialogflow.cx.v3.Pages.DeletePage\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeletePageRequest {
    /// Required. The name of the page to delete.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/Flows/<flowID>/pages/<PageID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// This field has no effect for pages with no incoming transitions.
    /// For pages with incoming transitions:
    ///
    /// * If `force` is set to false, an error will be returned with message
    ///   indicating the incoming transitions.
    /// * If `force` is set to true, Dialogflow will remove the page, as well as
    ///   any transitions to the page (i.e. \[Target
    ///   page\]\[EventHandler.target_page\] in event handlers or \[Target
    ///   page\]\[TransitionRoute.target_page\] in transition routes that point to
    ///   this page will be cleared).
    #[prost(bool, tag = "2")]
    pub force: bool,
}
/// The Knowledge Connector settings for this page or flow.
/// This includes information such as the attached Knowledge Bases, and the way
/// to execute fulfillment.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct KnowledgeConnectorSettings {
    /// Whether Knowledge Connector is enabled or not.
    #[prost(bool, tag = "1")]
    pub enabled: bool,
    /// The fulfillment to be triggered.
    ///
    /// When the answers from the Knowledge Connector are selected by Dialogflow,
    /// you can utitlize the request scoped parameter `$request.knowledge.answers`
    /// (contains up to the 5 highest confidence answers) and
    /// `$request.knowledge.questions` (contains the corresponding questions) to
    /// construct the fulfillment.
    #[prost(message, optional, tag = "3")]
    pub trigger_fulfillment: ::core::option::Option<Fulfillment>,
    /// Optional. List of related data store connections.
    #[prost(message, repeated, tag = "6")]
    pub data_store_connections: ::prost::alloc::vec::Vec<DataStoreConnection>,
    /// The target to transition to, either a page in the same host flow (the flow
    /// that owns this
    /// \[KnowledgeConnectorSettings\]\[google.cloud.dialogflow.cx.v3.KnowledgeConnectorSettings\]),
    /// or another flow in the same agent.
    #[prost(oneof = "knowledge_connector_settings::Target", tags = "4, 5")]
    pub target: ::core::option::Option<knowledge_connector_settings::Target>,
}
/// Nested message and enum types in `KnowledgeConnectorSettings`.
pub mod knowledge_connector_settings {
    /// The target to transition to, either a page in the same host flow (the flow
    /// that owns this
    /// \[KnowledgeConnectorSettings\]\[google.cloud.dialogflow.cx.v3.KnowledgeConnectorSettings\]),
    /// or another flow in the same agent.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Target {
        /// The target page to transition to.
        /// Format:
        /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/pages/<PageID>`.
        #[prost(string, tag = "4")]
        TargetPage(::prost::alloc::string::String),
        /// The target flow to transition to.
        /// Format:
        /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>`.
        #[prost(string, tag = "5")]
        TargetFlow(::prost::alloc::string::String),
    }
}
/// Generated client implementations.
pub mod pages_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing \[Pages\]\[google.cloud.dialogflow.cx.v3.Page\].
    #[derive(Debug, Clone)]
    pub struct PagesClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl PagesClient<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> PagesClient<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,
        ) -> PagesClient<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,
        {
            PagesClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Returns the list of all pages in the specified flow.
        pub async fn list_pages(
            &mut self,
            request: impl tonic::IntoRequest<super::ListPagesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListPagesResponse>,
            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.dialogflow.cx.v3.Pages/ListPages",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.dialogflow.cx.v3.Pages", "ListPages"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the specified page.
        pub async fn get_page(
            &mut self,
            request: impl tonic::IntoRequest<super::GetPageRequest>,
        ) -> std::result::Result<tonic::Response<super::Page>, 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.dialogflow.cx.v3.Pages/GetPage",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.dialogflow.cx.v3.Pages", "GetPage"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a page in the specified flow.
        ///
        /// Note: You should always train a flow prior to sending it queries. See the
        /// [training
        /// documentation](https://cloud.google.com/dialogflow/cx/docs/concept/training).
        pub async fn create_page(
            &mut self,
            request: impl tonic::IntoRequest<super::CreatePageRequest>,
        ) -> std::result::Result<tonic::Response<super::Page>, 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.dialogflow.cx.v3.Pages/CreatePage",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.dialogflow.cx.v3.Pages", "CreatePage"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified page.
        ///
        /// Note: You should always train a flow prior to sending it queries. See the
        /// [training
        /// documentation](https://cloud.google.com/dialogflow/cx/docs/concept/training).
        pub async fn update_page(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdatePageRequest>,
        ) -> std::result::Result<tonic::Response<super::Page>, 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.dialogflow.cx.v3.Pages/UpdatePage",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.dialogflow.cx.v3.Pages", "UpdatePage"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified page.
        ///
        /// Note: You should always train a flow prior to sending it queries. See the
        /// [training
        /// documentation](https://cloud.google.com/dialogflow/cx/docs/concept/training).
        pub async fn delete_page(
            &mut self,
            request: impl tonic::IntoRequest<super::DeletePageRequest>,
        ) -> 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.dialogflow.cx.v3.Pages/DeletePage",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.dialogflow.cx.v3.Pages", "DeletePage"),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Defines the properties of a parameter.
/// Used to define parameters used in the agent and the
/// input / output parameters for each fulfillment.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ParameterDefinition {
    /// Required. Name of parameter.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Type of parameter.
    #[deprecated]
    #[prost(enumeration = "parameter_definition::ParameterType", tag = "2")]
    pub r#type: i32,
    /// Optional. Type schema of parameter.
    #[prost(message, optional, tag = "4")]
    pub type_schema: ::core::option::Option<TypeSchema>,
    /// Human-readable description of the parameter. Limited to 300 characters.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
}
/// Nested message and enum types in `ParameterDefinition`.
pub mod parameter_definition {
    /// Parameter types are used for validation.
    /// These types are consistent with
    /// \[google.protobuf.Value\]\[google.protobuf.Value\].
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ParameterType {
        /// Not specified. No validation will be performed.
        Unspecified = 0,
        /// Represents any string value.
        String = 1,
        /// Represents any number value.
        Number = 2,
        /// Represents a boolean value.
        Boolean = 3,
        /// Represents a null value.
        Null = 4,
        /// Represents any object value.
        Object = 5,
        /// Represents a repeated value.
        List = 6,
    }
    impl ParameterType {
        /// 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 => "PARAMETER_TYPE_UNSPECIFIED",
                Self::String => "STRING",
                Self::Number => "NUMBER",
                Self::Boolean => "BOOLEAN",
                Self::Null => "NULL",
                Self::Object => "OBJECT",
                Self::List => "LIST",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "PARAMETER_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "STRING" => Some(Self::String),
                "NUMBER" => Some(Self::Number),
                "BOOLEAN" => Some(Self::Boolean),
                "NULL" => Some(Self::Null),
                "OBJECT" => Some(Self::Object),
                "LIST" => Some(Self::List),
                _ => None,
            }
        }
    }
}
/// Encapsulates different type schema variations: either a reference to an
/// a schema that's already defined by a tool, or an inline definition.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TypeSchema {
    /// The encapsulated schema.
    #[prost(oneof = "type_schema::Schema", tags = "1, 2")]
    pub schema: ::core::option::Option<type_schema::Schema>,
}
/// Nested message and enum types in `TypeSchema`.
pub mod type_schema {
    /// A reference to the schema of an existing tool.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct SchemaReference {
        /// The tool that contains this schema definition.
        /// Format:
        /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/tools/<ToolID>`.
        #[prost(string, tag = "1")]
        pub tool: ::prost::alloc::string::String,
        /// The name of the schema.
        #[prost(string, tag = "2")]
        pub schema: ::prost::alloc::string::String,
    }
    /// The encapsulated schema.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Schema {
        /// Set if this is an inline schema definition.
        #[prost(message, tag = "1")]
        InlineSchema(::prost::alloc::boxed::Box<super::InlineSchema>),
        /// Set if this is a schema reference.
        #[prost(message, tag = "2")]
        SchemaReference(SchemaReference),
    }
}
/// A type schema object that's specified inline.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InlineSchema {
    /// Data type of the schema.
    #[prost(enumeration = "DataType", tag = "1")]
    pub r#type: i32,
    /// Schema of the elements if this is an ARRAY type.
    #[prost(message, optional, boxed, tag = "2")]
    pub items: ::core::option::Option<::prost::alloc::boxed::Box<TypeSchema>>,
}
/// Defines data types that are supported for inlined schemas. These types are
/// consistent with \[google.protobuf.Value\]\[google.protobuf.Value\].
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum DataType {
    /// Not specified.
    Unspecified = 0,
    /// Represents any string value.
    String = 1,
    /// Represents any number value.
    Number = 2,
    /// Represents a boolean value.
    Boolean = 3,
    /// Represents a repeated value.
    Array = 6,
}
impl DataType {
    /// 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_TYPE_UNSPECIFIED",
            Self::String => "STRING",
            Self::Number => "NUMBER",
            Self::Boolean => "BOOLEAN",
            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 {
            "DATA_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "STRING" => Some(Self::String),
            "NUMBER" => Some(Self::Number),
            "BOOLEAN" => Some(Self::Boolean),
            "ARRAY" => Some(Self::Array),
            _ => None,
        }
    }
}
/// Agent/flow validation message.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ValidationMessage {
    /// The type of the resources where the message is found.
    #[prost(enumeration = "validation_message::ResourceType", tag = "1")]
    pub resource_type: i32,
    /// The names of the resources where the message is found.
    #[deprecated]
    #[prost(string, repeated, tag = "2")]
    pub resources: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// The resource names of the resources where the message is found.
    #[prost(message, repeated, tag = "6")]
    pub resource_names: ::prost::alloc::vec::Vec<ResourceName>,
    /// Indicates the severity of the message.
    #[prost(enumeration = "validation_message::Severity", tag = "3")]
    pub severity: i32,
    /// The message detail.
    #[prost(string, tag = "4")]
    pub detail: ::prost::alloc::string::String,
}
/// Nested message and enum types in `ValidationMessage`.
pub mod validation_message {
    /// Resource types.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ResourceType {
        /// Unspecified.
        Unspecified = 0,
        /// Agent.
        Agent = 1,
        /// Intent.
        Intent = 2,
        /// Intent training phrase.
        IntentTrainingPhrase = 8,
        /// Intent parameter.
        IntentParameter = 9,
        /// Multiple intents.
        Intents = 10,
        /// Multiple training phrases.
        IntentTrainingPhrases = 11,
        /// Entity type.
        EntityType = 3,
        /// Multiple entity types.
        EntityTypes = 12,
        /// Webhook.
        Webhook = 4,
        /// Flow.
        Flow = 5,
        /// Page.
        Page = 6,
        /// Multiple pages.
        Pages = 13,
        /// Transition route group.
        TransitionRouteGroup = 7,
        /// Agent transition route group.
        AgentTransitionRouteGroup = 14,
    }
    impl ResourceType {
        /// 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 => "RESOURCE_TYPE_UNSPECIFIED",
                Self::Agent => "AGENT",
                Self::Intent => "INTENT",
                Self::IntentTrainingPhrase => "INTENT_TRAINING_PHRASE",
                Self::IntentParameter => "INTENT_PARAMETER",
                Self::Intents => "INTENTS",
                Self::IntentTrainingPhrases => "INTENT_TRAINING_PHRASES",
                Self::EntityType => "ENTITY_TYPE",
                Self::EntityTypes => "ENTITY_TYPES",
                Self::Webhook => "WEBHOOK",
                Self::Flow => "FLOW",
                Self::Page => "PAGE",
                Self::Pages => "PAGES",
                Self::TransitionRouteGroup => "TRANSITION_ROUTE_GROUP",
                Self::AgentTransitionRouteGroup => "AGENT_TRANSITION_ROUTE_GROUP",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "RESOURCE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "AGENT" => Some(Self::Agent),
                "INTENT" => Some(Self::Intent),
                "INTENT_TRAINING_PHRASE" => Some(Self::IntentTrainingPhrase),
                "INTENT_PARAMETER" => Some(Self::IntentParameter),
                "INTENTS" => Some(Self::Intents),
                "INTENT_TRAINING_PHRASES" => Some(Self::IntentTrainingPhrases),
                "ENTITY_TYPE" => Some(Self::EntityType),
                "ENTITY_TYPES" => Some(Self::EntityTypes),
                "WEBHOOK" => Some(Self::Webhook),
                "FLOW" => Some(Self::Flow),
                "PAGE" => Some(Self::Page),
                "PAGES" => Some(Self::Pages),
                "TRANSITION_ROUTE_GROUP" => Some(Self::TransitionRouteGroup),
                "AGENT_TRANSITION_ROUTE_GROUP" => Some(Self::AgentTransitionRouteGroup),
                _ => None,
            }
        }
    }
    /// Severity level.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Severity {
        /// Unspecified.
        Unspecified = 0,
        /// The agent doesn't follow Dialogflow best practices.
        Info = 1,
        /// The agent may not behave as expected.
        Warning = 2,
        /// The agent may experience failures.
        Error = 3,
    }
    impl Severity {
        /// 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 => "SEVERITY_UNSPECIFIED",
                Self::Info => "INFO",
                Self::Warning => "WARNING",
                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 {
                "SEVERITY_UNSPECIFIED" => Some(Self::Unspecified),
                "INFO" => Some(Self::Info),
                "WARNING" => Some(Self::Warning),
                "ERROR" => Some(Self::Error),
                _ => None,
            }
        }
    }
}
/// Resource name and display name.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ResourceName {
    /// Name.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Display name.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
}
/// Settings related to NLU.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct NluSettings {
    /// Indicates the type of NLU model.
    #[prost(enumeration = "nlu_settings::ModelType", tag = "1")]
    pub model_type: i32,
    /// To filter out false positive results and still get variety in matched
    /// natural language inputs for your agent, you can tune the machine learning
    /// classification threshold. If the returned score value is less than the
    /// threshold value, then a no-match event will be triggered. The score values
    /// range from 0.0 (completely uncertain) to 1.0 (completely certain). If set
    /// to 0.0, the default of 0.3 is used. You can set a separate classification
    /// threshold for the flow in each language enabled for the agent.
    #[prost(float, tag = "3")]
    pub classification_threshold: f32,
    /// Indicates NLU model training mode.
    #[prost(enumeration = "nlu_settings::ModelTrainingMode", tag = "4")]
    pub model_training_mode: i32,
}
/// Nested message and enum types in `NluSettings`.
pub mod nlu_settings {
    /// NLU model type.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ModelType {
        /// Not specified. `MODEL_TYPE_STANDARD` will be used.
        Unspecified = 0,
        /// Use standard NLU model.
        Standard = 1,
        /// Use advanced NLU model.
        Advanced = 3,
    }
    impl ModelType {
        /// 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 => "MODEL_TYPE_UNSPECIFIED",
                Self::Standard => "MODEL_TYPE_STANDARD",
                Self::Advanced => "MODEL_TYPE_ADVANCED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "MODEL_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "MODEL_TYPE_STANDARD" => Some(Self::Standard),
                "MODEL_TYPE_ADVANCED" => Some(Self::Advanced),
                _ => None,
            }
        }
    }
    /// NLU model training mode.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ModelTrainingMode {
        /// Not specified. `MODEL_TRAINING_MODE_AUTOMATIC` will be used.
        Unspecified = 0,
        /// NLU model training is automatically triggered when a flow gets modified.
        /// User can also manually trigger model training in this mode.
        Automatic = 1,
        /// User needs to manually trigger NLU model training. Best for large flows
        /// whose models take long time to train.
        Manual = 2,
    }
    impl ModelTrainingMode {
        /// 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 => "MODEL_TRAINING_MODE_UNSPECIFIED",
                Self::Automatic => "MODEL_TRAINING_MODE_AUTOMATIC",
                Self::Manual => "MODEL_TRAINING_MODE_MANUAL",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "MODEL_TRAINING_MODE_UNSPECIFIED" => Some(Self::Unspecified),
                "MODEL_TRAINING_MODE_AUTOMATIC" => Some(Self::Automatic),
                "MODEL_TRAINING_MODE_MANUAL" => Some(Self::Manual),
                _ => None,
            }
        }
    }
}
/// Flows represents the conversation flows when you build your chatbot agent.
///
/// A flow consists of many pages connected by the transition routes.
/// Conversations always start with the built-in Start Flow (with an all-0 ID).
/// Transition routes can direct the conversation session from the current flow
/// (parent flow) to another flow (sub flow). When the sub flow is finished,
/// Dialogflow will bring the session back to the parent flow, where the sub flow
/// is started.
///
/// Usually, when a transition route is followed by a matched intent, the intent
/// will be "consumed". This means the intent won't activate more transition
/// routes. However, when the followed transition route moves the conversation
/// session into a different flow, the matched intent can be carried over and to
/// be consumed in the target flow.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Flow {
    /// The unique identifier of the flow.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. The human-readable name of the flow.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// The description of the flow. The maximum length is 500 characters. If
    /// exceeded, the request is rejected.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// A flow's transition routes serve two purposes:
    ///
    /// * They are responsible for matching the user's first utterances in the
    ///   flow.
    /// * They are inherited by every page's \[transition
    ///   routes\]\[Page.transition_routes\] and can support use cases such as the user
    ///   saying "help" or "can I talk to a human?", which can be handled in a common
    ///   way regardless of the current page. Transition routes defined in the page
    ///   have higher priority than those defined in the flow.
    ///
    /// TransitionRoutes are evaluated in the following order:
    ///
    /// * TransitionRoutes with intent specified.
    /// * TransitionRoutes with only condition specified.
    ///
    /// TransitionRoutes with intent specified are inherited by pages in the flow.
    #[prost(message, repeated, tag = "4")]
    pub transition_routes: ::prost::alloc::vec::Vec<TransitionRoute>,
    /// A flow's event handlers serve two purposes:
    ///
    /// * They are responsible for handling events (e.g. no match,
    ///   webhook errors) in the flow.
    /// * They are inherited by every page's \[event
    ///   handlers\]\[Page.event_handlers\], which can be used to handle common events
    ///   regardless of the current page. Event handlers defined in the page
    ///   have higher priority than those defined in the flow.
    ///
    /// Unlike
    /// \[transition_routes\]\[google.cloud.dialogflow.cx.v3.Flow.transition_routes\],
    /// these handlers are evaluated on a first-match basis. The first one that
    /// matches the event get executed, with the rest being ignored.
    #[prost(message, repeated, tag = "10")]
    pub event_handlers: ::prost::alloc::vec::Vec<EventHandler>,
    /// A flow's transition route group serve two purposes:
    ///
    /// * They are responsible for matching the user's first utterances in the
    ///   flow.
    /// * They are inherited by every page's \[transition
    ///   route groups\]\[Page.transition_route_groups\]. Transition route groups
    ///   defined in the page have higher priority than those defined in the flow.
    ///
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/transitionRouteGroups/<TransitionRouteGroupID>`
    /// or
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/transitionRouteGroups/<TransitionRouteGroupID>`
    /// for agent-level groups.
    #[prost(string, repeated, tag = "15")]
    pub transition_route_groups: ::prost::alloc::vec::Vec<
        ::prost::alloc::string::String,
    >,
    /// NLU related settings of the flow.
    #[prost(message, optional, tag = "11")]
    pub nlu_settings: ::core::option::Option<NluSettings>,
    /// Hierarchical advanced settings for this flow. The settings exposed at the
    /// lower level overrides the settings exposed at the higher level.
    #[prost(message, optional, tag = "14")]
    pub advanced_settings: ::core::option::Option<AdvancedSettings>,
    /// Optional. Knowledge connector configuration.
    #[prost(message, optional, tag = "18")]
    pub knowledge_connector_settings: ::core::option::Option<KnowledgeConnectorSettings>,
    /// Optional. Defined structured input parameters for this flow.
    #[prost(message, repeated, tag = "26")]
    pub input_parameter_definitions: ::prost::alloc::vec::Vec<ParameterDefinition>,
    /// Optional. Defined structured output parameters for this flow.
    #[prost(message, repeated, tag = "27")]
    pub output_parameter_definitions: ::prost::alloc::vec::Vec<ParameterDefinition>,
    /// Optional. Multi-lingual agent settings for this flow.
    #[prost(message, optional, tag = "28")]
    pub multi_language_settings: ::core::option::Option<flow::MultiLanguageSettings>,
    /// Indicates whether the flow is locked for changes. If the flow is locked,
    /// modifications to the flow will be rejected.
    #[prost(bool, tag = "30")]
    pub locked: bool,
}
/// Nested message and enum types in `Flow`.
pub mod flow {
    /// Settings for multi-lingual agents.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct MultiLanguageSettings {
        /// Optional. Enable multi-language detection for this flow. This can be set
        /// only if \[agent level multi language
        /// setting\]\[Agent.enable_multi_language_training\] is enabled.
        #[prost(bool, tag = "1")]
        pub enable_multi_language_detection: bool,
        /// Optional. Agent will respond in the detected language if the detected
        /// language code is in the supported resolved languages for this flow. This
        /// will be used only if multi-language training is enabled in the
        /// \[agent\]\[google.cloud.dialogflow.cx.v3.Agent.enable_multi_language_training\]
        /// and multi-language detection is enabled in the
        /// \[flow\]\[google.cloud.dialogflow.cx.v3.Flow.MultiLanguageSettings.enable_multi_language_detection\].
        /// The supported languages must be a subset of the languages supported by
        /// the agent.
        #[prost(string, repeated, tag = "2")]
        pub supported_response_language_codes: ::prost::alloc::vec::Vec<
            ::prost::alloc::string::String,
        >,
    }
}
/// The request message for
/// \[Flows.CreateFlow\]\[google.cloud.dialogflow.cx.v3.Flows.CreateFlow\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateFlowRequest {
    /// Required. The agent to create a flow for.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The flow to create.
    #[prost(message, optional, tag = "2")]
    pub flow: ::core::option::Option<Flow>,
    /// The language of the following fields in `flow`:
    ///
    /// * `Flow.event_handlers.trigger_fulfillment.messages`
    /// * `Flow.event_handlers.trigger_fulfillment.conditional_cases`
    /// * `Flow.transition_routes.trigger_fulfillment.messages`
    /// * `Flow.transition_routes.trigger_fulfillment.conditional_cases`
    ///
    /// If not specified, the agent's default language is used.
    /// [Many
    /// languages](<https://cloud.google.com/dialogflow/cx/docs/reference/language>)
    /// are supported.
    /// Note: languages must be enabled in the agent before they can be used.
    #[prost(string, tag = "3")]
    pub language_code: ::prost::alloc::string::String,
}
/// The request message for
/// \[Flows.DeleteFlow\]\[google.cloud.dialogflow.cx.v3.Flows.DeleteFlow\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteFlowRequest {
    /// Required. The name of the flow to delete.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// This field has no effect for flows with no incoming transitions.
    /// For flows with incoming transitions:
    ///
    /// * If `force` is set to false, an error will be returned with message
    ///   indicating the incoming transitions.
    /// * If `force` is set to true, Dialogflow will remove the flow, as well as
    ///   any transitions to the flow (i.e. \[Target
    ///   flow\]\[EventHandler.target_flow\] in event handlers or \[Target
    ///   flow\]\[TransitionRoute.target_flow\] in transition routes that point to
    ///   this flow will be cleared).
    #[prost(bool, tag = "2")]
    pub force: bool,
}
/// The request message for
/// \[Flows.ListFlows\]\[google.cloud.dialogflow.cx.v3.Flows.ListFlows\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListFlowsRequest {
    /// Required. The agent containing the flows.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of items to return in a single page. By default 100 and
    /// at most 1000.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// The language to list flows for. The following fields are language
    /// dependent:
    ///
    /// * `Flow.event_handlers.trigger_fulfillment.messages`
    /// * `Flow.event_handlers.trigger_fulfillment.conditional_cases`
    /// * `Flow.transition_routes.trigger_fulfillment.messages`
    /// * `Flow.transition_routes.trigger_fulfillment.conditional_cases`
    ///
    /// If not specified, the agent's default language is used.
    /// [Many
    /// languages](<https://cloud.google.com/dialogflow/cx/docs/reference/language>)
    /// are supported.
    /// Note: languages must be enabled in the agent before they can be used.
    #[prost(string, tag = "4")]
    pub language_code: ::prost::alloc::string::String,
}
/// The response message for
/// \[Flows.ListFlows\]\[google.cloud.dialogflow.cx.v3.Flows.ListFlows\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListFlowsResponse {
    /// The list of flows. There will be a maximum number of items returned based
    /// on the page_size field in the request.
    #[prost(message, repeated, tag = "1")]
    pub flows: ::prost::alloc::vec::Vec<Flow>,
    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The response message for
/// \[Flows.GetFlow\]\[google.cloud.dialogflow.cx.v3.Flows.GetFlow\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetFlowRequest {
    /// Required. The name of the flow to get.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The language to retrieve the flow for. The following fields are language
    /// dependent:
    ///
    /// * `Flow.event_handlers.trigger_fulfillment.messages`
    /// * `Flow.event_handlers.trigger_fulfillment.conditional_cases`
    /// * `Flow.transition_routes.trigger_fulfillment.messages`
    /// * `Flow.transition_routes.trigger_fulfillment.conditional_cases`
    ///
    /// If not specified, the agent's default language is used.
    /// [Many
    /// languages](<https://cloud.google.com/dialogflow/cx/docs/reference/language>)
    /// are supported.
    /// Note: languages must be enabled in the agent before they can be used.
    #[prost(string, tag = "2")]
    pub language_code: ::prost::alloc::string::String,
}
/// The request message for
/// \[Flows.UpdateFlow\]\[google.cloud.dialogflow.cx.v3.Flows.UpdateFlow\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateFlowRequest {
    /// Required. The flow to update.
    #[prost(message, optional, tag = "1")]
    pub flow: ::core::option::Option<Flow>,
    /// The mask 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>,
    /// The language of the following fields in `flow`:
    ///
    /// * `Flow.event_handlers.trigger_fulfillment.messages`
    /// * `Flow.event_handlers.trigger_fulfillment.conditional_cases`
    /// * `Flow.transition_routes.trigger_fulfillment.messages`
    /// * `Flow.transition_routes.trigger_fulfillment.conditional_cases`
    ///
    /// If not specified, the agent's default language is used.
    /// [Many
    /// languages](<https://cloud.google.com/dialogflow/cx/docs/reference/language>)
    /// are supported.
    /// Note: languages must be enabled in the agent before they can be used.
    #[prost(string, tag = "3")]
    pub language_code: ::prost::alloc::string::String,
}
/// The request message for
/// \[Flows.TrainFlow\]\[google.cloud.dialogflow.cx.v3.Flows.TrainFlow\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TrainFlowRequest {
    /// Required. The flow to train.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for
/// \[Flows.ValidateFlow\]\[google.cloud.dialogflow.cx.v3.Flows.ValidateFlow\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ValidateFlowRequest {
    /// Required. The flow to validate.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// If not specified, the agent's default language is used.
    #[prost(string, tag = "2")]
    pub language_code: ::prost::alloc::string::String,
}
/// The request message for
/// \[Flows.GetFlowValidationResult\]\[google.cloud.dialogflow.cx.v3.Flows.GetFlowValidationResult\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetFlowValidationResultRequest {
    /// Required. The flow name.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/validationResult`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// If not specified, the agent's default language is used.
    #[prost(string, tag = "2")]
    pub language_code: ::prost::alloc::string::String,
}
/// The response message for
/// \[Flows.GetFlowValidationResult\]\[google.cloud.dialogflow.cx.v3.Flows.GetFlowValidationResult\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FlowValidationResult {
    /// The unique identifier of the flow validation result.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/validationResult`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Contains all validation messages.
    #[prost(message, repeated, tag = "2")]
    pub validation_messages: ::prost::alloc::vec::Vec<ValidationMessage>,
    /// Last time the flow was validated.
    #[prost(message, optional, tag = "3")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// The request message for
/// \[Flows.ImportFlow\]\[google.cloud.dialogflow.cx.v3.Flows.ImportFlow\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ImportFlowRequest {
    /// Required. The agent to import the flow into.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Flow import mode. If not specified, `KEEP` is assumed.
    #[prost(enumeration = "import_flow_request::ImportOption", tag = "4")]
    pub import_option: i32,
    /// Optional. Specifies the import strategy used when resolving resource
    /// conflicts.
    #[prost(message, optional, tag = "5")]
    pub flow_import_strategy: ::core::option::Option<FlowImportStrategy>,
    /// Required. The flow to import.
    #[prost(oneof = "import_flow_request::Flow", tags = "2, 3")]
    pub flow: ::core::option::Option<import_flow_request::Flow>,
}
/// Nested message and enum types in `ImportFlowRequest`.
pub mod import_flow_request {
    /// Import option.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ImportOption {
        /// Unspecified. Treated as `KEEP`.
        Unspecified = 0,
        /// Always respect settings in exported flow content. It may cause a
        /// import failure if some settings (e.g. custom NLU) are not supported in
        /// the agent to import into.
        Keep = 1,
        /// Fallback to default settings if some settings are not supported in the
        /// agent to import into. E.g. Standard NLU will be used if custom NLU is
        /// not available.
        Fallback = 2,
    }
    impl ImportOption {
        /// 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 => "IMPORT_OPTION_UNSPECIFIED",
                Self::Keep => "KEEP",
                Self::Fallback => "FALLBACK",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "IMPORT_OPTION_UNSPECIFIED" => Some(Self::Unspecified),
                "KEEP" => Some(Self::Keep),
                "FALLBACK" => Some(Self::Fallback),
                _ => None,
            }
        }
    }
    /// Required. The flow to import.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Flow {
        /// The [Google Cloud Storage](<https://cloud.google.com/storage/docs/>) URI
        /// to import flow from. The format of this URI must be
        /// `gs://<bucket-name>/<object-name>`.
        ///
        /// Dialogflow performs a read operation for the Cloud Storage object
        /// on the caller's behalf, so your request authentication must
        /// have read permissions for the object. For more information, see
        /// [Dialogflow access
        /// control](<https://cloud.google.com/dialogflow/cx/docs/concept/access-control#storage>).
        #[prost(string, tag = "2")]
        FlowUri(::prost::alloc::string::String),
        /// Uncompressed raw byte content for flow.
        #[prost(bytes, tag = "3")]
        FlowContent(::prost::alloc::vec::Vec<u8>),
    }
}
/// The flow import strategy used for resource conflict resolution associated
/// with an \[ImportFlowRequest\]\[google.cloud.dialogflow.cx.v3.ImportFlowRequest\].
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FlowImportStrategy {
    /// Optional. Import strategy for resource conflict resolution, applied
    /// globally throughout the flow. It will be applied for all display name
    /// conflicts in the imported content. If not specified, 'CREATE_NEW' is
    /// assumed.
    #[prost(enumeration = "ImportStrategy", tag = "1")]
    pub global_import_strategy: i32,
}
/// The response message for
/// \[Flows.ImportFlow\]\[google.cloud.dialogflow.cx.v3.Flows.ImportFlow\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ImportFlowResponse {
    /// The unique identifier of the new flow.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>`.
    #[prost(string, tag = "1")]
    pub flow: ::prost::alloc::string::String,
}
/// The request message for
/// \[Flows.ExportFlow\]\[google.cloud.dialogflow.cx.v3.Flows.ExportFlow\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExportFlowRequest {
    /// Required. The name of the flow to export.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The [Google Cloud
    /// Storage](<https://cloud.google.com/storage/docs/>) URI to export the flow to.
    /// The format of this URI must be `gs://<bucket-name>/<object-name>`. If left
    /// unspecified, the serialized flow is returned inline.
    ///
    /// Dialogflow performs a write operation for the Cloud Storage object
    /// on the caller's behalf, so your request authentication must
    /// have write permissions for the object. For more information, see
    /// [Dialogflow access
    /// control](<https://cloud.google.com/dialogflow/cx/docs/concept/access-control#storage>).
    #[prost(string, tag = "2")]
    pub flow_uri: ::prost::alloc::string::String,
    /// Optional. Whether to export flows referenced by the specified flow.
    #[prost(bool, tag = "4")]
    pub include_referenced_flows: bool,
}
/// The response message for
/// \[Flows.ExportFlow\]\[google.cloud.dialogflow.cx.v3.Flows.ExportFlow\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExportFlowResponse {
    /// The exported flow.
    #[prost(oneof = "export_flow_response::Flow", tags = "1, 2")]
    pub flow: ::core::option::Option<export_flow_response::Flow>,
}
/// Nested message and enum types in `ExportFlowResponse`.
pub mod export_flow_response {
    /// The exported flow.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Flow {
        /// The URI to a file containing the exported flow. This field is populated
        /// only if `flow_uri` is specified in
        /// \[ExportFlowRequest\]\[google.cloud.dialogflow.cx.v3.ExportFlowRequest\].
        #[prost(string, tag = "1")]
        FlowUri(::prost::alloc::string::String),
        /// Uncompressed raw byte content for flow.
        #[prost(bytes, tag = "2")]
        FlowContent(::prost::alloc::vec::Vec<u8>),
    }
}
/// Generated client implementations.
pub mod flows_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing \[Flows\]\[google.cloud.dialogflow.cx.v3.Flow\].
    #[derive(Debug, Clone)]
    pub struct FlowsClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl FlowsClient<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> FlowsClient<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,
        ) -> FlowsClient<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,
        {
            FlowsClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Creates a flow in the specified agent.
        ///
        /// Note: You should always train a flow prior to sending it queries. See the
        /// [training
        /// documentation](https://cloud.google.com/dialogflow/cx/docs/concept/training).
        pub async fn create_flow(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateFlowRequest>,
        ) -> std::result::Result<tonic::Response<super::Flow>, 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.dialogflow.cx.v3.Flows/CreateFlow",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.dialogflow.cx.v3.Flows", "CreateFlow"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a specified flow.
        pub async fn delete_flow(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteFlowRequest>,
        ) -> 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.dialogflow.cx.v3.Flows/DeleteFlow",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.dialogflow.cx.v3.Flows", "DeleteFlow"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns the list of all flows in the specified agent.
        pub async fn list_flows(
            &mut self,
            request: impl tonic::IntoRequest<super::ListFlowsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListFlowsResponse>,
            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.dialogflow.cx.v3.Flows/ListFlows",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.dialogflow.cx.v3.Flows", "ListFlows"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the specified flow.
        pub async fn get_flow(
            &mut self,
            request: impl tonic::IntoRequest<super::GetFlowRequest>,
        ) -> std::result::Result<tonic::Response<super::Flow>, 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.dialogflow.cx.v3.Flows/GetFlow",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.dialogflow.cx.v3.Flows", "GetFlow"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified flow.
        ///
        /// Note: You should always train a flow prior to sending it queries. See the
        /// [training
        /// documentation](https://cloud.google.com/dialogflow/cx/docs/concept/training).
        pub async fn update_flow(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateFlowRequest>,
        ) -> std::result::Result<tonic::Response<super::Flow>, 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.dialogflow.cx.v3.Flows/UpdateFlow",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.dialogflow.cx.v3.Flows", "UpdateFlow"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Trains the specified flow. Note that only the flow in 'draft' environment
        /// is trained.
        ///
        /// This method is a [long-running
        /// operation](https://cloud.google.com/dialogflow/cx/docs/how/long-running-operation).
        /// The returned `Operation` type has the following method-specific fields:
        ///
        /// * `metadata`: An empty [Struct
        ///  message](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#struct)
        /// * `response`: An [Empty
        ///  message](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#empty)
        ///
        /// Note: You should always train a flow prior to sending it queries. See the
        /// [training
        /// documentation](https://cloud.google.com/dialogflow/cx/docs/concept/training).
        pub async fn train_flow(
            &mut self,
            request: impl tonic::IntoRequest<super::TrainFlowRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.dialogflow.cx.v3.Flows/TrainFlow",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.dialogflow.cx.v3.Flows", "TrainFlow"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Validates the specified flow and creates or updates validation results.
        /// Please call this API after the training is completed to get the complete
        /// validation results.
        pub async fn validate_flow(
            &mut self,
            request: impl tonic::IntoRequest<super::ValidateFlowRequest>,
        ) -> std::result::Result<
            tonic::Response<super::FlowValidationResult>,
            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.dialogflow.cx.v3.Flows/ValidateFlow",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Flows",
                        "ValidateFlow",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets the latest flow validation result. Flow validation is performed
        /// when ValidateFlow is called.
        pub async fn get_flow_validation_result(
            &mut self,
            request: impl tonic::IntoRequest<super::GetFlowValidationResultRequest>,
        ) -> std::result::Result<
            tonic::Response<super::FlowValidationResult>,
            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.dialogflow.cx.v3.Flows/GetFlowValidationResult",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Flows",
                        "GetFlowValidationResult",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Imports the specified flow to the specified agent from a binary file.
        ///
        /// This method is a [long-running
        /// operation](https://cloud.google.com/dialogflow/cx/docs/how/long-running-operation).
        /// The returned `Operation` type has the following method-specific fields:
        ///
        /// * `metadata`: An empty [Struct
        ///  message](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#struct)
        /// * `response`:
        ///  \[ImportFlowResponse\]\[google.cloud.dialogflow.cx.v3.ImportFlowResponse\]
        ///
        /// Note: You should always train a flow prior to sending it queries. See the
        /// [training
        /// documentation](https://cloud.google.com/dialogflow/cx/docs/concept/training).
        pub async fn import_flow(
            &mut self,
            request: impl tonic::IntoRequest<super::ImportFlowRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.dialogflow.cx.v3.Flows/ImportFlow",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.dialogflow.cx.v3.Flows", "ImportFlow"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Exports the specified flow to a binary file.
        ///
        /// This method is a [long-running
        /// operation](https://cloud.google.com/dialogflow/cx/docs/how/long-running-operation).
        /// The returned `Operation` type has the following method-specific fields:
        ///
        /// * `metadata`: An empty [Struct
        ///  message](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#struct)
        /// * `response`:
        ///  \[ExportFlowResponse\]\[google.cloud.dialogflow.cx.v3.ExportFlowResponse\]
        ///
        /// Note that resources (e.g. intents, entities, webhooks) that the flow
        /// references will also be exported.
        pub async fn export_flow(
            &mut self,
            request: impl tonic::IntoRequest<super::ExportFlowRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.dialogflow.cx.v3.Flows/ExportFlow",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.dialogflow.cx.v3.Flows", "ExportFlow"),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Settings for Generative Safety.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SafetySettings {
    /// Optional. Default phrase match strategy for banned phrases.
    #[prost(enumeration = "safety_settings::PhraseMatchStrategy", tag = "4")]
    pub default_banned_phrase_match_strategy: i32,
    /// Banned phrases for generated text.
    #[prost(message, repeated, tag = "1")]
    pub banned_phrases: ::prost::alloc::vec::Vec<safety_settings::Phrase>,
    /// Optional. Settings for Responsible AI checks.
    #[prost(message, optional, tag = "2")]
    pub rai_settings: ::core::option::Option<safety_settings::RaiSettings>,
    /// Optional. Immutable. Default RAI settings to be annotated on the agent, so
    /// that users will be able to restore their RAI configurations to the default
    /// settings. Read-only field for the API proto only.
    #[prost(message, optional, tag = "3")]
    pub default_rai_settings: ::core::option::Option<safety_settings::RaiSettings>,
    /// Optional. Settings for prompt security checks.
    #[prost(message, optional, tag = "8")]
    pub prompt_security_settings: ::core::option::Option<
        safety_settings::PromptSecuritySettings,
    >,
}
/// Nested message and enum types in `SafetySettings`.
pub mod safety_settings {
    /// Text input which can be used for prompt or banned phrases.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Phrase {
        /// Required. Text input which can be used for prompt or banned phrases.
        #[prost(string, tag = "1")]
        pub text: ::prost::alloc::string::String,
        /// Required. Language code of the phrase.
        #[prost(string, tag = "2")]
        pub language_code: ::prost::alloc::string::String,
    }
    /// Settings for Responsible AI.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RaiSettings {
        /// Optional. RAI blocking configurations.
        #[prost(message, repeated, tag = "3")]
        pub category_filters: ::prost::alloc::vec::Vec<rai_settings::CategoryFilter>,
    }
    /// Nested message and enum types in `RaiSettings`.
    pub mod rai_settings {
        /// Configuration of the sensitivity level for blocking an RAI category.
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct CategoryFilter {
            /// RAI category to configure.
            #[prost(enumeration = "SafetyCategory", tag = "1")]
            pub category: i32,
            /// Blocking sensitivity level to configure for the RAI category.
            #[prost(enumeration = "SafetyFilterLevel", tag = "2")]
            pub filter_level: i32,
        }
        /// Sensitivity level for RAI categories.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum SafetyFilterLevel {
            /// Unspecified -- uses default sensitivity levels.
            Unspecified = 0,
            /// Block no text -- effectively disables the category.
            BlockNone = 1,
            /// Block a few suspicious texts.
            BlockFew = 2,
            /// Block some suspicious texts.
            BlockSome = 3,
            /// Block most suspicious texts.
            BlockMost = 4,
        }
        impl SafetyFilterLevel {
            /// 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 => "SAFETY_FILTER_LEVEL_UNSPECIFIED",
                    Self::BlockNone => "BLOCK_NONE",
                    Self::BlockFew => "BLOCK_FEW",
                    Self::BlockSome => "BLOCK_SOME",
                    Self::BlockMost => "BLOCK_MOST",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "SAFETY_FILTER_LEVEL_UNSPECIFIED" => Some(Self::Unspecified),
                    "BLOCK_NONE" => Some(Self::BlockNone),
                    "BLOCK_FEW" => Some(Self::BlockFew),
                    "BLOCK_SOME" => Some(Self::BlockSome),
                    "BLOCK_MOST" => Some(Self::BlockMost),
                    _ => None,
                }
            }
        }
        /// RAI categories to configure.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum SafetyCategory {
            /// Unspecified.
            Unspecified = 0,
            /// Dangerous content.
            DangerousContent = 1,
            /// Hate speech.
            HateSpeech = 2,
            /// Harassment.
            Harassment = 3,
            /// Sexually explicit content.
            SexuallyExplicitContent = 4,
        }
        impl SafetyCategory {
            /// 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 => "SAFETY_CATEGORY_UNSPECIFIED",
                    Self::DangerousContent => "DANGEROUS_CONTENT",
                    Self::HateSpeech => "HATE_SPEECH",
                    Self::Harassment => "HARASSMENT",
                    Self::SexuallyExplicitContent => "SEXUALLY_EXPLICIT_CONTENT",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "SAFETY_CATEGORY_UNSPECIFIED" => Some(Self::Unspecified),
                    "DANGEROUS_CONTENT" => Some(Self::DangerousContent),
                    "HATE_SPEECH" => Some(Self::HateSpeech),
                    "HARASSMENT" => Some(Self::Harassment),
                    "SEXUALLY_EXPLICIT_CONTENT" => Some(Self::SexuallyExplicitContent),
                    _ => None,
                }
            }
        }
    }
    /// Settings for prompt security checks.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct PromptSecuritySettings {
        /// Optional. Enable prompt security checks.
        #[prost(bool, tag = "1")]
        pub enable_prompt_security: bool,
    }
    /// Strategy for matching phrases.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum PhraseMatchStrategy {
        /// Unspecified, defaults to PARTIAL_MATCH.
        Unspecified = 0,
        /// Text that contains the phrase as a substring will be matched, e.g. "foo"
        /// will match "afoobar".
        PartialMatch = 1,
        /// Text that contains the tokenized words of the phrase will be matched,
        /// e.g. "foo" will match "a foo bar" and "foo bar", but not "foobar".
        WordMatch = 2,
    }
    impl PhraseMatchStrategy {
        /// 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 => "PHRASE_MATCH_STRATEGY_UNSPECIFIED",
                Self::PartialMatch => "PARTIAL_MATCH",
                Self::WordMatch => "WORD_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 {
                "PHRASE_MATCH_STRATEGY_UNSPECIFIED" => Some(Self::Unspecified),
                "PARTIAL_MATCH" => Some(Self::PartialMatch),
                "WORD_MATCH" => Some(Self::WordMatch),
                _ => None,
            }
        }
    }
}
/// Settings for Generative AI.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GenerativeSettings {
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/generativeSettings`.
    #[prost(string, tag = "5")]
    pub name: ::prost::alloc::string::String,
    /// Settings for Generative Fallback.
    #[prost(message, optional, tag = "1")]
    pub fallback_settings: ::core::option::Option<generative_settings::FallbackSettings>,
    /// Settings for Generative Safety.
    #[prost(message, optional, tag = "3")]
    pub generative_safety_settings: ::core::option::Option<SafetySettings>,
    /// Settings for knowledge connector.
    #[prost(message, optional, tag = "7")]
    pub knowledge_connector_settings: ::core::option::Option<
        generative_settings::KnowledgeConnectorSettings,
    >,
    /// Language for this settings.
    #[prost(string, tag = "4")]
    pub language_code: ::prost::alloc::string::String,
    /// LLM model settings.
    #[prost(message, optional, tag = "8")]
    pub llm_model_settings: ::core::option::Option<LlmModelSettings>,
}
/// Nested message and enum types in `GenerativeSettings`.
pub mod generative_settings {
    /// Settings for Generative Fallback.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct FallbackSettings {
        /// Display name of the selected prompt.
        #[prost(string, tag = "3")]
        pub selected_prompt: ::prost::alloc::string::String,
        /// Stored prompts that can be selected, for example default templates like
        /// "conservative" or "chatty", or user defined ones.
        #[prost(message, repeated, tag = "4")]
        pub prompt_templates: ::prost::alloc::vec::Vec<
            fallback_settings::PromptTemplate,
        >,
    }
    /// Nested message and enum types in `FallbackSettings`.
    pub mod fallback_settings {
        /// Prompt template.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct PromptTemplate {
            /// Prompt name.
            #[prost(string, tag = "1")]
            pub display_name: ::prost::alloc::string::String,
            /// Prompt text that is sent to a LLM on no-match default, placeholders are
            /// filled downstream. For example: "Here is a conversation $conversation,
            /// a response is: "
            #[prost(string, tag = "2")]
            pub prompt_text: ::prost::alloc::string::String,
            /// If the flag is true, the prompt is frozen and cannot be modified by
            /// users.
            #[prost(bool, tag = "3")]
            pub frozen: bool,
        }
    }
    /// Settings for knowledge connector. These parameters are used for LLM prompt
    /// like "You are <agent>. You are a helpful and verbose \<agent_identity> at
    /// <business>, \<business_description>. Your task is to help humans on
    /// \<agent_scope>".
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct KnowledgeConnectorSettings {
        /// Name of the company, organization or other entity that the agent
        /// represents. Used for knowledge connector LLM prompt and for knowledge
        /// search.
        #[prost(string, tag = "1")]
        pub business: ::prost::alloc::string::String,
        /// Name of the virtual agent. Used for LLM prompt. Can be left empty.
        #[prost(string, tag = "2")]
        pub agent: ::prost::alloc::string::String,
        /// Identity of the agent, e.g. "virtual agent", "AI assistant".
        #[prost(string, tag = "3")]
        pub agent_identity: ::prost::alloc::string::String,
        /// Company description, used for LLM prompt, e.g. "a family company selling
        /// freshly roasted coffee beans".
        #[prost(string, tag = "4")]
        pub business_description: ::prost::alloc::string::String,
        /// Agent scope, e.g. "Example company website", "internal Example
        /// company website for employees", "manual of car owner".
        #[prost(string, tag = "5")]
        pub agent_scope: ::prost::alloc::string::String,
        /// Whether to disable fallback to Data Store search results (in case the LLM
        /// couldn't pick a proper answer). Per default the feature is enabled.
        #[prost(bool, tag = "8")]
        pub disable_data_store_fallback: bool,
    }
}
/// Settings for LLM models.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct LlmModelSettings {
    /// The selected LLM model.
    #[prost(string, tag = "1")]
    pub model: ::prost::alloc::string::String,
    /// The custom prompt to use.
    #[prost(string, tag = "2")]
    pub prompt_text: ::prost::alloc::string::String,
}
/// Settings related to speech recognition.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SpeechToTextSettings {
    /// Whether to use speech adaptation for speech recognition.
    #[prost(bool, tag = "1")]
    pub enable_speech_adaptation: bool,
}
/// Agents are best described as Natural Language Understanding (NLU) modules
/// that transform user requests into actionable data. You can include agents
/// in your app, product, or service to determine user intent and respond to the
/// user in a natural way.
///
/// After you create an agent, you can add
/// \[Intents\]\[google.cloud.dialogflow.cx.v3.Intent\], \[Entity
/// Types\]\[google.cloud.dialogflow.cx.v3.EntityType\],
/// \[Flows\]\[google.cloud.dialogflow.cx.v3.Flow\],
/// \[Fulfillments\]\[google.cloud.dialogflow.cx.v3.Fulfillment\],
/// \[Webhooks\]\[google.cloud.dialogflow.cx.v3.Webhook\],
/// \[TransitionRouteGroups\]\[google.cloud.dialogflow.cx.v3.TransitionRouteGroup\]
/// and so on to manage the conversation flows.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Agent {
    /// The unique identifier of the agent.
    /// Required for the
    /// \[Agents.UpdateAgent\]\[google.cloud.dialogflow.cx.v3.Agents.UpdateAgent\]
    /// method.
    /// \[Agents.CreateAgent\]\[google.cloud.dialogflow.cx.v3.Agents.CreateAgent\]
    /// populates the name automatically.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. The human-readable name of the agent, unique within the location.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Required. Immutable. The default language of the agent as a language tag.
    /// See [Language
    /// Support](<https://cloud.google.com/dialogflow/cx/docs/reference/language>)
    /// for a list of the currently supported language codes.
    /// This field cannot be set by the
    /// \[Agents.UpdateAgent\]\[google.cloud.dialogflow.cx.v3.Agents.UpdateAgent\]
    /// method.
    #[prost(string, tag = "3")]
    pub default_language_code: ::prost::alloc::string::String,
    /// The list of all languages supported by the agent (except for the
    /// `default_language_code`).
    #[prost(string, repeated, tag = "4")]
    pub supported_language_codes: ::prost::alloc::vec::Vec<
        ::prost::alloc::string::String,
    >,
    /// Required. The time zone of the agent from the [time zone
    /// database](<https://www.iana.org/time-zones>), e.g., America/New_York,
    /// Europe/Paris.
    #[prost(string, tag = "5")]
    pub time_zone: ::prost::alloc::string::String,
    /// The description of the agent. The maximum length is 500 characters. If
    /// exceeded, the request is rejected.
    #[prost(string, tag = "6")]
    pub description: ::prost::alloc::string::String,
    /// The URI of the agent's avatar. Avatars are used throughout the Dialogflow
    /// console and in the self-hosted [Web
    /// Demo](<https://cloud.google.com/dialogflow/docs/integrations/web-demo>)
    /// integration.
    #[prost(string, tag = "7")]
    pub avatar_uri: ::prost::alloc::string::String,
    /// Speech recognition related settings.
    #[prost(message, optional, tag = "13")]
    pub speech_to_text_settings: ::core::option::Option<SpeechToTextSettings>,
    /// Name of the
    /// \[SecuritySettings\]\[google.cloud.dialogflow.cx.v3.SecuritySettings\]
    /// reference for the agent. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/securitySettings/<SecuritySettingsID>`.
    #[prost(string, tag = "17")]
    pub security_settings: ::prost::alloc::string::String,
    /// Indicates if stackdriver logging is enabled for the agent.
    /// Please use
    /// \[agent.advanced_settings\]\[google.cloud.dialogflow.cx.v3.AdvancedSettings.LoggingSettings\]
    /// instead.
    #[deprecated]
    #[prost(bool, tag = "18")]
    pub enable_stackdriver_logging: bool,
    /// Indicates if automatic spell correction is enabled in detect intent
    /// requests.
    #[prost(bool, tag = "20")]
    pub enable_spell_correction: bool,
    /// Optional. Enable training multi-lingual models for this agent. These models
    /// will be trained on all the languages supported by the agent.
    #[prost(bool, tag = "40")]
    pub enable_multi_language_training: bool,
    /// Indicates whether the agent is locked for changes. If the agent is locked,
    /// modifications to the agent will be rejected except for \[RestoreAgent\]\[\].
    #[prost(bool, tag = "27")]
    pub locked: bool,
    /// Hierarchical advanced settings for this agent. The settings exposed at the
    /// lower level overrides the settings exposed at the higher level.
    #[prost(message, optional, tag = "22")]
    pub advanced_settings: ::core::option::Option<AdvancedSettings>,
    /// Git integration settings for this agent.
    #[prost(message, optional, tag = "30")]
    pub git_integration_settings: ::core::option::Option<agent::GitIntegrationSettings>,
    /// Settings on instructing the speech synthesizer on how to generate the
    /// output audio content.
    #[prost(message, optional, tag = "31")]
    pub text_to_speech_settings: ::core::option::Option<TextToSpeechSettings>,
    /// Gen App Builder-related agent-level settings.
    #[prost(message, optional, tag = "33")]
    pub gen_app_builder_settings: ::core::option::Option<agent::GenAppBuilderSettings>,
    /// Optional. Answer feedback collection settings.
    #[prost(message, optional, tag = "38")]
    pub answer_feedback_settings: ::core::option::Option<agent::AnswerFeedbackSettings>,
    /// Optional. Settings for end user personalization.
    #[prost(message, optional, tag = "42")]
    pub personalization_settings: ::core::option::Option<agent::PersonalizationSettings>,
    /// Optional. Settings for custom client certificates.
    #[prost(message, optional, tag = "43")]
    pub client_certificate_settings: ::core::option::Option<
        agent::ClientCertificateSettings,
    >,
    /// Optional. Output only. A read only boolean field reflecting Zone Separation
    /// status of the agent.
    #[prost(bool, optional, tag = "45")]
    pub satisfies_pzs: ::core::option::Option<bool>,
    /// Optional. Output only. A read only boolean field reflecting Zone Isolation
    /// status of the agent.
    #[prost(bool, optional, tag = "46")]
    pub satisfies_pzi: ::core::option::Option<bool>,
    /// The resource to start the conversations with for the agent.
    #[prost(oneof = "agent::SessionEntryResource", tags = "16, 39")]
    pub session_entry_resource: ::core::option::Option<agent::SessionEntryResource>,
}
/// Nested message and enum types in `Agent`.
pub mod agent {
    /// Settings for connecting to Git repository for an agent.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct GitIntegrationSettings {
        /// The git settings to specific systems.
        #[prost(oneof = "git_integration_settings::GitSettings", tags = "1")]
        pub git_settings: ::core::option::Option<git_integration_settings::GitSettings>,
    }
    /// Nested message and enum types in `GitIntegrationSettings`.
    pub mod git_integration_settings {
        /// Settings of integration with GitHub.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct GithubSettings {
            /// The unique repository display name for the GitHub repository.
            #[prost(string, tag = "1")]
            pub display_name: ::prost::alloc::string::String,
            /// The GitHub repository URI related to the agent.
            #[prost(string, tag = "2")]
            pub repository_uri: ::prost::alloc::string::String,
            /// The branch of the GitHub repository tracked for this agent.
            #[prost(string, tag = "3")]
            pub tracking_branch: ::prost::alloc::string::String,
            /// The access token used to authenticate the access to the GitHub
            /// repository.
            #[prost(string, tag = "4")]
            pub access_token: ::prost::alloc::string::String,
            /// A list of branches configured to be used from Dialogflow.
            #[prost(string, repeated, tag = "5")]
            pub branches: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        }
        /// The git settings to specific systems.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
        pub enum GitSettings {
            /// GitHub settings.
            #[prost(message, tag = "1")]
            GithubSettings(GithubSettings),
        }
    }
    /// Settings for Gen App Builder.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct GenAppBuilderSettings {
        /// Required. The full name of the Gen App Builder engine related to this
        /// agent if there is one. Format: `projects/{Project ID}/locations/{Location  ID}/collections/{Collection ID}/engines/{Engine ID}`
        #[prost(string, tag = "1")]
        pub engine: ::prost::alloc::string::String,
    }
    /// Settings for answer feedback collection.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct AnswerFeedbackSettings {
        /// Optional. If enabled, end users will be able to provide
        /// \[answer feedback\]\[google.cloud.dialogflow.cx.v3.AnswerFeedback\] to
        /// Dialogflow responses. Feature works only if interaction logging is
        /// enabled in the Dialogflow agent.
        #[prost(bool, tag = "1")]
        pub enable_answer_feedback: bool,
    }
    /// Settings for end user personalization.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct PersonalizationSettings {
        /// Optional. Default end user metadata, used when processing DetectIntent
        /// requests. Recommended to be filled as a template instead of hard-coded
        /// value, for example { "age": "$session.params.age" }. The data will be
        /// merged with the
        /// \[QueryParameters.end_user_metadata\]\[google.cloud.dialogflow.cx.v3.QueryParameters.end_user_metadata\]
        /// in
        /// \[DetectIntentRequest.query_params\]\[google.cloud.dialogflow.cx.v3.DetectIntentRequest.query_params\]
        /// during query processing.
        #[prost(message, optional, tag = "1")]
        pub default_end_user_metadata: ::core::option::Option<::prost_types::Struct>,
    }
    /// Settings for custom client certificates.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ClientCertificateSettings {
        /// Required. The ssl certificate encoded in PEM format. This string must
        /// include the begin header and end footer lines.
        #[prost(string, tag = "1")]
        pub ssl_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. 'passphrase' 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,
    }
    /// The resource to start the conversations with for the agent.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum SessionEntryResource {
        /// Name of the start flow in this agent. A start flow will be automatically
        /// created when the agent is created, and can only be deleted by deleting
        /// the agent.
        /// Format:
        /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>`.
        /// Currently only the default start flow with id
        /// "00000000-0000-0000-0000-000000000000" is allowed.
        #[prost(string, tag = "16")]
        StartFlow(::prost::alloc::string::String),
        /// Name of the start playbook in this agent. A start playbook will be
        /// automatically created when the agent is created, and can only be deleted
        /// by deleting the agent.
        /// Format:
        /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/playbooks/<PlaybookID>`.
        /// Currently only the
        /// default playbook with id
        /// "00000000-0000-0000-0000-000000000000" is allowed.
        #[prost(string, tag = "39")]
        StartPlaybook(::prost::alloc::string::String),
    }
}
/// The request message for
/// \[Agents.ListAgents\]\[google.cloud.dialogflow.cx.v3.Agents.ListAgents\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListAgentsRequest {
    /// Required. The location to list all agents for.
    /// Format: `projects/<ProjectID>/locations/<LocationID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of items to return in a single page. By default 100 and
    /// at most 1000.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response message for
/// \[Agents.ListAgents\]\[google.cloud.dialogflow.cx.v3.Agents.ListAgents\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListAgentsResponse {
    /// The list of agents. There will be a maximum number of items returned based
    /// on the page_size field in the request.
    #[prost(message, repeated, tag = "1")]
    pub agents: ::prost::alloc::vec::Vec<Agent>,
    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request message for
/// \[Agents.GetAgent\]\[google.cloud.dialogflow.cx.v3.Agents.GetAgent\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetAgentRequest {
    /// Required. The name of the agent.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for
/// \[Agents.CreateAgent\]\[google.cloud.dialogflow.cx.v3.Agents.CreateAgent\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateAgentRequest {
    /// Required. The location to create a agent for.
    /// Format: `projects/<ProjectID>/locations/<LocationID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The agent to create.
    #[prost(message, optional, tag = "2")]
    pub agent: ::core::option::Option<Agent>,
}
/// The request message for
/// \[Agents.UpdateAgent\]\[google.cloud.dialogflow.cx.v3.Agents.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>,
    /// The mask 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>,
}
/// The request message for
/// \[Agents.DeleteAgent\]\[google.cloud.dialogflow.cx.v3.Agents.DeleteAgent\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteAgentRequest {
    /// Required. The name of the agent to delete.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for
/// \[Agents.ExportAgent\]\[google.cloud.dialogflow.cx.v3.Agents.ExportAgent\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExportAgentRequest {
    /// Required. The name of the agent to export.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The [Google Cloud
    /// Storage](<https://cloud.google.com/storage/docs/>) URI to export the agent
    /// to. The format of this URI must be `gs://<bucket-name>/<object-name>`. If
    /// left unspecified, the serialized agent is returned inline.
    ///
    /// Dialogflow performs a write operation for the Cloud Storage object
    /// on the caller's behalf, so your request authentication must
    /// have write permissions for the object. For more information, see
    /// [Dialogflow access
    /// control](<https://cloud.google.com/dialogflow/cx/docs/concept/access-control#storage>).
    #[prost(string, tag = "2")]
    pub agent_uri: ::prost::alloc::string::String,
    /// Optional. The data format of the exported agent. If not specified, `BLOB`
    /// is assumed.
    #[prost(enumeration = "export_agent_request::DataFormat", tag = "3")]
    pub data_format: i32,
    /// Optional. Environment name. If not set, draft environment is assumed.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>`.
    #[prost(string, tag = "5")]
    pub environment: ::prost::alloc::string::String,
    /// Optional. The Git branch to export the agent to.
    #[prost(message, optional, tag = "6")]
    pub git_destination: ::core::option::Option<export_agent_request::GitDestination>,
    /// Optional. Whether to include BigQuery Export setting.
    #[prost(bool, tag = "7")]
    pub include_bigquery_export_settings: bool,
}
/// Nested message and enum types in `ExportAgentRequest`.
pub mod export_agent_request {
    /// Settings for exporting to a git branch.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct GitDestination {
        /// Tracking branch for the git push.
        #[prost(string, tag = "1")]
        pub tracking_branch: ::prost::alloc::string::String,
        /// Commit message for the git push.
        #[prost(string, tag = "2")]
        pub commit_message: ::prost::alloc::string::String,
    }
    /// Data format of the exported agent.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum DataFormat {
        /// Unspecified format.
        Unspecified = 0,
        /// Agent content will be exported as raw bytes.
        Blob = 1,
        /// Agent content will be exported in JSON Package format.
        JsonPackage = 4,
    }
    impl DataFormat {
        /// 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_FORMAT_UNSPECIFIED",
                Self::Blob => "BLOB",
                Self::JsonPackage => "JSON_PACKAGE",
            }
        }
        /// 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_FORMAT_UNSPECIFIED" => Some(Self::Unspecified),
                "BLOB" => Some(Self::Blob),
                "JSON_PACKAGE" => Some(Self::JsonPackage),
                _ => None,
            }
        }
    }
}
/// The response message for
/// \[Agents.ExportAgent\]\[google.cloud.dialogflow.cx.v3.Agents.ExportAgent\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExportAgentResponse {
    /// The exported agent.
    #[prost(oneof = "export_agent_response::Agent", tags = "1, 2, 3")]
    pub agent: ::core::option::Option<export_agent_response::Agent>,
}
/// Nested message and enum types in `ExportAgentResponse`.
pub mod export_agent_response {
    /// The exported agent.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Agent {
        /// The URI to a file containing the exported agent. This field is populated
        /// if `agent_uri` is specified in
        /// \[ExportAgentRequest\]\[google.cloud.dialogflow.cx.v3.ExportAgentRequest\].
        #[prost(string, tag = "1")]
        AgentUri(::prost::alloc::string::String),
        /// Uncompressed raw byte content for agent. This field is populated
        /// if none of `agent_uri` and `git_destination` are specified in
        /// \[ExportAgentRequest\]\[google.cloud.dialogflow.cx.v3.ExportAgentRequest\].
        #[prost(bytes, tag = "2")]
        AgentContent(::prost::alloc::vec::Vec<u8>),
        /// Commit SHA of the git push. This field is populated if
        /// `git_destination` is specified in
        /// \[ExportAgentRequest\]\[google.cloud.dialogflow.cx.v3.ExportAgentRequest\].
        #[prost(string, tag = "3")]
        CommitSha(::prost::alloc::string::String),
    }
}
/// The request message for
/// \[Agents.RestoreAgent\]\[google.cloud.dialogflow.cx.v3.Agents.RestoreAgent\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RestoreAgentRequest {
    /// Required. The name of the agent to restore into.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Agent restore mode. If not specified, `KEEP` is assumed.
    #[prost(enumeration = "restore_agent_request::RestoreOption", tag = "5")]
    pub restore_option: i32,
    /// Required. The agent to restore.
    #[prost(oneof = "restore_agent_request::Agent", tags = "2, 3, 6")]
    pub agent: ::core::option::Option<restore_agent_request::Agent>,
}
/// Nested message and enum types in `RestoreAgentRequest`.
pub mod restore_agent_request {
    /// Settings for restoring from a git branch
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct GitSource {
        /// tracking branch for the git pull
        #[prost(string, tag = "1")]
        pub tracking_branch: ::prost::alloc::string::String,
    }
    /// Restore option.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum RestoreOption {
        /// Unspecified. Treated as KEEP.
        Unspecified = 0,
        /// Always respect the settings from the exported agent file. It may cause
        /// a restoration failure if some settings (e.g. model type) are not
        /// supported in the target agent.
        Keep = 1,
        /// Fallback to default settings if some settings are not supported in the
        /// target agent.
        Fallback = 2,
    }
    impl RestoreOption {
        /// 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 => "RESTORE_OPTION_UNSPECIFIED",
                Self::Keep => "KEEP",
                Self::Fallback => "FALLBACK",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "RESTORE_OPTION_UNSPECIFIED" => Some(Self::Unspecified),
                "KEEP" => Some(Self::Keep),
                "FALLBACK" => Some(Self::Fallback),
                _ => None,
            }
        }
    }
    /// Required. The agent to restore.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Agent {
        /// The [Google Cloud Storage](<https://cloud.google.com/storage/docs/>) URI
        /// to restore agent from. The format of this URI must be
        /// `gs://<bucket-name>/<object-name>`.
        ///
        /// Dialogflow performs a read operation for the Cloud Storage object
        /// on the caller's behalf, so your request authentication must
        /// have read permissions for the object. For more information, see
        /// [Dialogflow access
        /// control](<https://cloud.google.com/dialogflow/cx/docs/concept/access-control#storage>).
        #[prost(string, tag = "2")]
        AgentUri(::prost::alloc::string::String),
        /// Uncompressed raw byte content for agent.
        #[prost(bytes, tag = "3")]
        AgentContent(::prost::alloc::vec::Vec<u8>),
        /// Setting for restoring from a git branch
        #[prost(message, tag = "6")]
        GitSource(GitSource),
    }
}
/// The request message for
/// \[Agents.ValidateAgent\]\[google.cloud.dialogflow.cx.v3.Agents.ValidateAgent\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ValidateAgentRequest {
    /// Required. The agent to validate.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// If not specified, the agent's default language is used.
    #[prost(string, tag = "2")]
    pub language_code: ::prost::alloc::string::String,
}
/// The request message for
/// \[Agents.GetAgentValidationResult\]\[google.cloud.dialogflow.cx.v3.Agents.GetAgentValidationResult\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetAgentValidationResultRequest {
    /// Required. The agent name.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/validationResult`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// If not specified, the agent's default language is used.
    #[prost(string, tag = "2")]
    pub language_code: ::prost::alloc::string::String,
}
/// The response message for
/// \[Agents.GetAgentValidationResult\]\[google.cloud.dialogflow.cx.v3.Agents.GetAgentValidationResult\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AgentValidationResult {
    /// The unique identifier of the agent validation result.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/validationResult`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Contains all flow validation results.
    #[prost(message, repeated, tag = "2")]
    pub flow_validation_results: ::prost::alloc::vec::Vec<FlowValidationResult>,
}
/// Request for
/// \[GetGenerativeSettings\]\[google.cloud.dialogflow.cx.v3.Agents.GetGenerativeSettings\]
/// RPC.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetGenerativeSettingsRequest {
    /// Required. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/generativeSettings`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. Language code of the generative settings.
    #[prost(string, tag = "2")]
    pub language_code: ::prost::alloc::string::String,
}
/// Request for
/// \[UpdateGenerativeSettings\]\[google.cloud.dialogflow.cx.v3.Agents.UpdateGenerativeSettings\]
/// RPC.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateGenerativeSettingsRequest {
    /// Required. Generative settings to update.
    #[prost(message, optional, tag = "1")]
    pub generative_settings: ::core::option::Option<GenerativeSettings>,
    /// Optional. The mask 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 agents_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing \[Agents\]\[google.cloud.dialogflow.cx.v3.Agent\].
    #[derive(Debug, Clone)]
    pub struct AgentsClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl AgentsClient<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> AgentsClient<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,
        ) -> AgentsClient<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,
        {
            AgentsClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Returns the list of all agents in the specified location.
        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.dialogflow.cx.v3.Agents/ListAgents",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.dialogflow.cx.v3.Agents", "ListAgents"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves 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.dialogflow.cx.v3.Agents/GetAgent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.dialogflow.cx.v3.Agents", "GetAgent"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates an agent in the specified location.
        ///
        /// Note: You should always train flows prior to sending them queries. See the
        /// [training
        /// documentation](https://cloud.google.com/dialogflow/cx/docs/concept/training).
        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.dialogflow.cx.v3.Agents/CreateAgent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Agents",
                        "CreateAgent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified agent.
        ///
        /// Note: You should always train flows prior to sending them queries. See the
        /// [training
        /// documentation](https://cloud.google.com/dialogflow/cx/docs/concept/training).
        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.dialogflow.cx.v3.Agents/UpdateAgent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Agents",
                        "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.dialogflow.cx.v3.Agents/DeleteAgent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Agents",
                        "DeleteAgent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Exports the specified agent to a binary file.
        ///
        /// This method is a [long-running
        /// operation](https://cloud.google.com/dialogflow/cx/docs/how/long-running-operation).
        /// The returned `Operation` type has the following method-specific fields:
        ///
        /// * `metadata`: An empty [Struct
        ///  message](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#struct)
        /// * `response`:
        ///  \[ExportAgentResponse\]\[google.cloud.dialogflow.cx.v3.ExportAgentResponse\]
        pub async fn export_agent(
            &mut self,
            request: impl tonic::IntoRequest<super::ExportAgentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.dialogflow.cx.v3.Agents/ExportAgent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Agents",
                        "ExportAgent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Restores the specified agent from a binary file.
        ///
        /// Replaces the current agent with a new one. Note that all existing resources
        /// in agent (e.g. intents, entity types, flows) will be removed.
        ///
        /// This method is a [long-running
        /// operation](https://cloud.google.com/dialogflow/cx/docs/how/long-running-operation).
        /// The returned `Operation` type has the following method-specific fields:
        ///
        /// * `metadata`: An empty [Struct
        ///  message](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#struct)
        /// * `response`: An [Empty
        ///  message](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#empty)
        ///
        /// Note: You should always train flows prior to sending them queries. See the
        /// [training
        /// documentation](https://cloud.google.com/dialogflow/cx/docs/concept/training).
        pub async fn restore_agent(
            &mut self,
            request: impl tonic::IntoRequest<super::RestoreAgentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.dialogflow.cx.v3.Agents/RestoreAgent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Agents",
                        "RestoreAgent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Validates the specified agent and creates or updates validation results.
        /// The agent in draft version is validated. Please call this API after the
        /// training is completed to get the complete validation results.
        pub async fn validate_agent(
            &mut self,
            request: impl tonic::IntoRequest<super::ValidateAgentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::AgentValidationResult>,
            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.dialogflow.cx.v3.Agents/ValidateAgent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Agents",
                        "ValidateAgent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets the latest agent validation result. Agent validation is performed
        /// when ValidateAgent is called.
        pub async fn get_agent_validation_result(
            &mut self,
            request: impl tonic::IntoRequest<super::GetAgentValidationResultRequest>,
        ) -> std::result::Result<
            tonic::Response<super::AgentValidationResult>,
            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.dialogflow.cx.v3.Agents/GetAgentValidationResult",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Agents",
                        "GetAgentValidationResult",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets the generative settings for the agent.
        pub async fn get_generative_settings(
            &mut self,
            request: impl tonic::IntoRequest<super::GetGenerativeSettingsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GenerativeSettings>,
            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.dialogflow.cx.v3.Agents/GetGenerativeSettings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Agents",
                        "GetGenerativeSettings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the generative settings for the agent.
        pub async fn update_generative_settings(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateGenerativeSettingsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GenerativeSettings>,
            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.dialogflow.cx.v3.Agents/UpdateGenerativeSettings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Agents",
                        "UpdateGenerativeSettings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// The request message for
/// \[Changelogs.ListChangelogs\]\[google.cloud.dialogflow.cx.v3.Changelogs.ListChangelogs\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListChangelogsRequest {
    /// Required. The agent containing the changelogs.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The filter string. Supports filter by user_email, resource, type and
    /// create_time. Some examples:
    ///
    /// 1. By user email:
    ///    user_email = "someone@google.com"
    /// 1. By resource name:
    ///    resource = "projects/123/locations/global/agents/456/flows/789"
    /// 1. By resource display name:
    ///    display_name = "my agent"
    /// 1. By action:
    ///    action = "Create"
    /// 1. By type:
    ///    type = "flows"
    /// 1. By create time. Currently predicates on `create_time` and
    ///    `create_time_epoch_seconds` are supported:
    ///    create_time_epoch_seconds > 1551790877 AND create_time \<=
    ///    2017-01-15T01:30:15.01Z
    /// 1. Combination of above filters:
    ///    resource = "projects/123/locations/global/agents/456/flows/789"
    ///    AND user_email = "someone@google.com"
    ///    AND create_time \<= 2017-01-15T01:30:15.01Z
    #[prost(string, tag = "2")]
    pub filter: ::prost::alloc::string::String,
    /// The maximum number of items to return in a single page. By default 100 and
    /// at most 1000.
    #[prost(int32, tag = "3")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous list request.
    #[prost(string, tag = "4")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response message for
/// \[Changelogs.ListChangelogs\]\[google.cloud.dialogflow.cx.v3.Changelogs.ListChangelogs\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListChangelogsResponse {
    /// The list of changelogs. There will be a maximum number of items returned
    /// based on the page_size field in the request. The changelogs will be ordered
    /// by timestamp.
    #[prost(message, repeated, tag = "1")]
    pub changelogs: ::prost::alloc::vec::Vec<Changelog>,
    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request message for
/// \[Changelogs.GetChangelog\]\[google.cloud.dialogflow.cx.v3.Changelogs.GetChangelog\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetChangelogRequest {
    /// Required. The name of the changelog to get.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/changelogs/<ChangelogID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Changelogs represents a change made to a given agent.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Changelog {
    /// The unique identifier of the changelog.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/changelogs/<ChangelogID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Email address of the authenticated user.
    #[prost(string, tag = "2")]
    pub user_email: ::prost::alloc::string::String,
    /// The affected resource display name of the change.
    #[prost(string, tag = "7")]
    pub display_name: ::prost::alloc::string::String,
    /// The action of the change.
    #[prost(string, tag = "11")]
    pub action: ::prost::alloc::string::String,
    /// The affected resource type.
    #[prost(string, tag = "8")]
    pub r#type: ::prost::alloc::string::String,
    /// The affected resource name of the change.
    #[prost(string, tag = "3")]
    pub resource: ::prost::alloc::string::String,
    /// The timestamp of the change.
    #[prost(message, optional, tag = "4")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The affected language code of the change.
    #[prost(string, tag = "14")]
    pub language_code: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod changelogs_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing \[Changelogs\]\[google.cloud.dialogflow.cx.v3.Changelog\].
    #[derive(Debug, Clone)]
    pub struct ChangelogsClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ChangelogsClient<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> ChangelogsClient<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,
        ) -> ChangelogsClient<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,
        {
            ChangelogsClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Returns the list of Changelogs.
        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.dialogflow.cx.v3.Changelogs/ListChangelogs",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Changelogs",
                        "ListChangelogs",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves 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.dialogflow.cx.v3.Changelogs/GetChangelog",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Changelogs",
                        "GetChangelog",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Represents a code block.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CodeBlock {
    /// Optional. Source code of the block in Python.
    #[prost(string, tag = "1")]
    pub code: ::prost::alloc::string::String,
}
/// Represents a deployment in an environment. A deployment happens when a flow
/// version configured to be active in the environment. You can configure running
/// pre-deployment steps, e.g. running validation test cases, experiment
/// auto-rollout, etc.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Deployment {
    /// The name of the deployment.
    /// Format:
    /// projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>/deployments/<DeploymentID>.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The name of the flow version for this deployment.
    /// Format:
    /// projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/versions/<VerionID>.
    #[prost(string, tag = "2")]
    pub flow_version: ::prost::alloc::string::String,
    /// The current state of the deployment.
    #[prost(enumeration = "deployment::State", tag = "3")]
    pub state: i32,
    /// Result of the deployment.
    #[prost(message, optional, tag = "4")]
    pub result: ::core::option::Option<deployment::Result>,
    /// Start time of this deployment.
    #[prost(message, optional, tag = "5")]
    pub start_time: ::core::option::Option<::prost_types::Timestamp>,
    /// End time of this deployment.
    #[prost(message, optional, tag = "6")]
    pub end_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Nested message and enum types in `Deployment`.
pub mod deployment {
    /// Result of the deployment.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Result {
        /// Results of test cases running before the deployment.
        /// Format:
        /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/testCases/<TestCaseID>/results/<TestCaseResultID>`.
        #[prost(string, repeated, tag = "1")]
        pub deployment_test_results: ::prost::alloc::vec::Vec<
            ::prost::alloc::string::String,
        >,
        /// The name of the experiment triggered by this deployment.
        /// Format:
        /// projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>/experiments/<ExperimentID>.
        #[prost(string, tag = "2")]
        pub experiment: ::prost::alloc::string::String,
    }
    /// The state of the deployment.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// State unspecified.
        Unspecified = 0,
        /// The deployment is running.
        Running = 1,
        /// The deployment succeeded.
        Succeeded = 2,
        /// The deployment failed.
        Failed = 3,
    }
    impl State {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "STATE_UNSPECIFIED",
                Self::Running => "RUNNING",
                Self::Succeeded => "SUCCEEDED",
                Self::Failed => "FAILED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "RUNNING" => Some(Self::Running),
                "SUCCEEDED" => Some(Self::Succeeded),
                "FAILED" => Some(Self::Failed),
                _ => None,
            }
        }
    }
}
/// The request message for
/// \[Deployments.ListDeployments\]\[google.cloud.dialogflow.cx.v3.Deployments.ListDeployments\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListDeploymentsRequest {
    /// Required. The \[Environment\]\[google.cloud.dialogflow.cx.v3.Environment\] to
    /// list all environments for. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of items to return in a single page. By default 20 and
    /// at most 100.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response message for
/// \[Deployments.ListDeployments\]\[google.cloud.dialogflow.cx.v3.Deployments.ListDeployments\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListDeploymentsResponse {
    /// The list of deployments. There will be a maximum number of items
    /// returned based on the page_size field in the request. The list may in some
    /// cases be empty or contain fewer entries than page_size even if this isn't
    /// the last page.
    #[prost(message, repeated, tag = "1")]
    pub deployments: ::prost::alloc::vec::Vec<Deployment>,
    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request message for
/// \[Deployments.GetDeployment\]\[google.cloud.dialogflow.cx.v3.Deployments.GetDeployment\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetDeploymentRequest {
    /// Required. The name of the
    /// \[Deployment\]\[google.cloud.dialogflow.cx.v3.Deployment\]. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>/deployments/<DeploymentID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod deployments_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing \[Deployments\]\[google.cloud.dialogflow.cx.v3.Deployment\].
    #[derive(Debug, Clone)]
    pub struct DeploymentsClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl DeploymentsClient<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> DeploymentsClient<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,
        ) -> DeploymentsClient<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,
        {
            DeploymentsClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Returns the list of all deployments in the specified
        /// \[Environment\]\[google.cloud.dialogflow.cx.v3.Environment\].
        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.dialogflow.cx.v3.Deployments/ListDeployments",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Deployments",
                        "ListDeployments",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the specified
        /// \[Deployment\]\[google.cloud.dialogflow.cx.v3.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.dialogflow.cx.v3.Deployments/GetDeployment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Deployments",
                        "GetDeployment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Inline destination for a Dialogflow operation that writes or exports objects
/// (e.g. \[intents\]\[google.cloud.dialogflow.cx.v3.Intent\]) outside of Dialogflow.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct InlineDestination {
    /// Output only. The uncompressed byte content for the objects.
    /// Only populated in responses.
    #[prost(bytes = "vec", tag = "1")]
    pub content: ::prost::alloc::vec::Vec<u8>,
}
/// Inline source for a Dialogflow operation that reads or imports objects
/// (e.g. \[intents\]\[google.cloud.dialogflow.cx.v3.Intent\]) into Dialogflow.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct InlineSource {
    /// The uncompressed byte content for the objects.
    #[prost(bytes = "vec", tag = "1")]
    pub content: ::prost::alloc::vec::Vec<u8>,
}
/// Entities are extracted from user input and represent parameters that are
/// meaningful to your application. For example, a date range, a proper name
/// such as a geographic location or landmark, and so on. Entities represent
/// actionable data for your application.
///
/// When you define an entity, you can also include synonyms that all map to
/// that entity. For example, "soft drink", "soda", "pop", and so on.
///
/// There are three types of entities:
///
/// * **System** - entities that are defined by the Dialogflow API for common
///   data types such as date, time, currency, and so on. A system entity is
///   represented by the `EntityType` type.
///
/// * **Custom** - entities that are defined by you that represent
///   actionable data that is meaningful to your application. For example,
///   you could define a `pizza.sauce` entity for red or white pizza sauce,
///   a `pizza.cheese` entity for the different types of cheese on a pizza,
///   a `pizza.topping` entity for different toppings, and so on. A custom
///   entity is represented by the `EntityType` type.
///
/// * **User** - entities that are built for an individual user such as
///   favorites, preferences, playlists, and so on. A user entity is
///   represented by the
///   \[SessionEntityType\]\[google.cloud.dialogflow.cx.v3.SessionEntityType\]
///   type.
///
/// For more information about entity types, see the [Dialogflow
/// documentation](<https://cloud.google.com/dialogflow/docs/entities-overview>).
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EntityType {
    /// The unique identifier of the entity type.
    /// Required for
    /// \[EntityTypes.UpdateEntityType\]\[google.cloud.dialogflow.cx.v3.EntityTypes.UpdateEntityType\].
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/entityTypes/<EntityTypeID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. The human-readable name of the entity type, unique within the
    /// agent.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Required. Indicates the kind of entity type.
    #[prost(enumeration = "entity_type::Kind", tag = "3")]
    pub kind: i32,
    /// Indicates whether the entity type can be automatically expanded.
    #[prost(enumeration = "entity_type::AutoExpansionMode", tag = "4")]
    pub auto_expansion_mode: i32,
    /// The collection of entity entries associated with the entity type.
    #[prost(message, repeated, tag = "5")]
    pub entities: ::prost::alloc::vec::Vec<entity_type::Entity>,
    /// Collection of exceptional words and phrases that shouldn't be matched.
    /// For example, if you have a size entity type with entry `giant`(an
    /// adjective), you might consider adding `giants`(a noun) as an exclusion.
    /// If the kind of entity type is `KIND_MAP`, then the phrases specified by
    /// entities and excluded phrases should be mutually exclusive.
    #[prost(message, repeated, tag = "6")]
    pub excluded_phrases: ::prost::alloc::vec::Vec<entity_type::ExcludedPhrase>,
    /// Enables fuzzy entity extraction during classification.
    #[prost(bool, tag = "7")]
    pub enable_fuzzy_extraction: bool,
    /// Indicates whether parameters of the entity type should be redacted in log.
    /// If redaction is enabled, page parameters and intent parameters referring to
    /// the entity type will be replaced by parameter name when logging.
    #[prost(bool, tag = "9")]
    pub redact: bool,
}
/// Nested message and enum types in `EntityType`.
pub mod entity_type {
    /// An **entity entry** for an associated entity type.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Entity {
        /// Required. The primary value associated with this entity entry.
        /// For example, if the entity type is *vegetable*, the value could be
        /// *scallions*.
        ///
        /// For `KIND_MAP` entity types:
        ///
        /// * A canonical value to be used in place of synonyms.
        ///
        /// For `KIND_LIST` entity types:
        ///
        /// * A string that can contain references to other entity types (with or
        ///   without aliases).
        #[prost(string, tag = "1")]
        pub value: ::prost::alloc::string::String,
        /// Required. A collection of value synonyms. For example, if the entity type
        /// is *vegetable*, and `value` is *scallions*, a synonym could be *green
        /// onions*.
        ///
        /// For `KIND_LIST` entity types:
        ///
        /// * This collection must contain exactly one synonym equal to `value`.
        #[prost(string, repeated, tag = "2")]
        pub synonyms: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    }
    /// An excluded entity phrase that should not be matched.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ExcludedPhrase {
        /// Required. The word or phrase to be excluded.
        #[prost(string, tag = "1")]
        pub value: ::prost::alloc::string::String,
    }
    /// Represents kinds of entities.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Kind {
        /// Not specified. This value should be never used.
        Unspecified = 0,
        /// Map entity types allow mapping of a group of synonyms to a canonical
        /// value.
        Map = 1,
        /// List entity types contain a set of entries that do not map to canonical
        /// values. However, list entity types can contain references to other entity
        /// types (with or without aliases).
        List = 2,
        /// Regexp entity types allow to specify regular expressions in entries
        /// values.
        Regexp = 3,
    }
    impl Kind {
        /// 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 => "KIND_UNSPECIFIED",
                Self::Map => "KIND_MAP",
                Self::List => "KIND_LIST",
                Self::Regexp => "KIND_REGEXP",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "KIND_UNSPECIFIED" => Some(Self::Unspecified),
                "KIND_MAP" => Some(Self::Map),
                "KIND_LIST" => Some(Self::List),
                "KIND_REGEXP" => Some(Self::Regexp),
                _ => None,
            }
        }
    }
    /// Represents different entity type expansion modes. Automated expansion
    /// allows an agent to recognize values that have not been explicitly listed in
    /// the entity (for example, new kinds of shopping list items).
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum AutoExpansionMode {
        /// Auto expansion disabled for the entity.
        Unspecified = 0,
        /// Allows an agent to recognize values that have not been explicitly
        /// listed in the entity.
        Default = 1,
    }
    impl AutoExpansionMode {
        /// 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 => "AUTO_EXPANSION_MODE_UNSPECIFIED",
                Self::Default => "AUTO_EXPANSION_MODE_DEFAULT",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "AUTO_EXPANSION_MODE_UNSPECIFIED" => Some(Self::Unspecified),
                "AUTO_EXPANSION_MODE_DEFAULT" => Some(Self::Default),
                _ => None,
            }
        }
    }
}
/// The request message for
/// \[EntityTypes.ExportEntityTypes\]\[google.cloud.dialogflow.cx.v3.EntityTypes.ExportEntityTypes\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExportEntityTypesRequest {
    /// Required. The name of the parent agent to export entity types.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The name of the entity types to export.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/entityTypes/<EntityTypeID>`.
    #[prost(string, repeated, tag = "2")]
    pub entity_types: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. The data format of the exported entity types. If not specified,
    /// `BLOB` is assumed.
    #[prost(enumeration = "export_entity_types_request::DataFormat", tag = "5")]
    pub data_format: i32,
    /// Optional. The language to retrieve the entity type for. The following
    /// fields are language dependent:
    ///
    /// * `EntityType.entities.value`
    /// * `EntityType.entities.synonyms`
    /// * `EntityType.excluded_phrases.value`
    ///
    /// If not specified, all language dependent fields will be retrieved.
    /// [Many
    /// languages](<https://cloud.google.com/dialogflow/docs/reference/language>)
    /// are supported.
    /// Note: languages must be enabled in the agent before they can be used.
    #[prost(string, tag = "6")]
    pub language_code: ::prost::alloc::string::String,
    /// The destination to export.
    #[prost(oneof = "export_entity_types_request::Destination", tags = "3, 4")]
    pub destination: ::core::option::Option<export_entity_types_request::Destination>,
}
/// Nested message and enum types in `ExportEntityTypesRequest`.
pub mod export_entity_types_request {
    /// Data format of the exported entity types.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum DataFormat {
        /// Unspecified format. Treated as `BLOB`.
        Unspecified = 0,
        /// EntityTypes will be exported as raw bytes.
        Blob = 1,
        /// EntityTypes will be exported in JSON Package format.
        JsonPackage = 5,
    }
    impl DataFormat {
        /// 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_FORMAT_UNSPECIFIED",
                Self::Blob => "BLOB",
                Self::JsonPackage => "JSON_PACKAGE",
            }
        }
        /// 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_FORMAT_UNSPECIFIED" => Some(Self::Unspecified),
                "BLOB" => Some(Self::Blob),
                "JSON_PACKAGE" => Some(Self::JsonPackage),
                _ => None,
            }
        }
    }
    /// The destination to export.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Destination {
        /// Optional. The [Google Cloud
        /// Storage](<https://cloud.google.com/storage/docs/>) URI to export the entity
        /// types to. The format of this URI must be
        /// `gs://<bucket-name>/<object-name>`.
        ///
        /// Dialogflow performs a write operation for the Cloud Storage object
        /// on the caller's behalf, so your request authentication must
        /// have write permissions for the object. For more information, see
        /// [Dialogflow access
        /// control](<https://cloud.google.com/dialogflow/cx/docs/concept/access-control#storage>).
        #[prost(string, tag = "3")]
        EntityTypesUri(::prost::alloc::string::String),
        /// Optional. The option to return the serialized entity types inline.
        #[prost(bool, tag = "4")]
        EntityTypesContentInline(bool),
    }
}
/// The response message for
/// \[EntityTypes.ExportEntityTypes\]\[google.cloud.dialogflow.cx.v3.EntityTypes.ExportEntityTypes\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExportEntityTypesResponse {
    /// Exported entity types can be either in cloud storage or local download.
    #[prost(oneof = "export_entity_types_response::ExportedEntityTypes", tags = "1, 2")]
    pub exported_entity_types: ::core::option::Option<
        export_entity_types_response::ExportedEntityTypes,
    >,
}
/// Nested message and enum types in `ExportEntityTypesResponse`.
pub mod export_entity_types_response {
    /// Exported entity types can be either in cloud storage or local download.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum ExportedEntityTypes {
        /// The URI to a file containing the exported entity types. This field is
        /// populated only if `entity_types_uri` is specified in
        /// \[ExportEntityTypesRequest\]\[google.cloud.dialogflow.cx.v3.ExportEntityTypesRequest\].
        #[prost(string, tag = "1")]
        EntityTypesUri(::prost::alloc::string::String),
        /// Uncompressed byte content for entity types. This field is populated only
        /// if `entity_types_content_inline` is set to true in
        /// \[ExportEntityTypesRequest\]\[google.cloud.dialogflow.cx.v3.ExportEntityTypesRequest\].
        #[prost(message, tag = "2")]
        EntityTypesContent(super::InlineDestination),
    }
}
/// Metadata returned for the
/// \[EntityTypes.ExportEntityTypes\]\[google.cloud.dialogflow.cx.v3.EntityTypes.ExportEntityTypes\]
/// long running operation.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExportEntityTypesMetadata {}
/// The request message for
/// \[EntityTypes.ImportEntityTypes\]\[google.cloud.dialogflow.cx.v3.EntityTypes.ImportEntityTypes\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ImportEntityTypesRequest {
    /// Required. The agent to import the entity types into.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. Merge option for importing entity types.
    #[prost(enumeration = "import_entity_types_request::MergeOption", tag = "4")]
    pub merge_option: i32,
    /// Optional. The target entity type to import into.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/entity_types/<EntityTypeID>`.
    /// If set, there should be only one entity type included in
    /// \[entity_types\]\[google.cloud.dialogflow.cx.v3.ImportEntityTypesRequest.entity_types\],
    /// of which the type should match the type of the target entity type. All
    /// \[entities\]\[google.cloud.dialogflow.cx.v3.EntityType.entities\] in the
    /// imported entity type will be added to the target entity type.
    #[prost(string, tag = "5")]
    pub target_entity_type: ::prost::alloc::string::String,
    /// Required. The entity types to import.
    #[prost(oneof = "import_entity_types_request::EntityTypes", tags = "2, 3")]
    pub entity_types: ::core::option::Option<import_entity_types_request::EntityTypes>,
}
/// Nested message and enum types in `ImportEntityTypesRequest`.
pub mod import_entity_types_request {
    /// Merge option when display name conflicts exist during import.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum MergeOption {
        /// Unspecified. If used, system uses REPORT_CONFLICT as default.
        Unspecified = 0,
        /// Replace the original entity type in the agent with the new entity type
        /// when display name conflicts exist.
        Replace = 1,
        /// Merge the original entity type with the new entity type when display name
        /// conflicts exist.
        Merge = 2,
        /// Create new entity types with new display names to differentiate them from
        /// the existing entity types when display name conflicts exist.
        Rename = 3,
        /// Report conflict information if display names conflict is detected.
        /// Otherwise, import entity types.
        ReportConflict = 4,
        /// Keep the original entity type and discard the conflicting new entity type
        /// when display name conflicts exist.
        Keep = 5,
    }
    impl MergeOption {
        /// 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 => "MERGE_OPTION_UNSPECIFIED",
                Self::Replace => "REPLACE",
                Self::Merge => "MERGE",
                Self::Rename => "RENAME",
                Self::ReportConflict => "REPORT_CONFLICT",
                Self::Keep => "KEEP",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "MERGE_OPTION_UNSPECIFIED" => Some(Self::Unspecified),
                "REPLACE" => Some(Self::Replace),
                "MERGE" => Some(Self::Merge),
                "RENAME" => Some(Self::Rename),
                "REPORT_CONFLICT" => Some(Self::ReportConflict),
                "KEEP" => Some(Self::Keep),
                _ => None,
            }
        }
    }
    /// Required. The entity types to import.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum EntityTypes {
        /// The [Google Cloud Storage](<https://cloud.google.com/storage/docs/>) URI
        /// to import entity types from. The format of this URI must be
        /// `gs://<bucket-name>/<object-name>`.
        ///
        /// Dialogflow performs a read operation for the Cloud Storage object
        /// on the caller's behalf, so your request authentication must
        /// have read permissions for the object. For more information, see
        /// [Dialogflow access
        /// control](<https://cloud.google.com/dialogflow/cx/docs/concept/access-control#storage>).
        #[prost(string, tag = "2")]
        EntityTypesUri(::prost::alloc::string::String),
        /// Uncompressed byte content of entity types.
        #[prost(message, tag = "3")]
        EntityTypesContent(super::InlineSource),
    }
}
/// The response message for
/// \[EntityTypes.ImportEntityTypes\]\[google.cloud.dialogflow.cx.v3.EntityTypes.ImportEntityTypes\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ImportEntityTypesResponse {
    /// The unique identifier of the imported entity types.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/entity_types/<EntityTypeID>`.
    #[prost(string, repeated, tag = "1")]
    pub entity_types: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Info which resources have conflicts when
    /// \[REPORT_CONFLICT\]\[ImportEntityTypesResponse.REPORT_CONFLICT\] merge_option
    /// is set in ImportEntityTypesRequest.
    #[prost(message, optional, tag = "2")]
    pub conflicting_resources: ::core::option::Option<
        import_entity_types_response::ConflictingResources,
    >,
}
/// Nested message and enum types in `ImportEntityTypesResponse`.
pub mod import_entity_types_response {
    /// Conflicting resources detected during the import process. Only filled when
    /// \[REPORT_CONFLICT\]\[ImportEntityTypesResponse.REPORT_CONFLICT\] is set in the
    /// request and there are conflicts in the display names.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ConflictingResources {
        /// Display names of conflicting entity types.
        #[prost(string, repeated, tag = "1")]
        pub entity_type_display_names: ::prost::alloc::vec::Vec<
            ::prost::alloc::string::String,
        >,
        /// Display names of conflicting entities.
        #[prost(string, repeated, tag = "2")]
        pub entity_display_names: ::prost::alloc::vec::Vec<
            ::prost::alloc::string::String,
        >,
    }
}
/// Metadata returned for the
/// \[EntityTypes.ImportEntityTypes\]\[google.cloud.dialogflow.cx.v3.EntityTypes.ImportEntityTypes\]
/// long running operation.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ImportEntityTypesMetadata {}
/// The request message for
/// \[EntityTypes.ListEntityTypes\]\[google.cloud.dialogflow.cx.v3.EntityTypes.ListEntityTypes\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListEntityTypesRequest {
    /// Required. The agent to list all entity types for.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The language to list entity types for. The following fields are language
    /// dependent:
    ///
    /// * `EntityType.entities.value`
    /// * `EntityType.entities.synonyms`
    /// * `EntityType.excluded_phrases.value`
    ///
    /// If not specified, the agent's default language is used.
    /// [Many
    /// languages](<https://cloud.google.com/dialogflow/cx/docs/reference/language>)
    /// are supported.
    /// Note: languages must be enabled in the agent before they can be used.
    #[prost(string, tag = "2")]
    pub language_code: ::prost::alloc::string::String,
    /// The maximum number of items to return in a single page. By default 100 and
    /// at most 1000.
    #[prost(int32, tag = "3")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous list request.
    #[prost(string, tag = "4")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response message for
/// \[EntityTypes.ListEntityTypes\]\[google.cloud.dialogflow.cx.v3.EntityTypes.ListEntityTypes\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListEntityTypesResponse {
    /// The list of entity types. There will be a maximum number of items returned
    /// based on the page_size field in the request.
    #[prost(message, repeated, tag = "1")]
    pub entity_types: ::prost::alloc::vec::Vec<EntityType>,
    /// Token to retrieve the next page of results, or empty if there are no
    /// more results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request message for
/// \[EntityTypes.GetEntityType\]\[google.cloud.dialogflow.cx.v3.EntityTypes.GetEntityType\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetEntityTypeRequest {
    /// Required. The name of the entity type.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/entityTypes/<EntityTypeID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The language to retrieve the entity type for. The following fields are
    /// language dependent:
    ///
    /// * `EntityType.entities.value`
    /// * `EntityType.entities.synonyms`
    /// * `EntityType.excluded_phrases.value`
    ///
    /// If not specified, the agent's default language is used.
    /// [Many
    /// languages](<https://cloud.google.com/dialogflow/cx/docs/reference/language>)
    /// are supported.
    /// Note: languages must be enabled in the agent before they can be used.
    #[prost(string, tag = "2")]
    pub language_code: ::prost::alloc::string::String,
}
/// The request message for
/// \[EntityTypes.CreateEntityType\]\[google.cloud.dialogflow.cx.v3.EntityTypes.CreateEntityType\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateEntityTypeRequest {
    /// Required. The agent to create a entity type for.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The entity type to create.
    #[prost(message, optional, tag = "2")]
    pub entity_type: ::core::option::Option<EntityType>,
    /// The language of the following fields in `entity_type`:
    ///
    /// * `EntityType.entities.value`
    /// * `EntityType.entities.synonyms`
    /// * `EntityType.excluded_phrases.value`
    ///
    /// If not specified, the agent's default language is used.
    /// [Many
    /// languages](<https://cloud.google.com/dialogflow/cx/docs/reference/language>)
    /// are supported.
    /// Note: languages must be enabled in the agent before they can be used.
    #[prost(string, tag = "3")]
    pub language_code: ::prost::alloc::string::String,
}
/// The request message for
/// \[EntityTypes.UpdateEntityType\]\[google.cloud.dialogflow.cx.v3.EntityTypes.UpdateEntityType\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateEntityTypeRequest {
    /// Required. The entity type to update.
    #[prost(message, optional, tag = "1")]
    pub entity_type: ::core::option::Option<EntityType>,
    /// The language of the following fields in `entity_type`:
    ///
    /// * `EntityType.entities.value`
    /// * `EntityType.entities.synonyms`
    /// * `EntityType.excluded_phrases.value`
    ///
    /// If not specified, the agent's default language is used.
    /// [Many
    /// languages](<https://cloud.google.com/dialogflow/cx/docs/reference/language>)
    /// are supported.
    /// Note: languages must be enabled in the agent before they can be used.
    #[prost(string, tag = "2")]
    pub language_code: ::prost::alloc::string::String,
    /// The mask to control which fields get updated.
    #[prost(message, optional, tag = "3")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// The request message for
/// \[EntityTypes.DeleteEntityType\]\[google.cloud.dialogflow.cx.v3.EntityTypes.DeleteEntityType\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteEntityTypeRequest {
    /// Required. The name of the entity type to delete.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/entityTypes/<EntityTypeID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// This field has no effect for entity type not being used.
    /// For entity types that are used by intents or pages:
    ///
    /// * If `force` is set to false, an error will be returned with message
    ///   indicating the referencing resources.
    /// * If `force` is set to true, Dialogflow will remove the entity type, as
    ///   well as any references to the entity type (i.e. Page
    ///   \[parameter\]\[google.cloud.dialogflow.cx.v3.Form.Parameter\] of the entity
    ///   type will be changed to
    ///   '@sys.any' and intent
    ///   \[parameter\]\[google.cloud.dialogflow.cx.v3.Intent.Parameter\] of the
    ///   entity type will be removed).
    #[prost(bool, tag = "2")]
    pub force: bool,
}
/// Generated client implementations.
pub mod entity_types_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing \[EntityTypes\]\[google.cloud.dialogflow.cx.v3.EntityType\].
    #[derive(Debug, Clone)]
    pub struct EntityTypesClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl EntityTypesClient<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> EntityTypesClient<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,
        ) -> EntityTypesClient<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,
        {
            EntityTypesClient::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
        }
        /// Retrieves the specified entity type.
        pub async fn get_entity_type(
            &mut self,
            request: impl tonic::IntoRequest<super::GetEntityTypeRequest>,
        ) -> std::result::Result<tonic::Response<super::EntityType>, 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.dialogflow.cx.v3.EntityTypes/GetEntityType",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.EntityTypes",
                        "GetEntityType",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates an entity type in the specified agent.
        ///
        /// Note: You should always train a flow prior to sending it queries. See the
        /// [training
        /// documentation](https://cloud.google.com/dialogflow/cx/docs/concept/training).
        pub async fn create_entity_type(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateEntityTypeRequest>,
        ) -> std::result::Result<tonic::Response<super::EntityType>, 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.dialogflow.cx.v3.EntityTypes/CreateEntityType",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.EntityTypes",
                        "CreateEntityType",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified entity type.
        ///
        /// Note: You should always train a flow prior to sending it queries. See the
        /// [training
        /// documentation](https://cloud.google.com/dialogflow/cx/docs/concept/training).
        pub async fn update_entity_type(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateEntityTypeRequest>,
        ) -> std::result::Result<tonic::Response<super::EntityType>, 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.dialogflow.cx.v3.EntityTypes/UpdateEntityType",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.EntityTypes",
                        "UpdateEntityType",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified entity type.
        ///
        /// Note: You should always train a flow prior to sending it queries. See the
        /// [training
        /// documentation](https://cloud.google.com/dialogflow/cx/docs/concept/training).
        pub async fn delete_entity_type(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteEntityTypeRequest>,
        ) -> 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.dialogflow.cx.v3.EntityTypes/DeleteEntityType",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.EntityTypes",
                        "DeleteEntityType",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns the list of all entity types in the specified agent.
        pub async fn list_entity_types(
            &mut self,
            request: impl tonic::IntoRequest<super::ListEntityTypesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListEntityTypesResponse>,
            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.dialogflow.cx.v3.EntityTypes/ListEntityTypes",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.EntityTypes",
                        "ListEntityTypes",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Exports the selected entity types.
        pub async fn export_entity_types(
            &mut self,
            request: impl tonic::IntoRequest<super::ExportEntityTypesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.dialogflow.cx.v3.EntityTypes/ExportEntityTypes",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.EntityTypes",
                        "ExportEntityTypes",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Imports the specified entitytypes into the agent.
        pub async fn import_entity_types(
            &mut self,
            request: impl tonic::IntoRequest<super::ImportEntityTypesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.dialogflow.cx.v3.EntityTypes/ImportEntityTypes",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.EntityTypes",
                        "ImportEntityTypes",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// An intent represents a user's intent to interact with a conversational agent.
///
/// You can provide information for the Dialogflow API to use to match user input
/// to an intent by adding training phrases (i.e., examples of user input) to
/// your intent.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Intent {
    /// The unique identifier of the intent.
    /// Required for the
    /// \[Intents.UpdateIntent\]\[google.cloud.dialogflow.cx.v3.Intents.UpdateIntent\]
    /// method.
    /// \[Intents.CreateIntent\]\[google.cloud.dialogflow.cx.v3.Intents.CreateIntent\]
    /// populates the name automatically.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/intents/<IntentID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. The human-readable name of the intent, unique within the agent.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// The collection of training phrases the agent is trained on to identify the
    /// intent.
    #[prost(message, repeated, tag = "3")]
    pub training_phrases: ::prost::alloc::vec::Vec<intent::TrainingPhrase>,
    /// The collection of parameters associated with the intent.
    #[prost(message, repeated, tag = "4")]
    pub parameters: ::prost::alloc::vec::Vec<intent::Parameter>,
    /// The priority of this intent. Higher numbers represent higher
    /// priorities.
    ///
    /// * If the supplied value is unspecified or 0, the service
    ///   translates the value to 500,000, which corresponds to the
    ///   `Normal` priority in the console.
    /// * If the supplied value is negative, the intent is ignored
    ///   in runtime detect intent requests.
    #[prost(int32, tag = "5")]
    pub priority: i32,
    /// Indicates whether this is a fallback intent. Currently only default
    /// fallback intent is allowed in the agent, which is added upon agent
    /// creation.
    /// Adding training phrases to fallback intent is useful in the case of
    /// requests that are mistakenly matched, since training phrases assigned to
    /// fallback intents act as negative examples that triggers no-match event.
    #[prost(bool, tag = "6")]
    pub is_fallback: bool,
    /// The key/value metadata to label an intent. Labels can contain
    /// lowercase letters, digits and the symbols '-' and '\_'. International
    /// characters are allowed, including letters from unicase alphabets. Keys must
    /// start with a letter. Keys and values can be no longer than 63 characters
    /// and no more than 128 bytes.
    ///
    /// Prefix "sys-" is reserved for Dialogflow defined labels. Currently allowed
    /// Dialogflow defined labels include:
    ///
    /// * sys-head
    /// * sys-contextual
    ///   The above labels do not require value. "sys-head" means the intent is a
    ///   head intent. "sys.contextual" means the intent is a contextual intent.
    #[prost(map = "string, string", tag = "7")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Human readable description for better understanding an intent like its
    /// scope, content, result etc. Maximum character limit: 140 characters.
    #[prost(string, tag = "8")]
    pub description: ::prost::alloc::string::String,
    /// Optional. Matching DTMF pattern for the intent.
    #[prost(string, tag = "16")]
    pub dtmf_pattern: ::prost::alloc::string::String,
}
/// Nested message and enum types in `Intent`.
pub mod intent {
    /// Represents an example that the agent is trained on to identify the intent.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct TrainingPhrase {
        /// Output only. The unique identifier of the training phrase.
        #[prost(string, tag = "1")]
        pub id: ::prost::alloc::string::String,
        /// Required. The ordered list of training phrase parts.
        /// The parts are concatenated in order to form the training phrase.
        ///
        /// Note: The API does not automatically annotate training phrases like the
        /// Dialogflow Console does.
        ///
        /// Note: Do not forget to include whitespace at part boundaries, so the
        /// training phrase is well formatted when the parts are concatenated.
        ///
        /// If the training phrase does not need to be annotated with parameters,
        /// you just need a single part with only the
        /// \[Part.text\]\[google.cloud.dialogflow.cx.v3.Intent.TrainingPhrase.Part.text\]
        /// field set.
        ///
        /// If you want to annotate the training phrase, you must create multiple
        /// parts, where the fields of each part are populated in one of two ways:
        ///
        /// * `Part.text` is set to a part of the phrase that has no parameters.
        /// * `Part.text` is set to a part of the phrase that you want to annotate,
        ///   and the `parameter_id` field is set.
        #[prost(message, repeated, tag = "2")]
        pub parts: ::prost::alloc::vec::Vec<training_phrase::Part>,
        /// Indicates how many times this example was added to the intent.
        #[prost(int32, tag = "3")]
        pub repeat_count: i32,
    }
    /// Nested message and enum types in `TrainingPhrase`.
    pub mod training_phrase {
        /// Represents a part of a training phrase.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Part {
            /// Required. The text for this part.
            #[prost(string, tag = "1")]
            pub text: ::prost::alloc::string::String,
            /// The \[parameter\]\[google.cloud.dialogflow.cx.v3.Intent.Parameter\] used to
            /// annotate this part of the training phrase. This field is required for
            /// annotated parts of the training phrase.
            #[prost(string, tag = "2")]
            pub parameter_id: ::prost::alloc::string::String,
        }
    }
    /// Represents an intent parameter.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Parameter {
        /// Required. The unique identifier of the parameter. This field
        /// is used by \[training
        /// phrases\]\[google.cloud.dialogflow.cx.v3.Intent.TrainingPhrase\] to annotate
        /// their \[parts\]\[google.cloud.dialogflow.cx.v3.Intent.TrainingPhrase.Part\].
        #[prost(string, tag = "1")]
        pub id: ::prost::alloc::string::String,
        /// Required. The entity type of the parameter.
        /// Format:
        /// `projects/-/locations/-/agents/-/entityTypes/<SystemEntityTypeID>` for
        /// system entity types (for example,
        /// `projects/-/locations/-/agents/-/entityTypes/sys.date`), or
        /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/entityTypes/<EntityTypeID>`
        /// for developer entity types.
        #[prost(string, tag = "2")]
        pub entity_type: ::prost::alloc::string::String,
        /// Indicates whether the parameter represents a list of values.
        #[prost(bool, tag = "3")]
        pub is_list: bool,
        /// Indicates whether the parameter content should be redacted in log. If
        /// redaction is enabled, the parameter content will be replaced by parameter
        /// name during logging.
        /// Note: the parameter content is subject to redaction if either parameter
        /// level redaction or \[entity type level
        /// redaction\]\[google.cloud.dialogflow.cx.v3.EntityType.redact\] is enabled.
        #[prost(bool, tag = "4")]
        pub redact: bool,
    }
}
/// The request message for
/// \[Intents.ListIntents\]\[google.cloud.dialogflow.cx.v3.Intents.ListIntents\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListIntentsRequest {
    /// Required. The agent to list all intents for.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The language to list intents for. The following fields are language
    /// dependent:
    ///
    /// * `Intent.training_phrases.parts.text`
    ///
    /// If not specified, the agent's default language is used.
    /// [Many
    /// languages](<https://cloud.google.com/dialogflow/cx/docs/reference/language>)
    /// are supported.
    /// Note: languages must be enabled in the agent before they can be used.
    #[prost(string, tag = "2")]
    pub language_code: ::prost::alloc::string::String,
    /// The resource view to apply to the returned intent.
    #[prost(enumeration = "IntentView", tag = "5")]
    pub intent_view: i32,
    /// The maximum number of items to return in a single page. By default 100 and
    /// at most 1000.
    #[prost(int32, tag = "3")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous list request.
    #[prost(string, tag = "4")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response message for
/// \[Intents.ListIntents\]\[google.cloud.dialogflow.cx.v3.Intents.ListIntents\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListIntentsResponse {
    /// The list of intents. There will be a maximum number of items returned based
    /// on the page_size field in the request.
    #[prost(message, repeated, tag = "1")]
    pub intents: ::prost::alloc::vec::Vec<Intent>,
    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request message for
/// \[Intents.GetIntent\]\[google.cloud.dialogflow.cx.v3.Intents.GetIntent\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetIntentRequest {
    /// Required. The name of the intent.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/intents/<IntentID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The language to retrieve the intent for. The following fields are language
    /// dependent:
    ///
    /// * `Intent.training_phrases.parts.text`
    ///
    /// If not specified, the agent's default language is used.
    /// [Many
    /// languages](<https://cloud.google.com/dialogflow/cx/docs/reference/language>)
    /// are supported.
    /// Note: languages must be enabled in the agent before they can be used.
    #[prost(string, tag = "2")]
    pub language_code: ::prost::alloc::string::String,
}
/// The request message for
/// \[Intents.CreateIntent\]\[google.cloud.dialogflow.cx.v3.Intents.CreateIntent\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateIntentRequest {
    /// Required. The agent to create an intent for.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The intent to create.
    #[prost(message, optional, tag = "2")]
    pub intent: ::core::option::Option<Intent>,
    /// The language of the following fields in `intent`:
    ///
    /// * `Intent.training_phrases.parts.text`
    ///
    /// If not specified, the agent's default language is used.
    /// [Many
    /// languages](<https://cloud.google.com/dialogflow/cx/docs/reference/language>)
    /// are supported.
    /// Note: languages must be enabled in the agent before they can be used.
    #[prost(string, tag = "3")]
    pub language_code: ::prost::alloc::string::String,
}
/// The request message for
/// \[Intents.UpdateIntent\]\[google.cloud.dialogflow.cx.v3.Intents.UpdateIntent\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateIntentRequest {
    /// Required. The intent to update.
    #[prost(message, optional, tag = "1")]
    pub intent: ::core::option::Option<Intent>,
    /// The language of the following fields in `intent`:
    ///
    /// * `Intent.training_phrases.parts.text`
    ///
    /// If not specified, the agent's default language is used.
    /// [Many
    /// languages](<https://cloud.google.com/dialogflow/cx/docs/reference/language>)
    /// are supported.
    /// Note: languages must be enabled in the agent before they can be used.
    #[prost(string, tag = "2")]
    pub language_code: ::prost::alloc::string::String,
    /// The mask to control which fields get updated. If the mask is not present,
    /// all fields will be updated.
    #[prost(message, optional, tag = "3")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// The request message for
/// \[Intents.DeleteIntent\]\[google.cloud.dialogflow.cx.v3.Intents.DeleteIntent\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteIntentRequest {
    /// Required. The name of the intent to delete.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/intents/<IntentID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for
/// \[Intents.ImportIntents\]\[google.cloud.dialogflow.cx.v3.Intents.ImportIntents\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ImportIntentsRequest {
    /// Required. The agent to import the intents into.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Merge option for importing intents. If not specified, `REJECT` is assumed.
    #[prost(enumeration = "import_intents_request::MergeOption", tag = "4")]
    pub merge_option: i32,
    /// Required. The intents to import.
    #[prost(oneof = "import_intents_request::Intents", tags = "2, 3")]
    pub intents: ::core::option::Option<import_intents_request::Intents>,
}
/// Nested message and enum types in `ImportIntentsRequest`.
pub mod import_intents_request {
    /// Merge option when display name conflicts exist during import.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum MergeOption {
        /// Unspecified. Should not be used.
        Unspecified = 0,
        /// DEPRECATED: Please use
        /// \[REPORT_CONFLICT\]\[ImportIntentsRequest.REPORT_CONFLICT\] instead.
        /// Fail the request if there are intents whose display names conflict with
        /// the display names of intents in the agent.
        #[deprecated]
        Reject = 1,
        /// Replace the original intent in the agent with the new intent when display
        /// name conflicts exist.
        Replace = 2,
        /// Merge the original intent with the new intent when display name conflicts
        /// exist.
        Merge = 3,
        /// Create new intents with new display names to differentiate them from the
        /// existing intents when display name conflicts exist.
        Rename = 4,
        /// Report conflict information if display names conflict is detected.
        /// Otherwise, import intents.
        ReportConflict = 5,
        /// Keep the original intent and discard the conflicting new intent when
        /// display name conflicts exist.
        Keep = 6,
    }
    impl MergeOption {
        /// 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 => "MERGE_OPTION_UNSPECIFIED",
                #[allow(deprecated)]
                Self::Reject => "REJECT",
                Self::Replace => "REPLACE",
                Self::Merge => "MERGE",
                Self::Rename => "RENAME",
                Self::ReportConflict => "REPORT_CONFLICT",
                Self::Keep => "KEEP",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "MERGE_OPTION_UNSPECIFIED" => Some(Self::Unspecified),
                "REJECT" => Some(#[allow(deprecated)] Self::Reject),
                "REPLACE" => Some(Self::Replace),
                "MERGE" => Some(Self::Merge),
                "RENAME" => Some(Self::Rename),
                "REPORT_CONFLICT" => Some(Self::ReportConflict),
                "KEEP" => Some(Self::Keep),
                _ => None,
            }
        }
    }
    /// Required. The intents to import.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Intents {
        /// The [Google Cloud Storage](<https://cloud.google.com/storage/docs/>) URI
        /// to import intents from. The format of this URI must be
        /// `gs://<bucket-name>/<object-name>`.
        ///
        /// Dialogflow performs a read operation for the Cloud Storage object
        /// on the caller's behalf, so your request authentication must
        /// have read permissions for the object. For more information, see
        /// [Dialogflow access
        /// control](<https://cloud.google.com/dialogflow/cx/docs/concept/access-control#storage>).
        #[prost(string, tag = "2")]
        IntentsUri(::prost::alloc::string::String),
        /// Uncompressed byte content of intents.
        #[prost(message, tag = "3")]
        IntentsContent(super::InlineSource),
    }
}
/// The response message for
/// \[Intents.ImportIntents\]\[google.cloud.dialogflow.cx.v3.Intents.ImportIntents\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ImportIntentsResponse {
    /// The unique identifier of the imported intents.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/intents/<IntentID>`.
    #[prost(string, repeated, tag = "1")]
    pub intents: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Info which resources have conflicts when
    /// \[REPORT_CONFLICT\]\[ImportIntentsResponse.REPORT_CONFLICT\] merge_option is
    /// set in ImportIntentsRequest.
    #[prost(message, optional, tag = "2")]
    pub conflicting_resources: ::core::option::Option<
        import_intents_response::ConflictingResources,
    >,
}
/// Nested message and enum types in `ImportIntentsResponse`.
pub mod import_intents_response {
    /// Conflicting resources detected during the import process. Only filled when
    /// \[REPORT_CONFLICT\]\[ImportIntentsResponse.REPORT_CONFLICT\] is set in the
    /// request and there are conflicts in the display names.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ConflictingResources {
        /// Display names of conflicting intents.
        #[prost(string, repeated, tag = "1")]
        pub intent_display_names: ::prost::alloc::vec::Vec<
            ::prost::alloc::string::String,
        >,
        /// Display names of conflicting entities.
        #[prost(string, repeated, tag = "2")]
        pub entity_display_names: ::prost::alloc::vec::Vec<
            ::prost::alloc::string::String,
        >,
    }
}
/// Metadata returned for the
/// \[Intents.ImportIntents\]\[google.cloud.dialogflow.cx.v3.Intents.ImportIntents\]
/// long running operation.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ImportIntentsMetadata {}
/// The request message for
/// \[Intents.ExportIntents\]\[google.cloud.dialogflow.cx.v3.Intents.ExportIntents\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExportIntentsRequest {
    /// Required. The name of the parent agent to export intents.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The name of the intents to export.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/intents/<IntentID>`.
    #[prost(string, repeated, tag = "2")]
    pub intents: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. The data format of the exported intents. If not specified, `BLOB`
    /// is assumed.
    #[prost(enumeration = "export_intents_request::DataFormat", tag = "5")]
    pub data_format: i32,
    /// The destination to export.
    #[prost(oneof = "export_intents_request::Destination", tags = "3, 4")]
    pub destination: ::core::option::Option<export_intents_request::Destination>,
}
/// Nested message and enum types in `ExportIntentsRequest`.
pub mod export_intents_request {
    /// Data format of the exported intents.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum DataFormat {
        /// Unspecified format. Treated as `BLOB`.
        Unspecified = 0,
        /// Intents will be exported as raw bytes.
        Blob = 1,
        /// Intents will be exported in JSON format.
        Json = 2,
        /// Intents will be exported in CSV format.
        Csv = 3,
    }
    impl DataFormat {
        /// 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_FORMAT_UNSPECIFIED",
                Self::Blob => "BLOB",
                Self::Json => "JSON",
                Self::Csv => "CSV",
            }
        }
        /// 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_FORMAT_UNSPECIFIED" => Some(Self::Unspecified),
                "BLOB" => Some(Self::Blob),
                "JSON" => Some(Self::Json),
                "CSV" => Some(Self::Csv),
                _ => None,
            }
        }
    }
    /// The destination to export.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Destination {
        /// Optional. The [Google Cloud
        /// Storage](<https://cloud.google.com/storage/docs/>) URI to export the
        /// intents to. The format of this URI must be
        /// `gs://<bucket-name>/<object-name>`.
        ///
        /// Dialogflow performs a write operation for the Cloud Storage object
        /// on the caller's behalf, so your request authentication must
        /// have write permissions for the object. For more information, see
        /// [Dialogflow access
        /// control](<https://cloud.google.com/dialogflow/cx/docs/concept/access-control#storage>).
        #[prost(string, tag = "3")]
        IntentsUri(::prost::alloc::string::String),
        /// Optional. The option to return the serialized intents inline.
        #[prost(bool, tag = "4")]
        IntentsContentInline(bool),
    }
}
/// The response message for
/// \[Intents.ExportIntents\]\[google.cloud.dialogflow.cx.v3.Intents.ExportIntents\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExportIntentsResponse {
    /// The exported intents.
    #[prost(oneof = "export_intents_response::Intents", tags = "1, 2")]
    pub intents: ::core::option::Option<export_intents_response::Intents>,
}
/// Nested message and enum types in `ExportIntentsResponse`.
pub mod export_intents_response {
    /// The exported intents.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Intents {
        /// The URI to a file containing the exported intents. This field is
        /// populated only if `intents_uri` is specified in
        /// \[ExportIntentsRequest\]\[google.cloud.dialogflow.cx.v3.ExportIntentsRequest\].
        #[prost(string, tag = "1")]
        IntentsUri(::prost::alloc::string::String),
        /// Uncompressed byte content for intents. This field is populated only if
        /// `intents_content_inline` is set to true in
        /// \[ExportIntentsRequest\]\[google.cloud.dialogflow.cx.v3.ExportIntentsRequest\].
        #[prost(message, tag = "2")]
        IntentsContent(super::InlineDestination),
    }
}
/// Metadata returned for the
/// \[Intents.ExportIntents\]\[google.cloud.dialogflow.cx.v3.Intents.ExportIntents\]
/// long running operation.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExportIntentsMetadata {}
/// Represents the options for views of an intent.
/// An intent can be a sizable object. Therefore, we provide a resource view that
/// does not return training phrases in the response.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum IntentView {
    /// Not specified. Treated as INTENT_VIEW_FULL.
    Unspecified = 0,
    /// Training phrases field is not populated in the response.
    Partial = 1,
    /// All fields are populated.
    Full = 2,
}
impl IntentView {
    /// 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 => "INTENT_VIEW_UNSPECIFIED",
            Self::Partial => "INTENT_VIEW_PARTIAL",
            Self::Full => "INTENT_VIEW_FULL",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "INTENT_VIEW_UNSPECIFIED" => Some(Self::Unspecified),
            "INTENT_VIEW_PARTIAL" => Some(Self::Partial),
            "INTENT_VIEW_FULL" => Some(Self::Full),
            _ => None,
        }
    }
}
/// Generated client implementations.
pub mod intents_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing \[Intents\]\[google.cloud.dialogflow.cx.v3.Intent\].
    #[derive(Debug, Clone)]
    pub struct IntentsClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl IntentsClient<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> IntentsClient<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,
        ) -> IntentsClient<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,
        {
            IntentsClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Returns the list of all intents in the specified agent.
        pub async fn list_intents(
            &mut self,
            request: impl tonic::IntoRequest<super::ListIntentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListIntentsResponse>,
            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.dialogflow.cx.v3.Intents/ListIntents",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Intents",
                        "ListIntents",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the specified intent.
        pub async fn get_intent(
            &mut self,
            request: impl tonic::IntoRequest<super::GetIntentRequest>,
        ) -> std::result::Result<tonic::Response<super::Intent>, 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.dialogflow.cx.v3.Intents/GetIntent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.dialogflow.cx.v3.Intents", "GetIntent"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates an intent in the specified agent.
        ///
        /// Note: You should always train a flow prior to sending it queries. See the
        /// [training
        /// documentation](https://cloud.google.com/dialogflow/cx/docs/concept/training).
        pub async fn create_intent(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateIntentRequest>,
        ) -> std::result::Result<tonic::Response<super::Intent>, 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.dialogflow.cx.v3.Intents/CreateIntent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Intents",
                        "CreateIntent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified intent.
        ///
        /// Note: You should always train a flow prior to sending it queries. See the
        /// [training
        /// documentation](https://cloud.google.com/dialogflow/cx/docs/concept/training).
        pub async fn update_intent(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateIntentRequest>,
        ) -> std::result::Result<tonic::Response<super::Intent>, 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.dialogflow.cx.v3.Intents/UpdateIntent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Intents",
                        "UpdateIntent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified intent.
        ///
        /// Note: You should always train a flow prior to sending it queries. See the
        /// [training
        /// documentation](https://cloud.google.com/dialogflow/cx/docs/concept/training).
        pub async fn delete_intent(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteIntentRequest>,
        ) -> 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.dialogflow.cx.v3.Intents/DeleteIntent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Intents",
                        "DeleteIntent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Imports the specified intents into the agent.
        ///
        /// This method is a [long-running
        /// operation](https://cloud.google.com/dialogflow/cx/docs/how/long-running-operation).
        /// The returned `Operation` type has the following method-specific fields:
        ///
        /// * `metadata`:
        ///  \[ImportIntentsMetadata\]\[google.cloud.dialogflow.cx.v3.ImportIntentsMetadata\]
        /// * `response`:
        ///  \[ImportIntentsResponse\]\[google.cloud.dialogflow.cx.v3.ImportIntentsResponse\]
        pub async fn import_intents(
            &mut self,
            request: impl tonic::IntoRequest<super::ImportIntentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.dialogflow.cx.v3.Intents/ImportIntents",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Intents",
                        "ImportIntents",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Exports the selected intents.
        ///
        /// This method is a [long-running
        /// operation](https://cloud.google.com/dialogflow/cx/docs/how/long-running-operation).
        /// The returned `Operation` type has the following method-specific fields:
        ///
        /// * `metadata`:
        ///  \[ExportIntentsMetadata\]\[google.cloud.dialogflow.cx.v3.ExportIntentsMetadata\]
        /// * `response`:
        ///  \[ExportIntentsResponse\]\[google.cloud.dialogflow.cx.v3.ExportIntentsResponse\]
        pub async fn export_intents(
            &mut self,
            request: impl tonic::IntoRequest<super::ExportIntentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.dialogflow.cx.v3.Intents/ExportIntents",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Intents",
                        "ExportIntents",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Session entity types are referred to as **User** entity types and are
/// entities that are built for an individual user such as favorites,
/// preferences, playlists, and so on.
///
/// You can redefine a session entity type at the session level to extend or
/// replace a \[custom entity type\]\[google.cloud.dialogflow.cx.v3.EntityType\] at
/// the user session level (we refer to the entity types defined at the agent
/// level as "custom entity types").
///
/// Note: session entity types apply to all queries, regardless of the language.
///
/// For more information about entity types, see the [Dialogflow
/// documentation](<https://cloud.google.com/dialogflow/docs/entities-overview>).
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SessionEntityType {
    /// Required. The unique identifier of the session entity type.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/sessions/<SessionID>/entityTypes/<EntityTypeID>`
    /// or
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>/sessions/<SessionID>/entityTypes/<EntityTypeID>`.
    /// If `Environment ID` is not specified, we assume default 'draft'
    /// environment.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. Indicates whether the additional data should override or
    /// supplement the custom entity type definition.
    #[prost(enumeration = "session_entity_type::EntityOverrideMode", tag = "3")]
    pub entity_override_mode: i32,
    /// Required. The collection of entities to override or supplement the custom
    /// entity type.
    #[prost(message, repeated, tag = "4")]
    pub entities: ::prost::alloc::vec::Vec<entity_type::Entity>,
}
/// Nested message and enum types in `SessionEntityType`.
pub mod session_entity_type {
    /// The types of modifications for the session entity type.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum EntityOverrideMode {
        /// Not specified. This value should be never used.
        Unspecified = 0,
        /// The collection of session entities overrides the collection of entities
        /// in the corresponding custom entity type.
        Override = 1,
        /// The collection of session entities extends the collection of entities in
        /// the corresponding custom entity type.
        ///
        /// Note: Even in this override mode calls to `ListSessionEntityTypes`,
        /// `GetSessionEntityType`, `CreateSessionEntityType` and
        /// `UpdateSessionEntityType` only return the additional entities added in
        /// this session entity type. If you want to get the supplemented list,
        /// please call
        /// \[EntityTypes.GetEntityType\]\[google.cloud.dialogflow.cx.v3.EntityTypes.GetEntityType\]
        /// on the custom entity type and merge.
        Supplement = 2,
    }
    impl EntityOverrideMode {
        /// 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 => "ENTITY_OVERRIDE_MODE_UNSPECIFIED",
                Self::Override => "ENTITY_OVERRIDE_MODE_OVERRIDE",
                Self::Supplement => "ENTITY_OVERRIDE_MODE_SUPPLEMENT",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ENTITY_OVERRIDE_MODE_UNSPECIFIED" => Some(Self::Unspecified),
                "ENTITY_OVERRIDE_MODE_OVERRIDE" => Some(Self::Override),
                "ENTITY_OVERRIDE_MODE_SUPPLEMENT" => Some(Self::Supplement),
                _ => None,
            }
        }
    }
}
/// The request message for
/// \[SessionEntityTypes.ListSessionEntityTypes\]\[google.cloud.dialogflow.cx.v3.SessionEntityTypes.ListSessionEntityTypes\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListSessionEntityTypesRequest {
    /// Required. The session to list all session entity types from.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/sessions/<SessionID>`
    /// or
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>/sessions/<SessionID>`.
    /// If `Environment ID` is not specified, we assume default 'draft'
    /// environment.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of items to return in a single page. By default 100 and
    /// at most 1000.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response message for
/// \[SessionEntityTypes.ListSessionEntityTypes\]\[google.cloud.dialogflow.cx.v3.SessionEntityTypes.ListSessionEntityTypes\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSessionEntityTypesResponse {
    /// The list of session entity types. There will be a maximum number of items
    /// returned based on the page_size field in the request.
    #[prost(message, repeated, tag = "1")]
    pub session_entity_types: ::prost::alloc::vec::Vec<SessionEntityType>,
    /// Token to retrieve the next page of results, or empty if there are no
    /// more results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request message for
/// \[SessionEntityTypes.GetSessionEntityType\]\[google.cloud.dialogflow.cx.v3.SessionEntityTypes.GetSessionEntityType\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetSessionEntityTypeRequest {
    /// Required. The name of the session entity type.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/sessions/<SessionID>/entityTypes/<EntityTypeID>`
    /// or
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>/sessions/<SessionID>/entityTypes/<EntityTypeID>`.
    /// If `Environment ID` is not specified, we assume default 'draft'
    /// environment.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for
/// \[SessionEntityTypes.CreateSessionEntityType\]\[google.cloud.dialogflow.cx.v3.SessionEntityTypes.CreateSessionEntityType\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateSessionEntityTypeRequest {
    /// Required. The session to create a session entity type for.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/sessions/<SessionID>`
    /// or
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>/sessions/<SessionID>`.
    /// If `Environment ID` is not specified, we assume default 'draft'
    /// environment.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The session entity type to create.
    #[prost(message, optional, tag = "2")]
    pub session_entity_type: ::core::option::Option<SessionEntityType>,
}
/// The request message for
/// \[SessionEntityTypes.UpdateSessionEntityType\]\[google.cloud.dialogflow.cx.v3.SessionEntityTypes.UpdateSessionEntityType\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateSessionEntityTypeRequest {
    /// Required. The session entity type to update.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/sessions/<SessionID>/entityTypes/<EntityTypeID>`
    /// or
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>/sessions/<SessionID>/entityTypes/<EntityTypeID>`.
    /// If `Environment ID` is not specified,
    /// we assume default 'draft' environment.
    #[prost(message, optional, tag = "1")]
    pub session_entity_type: ::core::option::Option<SessionEntityType>,
    /// The mask to control which fields get updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// The request message for
/// \[SessionEntityTypes.DeleteSessionEntityType\]\[google.cloud.dialogflow.cx.v3.SessionEntityTypes.DeleteSessionEntityType\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteSessionEntityTypeRequest {
    /// Required. The name of the session entity type to delete.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/sessions/<SessionID>/entityTypes/<EntityTypeID>`
    /// or
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>/sessions/<SessionID>/entityTypes/<EntityTypeID>`.
    /// If `Environment ID` is not specified,
    /// we assume default 'draft' environment.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod session_entity_types_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing
    /// \[SessionEntityTypes\]\[google.cloud.dialogflow.cx.v3.SessionEntityType\].
    #[derive(Debug, Clone)]
    pub struct SessionEntityTypesClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl SessionEntityTypesClient<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> SessionEntityTypesClient<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,
        ) -> SessionEntityTypesClient<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,
        {
            SessionEntityTypesClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Returns the list of all session entity types in the specified session.
        pub async fn list_session_entity_types(
            &mut self,
            request: impl tonic::IntoRequest<super::ListSessionEntityTypesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListSessionEntityTypesResponse>,
            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.dialogflow.cx.v3.SessionEntityTypes/ListSessionEntityTypes",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.SessionEntityTypes",
                        "ListSessionEntityTypes",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the specified session entity type.
        pub async fn get_session_entity_type(
            &mut self,
            request: impl tonic::IntoRequest<super::GetSessionEntityTypeRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SessionEntityType>,
            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.dialogflow.cx.v3.SessionEntityTypes/GetSessionEntityType",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.SessionEntityTypes",
                        "GetSessionEntityType",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a session entity type.
        pub async fn create_session_entity_type(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateSessionEntityTypeRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SessionEntityType>,
            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.dialogflow.cx.v3.SessionEntityTypes/CreateSessionEntityType",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.SessionEntityTypes",
                        "CreateSessionEntityType",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified session entity type.
        pub async fn update_session_entity_type(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateSessionEntityTypeRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SessionEntityType>,
            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.dialogflow.cx.v3.SessionEntityTypes/UpdateSessionEntityType",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.SessionEntityTypes",
                        "UpdateSessionEntityType",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified session entity type.
        pub async fn delete_session_entity_type(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteSessionEntityTypeRequest>,
        ) -> 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.dialogflow.cx.v3.SessionEntityTypes/DeleteSessionEntityType",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.SessionEntityTypes",
                        "DeleteSessionEntityType",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// The trace block tracks a sequence of actions taken by the agent in a flow or
/// a playbook.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TraceBlock {
    /// The actions performed by the agent and the user during this session.
    #[prost(message, repeated, tag = "3")]
    pub actions: ::prost::alloc::vec::Vec<Action>,
    /// Output only. Timestamp of the start of the trace block.
    #[prost(message, optional, tag = "4")]
    pub start_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Timestamp of the end of the trace block.
    #[prost(message, optional, tag = "5")]
    pub complete_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Optional. A list of input parameters of the trace block.
    #[prost(message, optional, tag = "9")]
    pub input_parameters: ::core::option::Option<::prost_types::Struct>,
    /// Optional. A list of output parameters of the trace block.
    #[prost(message, optional, tag = "6")]
    pub output_parameters: ::core::option::Option<::prost_types::Struct>,
    /// Optional. Output only. The end state of the trace block.
    #[prost(enumeration = "OutputState", tag = "7")]
    pub end_state: i32,
    /// Metadata of the trace.
    #[prost(oneof = "trace_block::TraceMetadata", tags = "1, 2, 8")]
    pub trace_metadata: ::core::option::Option<trace_block::TraceMetadata>,
}
/// Nested message and enum types in `TraceBlock`.
pub mod trace_block {
    /// Metadata of the trace.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum TraceMetadata {
        /// Metadata of the playbook trace.
        #[prost(message, tag = "1")]
        PlaybookTraceMetadata(super::PlaybookTraceMetadata),
        /// Metadata of the flow trace.
        #[prost(message, tag = "2")]
        FlowTraceMetadata(super::FlowTraceMetadata),
        /// Metadata of the speech-to-text and speech-to-text processing.
        #[prost(message, tag = "8")]
        SpeechProcessingMetadata(super::SpeechProcessingMetadata),
    }
}
/// Metadata of the speech-to-text and text-to-speech processing.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SpeechProcessingMetadata {
    /// Output only. The display name of the speech processing.
    #[prost(string, tag = "1")]
    pub display_name: ::prost::alloc::string::String,
}
/// Metadata of the playbook trace.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PlaybookTraceMetadata {
    /// Required. The unique identifier of the playbook.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/playbooks/<PlaybookID>`.
    #[prost(string, tag = "1")]
    pub playbook: ::prost::alloc::string::String,
    /// Output only. The display name of the playbook.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
}
/// Metadata of the flow trace.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FlowTraceMetadata {
    /// Required. The unique identifier of the flow.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>`.
    #[prost(string, tag = "1")]
    pub flow: ::prost::alloc::string::String,
    /// Output only. The display name of the flow.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
}
/// Input of the playbook.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PlaybookInput {
    /// Optional. Summary string of the preceding conversation for the child
    /// playbook invocation.
    #[prost(string, tag = "1")]
    pub preceding_conversation_summary: ::prost::alloc::string::String,
}
/// Output of the playbook.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PlaybookOutput {
    /// Optional. Summary string of the execution result of the child playbook.
    #[prost(string, tag = "1")]
    pub execution_summary: ::prost::alloc::string::String,
}
/// Action performed by end user or Dialogflow agent in the conversation.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Action {
    /// Action details.
    #[prost(oneof = "action::Action", tags = "1, 2, 3, 4, 5, 12, 13")]
    pub action: ::core::option::Option<action::Action>,
}
/// Nested message and enum types in `Action`.
pub mod action {
    /// Action details.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Action {
        /// Optional. Agent obtained a message from the customer.
        #[prost(message, tag = "1")]
        UserUtterance(super::UserUtterance),
        /// Optional. Action performed by the agent as a message.
        #[prost(message, tag = "2")]
        AgentUtterance(super::AgentUtterance),
        /// Optional. Action performed on behalf of the agent by calling a plugin
        /// tool.
        #[prost(message, tag = "3")]
        ToolUse(super::ToolUse),
        /// Optional. Action performed on behalf of the agent by invoking a child
        /// playbook.
        #[prost(message, tag = "4")]
        PlaybookInvocation(super::PlaybookInvocation),
        /// Optional. Action performed on behalf of the agent by invoking a CX flow.
        #[prost(message, tag = "5")]
        FlowInvocation(super::FlowInvocation),
        /// Optional. Action performed on behalf of the agent by transitioning to a
        /// target playbook.
        #[prost(message, tag = "12")]
        PlaybookTransition(super::PlaybookTransition),
        /// Optional. Action performed on behalf of the agent by transitioning to a
        /// target CX flow.
        #[prost(message, tag = "13")]
        FlowTransition(super::FlowTransition),
    }
}
/// UserUtterance represents one message sent by the customer.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UserUtterance {
    /// Required. Message content in text.
    #[prost(string, tag = "1")]
    pub text: ::prost::alloc::string::String,
}
/// AgentUtterance represents one message sent by the agent.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AgentUtterance {
    /// Required. Message content in text.
    #[prost(string, tag = "1")]
    pub text: ::prost::alloc::string::String,
}
/// Stores metadata of the invocation of an action supported by a tool.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ToolUse {
    /// Required. The \[tool\]\[google.cloud.dialogflow.cx.v3.Tool\] that should be
    /// used. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/tools/<ToolID>`.
    #[prost(string, tag = "1")]
    pub tool: ::prost::alloc::string::String,
    /// Output only. The display name of the tool.
    #[prost(string, tag = "8")]
    pub display_name: ::prost::alloc::string::String,
    /// Optional. Name of the action to be called during the tool use.
    #[prost(string, tag = "2")]
    pub action: ::prost::alloc::string::String,
    /// Optional. A list of input parameters for the action.
    #[prost(message, optional, tag = "5")]
    pub input_action_parameters: ::core::option::Option<::prost_types::Struct>,
    /// Optional. A list of output parameters generated by the action.
    #[prost(message, optional, tag = "6")]
    pub output_action_parameters: ::core::option::Option<::prost_types::Struct>,
}
/// Stores metadata of the invocation of a child playbook.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PlaybookInvocation {
    /// Required. The unique identifier of the playbook.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/playbooks/<PlaybookID>`.
    #[prost(string, tag = "1")]
    pub playbook: ::prost::alloc::string::String,
    /// Output only. The display name of the playbook.
    #[prost(string, tag = "5")]
    pub display_name: ::prost::alloc::string::String,
    /// Optional. Input of the child playbook invocation.
    #[prost(message, optional, tag = "2")]
    pub playbook_input: ::core::option::Option<PlaybookInput>,
    /// Optional. Output of the child playbook invocation.
    #[prost(message, optional, tag = "3")]
    pub playbook_output: ::core::option::Option<PlaybookOutput>,
    /// Required. Playbook invocation's output state.
    #[prost(enumeration = "OutputState", tag = "4")]
    pub playbook_state: i32,
}
/// Stores metadata of the invocation of a CX flow.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FlowInvocation {
    /// Required. The unique identifier of the flow.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>`.
    #[prost(string, tag = "1")]
    pub flow: ::prost::alloc::string::String,
    /// Output only. The display name of the flow.
    #[prost(string, tag = "7")]
    pub display_name: ::prost::alloc::string::String,
    /// Required. Flow invocation's output state.
    #[prost(enumeration = "OutputState", tag = "4")]
    pub flow_state: i32,
}
/// Stores metadata of the transition to another target playbook. Playbook
/// transition actions exit the caller playbook and enter the target playbook.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PlaybookTransition {
    /// Required. The unique identifier of the playbook.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/playbooks/<PlaybookID>`.
    #[prost(string, tag = "1")]
    pub playbook: ::prost::alloc::string::String,
    /// Output only. The display name of the playbook.
    #[prost(string, tag = "3")]
    pub display_name: ::prost::alloc::string::String,
}
/// Stores metadata of the transition to a target CX flow. Flow transition
/// actions exit the caller playbook and enter the child flow.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FlowTransition {
    /// Required. The unique identifier of the flow.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<Agentflows/<FlowID>`.
    #[prost(string, tag = "1")]
    pub flow: ::prost::alloc::string::String,
    /// Output only. The display name of the flow.
    #[prost(string, tag = "3")]
    pub display_name: ::prost::alloc::string::String,
}
/// Output state.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum OutputState {
    /// Unspecified output.
    Unspecified = 0,
    /// Succeeded.
    Ok = 1,
    /// Cancelled.
    Cancelled = 2,
    /// Failed.
    Failed = 3,
    /// Escalated.
    Escalated = 4,
    /// Pending.
    Pending = 5,
}
impl OutputState {
    /// 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 => "OUTPUT_STATE_UNSPECIFIED",
            Self::Ok => "OUTPUT_STATE_OK",
            Self::Cancelled => "OUTPUT_STATE_CANCELLED",
            Self::Failed => "OUTPUT_STATE_FAILED",
            Self::Escalated => "OUTPUT_STATE_ESCALATED",
            Self::Pending => "OUTPUT_STATE_PENDING",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "OUTPUT_STATE_UNSPECIFIED" => Some(Self::Unspecified),
            "OUTPUT_STATE_OK" => Some(Self::Ok),
            "OUTPUT_STATE_CANCELLED" => Some(Self::Cancelled),
            "OUTPUT_STATE_FAILED" => Some(Self::Failed),
            "OUTPUT_STATE_ESCALATED" => Some(Self::Escalated),
            "OUTPUT_STATE_PENDING" => Some(Self::Pending),
            _ => None,
        }
    }
}
/// Stores information about feedback provided by users about a response.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AnswerFeedback {
    /// Optional. Rating from user for the specific Dialogflow response.
    #[prost(enumeration = "answer_feedback::Rating", tag = "1")]
    pub rating: i32,
    /// Optional. In case of thumbs down rating provided, users can optionally
    /// provide context about the rating.
    #[prost(message, optional, tag = "2")]
    pub rating_reason: ::core::option::Option<answer_feedback::RatingReason>,
    /// Optional. Custom rating from the user about the provided answer, with
    /// maximum length of 1024 characters. For example, client could use a
    /// customized JSON object to indicate the rating.
    #[prost(string, tag = "3")]
    pub custom_rating: ::prost::alloc::string::String,
}
/// Nested message and enum types in `AnswerFeedback`.
pub mod answer_feedback {
    /// Stores extra information about why users provided thumbs down rating.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct RatingReason {
        /// Optional. Custom reason labels for thumbs down rating provided by the
        /// user. The maximum number of labels allowed is 10 and the maximum length
        /// of a single label is 128 characters.
        #[prost(string, repeated, tag = "3")]
        pub reason_labels: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        /// Optional. Additional feedback about the rating.
        /// This field can be populated without choosing a predefined `reason`.
        #[prost(string, tag = "2")]
        pub feedback: ::prost::alloc::string::String,
    }
    /// Represents thumbs up/down rating provided by user about a response.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Rating {
        /// Rating not specified.
        Unspecified = 0,
        /// Thumbs up feedback from user.
        ThumbsUp = 1,
        /// Thumbs down feedback from user.
        ThumbsDown = 2,
    }
    impl Rating {
        /// 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 => "RATING_UNSPECIFIED",
                Self::ThumbsUp => "THUMBS_UP",
                Self::ThumbsDown => "THUMBS_DOWN",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "RATING_UNSPECIFIED" => Some(Self::Unspecified),
                "THUMBS_UP" => Some(Self::ThumbsUp),
                "THUMBS_DOWN" => Some(Self::ThumbsDown),
                _ => None,
            }
        }
    }
}
/// The request to set the feedback for a bot answer.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SubmitAnswerFeedbackRequest {
    /// Required. The name of the session the feedback was sent to.
    #[prost(string, tag = "1")]
    pub session: ::prost::alloc::string::String,
    /// Required. ID of the response to update its feedback. This is the same as
    /// DetectIntentResponse.response_id.
    #[prost(string, tag = "2")]
    pub response_id: ::prost::alloc::string::String,
    /// Required. Feedback provided for a bot answer.
    #[prost(message, optional, tag = "3")]
    pub answer_feedback: ::core::option::Option<AnswerFeedback>,
    /// Optional. The mask to control which fields to update. If the mask is not
    /// present, all fields will be updated.
    #[prost(message, optional, tag = "4")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// The request to detect user's intent.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DetectIntentRequest {
    /// Required. The name of the session this query is sent to.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/sessions/<Session  ID>` or
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>/sessions/<SessionID>`.
    /// If `Environment ID` is not specified, we assume default 'draft'
    /// environment.
    /// It's up to the API caller to choose an appropriate `Session ID`. It can be
    /// a random number or some type of session identifiers (preferably hashed).
    /// The length of the `Session ID` must not exceed 36 characters.
    ///
    /// For more information, see the [sessions
    /// guide](<https://cloud.google.com/dialogflow/cx/docs/concept/session>).
    ///
    /// Note: Always use agent versions for production traffic.
    /// See [Versions and
    /// environments](<https://cloud.google.com/dialogflow/cx/docs/concept/version>).
    #[prost(string, tag = "1")]
    pub session: ::prost::alloc::string::String,
    /// The parameters of this query.
    #[prost(message, optional, tag = "2")]
    pub query_params: ::core::option::Option<QueryParameters>,
    /// Required. The input specification.
    #[prost(message, optional, tag = "3")]
    pub query_input: ::core::option::Option<QueryInput>,
    /// Instructs the speech synthesizer how to generate the output audio.
    #[prost(message, optional, tag = "4")]
    pub output_audio_config: ::core::option::Option<OutputAudioConfig>,
    /// Optional. Specifies which fields in the
    /// \[QueryResult\]\[google.cloud.dialogflow.cx.v3.QueryResult\] to return. If not
    /// set, the default is DETECT_INTENT_RESPONSE_VIEW_FULL.
    #[prost(enumeration = "DetectIntentResponseView", tag = "9")]
    pub response_view: i32,
}
/// The message returned from the DetectIntent method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DetectIntentResponse {
    /// Output only. The unique identifier of the response. It can be used to
    /// locate a response in the training example set or for reporting issues.
    #[prost(string, tag = "1")]
    pub response_id: ::prost::alloc::string::String,
    /// The result of the conversational query.
    #[prost(message, optional, tag = "2")]
    pub query_result: ::core::option::Option<QueryResult>,
    /// The audio data bytes encoded as specified in the request.
    /// Note: The output audio is generated based on the values of default platform
    /// text responses found in the
    /// \[`query_result.response_messages`\]\[google.cloud.dialogflow.cx.v3.QueryResult.response_messages\]
    /// field. If multiple default text responses exist, they will be concatenated
    /// when generating audio. If no default platform text responses exist, the
    /// generated audio content will be empty.
    ///
    /// In some scenarios, multiple output audio fields may be present in the
    /// response structure. In these cases, only the top-most-level audio output
    /// has content.
    #[prost(bytes = "vec", tag = "4")]
    pub output_audio: ::prost::alloc::vec::Vec<u8>,
    /// The config used by the speech synthesizer to generate the output audio.
    #[prost(message, optional, tag = "5")]
    pub output_audio_config: ::core::option::Option<OutputAudioConfig>,
    /// Response type.
    #[prost(enumeration = "detect_intent_response::ResponseType", tag = "6")]
    pub response_type: i32,
    /// Indicates whether the partial response can be cancelled when a later
    /// response arrives. e.g. if the agent specified some music as partial
    /// response, it can be cancelled.
    #[prost(bool, tag = "7")]
    pub allow_cancellation: bool,
}
/// Nested message and enum types in `DetectIntentResponse`.
pub mod detect_intent_response {
    /// Represents different DetectIntentResponse types.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ResponseType {
        /// Not specified. This should never happen.
        Unspecified = 0,
        /// Partial response. e.g. Aggregated responses in a Fulfillment that enables
        /// `return_partial_response` can be returned as partial response.
        /// WARNING: partial response is not eligible for barge-in.
        Partial = 1,
        /// Final response.
        Final = 2,
    }
    impl ResponseType {
        /// 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 => "RESPONSE_TYPE_UNSPECIFIED",
                Self::Partial => "PARTIAL",
                Self::Final => "FINAL",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "RESPONSE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "PARTIAL" => Some(Self::Partial),
                "FINAL" => Some(Self::Final),
                _ => None,
            }
        }
    }
}
/// The top-level message sent by the client to the
/// \[Sessions.StreamingDetectIntent\]\[google.cloud.dialogflow.cx.v3.Sessions.StreamingDetectIntent\]
/// method.
///
/// Multiple request messages should be sent in order:
///
/// 1. The first message must contain
///    \[session\]\[google.cloud.dialogflow.cx.v3.StreamingDetectIntentRequest.session\],
///    \[query_input\]\[google.cloud.dialogflow.cx.v3.StreamingDetectIntentRequest.query_input\]
///    plus optionally
///    \[query_params\]\[google.cloud.dialogflow.cx.v3.StreamingDetectIntentRequest.query_params\].
///    If the client wants to receive an audio response, it should also contain
///    \[output_audio_config\]\[google.cloud.dialogflow.cx.v3.StreamingDetectIntentRequest.output_audio_config\].
///
/// 1. If
///    \[query_input\]\[google.cloud.dialogflow.cx.v3.StreamingDetectIntentRequest.query_input\]
///    was set to
///    \[query_input.audio.config\]\[google.cloud.dialogflow.cx.v3.AudioInput.config\],
///    all subsequent messages must contain
///    \[query_input.audio.audio\]\[google.cloud.dialogflow.cx.v3.AudioInput.audio\]
///    to continue with Speech recognition. If you decide to rather detect an
///    intent from text input after you already started Speech recognition,
///    please send a message with
///    \[query_input.text\]\[google.cloud.dialogflow.cx.v3.QueryInput.text\].
///
///    However, note that:
///
///    * Dialogflow will bill you for the audio duration so far.
///    * Dialogflow discards all Speech recognition results in favor of the
///      input text.
///    * Dialogflow will use the language code from the first message.
///
/// After you sent all input, you must half-close or abort the request stream.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StreamingDetectIntentRequest {
    /// The name of the session this query is sent to.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/sessions/<SessionID>`
    /// or
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>/sessions/<SessionID>`.
    /// If `Environment ID` is not specified, we assume default 'draft'
    /// environment.
    /// It's up to the API caller to choose an appropriate `Session ID`. It can be
    /// a random number or some type of session identifiers (preferably hashed).
    /// The length of the `Session ID` must not exceed 36 characters.
    /// Note: session must be set in the first request.
    ///
    /// For more information, see the [sessions
    /// guide](<https://cloud.google.com/dialogflow/cx/docs/concept/session>).
    ///
    /// Note: Always use agent versions for production traffic.
    /// See [Versions and
    /// environments](<https://cloud.google.com/dialogflow/cx/docs/concept/version>).
    #[prost(string, tag = "1")]
    pub session: ::prost::alloc::string::String,
    /// The parameters of this query.
    #[prost(message, optional, tag = "2")]
    pub query_params: ::core::option::Option<QueryParameters>,
    /// Required. The input specification.
    #[prost(message, optional, tag = "3")]
    pub query_input: ::core::option::Option<QueryInput>,
    /// Instructs the speech synthesizer how to generate the output audio.
    #[prost(message, optional, tag = "4")]
    pub output_audio_config: ::core::option::Option<OutputAudioConfig>,
    /// Enable partial detect intent response. If this flag is not enabled,
    /// response stream still contains only one final `DetectIntentResponse` even
    /// if some `Fulfillment`s in the agent have been configured to return partial
    /// responses.
    #[prost(bool, tag = "5")]
    pub enable_partial_response: bool,
    /// If true, `StreamingDetectIntentResponse.debugging_info` will get populated.
    #[prost(bool, tag = "8")]
    pub enable_debugging_info: bool,
    /// Optional. Specifies which fields in the
    /// \[QueryResult\]\[google.cloud.dialogflow.cx.v3.QueryResult\] to return. If not
    /// set, the default is DETECT_INTENT_RESPONSE_VIEW_FULL.
    #[prost(enumeration = "DetectIntentResponseView", tag = "16")]
    pub response_view: i32,
}
/// Cloud conversation info for easier debugging.
/// It will get populated in `StreamingDetectIntentResponse` or
/// `StreamingAnalyzeContentResponse` when the flag `enable_debugging_info` is
/// set to true in corresponding requests.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CloudConversationDebuggingInfo {
    /// Number of input audio data chunks in streaming requests.
    #[prost(int32, tag = "1")]
    pub audio_data_chunks: i32,
    /// Time offset of the end of speech utterance relative to the
    /// beginning of the first audio chunk.
    #[prost(message, optional, tag = "2")]
    pub result_end_time_offset: ::core::option::Option<::prost_types::Duration>,
    /// Duration of first audio chunk.
    #[prost(message, optional, tag = "3")]
    pub first_audio_duration: ::core::option::Option<::prost_types::Duration>,
    /// Whether client used single utterance mode.
    #[prost(bool, tag = "5")]
    pub single_utterance: bool,
    /// Time offsets of the speech partial results relative to the beginning of
    /// the stream.
    #[prost(message, repeated, tag = "6")]
    pub speech_partial_results_end_times: ::prost::alloc::vec::Vec<
        ::prost_types::Duration,
    >,
    /// Time offsets of the speech final results (is_final=true) relative to the
    /// beginning of the stream.
    #[prost(message, repeated, tag = "7")]
    pub speech_final_results_end_times: ::prost::alloc::vec::Vec<
        ::prost_types::Duration,
    >,
    /// Total number of partial responses.
    #[prost(int32, tag = "8")]
    pub partial_responses: i32,
    /// Time offset of Speaker ID stream close time relative to the Speech stream
    /// close time in milliseconds. Only meaningful for conversations involving
    /// passive verification.
    #[prost(int32, tag = "9")]
    pub speaker_id_passive_latency_ms_offset: i32,
    /// Whether a barge-in event is triggered in this request.
    #[prost(bool, tag = "10")]
    pub bargein_event_triggered: bool,
    /// Whether speech uses single utterance mode.
    #[prost(bool, tag = "11")]
    pub speech_single_utterance: bool,
    /// Time offsets of the DTMF partial results relative to the beginning of
    /// the stream.
    #[prost(message, repeated, tag = "12")]
    pub dtmf_partial_results_times: ::prost::alloc::vec::Vec<::prost_types::Duration>,
    /// Time offsets of the DTMF final results relative to the beginning of
    /// the stream.
    #[prost(message, repeated, tag = "13")]
    pub dtmf_final_results_times: ::prost::alloc::vec::Vec<::prost_types::Duration>,
    /// Time offset of the end-of-single-utterance signal relative to the
    /// beginning of the stream.
    #[prost(message, optional, tag = "14")]
    pub single_utterance_end_time_offset: ::core::option::Option<
        ::prost_types::Duration,
    >,
    /// No speech timeout settings for the stream.
    #[prost(message, optional, tag = "15")]
    pub no_speech_timeout: ::core::option::Option<::prost_types::Duration>,
    /// Speech endpointing timeout settings for the stream.
    #[prost(message, optional, tag = "19")]
    pub endpointing_timeout: ::core::option::Option<::prost_types::Duration>,
    /// Whether the streaming terminates with an injected text query.
    #[prost(bool, tag = "16")]
    pub is_input_text: bool,
    /// Client half close time in terms of input audio duration.
    #[prost(message, optional, tag = "17")]
    pub client_half_close_time_offset: ::core::option::Option<::prost_types::Duration>,
    /// Client half close time in terms of API streaming duration.
    #[prost(message, optional, tag = "18")]
    pub client_half_close_streaming_time_offset: ::core::option::Option<
        ::prost_types::Duration,
    >,
}
/// The top-level message returned from the
/// \[StreamingDetectIntent\]\[google.cloud.dialogflow.cx.v3.Sessions.StreamingDetectIntent\]
/// method.
///
/// Multiple response messages can be returned in order:
///
/// * If the `StreamingDetectIntentRequest.query_input.audio` field was
///   set, the first M messages contain `recognition_result`.
///   Each `recognition_result` represents a more complete transcript of what
///   the user said. The last `recognition_result` has `is_final` set to
///   `true`.
///
/// * If the `StreamingDetectIntentRequest.enable_partial_response` field was
///   true, the `detect_intent_response` field is populated for each
///   of the following N responses, where 0 \<= N \<= 5.
///   These responses set the
///   \[DetectIntentResponse.response_type\]\[google.cloud.dialogflow.cx.v3.DetectIntentResponse.response_type\]
///   field to `PARTIAL`.
///
/// For the last response message, the `detect_intent_response` is fully
/// populated, and
/// \[DetectIntentResponse.response_type\]\[google.cloud.dialogflow.cx.v3.DetectIntentResponse.response_type\]
/// is set to `FINAL`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StreamingDetectIntentResponse {
    /// Debugging info that would get populated when
    /// `StreamingDetectIntentRequest.enable_debugging_info` is set to true.
    #[prost(message, optional, tag = "4")]
    pub debugging_info: ::core::option::Option<CloudConversationDebuggingInfo>,
    /// The output response.
    #[prost(oneof = "streaming_detect_intent_response::Response", tags = "1, 2")]
    pub response: ::core::option::Option<streaming_detect_intent_response::Response>,
}
/// Nested message and enum types in `StreamingDetectIntentResponse`.
pub mod streaming_detect_intent_response {
    /// The output response.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Response {
        /// The result of speech recognition.
        #[prost(message, tag = "1")]
        RecognitionResult(super::StreamingRecognitionResult),
        /// The response from detect intent.
        #[prost(message, tag = "2")]
        DetectIntentResponse(super::DetectIntentResponse),
    }
}
/// Contains a speech recognition result corresponding to a portion of the audio
/// that is currently being processed or an indication that this is the end
/// of the single requested utterance.
///
/// While end-user audio is being processed, Dialogflow sends a series of
/// results. Each result may contain a `transcript` value. A transcript
/// represents a portion of the utterance. While the recognizer is processing
/// audio, transcript values may be interim values or finalized values.
/// Once a transcript is finalized, the `is_final` value is set to true and
/// processing continues for the next transcript.
///
/// If `StreamingDetectIntentRequest.query_input.audio.config.single_utterance`
/// was true, and the recognizer has completed processing audio,
/// the `message_type` value is set to \`END_OF_SINGLE_UTTERANCE and the
/// following (last) result contains the last finalized transcript.
///
/// The complete end-user utterance is determined by concatenating the
/// finalized transcript values received for the series of results.
///
/// In the following example, single utterance is enabled. In the case where
/// single utterance is not enabled, result 7 would not occur.
///
/// ```text,
/// Num | transcript              | message_type            | is_final
/// --- | ----------------------- | ----------------------- | --------
/// 1   | "tube"                  | TRANSCRIPT              | false
/// 2   | "to be a"               | TRANSCRIPT              | false
/// 3   | "to be"                 | TRANSCRIPT              | false
/// 4   | "to be or not to be"    | TRANSCRIPT              | true
/// 5   | "that's"                | TRANSCRIPT              | false
/// 6   | "that is                | TRANSCRIPT              | false
/// 7   | unset                   | END_OF_SINGLE_UTTERANCE | unset
/// 8   | " that is the question" | TRANSCRIPT              | true
/// ```
///
/// Concatenating the finalized transcripts with `is_final` set to true,
/// the complete utterance becomes "to be or not to be that is the question".
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StreamingRecognitionResult {
    /// Type of the result message.
    #[prost(enumeration = "streaming_recognition_result::MessageType", tag = "1")]
    pub message_type: i32,
    /// Transcript text representing the words that the user spoke.
    /// Populated if and only if `message_type` = `TRANSCRIPT`.
    #[prost(string, tag = "2")]
    pub transcript: ::prost::alloc::string::String,
    /// If `false`, the `StreamingRecognitionResult` represents an
    /// interim result that may change. If `true`, the recognizer will not return
    /// any further hypotheses about this piece of the audio. May only be populated
    /// for `message_type` = `TRANSCRIPT`.
    #[prost(bool, tag = "3")]
    pub is_final: bool,
    /// The Speech confidence between 0.0 and 1.0 for the current portion of audio.
    /// A higher number indicates an estimated greater likelihood that the
    /// recognized words are correct. The default of 0.0 is a sentinel value
    /// indicating that confidence was not set.
    ///
    /// This field is typically only provided if `is_final` is true and you should
    /// not rely on it being accurate or even set.
    #[prost(float, tag = "4")]
    pub confidence: f32,
    /// An estimate of the likelihood that the speech recognizer will
    /// not change its guess about this interim recognition result:
    ///
    /// * If the value is unspecified or 0.0, Dialogflow didn't compute the
    ///   stability. In particular, Dialogflow will only provide stability for
    ///   `TRANSCRIPT` results with `is_final = false`.
    /// * Otherwise, the value is in (0.0, 1.0\] where 0.0 means completely
    ///   unstable and 1.0 means completely stable.
    #[prost(float, tag = "6")]
    pub stability: f32,
    /// Word-specific information for the words recognized by Speech in
    /// \[transcript\]\[google.cloud.dialogflow.cx.v3.StreamingRecognitionResult.transcript\].
    /// Populated if and only if `message_type` = `TRANSCRIPT` and
    /// \[InputAudioConfig.enable_word_info\] is set.
    #[prost(message, repeated, tag = "7")]
    pub speech_word_info: ::prost::alloc::vec::Vec<SpeechWordInfo>,
    /// Time offset of the end of this Speech recognition result relative to the
    /// beginning of the audio. Only populated for `message_type` =
    /// `TRANSCRIPT`.
    #[prost(message, optional, tag = "8")]
    pub speech_end_offset: ::core::option::Option<::prost_types::Duration>,
    /// Detected language code for the transcript.
    #[prost(string, tag = "10")]
    pub language_code: ::prost::alloc::string::String,
}
/// Nested message and enum types in `StreamingRecognitionResult`.
pub mod streaming_recognition_result {
    /// Type of the response message.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum MessageType {
        /// Not specified. Should never be used.
        Unspecified = 0,
        /// Message contains a (possibly partial) transcript.
        Transcript = 1,
        /// This event indicates that the server has detected the end of the user's
        /// speech utterance and expects no additional speech. Therefore, the server
        /// will not process additional audio (although it may subsequently return
        /// additional results). The client should stop sending additional audio
        /// data, half-close the gRPC connection, and wait for any additional results
        /// until the server closes the gRPC connection. This message is only sent if
        /// \[`single_utterance`\]\[google.cloud.dialogflow.cx.v3.InputAudioConfig.single_utterance\]
        /// was set to `true`, and is not used otherwise.
        EndOfSingleUtterance = 2,
    }
    impl MessageType {
        /// 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 => "MESSAGE_TYPE_UNSPECIFIED",
                Self::Transcript => "TRANSCRIPT",
                Self::EndOfSingleUtterance => "END_OF_SINGLE_UTTERANCE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "MESSAGE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "TRANSCRIPT" => Some(Self::Transcript),
                "END_OF_SINGLE_UTTERANCE" => Some(Self::EndOfSingleUtterance),
                _ => None,
            }
        }
    }
}
/// Represents the parameters of a conversational query.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryParameters {
    /// The time zone of this conversational query from the [time zone
    /// database](<https://www.iana.org/time-zones>), e.g., America/New_York,
    /// Europe/Paris. If not provided, the time zone specified in the agent is
    /// used.
    #[prost(string, tag = "1")]
    pub time_zone: ::prost::alloc::string::String,
    /// The geo location of this conversational query.
    #[prost(message, optional, tag = "2")]
    pub geo_location: ::core::option::Option<super::super::super::super::r#type::LatLng>,
    /// Additional session entity types to replace or extend developer entity types
    /// with. The entity synonyms apply to all languages and persist for the
    /// session of this query.
    #[prost(message, repeated, tag = "3")]
    pub session_entity_types: ::prost::alloc::vec::Vec<SessionEntityType>,
    /// This field can be used to pass custom data into the webhook associated with
    /// the agent. Arbitrary JSON objects are supported.
    /// Some integrations that query a Dialogflow agent may provide additional
    /// information in the payload.
    /// In particular, for the Dialogflow Phone Gateway integration, this field has
    /// the form:
    ///
    /// ```text,
    /// {
    /// "telephony": {
    ///    "caller_id": "+18558363987"
    /// }
    /// }
    /// ```
    #[prost(message, optional, tag = "4")]
    pub payload: ::core::option::Option<::prost_types::Struct>,
    /// Additional parameters to be put into \[session
    /// parameters\]\[SessionInfo.parameters\]. To remove a
    /// parameter from the session, clients should explicitly set the parameter
    /// value to null.
    ///
    /// You can reference the session parameters in the agent with the following
    /// format: $session.params.parameter-id.
    ///
    /// Depending on your protocol or client library language, this is a
    /// map, associative array, symbol table, dictionary, or JSON object
    /// composed of a collection of (MapKey, MapValue) pairs:
    ///
    /// * MapKey type: string
    /// * MapKey value: parameter name
    /// * MapValue type: If parameter's entity type is a composite entity then use
    ///   map, otherwise, depending on the parameter value type, it could be one of
    ///   string, number, boolean, null, list or map.
    /// * MapValue value: If parameter's entity type is a composite entity then use
    ///   map from composite entity property names to property values, otherwise,
    ///   use parameter value.
    #[prost(message, optional, tag = "5")]
    pub parameters: ::core::option::Option<::prost_types::Struct>,
    /// Scope for the parameters. If not specified, parameters will be treated as
    /// session parameters. Parameters with custom scope will not be put into
    /// \[session parameters\]\[google.cloud.dialogflow.cx.v3.SessionInfo.parameters\].
    ///
    /// You can reference the parameters with custom scope in the agent with the
    /// following format: $parameter-scope.params.parameter-id.
    #[prost(string, tag = "12")]
    pub parameter_scope: ::prost::alloc::string::String,
    /// The unique identifier of the \[page\]\[google.cloud.dialogflow.cx.v3.Page\] to
    /// override the \[current page\]\[QueryResult.current_page\] in the session.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/pages/<PageID>`.
    ///
    /// If `current_page` is specified, the previous state of the session will be
    /// ignored by Dialogflow, including the \[previous
    /// page\]\[QueryResult.current_page\] and the \[previous session
    /// parameters\]\[QueryResult.parameters\].
    /// In most cases,
    /// \[current_page\]\[google.cloud.dialogflow.cx.v3.QueryParameters.current_page\]
    /// and \[parameters\]\[google.cloud.dialogflow.cx.v3.QueryParameters.parameters\]
    /// should be configured together to direct a session to a specific state.
    #[prost(string, tag = "6")]
    pub current_page: ::prost::alloc::string::String,
    /// Whether to disable webhook calls for this request.
    #[prost(bool, tag = "7")]
    pub disable_webhook: bool,
    /// Configures whether sentiment analysis should be performed. If not
    /// provided, sentiment analysis is not performed.
    #[prost(bool, tag = "8")]
    pub analyze_query_text_sentiment: bool,
    /// This field can be used to pass HTTP headers for a webhook
    /// call. These headers will be sent to webhook along with the headers that
    /// have been configured through Dialogflow web console. The headers defined
    /// within this field will overwrite the headers configured through Dialogflow
    /// console if there is a conflict. Header names are case-insensitive.
    /// Google's specified headers are not allowed. Including: "Host",
    /// "Content-Length", "Connection", "From", "User-Agent", "Accept-Encoding",
    /// "If-Modified-Since", "If-None-Match", "X-Forwarded-For", etc.
    #[prost(map = "string, string", tag = "10")]
    pub webhook_headers: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// A list of flow versions to override for the request.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/versions/<VersionID>`.
    ///
    /// If version 1 of flow X is included in this list, the traffic of
    /// flow X will go through version 1 regardless of the version configuration in
    /// the environment. Each flow can have at most one version specified in this
    /// list.
    #[prost(string, repeated, tag = "14")]
    pub flow_versions: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. The unique identifier of the
    /// \[playbook\]\[google.cloud.dialogflow.cx.v3.Playbook\] to start or continue the
    /// session with. If `current_playbook` is specified, the previous state of the
    /// session will be ignored by Dialogflow.
    ///
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/playbooks/<PlaybookID>`.
    #[prost(string, tag = "19")]
    pub current_playbook: ::prost::alloc::string::String,
    /// Optional. Use the specified LLM model settings for processing the request.
    #[prost(message, optional, tag = "21")]
    pub llm_model_settings: ::core::option::Option<LlmModelSettings>,
    /// The channel which this query is for.
    ///
    /// If specified, only the
    /// \[ResponseMessage\]\[google.cloud.dialogflow.cx.v3.ResponseMessage\] associated
    /// with the channel will be returned. If no
    /// \[ResponseMessage\]\[google.cloud.dialogflow.cx.v3.ResponseMessage\] is
    /// associated with the channel, it falls back to the
    /// \[ResponseMessage\]\[google.cloud.dialogflow.cx.v3.ResponseMessage\] with
    /// unspecified channel.
    ///
    /// If unspecified, the
    /// \[ResponseMessage\]\[google.cloud.dialogflow.cx.v3.ResponseMessage\] with
    /// unspecified channel will be returned.
    #[prost(string, tag = "15")]
    pub channel: ::prost::alloc::string::String,
    /// Optional. Configure lifetime of the Dialogflow session.
    /// By default, a Dialogflow session remains active and its data is stored for
    /// 30 minutes after the last request is sent for the session.
    /// This value should be no longer than 1 day.
    #[prost(message, optional, tag = "16")]
    pub session_ttl: ::core::option::Option<::prost_types::Duration>,
    /// Optional. Information about the end-user to improve the relevance and
    /// accuracy of generative answers.
    ///
    /// This will be interpreted and used by a language model, so, for good
    /// results, the data should be self-descriptive, and in a simple structure.
    ///
    /// Example:
    ///
    /// ```text,json
    /// {
    ///   "subscription plan": "Business Premium Plus",
    ///   "devices owned": [
    ///     {"model": "Google Pixel 7"},
    ///     {"model": "Google Pixel Tablet"}
    ///   ]
    /// }
    /// ```
    #[prost(message, optional, tag = "18")]
    pub end_user_metadata: ::core::option::Option<::prost_types::Struct>,
    /// Optional. Search configuration for UCS search queries.
    #[prost(message, optional, tag = "20")]
    pub search_config: ::core::option::Option<SearchConfig>,
    /// Optional. If set to true and data stores are involved in serving the
    /// request then
    /// DetectIntentResponse.query_result.data_store_connection_signals
    /// will be filled with data that can help evaluations.
    #[deprecated]
    #[prost(bool, tag = "25")]
    pub populate_data_store_connection_signals: bool,
}
/// Search configuration for UCS search queries.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchConfig {
    /// Optional. Boosting configuration for the datastores.
    ///
    /// Maps from datastore name to their boost configuration. Do not specify more
    /// than one BoostSpecs for each datastore name. If multiple BoostSpecs are
    /// provided for the same datastore name, the behavior is undefined.
    #[prost(message, repeated, tag = "1")]
    pub boost_specs: ::prost::alloc::vec::Vec<BoostSpecs>,
    /// Optional. Filter configuration for the datastores.
    ///
    /// Maps from datastore name to the filter expression for that datastore. Do
    /// not specify more than one FilterSpecs for each datastore name. If multiple
    /// FilterSpecs are provided for the same datastore name, the behavior is
    /// undefined.
    #[prost(message, repeated, tag = "2")]
    pub filter_specs: ::prost::alloc::vec::Vec<FilterSpecs>,
}
/// Boost specification to boost certain documents.
/// A copy of google.cloud.discoveryengine.v1main.BoostSpec, field documentation
/// is available at
/// <https://cloud.google.com/generative-ai-app-builder/docs/reference/rest/v1alpha/BoostSpec>
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BoostSpec {
    /// Optional. Condition boost specifications. If a document matches multiple
    /// conditions in the specifications, boost scores from these specifications
    /// are all applied and combined in a non-linear way. Maximum number of
    /// specifications is 20.
    #[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 applies to documents which match a condition.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ConditionBoostSpec {
        /// Optional. An expression which specifies a boost condition. The syntax and
        /// supported fields are the same as a filter expression.
        /// Examples:
        ///
        /// * To boost documents with document ID "doc_1" or "doc_2", and
        ///   color
        ///   "Red" or "Blue":
        ///   * (id: ANY("doc_1", "doc_2")) AND (color: ANY("Red","Blue"))
        #[prost(string, tag = "1")]
        pub condition: ::prost::alloc::string::String,
        /// Optional. Strength of the condition boost, which should be in \[-1, 1\].
        /// Negative boost means demotion. Default is 0.0.
        ///
        /// Setting to 1.0 gives the document a big promotion. However, it does not
        /// necessarily mean that the boosted document will be the top result at
        /// all times, nor that other documents will be excluded. Results could
        /// still be shown even when none of them matches the condition. And
        /// results that are significantly more relevant to the search query can
        /// still trump your heavily favored but irrelevant documents.
        ///
        /// Setting to -1.0 gives the document a big demotion. However, results
        /// that are deeply relevant might still be shown. The document will have
        /// an upstream battle to get a fairly high ranking, but it is not blocked
        /// out completely.
        ///
        /// 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,
                    }
                }
            }
        }
    }
}
/// Boost specifications for data stores.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BoostSpecs {
    /// Optional. Data Stores where the boosting configuration is applied. The full
    /// names of the referenced data stores. Formats:
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}`
    /// `projects/{project}/locations/{location}/dataStores/{data_store}`
    #[prost(string, repeated, tag = "1")]
    pub data_stores: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. A list of boosting specifications.
    #[prost(message, repeated, tag = "2")]
    pub spec: ::prost::alloc::vec::Vec<BoostSpec>,
}
/// Filter specifications for data stores.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FilterSpecs {
    /// Optional. Data Stores where the boosting configuration is applied. The full
    /// names of the referenced data stores. Formats:
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}`
    /// `projects/{project}/locations/{location}/dataStores/{data_store}`
    #[prost(string, repeated, tag = "1")]
    pub data_stores: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. The filter expression to be applied.
    /// Expression syntax is documented at
    /// <https://cloud.google.com/generative-ai-app-builder/docs/filter-search-metadata#filter-expression-syntax>
    #[prost(string, tag = "2")]
    pub filter: ::prost::alloc::string::String,
}
/// Represents the query input. It can contain one of:
///
/// 1. A conversational query in the form of text.
///
/// 1. An intent query that specifies which intent to trigger.
///
/// 1. Natural language speech audio to be processed.
///
/// 1. An event to be triggered.
///
/// 1. DTMF digits to invoke an intent and fill in parameter value.
///
/// 1. The results of a tool executed by the client.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryInput {
    /// Required. The language of the input. See [Language
    /// Support](<https://cloud.google.com/dialogflow/cx/docs/reference/language>)
    /// for a list of the currently supported language codes. Note that queries in
    /// the same session do not necessarily need to specify the same language.
    #[prost(string, tag = "4")]
    pub language_code: ::prost::alloc::string::String,
    /// Required. The input specification.
    #[prost(oneof = "query_input::Input", tags = "2, 3, 5, 6, 7, 11")]
    pub input: ::core::option::Option<query_input::Input>,
}
/// Nested message and enum types in `QueryInput`.
pub mod query_input {
    /// Required. The input specification.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Input {
        /// The natural language text to be processed.
        #[prost(message, tag = "2")]
        Text(super::TextInput),
        /// The intent to be triggered.
        #[prost(message, tag = "3")]
        Intent(super::IntentInput),
        /// The natural language speech audio to be processed.
        #[prost(message, tag = "5")]
        Audio(super::AudioInput),
        /// The event to be triggered.
        #[prost(message, tag = "6")]
        Event(super::EventInput),
        /// The DTMF event to be handled.
        #[prost(message, tag = "7")]
        Dtmf(super::DtmfInput),
        /// The results of a tool executed by the client.
        #[prost(message, tag = "11")]
        ToolCallResult(super::ToolCallResult),
    }
}
/// Represents the result of a conversational query.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryResult {
    /// The language that was triggered during intent detection.
    /// See [Language
    /// Support](<https://cloud.google.com/dialogflow/cx/docs/reference/language>)
    /// for a list of the currently supported language codes.
    #[prost(string, tag = "2")]
    pub language_code: ::prost::alloc::string::String,
    /// The collected \[session
    /// parameters\]\[google.cloud.dialogflow.cx.v3.SessionInfo.parameters\].
    ///
    /// Depending on your protocol or client library language, this is a
    /// map, associative array, symbol table, dictionary, or JSON object
    /// composed of a collection of (MapKey, MapValue) pairs:
    ///
    /// * MapKey type: string
    /// * MapKey value: parameter name
    /// * MapValue type: If parameter's entity type is a composite entity then use
    ///   map, otherwise, depending on the parameter value type, it could be one of
    ///   string, number, boolean, null, list or map.
    /// * MapValue value: If parameter's entity type is a composite entity then use
    ///   map from composite entity property names to property values, otherwise,
    ///   use parameter value.
    #[prost(message, optional, tag = "3")]
    pub parameters: ::core::option::Option<::prost_types::Struct>,
    /// The list of rich messages returned to the client. Responses vary from
    /// simple text messages to more sophisticated, structured payloads used
    /// to drive complex logic.
    #[prost(message, repeated, tag = "4")]
    pub response_messages: ::prost::alloc::vec::Vec<ResponseMessage>,
    /// The list of webhook call status in the order of call sequence.
    #[prost(message, repeated, tag = "13")]
    pub webhook_statuses: ::prost::alloc::vec::Vec<
        super::super::super::super::rpc::Status,
    >,
    /// The list of webhook payload in
    /// \[WebhookResponse.payload\]\[google.cloud.dialogflow.cx.v3.WebhookResponse.payload\],
    /// in the order of call sequence. If some webhook call fails or doesn't return
    /// any payload, an empty `Struct` would be used instead.
    #[prost(message, repeated, tag = "6")]
    pub webhook_payloads: ::prost::alloc::vec::Vec<::prost_types::Struct>,
    /// The current \[Page\]\[google.cloud.dialogflow.cx.v3.Page\]. Some, not all
    /// fields are filled in this message, including but not limited to `name` and
    /// `display_name`.
    #[prost(message, optional, tag = "7")]
    pub current_page: ::core::option::Option<Page>,
    /// The current \[Flow\]\[google.cloud.dialogflow.cx.v3.Flow\]. Some, not all
    /// fields are filled in this message, including but not limited to `name` and
    /// `display_name`.
    #[prost(message, optional, tag = "31")]
    pub current_flow: ::core::option::Option<Flow>,
    /// The \[Intent\]\[google.cloud.dialogflow.cx.v3.Intent\] that matched the
    /// conversational query. Some, not all fields are filled in this message,
    /// including but not limited to: `name` and `display_name`. This field is
    /// deprecated, please use
    /// \[QueryResult.match\]\[google.cloud.dialogflow.cx.v3.QueryResult.match\]
    /// instead.
    #[deprecated]
    #[prost(message, optional, tag = "8")]
    pub intent: ::core::option::Option<Intent>,
    /// The intent detection confidence. Values range from 0.0 (completely
    /// uncertain) to 1.0 (completely certain).
    /// This value is for informational purpose only and is only used to
    /// help match the best intent within the classification threshold.
    /// This value may change for the same end-user expression at any time due to a
    /// model retraining or change in implementation.
    /// This field is deprecated, please use
    /// \[QueryResult.match\]\[google.cloud.dialogflow.cx.v3.QueryResult.match\]
    /// instead.
    #[deprecated]
    #[prost(float, tag = "9")]
    pub intent_detection_confidence: f32,
    /// Intent match result, could be an intent or an event.
    #[prost(message, optional, tag = "15")]
    pub r#match: ::core::option::Option<Match>,
    /// The free-form diagnostic info. For example, this field could contain
    /// webhook call latency. The fields of this data can change without notice,
    /// so you should not write code that depends on its structure.
    ///
    /// One of the fields is called "Alternative Matched Intents", which may
    /// aid with debugging. The following describes these intent results:
    ///
    /// * The list is empty if no intent was matched to end-user input.
    /// * Only intents that are referenced in the currently active flow are
    ///   included.
    /// * The matched intent is included.
    /// * Other intents that could have matched end-user input, but did not match
    ///   because they are referenced by intent routes that are out of
    ///   [scope](<https://cloud.google.com/dialogflow/cx/docs/concept/handler#scope>),
    ///   are included.
    /// * Other intents referenced by intent routes in scope that matched end-user
    ///   input, but had a lower confidence score.
    #[prost(message, optional, tag = "10")]
    pub diagnostic_info: ::core::option::Option<::prost_types::Struct>,
    /// The sentiment analyss result, which depends on
    /// \[`analyze_query_text_sentiment`\]
    /// \[google.cloud.dialogflow.cx.v3.QueryParameters.analyze_query_text_sentiment\],
    /// specified in the request.
    #[prost(message, optional, tag = "17")]
    pub sentiment_analysis_result: ::core::option::Option<SentimentAnalysisResult>,
    /// Returns the current advanced settings including IVR settings. Even though
    /// the operations configured by these settings are performed by Dialogflow,
    /// the client may need to perform special logic at the moment. For example, if
    /// Dialogflow exports audio to Google Cloud Storage, then the client may need
    /// to wait for the resulting object to appear in the bucket before proceeding.
    #[prost(message, optional, tag = "21")]
    pub advanced_settings: ::core::option::Option<AdvancedSettings>,
    /// Indicates whether the Thumbs up/Thumbs down rating controls are need to be
    /// shown for the response in the Dialogflow Messenger widget.
    #[prost(bool, tag = "32")]
    pub allow_answer_feedback: bool,
    /// Optional. Data store connection feature output signals.
    /// Filled only when data stores are involved in serving the query.
    #[prost(message, optional, tag = "35")]
    pub data_store_connection_signals: ::core::option::Option<
        DataStoreConnectionSignals,
    >,
    /// Optional. Contains the sequence of trace blocks from the current
    /// conversation turn. Trace blocks are ordered chronologically and contain
    /// detailed traces of runtime behavior such as tool calls, LLM calls, flow and
    /// playbook invocations, agent utterances and user utterances.
    #[prost(message, repeated, tag = "37")]
    pub trace_blocks: ::prost::alloc::vec::Vec<TraceBlock>,
    /// The original conversational query.
    #[prost(oneof = "query_result::Query", tags = "1, 11, 12, 14, 23")]
    pub query: ::core::option::Option<query_result::Query>,
}
/// Nested message and enum types in `QueryResult`.
pub mod query_result {
    /// The original conversational query.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Query {
        /// If \[natural language text\]\[google.cloud.dialogflow.cx.v3.TextInput\] was
        /// provided as input, this field will contain a copy of the text.
        #[prost(string, tag = "1")]
        Text(::prost::alloc::string::String),
        /// If an \[intent\]\[google.cloud.dialogflow.cx.v3.IntentInput\] was provided as
        /// input, this field will contain a copy of the intent identifier. Format:
        /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/intents/<IntentID>`.
        #[prost(string, tag = "11")]
        TriggerIntent(::prost::alloc::string::String),
        /// If \[natural language speech
        /// audio\]\[google.cloud.dialogflow.cx.v3.AudioInput\] was provided as input,
        /// this field will contain the transcript for the audio.
        #[prost(string, tag = "12")]
        Transcript(::prost::alloc::string::String),
        /// If an \[event\]\[google.cloud.dialogflow.cx.v3.EventInput\] was provided as
        /// input, this field will contain the name of the event.
        #[prost(string, tag = "14")]
        TriggerEvent(::prost::alloc::string::String),
        /// If a \[DTMF\]\[google.cloud.dialogflow.cx.v3.DtmfInput\] was provided as
        /// input, this field will contain a copy of the
        /// \[DtmfInput\]\[google.cloud.dialogflow.cx.v3.DtmfInput\].
        #[prost(message, tag = "23")]
        Dtmf(super::DtmfInput),
    }
}
/// Represents the natural language text to be processed.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TextInput {
    /// Required. The UTF-8 encoded natural language text to be processed.
    #[prost(string, tag = "1")]
    pub text: ::prost::alloc::string::String,
}
/// Represents the intent to trigger programmatically rather than as a result of
/// natural language processing.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct IntentInput {
    /// Required. The unique identifier of the intent.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/intents/<IntentID>`.
    #[prost(string, tag = "1")]
    pub intent: ::prost::alloc::string::String,
}
/// Represents the natural speech audio to be processed.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AudioInput {
    /// Required. Instructs the speech recognizer how to process the speech audio.
    #[prost(message, optional, tag = "1")]
    pub config: ::core::option::Option<InputAudioConfig>,
    /// The natural language speech audio to be processed.
    /// A single request can contain up to 2 minutes of speech audio data.
    /// The \[transcribed
    /// text\]\[google.cloud.dialogflow.cx.v3.QueryResult.transcript\] cannot contain
    /// more than 256 bytes.
    ///
    /// For non-streaming audio detect intent, both `config` and `audio` must be
    /// provided.
    /// For streaming audio detect intent, `config` must be provided in
    /// the first request and `audio` must be provided in all following requests.
    #[prost(bytes = "vec", tag = "2")]
    pub audio: ::prost::alloc::vec::Vec<u8>,
}
/// Represents the event to trigger.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct EventInput {
    /// Name of the event.
    #[prost(string, tag = "1")]
    pub event: ::prost::alloc::string::String,
}
/// Represents the input for dtmf event.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DtmfInput {
    /// The dtmf digits.
    #[prost(string, tag = "1")]
    pub digits: ::prost::alloc::string::String,
    /// The finish digit (if any).
    #[prost(string, tag = "2")]
    pub finish_digit: ::prost::alloc::string::String,
}
/// Represents one match result of \[MatchIntent\]\[\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Match {
    /// The \[Intent\]\[google.cloud.dialogflow.cx.v3.Intent\] that matched the query.
    /// Some, not all fields are filled in this message, including but not limited
    /// to: `name` and `display_name`. Only filled for
    /// \[`INTENT`\]\[google.cloud.dialogflow.cx.v3.Match.MatchType\] match type.
    #[prost(message, optional, tag = "1")]
    pub intent: ::core::option::Option<Intent>,
    /// The event that matched the query. Filled for
    /// \[`EVENT`\]\[google.cloud.dialogflow.cx.v3.Match.MatchType\],
    /// \[`NO_MATCH`\]\[google.cloud.dialogflow.cx.v3.Match.MatchType\] and
    /// \[`NO_INPUT`\]\[google.cloud.dialogflow.cx.v3.Match.MatchType\] match types.
    #[prost(string, tag = "6")]
    pub event: ::prost::alloc::string::String,
    /// The collection of parameters extracted from the query.
    ///
    /// Depending on your protocol or client library language, this is a
    /// map, associative array, symbol table, dictionary, or JSON object
    /// composed of a collection of (MapKey, MapValue) pairs:
    ///
    /// * MapKey type: string
    /// * MapKey value: parameter name
    /// * MapValue type: If parameter's entity type is a composite entity then use
    ///   map, otherwise, depending on the parameter value type, it could be one of
    ///   string, number, boolean, null, list or map.
    /// * MapValue value: If parameter's entity type is a composite entity then use
    ///   map from composite entity property names to property values, otherwise,
    ///   use parameter value.
    #[prost(message, optional, tag = "2")]
    pub parameters: ::core::option::Option<::prost_types::Struct>,
    /// Final text input which was matched during MatchIntent. This value can be
    /// different from original input sent in request because of spelling
    /// correction or other processing.
    #[prost(string, tag = "3")]
    pub resolved_input: ::prost::alloc::string::String,
    /// Type of this \[Match\]\[google.cloud.dialogflow.cx.v3.Match\].
    #[prost(enumeration = "r#match::MatchType", tag = "4")]
    pub match_type: i32,
    /// The confidence of this match. Values range from 0.0 (completely uncertain)
    /// to 1.0 (completely certain).
    /// This value is for informational purpose only and is only used to help match
    /// the best intent within the classification threshold. This value may change
    /// for the same end-user expression at any time due to a model retraining or
    /// change in implementation.
    #[prost(float, tag = "5")]
    pub confidence: f32,
}
/// Nested message and enum types in `Match`.
pub mod r#match {
    /// Type of a Match.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum MatchType {
        /// Not specified. Should never be used.
        Unspecified = 0,
        /// The query was matched to an intent.
        Intent = 1,
        /// The query directly triggered an intent.
        DirectIntent = 2,
        /// The query was used for parameter filling.
        ParameterFilling = 3,
        /// No match was found for the query.
        NoMatch = 4,
        /// Indicates an empty query.
        NoInput = 5,
        /// The query directly triggered an event.
        Event = 6,
        /// The query was matched to a Knowledge Connector answer.
        KnowledgeConnector = 8,
        /// The query was handled by a
        /// \[`Playbook`\]\[google.cloud.dialogflow.cx.v3.Playbook\].
        Playbook = 9,
    }
    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::Intent => "INTENT",
                Self::DirectIntent => "DIRECT_INTENT",
                Self::ParameterFilling => "PARAMETER_FILLING",
                Self::NoMatch => "NO_MATCH",
                Self::NoInput => "NO_INPUT",
                Self::Event => "EVENT",
                Self::KnowledgeConnector => "KNOWLEDGE_CONNECTOR",
                Self::Playbook => "PLAYBOOK",
            }
        }
        /// 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),
                "INTENT" => Some(Self::Intent),
                "DIRECT_INTENT" => Some(Self::DirectIntent),
                "PARAMETER_FILLING" => Some(Self::ParameterFilling),
                "NO_MATCH" => Some(Self::NoMatch),
                "NO_INPUT" => Some(Self::NoInput),
                "EVENT" => Some(Self::Event),
                "KNOWLEDGE_CONNECTOR" => Some(Self::KnowledgeConnector),
                "PLAYBOOK" => Some(Self::Playbook),
                _ => None,
            }
        }
    }
}
/// Request of \[MatchIntent\]\[\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MatchIntentRequest {
    /// Required. The name of the session this query is sent to.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/sessions/<SessionID>`
    /// or
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>/sessions/<SessionID>`.
    /// If `Environment ID` is not specified, we assume default 'draft'
    /// environment.
    /// It's up to the API caller to choose an appropriate `Session ID`. It can be
    /// a random number or some type of session identifiers (preferably hashed).
    /// The length of the `Session ID` must not exceed 36 characters.
    ///
    /// For more information, see the [sessions
    /// guide](<https://cloud.google.com/dialogflow/cx/docs/concept/session>).
    #[prost(string, tag = "1")]
    pub session: ::prost::alloc::string::String,
    /// The parameters of this query.
    #[prost(message, optional, tag = "2")]
    pub query_params: ::core::option::Option<QueryParameters>,
    /// Required. The input specification.
    #[prost(message, optional, tag = "3")]
    pub query_input: ::core::option::Option<QueryInput>,
    /// Persist session parameter changes from `query_params`.
    #[prost(bool, tag = "5")]
    pub persist_parameter_changes: bool,
}
/// Response of \[MatchIntent\]\[\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MatchIntentResponse {
    /// Match results, if more than one, ordered descendingly by the confidence
    /// we have that the particular intent matches the query.
    #[prost(message, repeated, tag = "4")]
    pub matches: ::prost::alloc::vec::Vec<Match>,
    /// The current \[Page\]\[google.cloud.dialogflow.cx.v3.Page\]. Some, not all
    /// fields are filled in this message, including but not limited to `name` and
    /// `display_name`.
    #[prost(message, optional, tag = "5")]
    pub current_page: ::core::option::Option<Page>,
    /// The original conversational query.
    #[prost(oneof = "match_intent_response::Query", tags = "1, 2, 3, 6")]
    pub query: ::core::option::Option<match_intent_response::Query>,
}
/// Nested message and enum types in `MatchIntentResponse`.
pub mod match_intent_response {
    /// The original conversational query.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Query {
        /// If \[natural language text\]\[google.cloud.dialogflow.cx.v3.TextInput\] was
        /// provided as input, this field will contain a copy of the text.
        #[prost(string, tag = "1")]
        Text(::prost::alloc::string::String),
        /// If an \[intent\]\[google.cloud.dialogflow.cx.v3.IntentInput\] was provided as
        /// input, this field will contain a copy of the intent identifier. Format:
        /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/intents/<IntentID>`.
        #[prost(string, tag = "2")]
        TriggerIntent(::prost::alloc::string::String),
        /// If \[natural language speech
        /// audio\]\[google.cloud.dialogflow.cx.v3.AudioInput\] was provided as input,
        /// this field will contain the transcript for the audio.
        #[prost(string, tag = "3")]
        Transcript(::prost::alloc::string::String),
        /// If an \[event\]\[google.cloud.dialogflow.cx.v3.EventInput\] was provided as
        /// input, this field will contain a copy of the event name.
        #[prost(string, tag = "6")]
        TriggerEvent(::prost::alloc::string::String),
    }
}
/// Request of \[FulfillIntent\]\[\]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FulfillIntentRequest {
    /// Must be same as the corresponding MatchIntent request, otherwise the
    /// behavior is undefined.
    #[prost(message, optional, tag = "1")]
    pub match_intent_request: ::core::option::Option<MatchIntentRequest>,
    /// The matched intent/event to fulfill.
    #[prost(message, optional, tag = "2")]
    pub r#match: ::core::option::Option<Match>,
    /// Instructs the speech synthesizer how to generate output audio.
    #[prost(message, optional, tag = "3")]
    pub output_audio_config: ::core::option::Option<OutputAudioConfig>,
}
/// Response of \[FulfillIntent\]\[\]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FulfillIntentResponse {
    /// Output only. The unique identifier of the response. It can be used to
    /// locate a response in the training example set or for reporting issues.
    #[prost(string, tag = "1")]
    pub response_id: ::prost::alloc::string::String,
    /// The result of the conversational query.
    #[prost(message, optional, tag = "2")]
    pub query_result: ::core::option::Option<QueryResult>,
    /// The audio data bytes encoded as specified in the request.
    /// Note: The output audio is generated based on the values of default platform
    /// text responses found in the
    /// \[`query_result.response_messages`\]\[google.cloud.dialogflow.cx.v3.QueryResult.response_messages\]
    /// field. If multiple default text responses exist, they will be concatenated
    /// when generating audio. If no default platform text responses exist, the
    /// generated audio content will be empty.
    ///
    /// In some scenarios, multiple output audio fields may be present in the
    /// response structure. In these cases, only the top-most-level audio output
    /// has content.
    #[prost(bytes = "vec", tag = "3")]
    pub output_audio: ::prost::alloc::vec::Vec<u8>,
    /// The config used by the speech synthesizer to generate the output audio.
    #[prost(message, optional, tag = "4")]
    pub output_audio_config: ::core::option::Option<OutputAudioConfig>,
}
/// The result of sentiment analysis. Sentiment analysis inspects user input
/// and identifies the prevailing subjective opinion, especially to determine a
/// user's attitude as positive, negative, or neutral.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct SentimentAnalysisResult {
    /// Sentiment score between -1.0 (negative sentiment) and 1.0 (positive
    /// sentiment).
    #[prost(float, tag = "1")]
    pub score: f32,
    /// A non-negative number in the \[0, +inf) range, which represents the absolute
    /// magnitude of sentiment, regardless of score (positive or negative).
    #[prost(float, tag = "2")]
    pub magnitude: f32,
}
/// The response view specifies which fields in the
/// \[QueryResult\]\[google.cloud.dialogflow.cx.v3.QueryResult\] to return.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum DetectIntentResponseView {
    /// Not specified. `DETECT_INTENT_RESPONSE_VIEW_DEFAULT` will be used.
    Unspecified = 0,
    /// Full response view includes all fields.
    Full = 1,
    /// ## Basic response view omits the following fields:
    ///
    /// \[QueryResult.diagnostic_info\]\[google.cloud.dialogflow.cx.v3.QueryResult.diagnostic_info\]
    Basic = 2,
    /// ## Default response view omits the following fields:
    ///
    /// \[QueryResult.trace_blocks\]\[google.cloud.dialogflow.cx.v3.QueryResult.trace_blocks\]
    Default = 3,
}
impl DetectIntentResponseView {
    /// 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 => "DETECT_INTENT_RESPONSE_VIEW_UNSPECIFIED",
            Self::Full => "DETECT_INTENT_RESPONSE_VIEW_FULL",
            Self::Basic => "DETECT_INTENT_RESPONSE_VIEW_BASIC",
            Self::Default => "DETECT_INTENT_RESPONSE_VIEW_DEFAULT",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "DETECT_INTENT_RESPONSE_VIEW_UNSPECIFIED" => Some(Self::Unspecified),
            "DETECT_INTENT_RESPONSE_VIEW_FULL" => Some(Self::Full),
            "DETECT_INTENT_RESPONSE_VIEW_BASIC" => Some(Self::Basic),
            "DETECT_INTENT_RESPONSE_VIEW_DEFAULT" => Some(Self::Default),
            _ => None,
        }
    }
}
/// Generated client implementations.
pub mod sessions_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// A session represents an interaction with a user. You retrieve user input
    /// and pass it to the
    /// \[DetectIntent\]\[google.cloud.dialogflow.cx.v3.Sessions.DetectIntent\] method to
    /// determine user intent and respond.
    #[derive(Debug, Clone)]
    pub struct SessionsClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl SessionsClient<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> SessionsClient<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,
        ) -> SessionsClient<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,
        {
            SessionsClient::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
        }
        /// Processes a natural language query and returns structured, actionable data
        /// as a result. This method is not idempotent, because it may cause session
        /// entity types to be updated, which in turn might affect results of future
        /// queries.
        ///
        /// Note: Always use agent versions for production traffic.
        /// See [Versions and
        /// environments](https://cloud.google.com/dialogflow/cx/docs/concept/version).
        pub async fn detect_intent(
            &mut self,
            request: impl tonic::IntoRequest<super::DetectIntentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::DetectIntentResponse>,
            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.dialogflow.cx.v3.Sessions/DetectIntent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Sessions",
                        "DetectIntent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Processes a natural language query and returns structured, actionable data
        /// as a result through server-side streaming. Server-side streaming allows
        /// Dialogflow to send [partial
        /// responses](https://cloud.google.com/dialogflow/cx/docs/concept/fulfillment#partial-response)
        /// earlier in a single request.
        pub async fn server_streaming_detect_intent(
            &mut self,
            request: impl tonic::IntoRequest<super::DetectIntentRequest>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::DetectIntentResponse>>,
            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.dialogflow.cx.v3.Sessions/ServerStreamingDetectIntent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Sessions",
                        "ServerStreamingDetectIntent",
                    ),
                );
            self.inner.server_streaming(req, path, codec).await
        }
        /// Processes a natural language query in audio format in a streaming fashion
        /// and returns structured, actionable data as a result. This method is only
        /// available via the gRPC API (not REST).
        ///
        /// Note: Always use agent versions for production traffic.
        /// See [Versions and
        /// environments](https://cloud.google.com/dialogflow/cx/docs/concept/version).
        pub async fn streaming_detect_intent(
            &mut self,
            request: impl tonic::IntoStreamingRequest<
                Message = super::StreamingDetectIntentRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<
                tonic::codec::Streaming<super::StreamingDetectIntentResponse>,
            >,
            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.dialogflow.cx.v3.Sessions/StreamingDetectIntent",
            );
            let mut req = request.into_streaming_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Sessions",
                        "StreamingDetectIntent",
                    ),
                );
            self.inner.streaming(req, path, codec).await
        }
        /// Returns preliminary intent match results, doesn't change the session
        /// status.
        pub async fn match_intent(
            &mut self,
            request: impl tonic::IntoRequest<super::MatchIntentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::MatchIntentResponse>,
            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.dialogflow.cx.v3.Sessions/MatchIntent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Sessions",
                        "MatchIntent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Fulfills a matched intent returned by
        /// \[MatchIntent\]\[google.cloud.dialogflow.cx.v3.Sessions.MatchIntent\]. Must be
        /// called after
        /// \[MatchIntent\]\[google.cloud.dialogflow.cx.v3.Sessions.MatchIntent\], with
        /// input from
        /// \[MatchIntentResponse\]\[google.cloud.dialogflow.cx.v3.MatchIntentResponse\].
        /// Otherwise, the behavior is undefined.
        pub async fn fulfill_intent(
            &mut self,
            request: impl tonic::IntoRequest<super::FulfillIntentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::FulfillIntentResponse>,
            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.dialogflow.cx.v3.Sessions/FulfillIntent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Sessions",
                        "FulfillIntent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the feedback received from the user for a single turn of the bot
        /// response.
        pub async fn submit_answer_feedback(
            &mut self,
            request: impl tonic::IntoRequest<super::SubmitAnswerFeedbackRequest>,
        ) -> std::result::Result<tonic::Response<super::AnswerFeedback>, 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.dialogflow.cx.v3.Sessions/SubmitAnswerFeedback",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Sessions",
                        "SubmitAnswerFeedback",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// A TransitionRouteGroup represents a group of
/// \[`TransitionRoutes`\]\[google.cloud.dialogflow.cx.v3.TransitionRoute\] to be
/// used by a \[Page\]\[google.cloud.dialogflow.cx.v3.Page\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TransitionRouteGroup {
    /// The unique identifier of the transition route group.
    /// \[TransitionRouteGroups.CreateTransitionRouteGroup\]\[google.cloud.dialogflow.cx.v3.TransitionRouteGroups.CreateTransitionRouteGroup\]
    /// populates the name automatically. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/transitionRouteGroups/<TransitionRouteGroupID>`
    /// .
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. The human-readable name of the transition route group, unique
    /// within the flow. The display name can be no longer than 30 characters.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Transition routes associated with the
    /// \[TransitionRouteGroup\]\[google.cloud.dialogflow.cx.v3.TransitionRouteGroup\].
    #[prost(message, repeated, tag = "5")]
    pub transition_routes: ::prost::alloc::vec::Vec<TransitionRoute>,
}
/// The request message for
/// \[TransitionRouteGroups.ListTransitionRouteGroups\]\[google.cloud.dialogflow.cx.v3.TransitionRouteGroups.ListTransitionRouteGroups\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListTransitionRouteGroupsRequest {
    /// Required. The flow to list all transition route groups for.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>`
    /// or \`projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of items to return in a single page. By default 100 and
    /// at most 1000.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// The language to list transition route groups for. The following fields are
    /// language dependent:
    ///
    /// * `TransitionRouteGroup.transition_routes.trigger_fulfillment.messages`
    /// *
    ///
    /// `TransitionRouteGroup.transition_routes.trigger_fulfillment.conditional_cases`
    ///
    /// If not specified, the agent's default language is used.
    /// [Many
    /// languages](<https://cloud.google.com/dialogflow/cx/docs/reference/language>)
    /// are supported.
    /// Note: languages must be enabled in the agent before they can be used.
    #[prost(string, tag = "4")]
    pub language_code: ::prost::alloc::string::String,
}
/// The response message for
/// \[TransitionRouteGroups.ListTransitionRouteGroups\]\[google.cloud.dialogflow.cx.v3.TransitionRouteGroups.ListTransitionRouteGroups\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListTransitionRouteGroupsResponse {
    /// The list of transition route groups. There will be a maximum number of
    /// items returned based on the page_size field in the request. The list may in
    /// some cases be empty or contain fewer entries than page_size even if this
    /// isn't the last page.
    #[prost(message, repeated, tag = "1")]
    pub transition_route_groups: ::prost::alloc::vec::Vec<TransitionRouteGroup>,
    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request message for
/// \[TransitionRouteGroups.GetTransitionRouteGroup\]\[google.cloud.dialogflow.cx.v3.TransitionRouteGroups.GetTransitionRouteGroup\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetTransitionRouteGroupRequest {
    /// Required. The name of the
    /// \[TransitionRouteGroup\]\[google.cloud.dialogflow.cx.v3.TransitionRouteGroup\].
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/transitionRouteGroups/<TransitionRouteGroupID>`
    /// or
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/transitionRouteGroups/<TransitionRouteGroupID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The language to retrieve the transition route group for. The following
    /// fields are language dependent:
    ///
    /// * `TransitionRouteGroup.transition_routes.trigger_fulfillment.messages`
    /// *
    ///
    /// `TransitionRouteGroup.transition_routes.trigger_fulfillment.conditional_cases`
    ///
    /// If not specified, the agent's default language is used.
    /// [Many
    /// languages](<https://cloud.google.com/dialogflow/cx/docs/reference/language>)
    /// are supported.
    /// Note: languages must be enabled in the agent before they can be used.
    #[prost(string, tag = "2")]
    pub language_code: ::prost::alloc::string::String,
}
/// The request message for
/// \[TransitionRouteGroups.CreateTransitionRouteGroup\]\[google.cloud.dialogflow.cx.v3.TransitionRouteGroups.CreateTransitionRouteGroup\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateTransitionRouteGroupRequest {
    /// Required. The flow to create an
    /// \[TransitionRouteGroup\]\[google.cloud.dialogflow.cx.v3.TransitionRouteGroup\]
    /// for. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>`
    /// or `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`
    /// for agent-level groups.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The transition route group to create.
    #[prost(message, optional, tag = "2")]
    pub transition_route_group: ::core::option::Option<TransitionRouteGroup>,
    /// The language of the following fields in `TransitionRouteGroup`:
    ///
    /// * `TransitionRouteGroup.transition_routes.trigger_fulfillment.messages`
    /// *
    ///
    /// `TransitionRouteGroup.transition_routes.trigger_fulfillment.conditional_cases`
    ///
    /// If not specified, the agent's default language is used.
    /// [Many
    /// languages](<https://cloud.google.com/dialogflow/cx/docs/reference/language>)
    /// are supported.
    /// Note: languages must be enabled in the agent before they can be used.
    #[prost(string, tag = "3")]
    pub language_code: ::prost::alloc::string::String,
}
/// The request message for
/// \[TransitionRouteGroups.UpdateTransitionRouteGroup\]\[google.cloud.dialogflow.cx.v3.TransitionRouteGroups.UpdateTransitionRouteGroup\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateTransitionRouteGroupRequest {
    /// Required. The transition route group to update.
    #[prost(message, optional, tag = "1")]
    pub transition_route_group: ::core::option::Option<TransitionRouteGroup>,
    /// The mask to control which fields get updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// The language of the following fields in `TransitionRouteGroup`:
    ///
    /// * `TransitionRouteGroup.transition_routes.trigger_fulfillment.messages`
    /// *
    ///
    /// `TransitionRouteGroup.transition_routes.trigger_fulfillment.conditional_cases`
    ///
    /// If not specified, the agent's default language is used.
    /// [Many
    /// languages](<https://cloud.google.com/dialogflow/cx/docs/reference/language>)
    /// are supported.
    /// Note: languages must be enabled in the agent before they can be used.
    #[prost(string, tag = "3")]
    pub language_code: ::prost::alloc::string::String,
}
/// The request message for
/// \[TransitionRouteGroups.DeleteTransitionRouteGroup\]\[google.cloud.dialogflow.cx.v3.TransitionRouteGroups.DeleteTransitionRouteGroup\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteTransitionRouteGroupRequest {
    /// Required. The name of the
    /// \[TransitionRouteGroup\]\[google.cloud.dialogflow.cx.v3.TransitionRouteGroup\]
    /// to delete. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/transitionRouteGroups/<TransitionRouteGroupID>`
    /// or
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/transitionRouteGroups/<TransitionRouteGroupID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// This field has no effect for transition route group that no page is using.
    /// If the transition route group is referenced by any page:
    ///
    /// * If `force` is set to false, an error will be returned with message
    ///   indicating pages that reference the transition route group.
    /// * If `force` is set to true, Dialogflow will remove the transition route
    ///   group, as well as any reference to it.
    #[prost(bool, tag = "2")]
    pub force: bool,
}
/// Generated client implementations.
pub mod transition_route_groups_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing
    /// \[TransitionRouteGroups\]\[google.cloud.dialogflow.cx.v3.TransitionRouteGroup\].
    #[derive(Debug, Clone)]
    pub struct TransitionRouteGroupsClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl TransitionRouteGroupsClient<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> TransitionRouteGroupsClient<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,
        ) -> TransitionRouteGroupsClient<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,
        {
            TransitionRouteGroupsClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Returns the list of all transition route groups in the specified flow.
        pub async fn list_transition_route_groups(
            &mut self,
            request: impl tonic::IntoRequest<super::ListTransitionRouteGroupsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListTransitionRouteGroupsResponse>,
            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.dialogflow.cx.v3.TransitionRouteGroups/ListTransitionRouteGroups",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.TransitionRouteGroups",
                        "ListTransitionRouteGroups",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the specified
        /// \[TransitionRouteGroup\]\[google.cloud.dialogflow.cx.v3.TransitionRouteGroup\].
        pub async fn get_transition_route_group(
            &mut self,
            request: impl tonic::IntoRequest<super::GetTransitionRouteGroupRequest>,
        ) -> std::result::Result<
            tonic::Response<super::TransitionRouteGroup>,
            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.dialogflow.cx.v3.TransitionRouteGroups/GetTransitionRouteGroup",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.TransitionRouteGroups",
                        "GetTransitionRouteGroup",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates an
        /// \[TransitionRouteGroup\]\[google.cloud.dialogflow.cx.v3.TransitionRouteGroup\]
        /// in the specified flow.
        ///
        /// Note: You should always train a flow prior to sending it queries. See the
        /// [training
        /// documentation](https://cloud.google.com/dialogflow/cx/docs/concept/training).
        pub async fn create_transition_route_group(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateTransitionRouteGroupRequest>,
        ) -> std::result::Result<
            tonic::Response<super::TransitionRouteGroup>,
            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.dialogflow.cx.v3.TransitionRouteGroups/CreateTransitionRouteGroup",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.TransitionRouteGroups",
                        "CreateTransitionRouteGroup",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified
        /// \[TransitionRouteGroup\]\[google.cloud.dialogflow.cx.v3.TransitionRouteGroup\].
        ///
        /// Note: You should always train a flow prior to sending it queries. See the
        /// [training
        /// documentation](https://cloud.google.com/dialogflow/cx/docs/concept/training).
        pub async fn update_transition_route_group(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateTransitionRouteGroupRequest>,
        ) -> std::result::Result<
            tonic::Response<super::TransitionRouteGroup>,
            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.dialogflow.cx.v3.TransitionRouteGroups/UpdateTransitionRouteGroup",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.TransitionRouteGroups",
                        "UpdateTransitionRouteGroup",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified
        /// \[TransitionRouteGroup\]\[google.cloud.dialogflow.cx.v3.TransitionRouteGroup\].
        ///
        /// Note: You should always train a flow prior to sending it queries. See the
        /// [training
        /// documentation](https://cloud.google.com/dialogflow/cx/docs/concept/training).
        pub async fn delete_transition_route_group(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteTransitionRouteGroupRequest>,
        ) -> 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.dialogflow.cx.v3.TransitionRouteGroups/DeleteTransitionRouteGroup",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.TransitionRouteGroups",
                        "DeleteTransitionRouteGroup",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Represents a test case.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TestCase {
    /// The unique identifier of the test case.
    /// \[TestCases.CreateTestCase\]\[google.cloud.dialogflow.cx.v3.TestCases.CreateTestCase\]
    /// will populate the name automatically. Otherwise use format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/testCases/<TestCaseID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Tags are short descriptions that users may apply to test cases for
    /// organizational and filtering purposes. Each tag should start with "#" and
    /// has a limit of 30 characters.
    #[prost(string, repeated, tag = "2")]
    pub tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Required. The human-readable name of the test case, unique within the
    /// agent. Limit of 200 characters.
    #[prost(string, tag = "3")]
    pub display_name: ::prost::alloc::string::String,
    /// Additional freeform notes about the test case. Limit of 400 characters.
    #[prost(string, tag = "4")]
    pub notes: ::prost::alloc::string::String,
    /// Config for the test case.
    #[prost(message, optional, tag = "13")]
    pub test_config: ::core::option::Option<TestConfig>,
    /// The conversation turns uttered when the test case was created, in
    /// chronological order. These include the canonical set of agent utterances
    /// that should occur when the agent is working properly.
    #[prost(message, repeated, tag = "5")]
    pub test_case_conversation_turns: ::prost::alloc::vec::Vec<ConversationTurn>,
    /// Output only. When the test was created.
    #[prost(message, optional, tag = "10")]
    pub creation_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The latest test result.
    #[prost(message, optional, tag = "12")]
    pub last_test_result: ::core::option::Option<TestCaseResult>,
}
/// Represents a result from running a test case in an agent environment.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TestCaseResult {
    /// The resource name for the test case result. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/testCases/<TestCaseID>/results/<TestCaseResultID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Environment where the test was run. If not set, it indicates the draft
    /// environment.
    #[prost(string, tag = "2")]
    pub environment: ::prost::alloc::string::String,
    /// The conversation turns uttered during the test case replay in chronological
    /// order.
    #[prost(message, repeated, tag = "3")]
    pub conversation_turns: ::prost::alloc::vec::Vec<ConversationTurn>,
    /// Whether the test case passed in the agent environment.
    #[prost(enumeration = "TestResult", tag = "4")]
    pub test_result: i32,
    /// The time that the test was run.
    #[prost(message, optional, tag = "5")]
    pub test_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Represents configurations for a test case.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TestConfig {
    /// Session parameters to be compared when calculating differences.
    #[prost(string, repeated, tag = "1")]
    pub tracking_parameters: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Flow name to start the test case with.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>`.
    ///
    /// Only one of `flow` and `page` should be set to indicate the starting point
    /// of the test case. If neither is set, the test case will start with start
    /// page on the default start flow.
    #[prost(string, tag = "2")]
    pub flow: ::prost::alloc::string::String,
    /// The \[page\]\[google.cloud.dialogflow.cx.v3.Page\] to start the test case with.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/pages/<PageID>`.
    ///
    /// Only one of `flow` and `page` should be set to indicate the starting point
    /// of the test case. If neither is set, the test case will start with start
    /// page on the default start flow.
    #[prost(string, tag = "3")]
    pub page: ::prost::alloc::string::String,
}
/// One interaction between a human and virtual agent. The human provides some
/// input and the virtual agent provides a response.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConversationTurn {
    /// The user input.
    #[prost(message, optional, tag = "1")]
    pub user_input: ::core::option::Option<conversation_turn::UserInput>,
    /// The virtual agent output.
    #[prost(message, optional, tag = "2")]
    pub virtual_agent_output: ::core::option::Option<
        conversation_turn::VirtualAgentOutput,
    >,
}
/// Nested message and enum types in `ConversationTurn`.
pub mod conversation_turn {
    /// The input from the human user.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct UserInput {
        /// Supports \[text input\]\[google.cloud.dialogflow.cx.v3.QueryInput.text\],
        /// \[event input\]\[google.cloud.dialogflow.cx.v3.QueryInput.event\], \[dtmf
        /// input\]\[google.cloud.dialogflow.cx.v3.QueryInput.dtmf\] in the test case.
        #[prost(message, optional, tag = "5")]
        pub input: ::core::option::Option<super::QueryInput>,
        /// Parameters that need to be injected into the conversation during intent
        /// detection.
        #[prost(message, optional, tag = "2")]
        pub injected_parameters: ::core::option::Option<::prost_types::Struct>,
        /// If webhooks should be allowed to trigger in response to the user
        /// utterance. Often if parameters are injected, webhooks should not be
        /// enabled.
        #[prost(bool, tag = "3")]
        pub is_webhook_enabled: bool,
        /// Whether sentiment analysis is enabled.
        #[prost(bool, tag = "7")]
        pub enable_sentiment_analysis: bool,
    }
    /// The output from the virtual agent.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct VirtualAgentOutput {
        /// The session parameters available to the bot at this point.
        #[prost(message, optional, tag = "4")]
        pub session_parameters: ::core::option::Option<::prost_types::Struct>,
        /// Output only. If this is part of a \[result conversation
        /// turn\]\[TestCaseResult.conversation_turns\], the list of differences
        /// between the original run and the replay for this output, if any.
        #[prost(message, repeated, tag = "5")]
        pub differences: ::prost::alloc::vec::Vec<super::TestRunDifference>,
        /// Required. Input only. The diagnostic
        /// \[info\]\[Session.DetectIntentResponse.QueryResult.diagnostic_info\]
        /// output for the turn. Required to calculate the testing coverage.
        #[prost(message, optional, tag = "6")]
        pub diagnostic_info: ::core::option::Option<::prost_types::Struct>,
        /// The \[Intent\]\[google.cloud.dialogflow.cx.v3.Intent\] that triggered the
        /// response. Only name and displayName will be set.
        #[prost(message, optional, tag = "7")]
        pub triggered_intent: ::core::option::Option<super::Intent>,
        /// The \[Page\]\[google.cloud.dialogflow.cx.v3.Page\] on which the utterance was
        /// spoken. Only name and displayName will be set.
        #[prost(message, optional, tag = "8")]
        pub current_page: ::core::option::Option<super::Page>,
        /// The \[text\]\[google.cloud.dialogflow.cx.v3.ResponseMessage.Text\] responses
        /// from the agent for the turn.
        #[prost(message, repeated, tag = "9")]
        pub text_responses: ::prost::alloc::vec::Vec<super::response_message::Text>,
        /// Response error from the agent in the test result. If set, other output
        /// is empty.
        #[prost(message, optional, tag = "10")]
        pub status: ::core::option::Option<
            super::super::super::super::super::rpc::Status,
        >,
    }
}
/// The description of differences between original and replayed agent output.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TestRunDifference {
    /// The type of diff.
    #[prost(enumeration = "test_run_difference::DiffType", tag = "1")]
    pub r#type: i32,
    /// A human readable description of the diff, showing the actual output vs
    /// expected output.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
}
/// Nested message and enum types in `TestRunDifference`.
pub mod test_run_difference {
    /// What part of the message replay differs from the test case.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum DiffType {
        /// Should never be used.
        Unspecified = 0,
        /// The intent.
        Intent = 1,
        /// The page.
        Page = 2,
        /// The parameters.
        Parameters = 3,
        /// The message utterance.
        Utterance = 4,
        /// The flow.
        Flow = 5,
    }
    impl DiffType {
        /// 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 => "DIFF_TYPE_UNSPECIFIED",
                Self::Intent => "INTENT",
                Self::Page => "PAGE",
                Self::Parameters => "PARAMETERS",
                Self::Utterance => "UTTERANCE",
                Self::Flow => "FLOW",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "DIFF_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "INTENT" => Some(Self::Intent),
                "PAGE" => Some(Self::Page),
                "PARAMETERS" => Some(Self::Parameters),
                "UTTERANCE" => Some(Self::Utterance),
                "FLOW" => Some(Self::Flow),
                _ => None,
            }
        }
    }
}
/// Transition coverage represents the percentage of all possible page
/// transitions (page-level transition routes and event handlers, excluding
/// transition route groups) present within any of a parent's test cases.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TransitionCoverage {
    /// The list of Transitions present in the agent.
    #[prost(message, repeated, tag = "1")]
    pub transitions: ::prost::alloc::vec::Vec<transition_coverage::Transition>,
    /// The percent of transitions in the agent that are covered.
    #[prost(float, tag = "2")]
    pub coverage_score: f32,
}
/// Nested message and enum types in `TransitionCoverage`.
pub mod transition_coverage {
    /// The source or target of a transition.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct TransitionNode {
        /// A TransitionNode can be either a page or a flow.
        #[prost(oneof = "transition_node::Kind", tags = "1, 2")]
        pub kind: ::core::option::Option<transition_node::Kind>,
    }
    /// Nested message and enum types in `TransitionNode`.
    pub mod transition_node {
        /// A TransitionNode can be either a page or a flow.
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Kind {
            /// Indicates a transition to a \[Page\]\[google.cloud.dialogflow.cx.v3.Page\].
            /// Only some fields such as name and displayname will be set.
            #[prost(message, tag = "1")]
            Page(super::super::Page),
            /// Indicates a transition to a \[Flow\]\[google.cloud.dialogflow.cx.v3.Flow\].
            /// Only some fields such as name and displayname will be set.
            #[prost(message, tag = "2")]
            Flow(super::super::Flow),
        }
    }
    /// A transition in a page.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Transition {
        /// The start node of a transition.
        #[prost(message, optional, tag = "1")]
        pub source: ::core::option::Option<TransitionNode>,
        /// The index of a transition in the transition list. Starting from 0.
        #[prost(int32, tag = "4")]
        pub index: i32,
        /// The end node of a transition.
        #[prost(message, optional, tag = "2")]
        pub target: ::core::option::Option<TransitionNode>,
        /// Whether the transition is covered by at least one of the
        /// agent's test cases.
        #[prost(bool, tag = "3")]
        pub covered: bool,
        /// The detailed transition.
        #[prost(oneof = "transition::Detail", tags = "5, 6")]
        pub detail: ::core::option::Option<transition::Detail>,
    }
    /// Nested message and enum types in `Transition`.
    pub mod transition {
        /// The detailed transition.
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Detail {
            /// Intent route or condition route.
            #[prost(message, tag = "5")]
            TransitionRoute(super::super::TransitionRoute),
            /// Event handler.
            #[prost(message, tag = "6")]
            EventHandler(super::super::EventHandler),
        }
    }
}
/// Transition route group coverage represents the percentage of all possible
/// transition routes present within any of a parent's test cases. The results
/// are grouped by the transition route group.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TransitionRouteGroupCoverage {
    /// Transition route group coverages.
    #[prost(message, repeated, tag = "1")]
    pub coverages: ::prost::alloc::vec::Vec<transition_route_group_coverage::Coverage>,
    /// The percent of transition routes in all the transition route groups that
    /// are covered.
    #[prost(float, tag = "2")]
    pub coverage_score: f32,
}
/// Nested message and enum types in `TransitionRouteGroupCoverage`.
pub mod transition_route_group_coverage {
    /// Coverage result message for one transition route group.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Coverage {
        /// Transition route group metadata. Only name and displayName will be set.
        #[prost(message, optional, tag = "1")]
        pub route_group: ::core::option::Option<super::TransitionRouteGroup>,
        /// The list of transition routes and coverage in the transition route group.
        #[prost(message, repeated, tag = "2")]
        pub transitions: ::prost::alloc::vec::Vec<coverage::Transition>,
        /// The percent of transition routes in the transition route group that are
        /// covered.
        #[prost(float, tag = "3")]
        pub coverage_score: f32,
    }
    /// Nested message and enum types in `Coverage`.
    pub mod coverage {
        /// A transition coverage in a transition route group.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct Transition {
            /// Intent route or condition route.
            #[prost(message, optional, tag = "1")]
            pub transition_route: ::core::option::Option<super::super::TransitionRoute>,
            /// Whether the transition route is covered by at least one of the
            /// agent's test cases.
            #[prost(bool, tag = "2")]
            pub covered: bool,
        }
    }
}
/// Intent coverage represents the percentage of all possible intents in the
/// agent that are triggered in any of a parent's test cases.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IntentCoverage {
    /// The list of Intents present in the agent
    #[prost(message, repeated, tag = "1")]
    pub intents: ::prost::alloc::vec::Vec<intent_coverage::Intent>,
    /// The percent of intents in the agent that are covered.
    #[prost(float, tag = "2")]
    pub coverage_score: f32,
}
/// Nested message and enum types in `IntentCoverage`.
pub mod intent_coverage {
    /// The agent's intent.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Intent {
        /// The intent full resource name
        #[prost(string, tag = "1")]
        pub intent: ::prost::alloc::string::String,
        /// Whether the intent is covered by at least one of the agent's
        /// test cases.
        #[prost(bool, tag = "2")]
        pub covered: bool,
    }
}
/// The request message for
/// \[TestCases.CalculateCoverage\]\[google.cloud.dialogflow.cx.v3.TestCases.CalculateCoverage\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CalculateCoverageRequest {
    /// Required. The agent to calculate coverage for.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "3")]
    pub agent: ::prost::alloc::string::String,
    /// Required. The type of coverage requested.
    #[prost(enumeration = "calculate_coverage_request::CoverageType", tag = "2")]
    pub r#type: i32,
}
/// Nested message and enum types in `CalculateCoverageRequest`.
pub mod calculate_coverage_request {
    /// The type of coverage score requested.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum CoverageType {
        /// Should never be used.
        Unspecified = 0,
        /// Intent coverage.
        Intent = 1,
        /// Page transition coverage.
        PageTransition = 2,
        /// Transition route group coverage.
        TransitionRouteGroup = 3,
    }
    impl CoverageType {
        /// 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 => "COVERAGE_TYPE_UNSPECIFIED",
                Self::Intent => "INTENT",
                Self::PageTransition => "PAGE_TRANSITION",
                Self::TransitionRouteGroup => "TRANSITION_ROUTE_GROUP",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "COVERAGE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "INTENT" => Some(Self::Intent),
                "PAGE_TRANSITION" => Some(Self::PageTransition),
                "TRANSITION_ROUTE_GROUP" => Some(Self::TransitionRouteGroup),
                _ => None,
            }
        }
    }
}
/// The response message for
/// \[TestCases.CalculateCoverage\]\[google.cloud.dialogflow.cx.v3.TestCases.CalculateCoverage\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CalculateCoverageResponse {
    /// The agent to calculate coverage for.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "5")]
    pub agent: ::prost::alloc::string::String,
    /// The type of coverage requested.
    #[prost(oneof = "calculate_coverage_response::CoverageType", tags = "2, 4, 6")]
    pub coverage_type: ::core::option::Option<calculate_coverage_response::CoverageType>,
}
/// Nested message and enum types in `CalculateCoverageResponse`.
pub mod calculate_coverage_response {
    /// The type of coverage requested.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum CoverageType {
        /// Intent coverage.
        #[prost(message, tag = "2")]
        IntentCoverage(super::IntentCoverage),
        /// Transition (excluding transition route groups) coverage.
        #[prost(message, tag = "4")]
        TransitionCoverage(super::TransitionCoverage),
        /// Transition route group coverage.
        #[prost(message, tag = "6")]
        RouteGroupCoverage(super::TransitionRouteGroupCoverage),
    }
}
/// The request message for
/// \[TestCases.ListTestCases\]\[google.cloud.dialogflow.cx.v3.TestCases.ListTestCases\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListTestCasesRequest {
    /// Required. The agent to list all pages for.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of items to return in a single page. By default 20.
    /// Note that when TestCaseView = FULL, the maximum page size allowed is 20.
    /// When TestCaseView = BASIC, the maximum page size allowed is 500.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Specifies whether response should include all fields or just the metadata.
    #[prost(enumeration = "list_test_cases_request::TestCaseView", tag = "4")]
    pub view: i32,
}
/// Nested message and enum types in `ListTestCasesRequest`.
pub mod list_test_cases_request {
    /// Specifies how much test case information to include in the response.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum TestCaseView {
        /// The default / unset value.
        /// The API will default to the BASIC view.
        Unspecified = 0,
        /// Include basic metadata about the test case, but not the conversation
        /// turns. This is the default value.
        Basic = 1,
        /// Include everything.
        Full = 2,
    }
    impl TestCaseView {
        /// 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 => "TEST_CASE_VIEW_UNSPECIFIED",
                Self::Basic => "BASIC",
                Self::Full => "FULL",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TEST_CASE_VIEW_UNSPECIFIED" => Some(Self::Unspecified),
                "BASIC" => Some(Self::Basic),
                "FULL" => Some(Self::Full),
                _ => None,
            }
        }
    }
}
/// The response message for
/// \[TestCases.ListTestCases\]\[google.cloud.dialogflow.cx.v3.TestCases.ListTestCases\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListTestCasesResponse {
    /// The list of test cases. There will be a maximum number of items returned
    /// based on the page_size field in the request.
    #[prost(message, repeated, tag = "1")]
    pub test_cases: ::prost::alloc::vec::Vec<TestCase>,
    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request message for
/// \[TestCases.BatchDeleteTestCases\]\[google.cloud.dialogflow.cx.v3.TestCases.BatchDeleteTestCases\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BatchDeleteTestCasesRequest {
    /// Required. The agent to delete test cases from.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. Format of test case names:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/testCases/<TestCaseID>`.
    #[prost(string, repeated, tag = "3")]
    pub names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// The request message for
/// \[TestCases.CreateTestCase\]\[google.cloud.dialogflow.cx.v3.TestCases.CreateTestCase\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateTestCaseRequest {
    /// Required. The agent to create the test case for.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The test case to create.
    #[prost(message, optional, tag = "2")]
    pub test_case: ::core::option::Option<TestCase>,
}
/// The request message for
/// \[TestCases.UpdateTestCase\]\[google.cloud.dialogflow.cx.v3.TestCases.UpdateTestCase\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateTestCaseRequest {
    /// Required. The test case to update.
    #[prost(message, optional, tag = "1")]
    pub test_case: ::core::option::Option<TestCase>,
    /// Required. The mask to specify which fields should be updated. The
    /// \[`creationTime`\]\[google.cloud.dialogflow.cx.v3.TestCase.creation_time\] and
    /// \[`lastTestResult`\]\[google.cloud.dialogflow.cx.v3.TestCase.last_test_result\]
    /// cannot be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// The request message for
/// \[TestCases.GetTestCase\]\[google.cloud.dialogflow.cx.v3.TestCases.GetTestCase\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetTestCaseRequest {
    /// Required. The name of the testcase.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/testCases/<TestCaseID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for
/// \[TestCases.RunTestCase\]\[google.cloud.dialogflow.cx.v3.TestCases.RunTestCase\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RunTestCaseRequest {
    /// Required. Format of test case name to run:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/testCases/<TestCaseID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. Environment name. If not set, draft environment is assumed.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>`.
    #[prost(string, tag = "2")]
    pub environment: ::prost::alloc::string::String,
}
/// The response message for
/// \[TestCases.RunTestCase\]\[google.cloud.dialogflow.cx.v3.TestCases.RunTestCase\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RunTestCaseResponse {
    /// The result.
    #[prost(message, optional, tag = "2")]
    pub result: ::core::option::Option<TestCaseResult>,
}
/// Metadata returned for the
/// \[TestCases.RunTestCase\]\[google.cloud.dialogflow.cx.v3.TestCases.RunTestCase\]
/// long running operation. This message currently has no fields.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RunTestCaseMetadata {}
/// The request message for
/// \[TestCases.BatchRunTestCases\]\[google.cloud.dialogflow.cx.v3.TestCases.BatchRunTestCases\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BatchRunTestCasesRequest {
    /// Required. Agent name. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. If not set, draft environment is assumed. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>`.
    #[prost(string, tag = "2")]
    pub environment: ::prost::alloc::string::String,
    /// Required. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/testCases/<TestCaseID>`.
    #[prost(string, repeated, tag = "3")]
    pub test_cases: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// The response message for
/// \[TestCases.BatchRunTestCases\]\[google.cloud.dialogflow.cx.v3.TestCases.BatchRunTestCases\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchRunTestCasesResponse {
    /// The test case results. The detailed
    /// \[conversation
    /// turns\]\[google.cloud.dialogflow.cx.v3.TestCaseResult.conversation_turns\] are
    /// empty in this response.
    #[prost(message, repeated, tag = "1")]
    pub results: ::prost::alloc::vec::Vec<TestCaseResult>,
}
/// Metadata returned for the
/// \[TestCases.BatchRunTestCases\]\[google.cloud.dialogflow.cx.v3.TestCases.BatchRunTestCases\]
/// long running operation.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchRunTestCasesMetadata {
    /// The test errors.
    #[prost(message, repeated, tag = "1")]
    pub errors: ::prost::alloc::vec::Vec<TestError>,
}
/// Error info for running a test.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TestError {
    /// The test case resource name.
    #[prost(string, tag = "1")]
    pub test_case: ::prost::alloc::string::String,
    /// The status associated with the test.
    #[prost(message, optional, tag = "2")]
    pub status: ::core::option::Option<super::super::super::super::rpc::Status>,
    /// The timestamp when the test was completed.
    #[prost(message, optional, tag = "3")]
    pub test_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// The request message for
/// \[TestCases.ImportTestCases\]\[google.cloud.dialogflow.cx.v3.TestCases.ImportTestCases\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ImportTestCasesRequest {
    /// Required. The agent to import test cases to.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The source to import.
    #[prost(oneof = "import_test_cases_request::Source", tags = "2, 3")]
    pub source: ::core::option::Option<import_test_cases_request::Source>,
}
/// Nested message and enum types in `ImportTestCasesRequest`.
pub mod import_test_cases_request {
    /// Required. The source to import.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Source {
        /// The [Google Cloud Storage](<https://cloud.google.com/storage/docs/>) URI
        /// to import test cases from. The format of this URI must be
        /// `gs://<bucket-name>/<object-name>`.
        ///
        /// Dialogflow performs a read operation for the Cloud Storage object
        /// on the caller's behalf, so your request authentication must
        /// have read permissions for the object. For more information, see
        /// [Dialogflow access
        /// control](<https://cloud.google.com/dialogflow/cx/docs/concept/access-control#storage>).
        #[prost(string, tag = "2")]
        GcsUri(::prost::alloc::string::String),
        /// Uncompressed raw byte content for test cases.
        #[prost(bytes, tag = "3")]
        Content(::prost::alloc::vec::Vec<u8>),
    }
}
/// The response message for
/// \[TestCases.ImportTestCases\]\[google.cloud.dialogflow.cx.v3.TestCases.ImportTestCases\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ImportTestCasesResponse {
    /// The unique identifiers of the new test cases.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/testCases/<TestCaseID>`.
    #[prost(string, repeated, tag = "1")]
    pub names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Metadata returned for the
/// \[TestCases.ImportTestCases\]\[google.cloud.dialogflow.cx.v3.TestCases.ImportTestCases\]
/// long running operation.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ImportTestCasesMetadata {
    /// Errors for failed test cases.
    #[prost(message, repeated, tag = "1")]
    pub errors: ::prost::alloc::vec::Vec<TestCaseError>,
}
/// Error info for importing a test.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TestCaseError {
    /// The test case.
    #[prost(message, optional, tag = "1")]
    pub test_case: ::core::option::Option<TestCase>,
    /// The status associated with the test case.
    #[prost(message, optional, tag = "2")]
    pub status: ::core::option::Option<super::super::super::super::rpc::Status>,
}
/// The request message for
/// \[TestCases.ExportTestCases\]\[google.cloud.dialogflow.cx.v3.TestCases.ExportTestCases\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExportTestCasesRequest {
    /// Required. The agent where to export test cases from.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The data format of the exported test cases. If not specified, `BLOB` is
    /// assumed.
    #[prost(enumeration = "export_test_cases_request::DataFormat", tag = "3")]
    pub data_format: i32,
    /// The filter expression used to filter exported test cases, see
    /// [API Filtering](<https://aip.dev/160>). The expression is case insensitive
    /// and supports the following syntax:
    ///
    /// name = <value> \[OR name = <value>\] ...
    ///
    /// For example:
    ///
    /// * "name = t1 OR name = t2" matches the test case with the exact resource
    ///   name "t1" or "t2".
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// The destination to export.
    #[prost(oneof = "export_test_cases_request::Destination", tags = "2")]
    pub destination: ::core::option::Option<export_test_cases_request::Destination>,
}
/// Nested message and enum types in `ExportTestCasesRequest`.
pub mod export_test_cases_request {
    /// Data format of the exported test cases.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum DataFormat {
        /// Unspecified format.
        Unspecified = 0,
        /// Raw bytes.
        Blob = 1,
        /// JSON format.
        Json = 2,
    }
    impl DataFormat {
        /// 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_FORMAT_UNSPECIFIED",
                Self::Blob => "BLOB",
                Self::Json => "JSON",
            }
        }
        /// 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_FORMAT_UNSPECIFIED" => Some(Self::Unspecified),
                "BLOB" => Some(Self::Blob),
                "JSON" => Some(Self::Json),
                _ => None,
            }
        }
    }
    /// The destination to export.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Destination {
        /// The [Google Cloud Storage](<https://cloud.google.com/storage/docs/>) URI to
        /// export the test cases to. The format of this URI must be
        /// `gs://<bucket-name>/<object-name>`. If unspecified, the serialized test
        /// cases is returned inline.
        ///
        /// Dialogflow performs a write operation for the Cloud Storage object
        /// on the caller's behalf, so your request authentication must
        /// have write permissions for the object. For more information, see
        /// [Dialogflow access
        /// control](<https://cloud.google.com/dialogflow/cx/docs/concept/access-control#storage>).
        #[prost(string, tag = "2")]
        GcsUri(::prost::alloc::string::String),
    }
}
/// The response message for
/// \[TestCases.ExportTestCases\]\[google.cloud.dialogflow.cx.v3.TestCases.ExportTestCases\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExportTestCasesResponse {
    /// The exported test cases.
    #[prost(oneof = "export_test_cases_response::Destination", tags = "1, 2")]
    pub destination: ::core::option::Option<export_test_cases_response::Destination>,
}
/// Nested message and enum types in `ExportTestCasesResponse`.
pub mod export_test_cases_response {
    /// The exported test cases.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Destination {
        /// The URI to a file containing the exported test cases. This field is
        /// populated only if `gcs_uri` is specified in
        /// \[ExportTestCasesRequest\]\[google.cloud.dialogflow.cx.v3.ExportTestCasesRequest\].
        #[prost(string, tag = "1")]
        GcsUri(::prost::alloc::string::String),
        /// Uncompressed raw byte content for test cases.
        #[prost(bytes, tag = "2")]
        Content(::prost::alloc::vec::Vec<u8>),
    }
}
/// Metadata returned for the
/// \[TestCases.ExportTestCases\]\[google.cloud.dialogflow.cx.v3.TestCases.ExportTestCases\]
/// long running operation. This message currently has no fields.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExportTestCasesMetadata {}
/// The request message for
/// \[TestCases.ListTestCaseResults\]\[google.cloud.dialogflow.cx.v3.TestCases.ListTestCaseResults\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListTestCaseResultsRequest {
    /// Required. The test case to list results for.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/testCases/<TestCaseID>`.
    /// Specify a `-` as a wildcard for TestCase ID to
    /// list results across multiple test cases.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of items to return in a single page. By default 100 and
    /// at most 1000.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// The filter expression used to filter test case results. See
    /// [API Filtering](<https://aip.dev/160>).
    ///
    /// The expression is case insensitive. Only 'AND' is supported for logical
    /// operators. The supported syntax is listed below in detail:
    ///
    /// <field> <operator> <value> \[AND <field> <operator> <value>\] ...
    /// \[AND latest\]
    ///
    /// The supported fields and operators are:
    /// field                 operator
    /// `environment`         `=`, `IN`  (Use value `draft` for draft environment)
    /// `test_time`           `>`, `<`
    ///
    /// `latest` only returns the latest test result in all results for each test
    /// case.
    ///
    /// Examples:
    ///
    /// * "environment=draft AND latest" matches the latest test result for each
    ///   test case in the draft environment.
    /// * "environment IN (e1,e2)" matches any test case results with an
    ///   environment resource name of either "e1" or "e2".
    /// * "test_time > 1602540713" matches any test case results with test time
    ///   later than a unix timestamp in seconds 1602540713.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
/// The response message for
/// \[TestCases.ListTestCaseResults\]\[google.cloud.dialogflow.cx.v3.TestCases.ListTestCaseResults\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListTestCaseResultsResponse {
    /// The list of test case results.
    #[prost(message, repeated, tag = "1")]
    pub test_case_results: ::prost::alloc::vec::Vec<TestCaseResult>,
    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request message for
/// \[TestCases.GetTestCaseResult\]\[google.cloud.dialogflow.cx.v3.TestCases.GetTestCaseResult\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetTestCaseResultRequest {
    /// Required. The name of the testcase.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/testCases/<TestCaseID>/results/<TestCaseResultID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The test result for a test case and an agent environment.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum TestResult {
    /// Not specified. Should never be used.
    Unspecified = 0,
    /// The test passed.
    Passed = 1,
    /// The test did not pass.
    Failed = 2,
}
impl TestResult {
    /// 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 => "TEST_RESULT_UNSPECIFIED",
            Self::Passed => "PASSED",
            Self::Failed => "FAILED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "TEST_RESULT_UNSPECIFIED" => Some(Self::Unspecified),
            "PASSED" => Some(Self::Passed),
            "FAILED" => Some(Self::Failed),
            _ => None,
        }
    }
}
/// Generated client implementations.
pub mod test_cases_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing \[Test Cases\]\[google.cloud.dialogflow.cx.v3.TestCase\] and
    /// \[Test Case Results\]\[google.cloud.dialogflow.cx.v3.TestCaseResult\].
    #[derive(Debug, Clone)]
    pub struct TestCasesClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl TestCasesClient<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> TestCasesClient<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,
        ) -> TestCasesClient<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,
        {
            TestCasesClient::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
        }
        /// Fetches a list of test cases for a given agent.
        pub async fn list_test_cases(
            &mut self,
            request: impl tonic::IntoRequest<super::ListTestCasesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListTestCasesResponse>,
            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.dialogflow.cx.v3.TestCases/ListTestCases",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.TestCases",
                        "ListTestCases",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Batch deletes test cases.
        pub async fn batch_delete_test_cases(
            &mut self,
            request: impl tonic::IntoRequest<super::BatchDeleteTestCasesRequest>,
        ) -> 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.dialogflow.cx.v3.TestCases/BatchDeleteTestCases",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.TestCases",
                        "BatchDeleteTestCases",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets a test case.
        pub async fn get_test_case(
            &mut self,
            request: impl tonic::IntoRequest<super::GetTestCaseRequest>,
        ) -> std::result::Result<tonic::Response<super::TestCase>, 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.dialogflow.cx.v3.TestCases/GetTestCase",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.TestCases",
                        "GetTestCase",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a test case for the given agent.
        pub async fn create_test_case(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateTestCaseRequest>,
        ) -> std::result::Result<tonic::Response<super::TestCase>, 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.dialogflow.cx.v3.TestCases/CreateTestCase",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.TestCases",
                        "CreateTestCase",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified test case.
        pub async fn update_test_case(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateTestCaseRequest>,
        ) -> std::result::Result<tonic::Response<super::TestCase>, 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.dialogflow.cx.v3.TestCases/UpdateTestCase",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.TestCases",
                        "UpdateTestCase",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Kicks off a test case run.
        ///
        /// This method is a [long-running
        /// operation](https://cloud.google.com/dialogflow/cx/docs/how/long-running-operation).
        /// The returned `Operation` type has the following method-specific fields:
        ///
        /// * `metadata`:
        ///  \[RunTestCaseMetadata\]\[google.cloud.dialogflow.cx.v3.RunTestCaseMetadata\]
        /// * `response`:
        ///  \[RunTestCaseResponse\]\[google.cloud.dialogflow.cx.v3.RunTestCaseResponse\]
        pub async fn run_test_case(
            &mut self,
            request: impl tonic::IntoRequest<super::RunTestCaseRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.dialogflow.cx.v3.TestCases/RunTestCase",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.TestCases",
                        "RunTestCase",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Kicks off a batch run of test cases.
        ///
        /// This method is a [long-running
        /// operation](https://cloud.google.com/dialogflow/cx/docs/how/long-running-operation).
        /// The returned `Operation` type has the following method-specific fields:
        ///
        /// * `metadata`:
        ///  \[BatchRunTestCasesMetadata\]\[google.cloud.dialogflow.cx.v3.BatchRunTestCasesMetadata\]
        /// * `response`:
        ///  \[BatchRunTestCasesResponse\]\[google.cloud.dialogflow.cx.v3.BatchRunTestCasesResponse\]
        pub async fn batch_run_test_cases(
            &mut self,
            request: impl tonic::IntoRequest<super::BatchRunTestCasesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.dialogflow.cx.v3.TestCases/BatchRunTestCases",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.TestCases",
                        "BatchRunTestCases",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Calculates the test coverage for an agent.
        pub async fn calculate_coverage(
            &mut self,
            request: impl tonic::IntoRequest<super::CalculateCoverageRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CalculateCoverageResponse>,
            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.dialogflow.cx.v3.TestCases/CalculateCoverage",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.TestCases",
                        "CalculateCoverage",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Imports the test cases from a Cloud Storage bucket or a local file. It
        /// always creates new test cases and won't overwrite any existing ones. The
        /// provided ID in the imported test case is neglected.
        ///
        /// This method is a [long-running
        /// operation](https://cloud.google.com/dialogflow/cx/docs/how/long-running-operation).
        /// The returned `Operation` type has the following method-specific fields:
        ///
        /// * `metadata`:
        ///  \[ImportTestCasesMetadata\]\[google.cloud.dialogflow.cx.v3.ImportTestCasesMetadata\]
        /// * `response`:
        ///  \[ImportTestCasesResponse\]\[google.cloud.dialogflow.cx.v3.ImportTestCasesResponse\]
        pub async fn import_test_cases(
            &mut self,
            request: impl tonic::IntoRequest<super::ImportTestCasesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.dialogflow.cx.v3.TestCases/ImportTestCases",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.TestCases",
                        "ImportTestCases",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Exports the test cases under the agent to a Cloud Storage bucket or a local
        /// file. Filter can be applied to export a subset of test cases.
        ///
        /// This method is a [long-running
        /// operation](https://cloud.google.com/dialogflow/cx/docs/how/long-running-operation).
        /// The returned `Operation` type has the following method-specific fields:
        ///
        /// * `metadata`:
        ///  \[ExportTestCasesMetadata\]\[google.cloud.dialogflow.cx.v3.ExportTestCasesMetadata\]
        /// * `response`:
        ///  \[ExportTestCasesResponse\]\[google.cloud.dialogflow.cx.v3.ExportTestCasesResponse\]
        pub async fn export_test_cases(
            &mut self,
            request: impl tonic::IntoRequest<super::ExportTestCasesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.dialogflow.cx.v3.TestCases/ExportTestCases",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.TestCases",
                        "ExportTestCases",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Fetches the list of run results for the given test case. A maximum of 100
        /// results are kept for each test case.
        pub async fn list_test_case_results(
            &mut self,
            request: impl tonic::IntoRequest<super::ListTestCaseResultsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListTestCaseResultsResponse>,
            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.dialogflow.cx.v3.TestCases/ListTestCaseResults",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.TestCases",
                        "ListTestCaseResults",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets a test case result.
        pub async fn get_test_case_result(
            &mut self,
            request: impl tonic::IntoRequest<super::GetTestCaseResultRequest>,
        ) -> std::result::Result<tonic::Response<super::TestCaseResult>, 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.dialogflow.cx.v3.TestCases/GetTestCaseResult",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.TestCases",
                        "GetTestCaseResult",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Webhooks host the developer's business logic. During a session, webhooks
/// allow the developer to use the data extracted by Dialogflow's natural
/// language processing to generate dynamic responses, validate collected data,
/// or trigger actions on the backend.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Webhook {
    /// The unique identifier of the webhook.
    /// Required for the
    /// \[Webhooks.UpdateWebhook\]\[google.cloud.dialogflow.cx.v3.Webhooks.UpdateWebhook\]
    /// method.
    /// \[Webhooks.CreateWebhook\]\[google.cloud.dialogflow.cx.v3.Webhooks.CreateWebhook\]
    /// populates the name automatically. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/webhooks/<WebhookID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. The human-readable name of the webhook, unique within the agent.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Webhook execution timeout. Execution is considered failed if Dialogflow
    /// doesn't receive a response from webhook at the end of the timeout period.
    /// Defaults to 5 seconds, maximum allowed timeout is 30 seconds.
    #[prost(message, optional, tag = "6")]
    pub timeout: ::core::option::Option<::prost_types::Duration>,
    /// Indicates whether the webhook is disabled.
    #[prost(bool, tag = "5")]
    pub disabled: bool,
    /// Required. The webhook configuration.
    #[prost(oneof = "webhook::Webhook", tags = "4, 7")]
    pub webhook: ::core::option::Option<webhook::Webhook>,
}
/// Nested message and enum types in `Webhook`.
pub mod webhook {
    /// Represents configuration for a generic web service.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct GenericWebService {
        /// Required. The webhook URI for receiving POST requests. It must use https
        /// protocol.
        #[prost(string, tag = "1")]
        pub uri: ::prost::alloc::string::String,
        /// The user name for HTTP Basic authentication.
        #[deprecated]
        #[prost(string, tag = "2")]
        pub username: ::prost::alloc::string::String,
        /// The password for HTTP Basic authentication.
        #[deprecated]
        #[prost(string, tag = "3")]
        pub password: ::prost::alloc::string::String,
        /// Optional. The SecretManager secret version resource storing the
        /// username:password pair for HTTP Basic authentication. Format:
        /// `projects/{project}/secrets/{secret}/versions/{version}`
        #[prost(string, tag = "19")]
        pub secret_version_for_username_password: ::prost::alloc::string::String,
        /// The HTTP request headers to send together with webhook requests.
        #[prost(map = "string, string", tag = "4")]
        pub request_headers: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            ::prost::alloc::string::String,
        >,
        /// Optional. The HTTP request headers to send together with webhook
        /// requests. Header values are stored in SecretManager secret versions.
        ///
        /// When the same header name is specified in both `request_headers` and
        /// `secret_versions_for_request_headers`, the value in
        /// `secret_versions_for_request_headers` will be used.
        #[prost(map = "string, message", tag = "20")]
        pub secret_versions_for_request_headers: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            generic_web_service::SecretVersionHeaderValue,
        >,
        /// Optional. Specifies a list of allowed custom CA certificates (in DER
        /// format) for HTTPS verification. This overrides the default SSL trust
        /// store. If this is empty or unspecified, Dialogflow 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", repeated, tag = "5")]
        pub allowed_ca_certs: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
        /// Optional. The OAuth configuration of the webhook. If specified,
        /// Dialogflow will initiate the OAuth client credential flow to exchange an
        /// access token from the 3rd party platform and put it in the auth header.
        #[prost(message, optional, tag = "11")]
        pub oauth_config: ::core::option::Option<generic_web_service::OAuthConfig>,
        /// Optional. Indicate the auth token type generated from the [Diglogflow
        /// service
        /// agent](<https://cloud.google.com/iam/docs/service-agents#dialogflow-service-agent>).
        /// The generated token is sent in the Authorization header.
        #[prost(enumeration = "generic_web_service::ServiceAgentAuth", tag = "12")]
        pub service_agent_auth: i32,
        /// Optional. Configuration for service account authentication.
        #[prost(message, optional, tag = "18")]
        pub service_account_auth_config: ::core::option::Option<
            generic_web_service::ServiceAccountAuthConfig,
        >,
        /// Optional. Type of the webhook.
        #[prost(enumeration = "generic_web_service::WebhookType", tag = "6")]
        pub webhook_type: i32,
        /// Optional. HTTP method for the flexible webhook calls. Standard webhook
        /// always uses POST.
        #[prost(enumeration = "generic_web_service::HttpMethod", tag = "7")]
        pub http_method: i32,
        /// Optional. Defines a custom JSON object as request body to send to
        /// flexible webhook.
        #[prost(string, tag = "8")]
        pub request_body: ::prost::alloc::string::String,
        /// Optional. Maps the values extracted from specific fields of the flexible
        /// webhook response into session parameters.
        ///
        /// * Key: session parameter name
        /// * Value: field path in the webhook response
        #[prost(map = "string, string", tag = "9")]
        pub parameter_mapping: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            ::prost::alloc::string::String,
        >,
    }
    /// Nested message and enum types in `GenericWebService`.
    pub mod generic_web_service {
        /// Represents the value of an HTTP header stored in a SecretManager secret
        /// version.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct SecretVersionHeaderValue {
            /// Required. The SecretManager secret version resource storing the header
            /// value. Format: `projects/{project}/secrets/{secret}/versions/{version}`
            #[prost(string, tag = "1")]
            pub secret_version: ::prost::alloc::string::String,
        }
        /// Represents configuration of OAuth client credential flow for 3rd party
        /// API authentication.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct OAuthConfig {
            /// Required. The client ID provided by the 3rd party platform.
            #[prost(string, tag = "1")]
            pub client_id: ::prost::alloc::string::String,
            /// Optional. The client secret provided by the 3rd party platform.
            #[prost(string, tag = "2")]
            pub client_secret: ::prost::alloc::string::String,
            /// Optional. The name of the SecretManager secret version resource storing
            /// the client secret. If this field is set, the `client_secret` field will
            /// be ignored. Format:
            /// `projects/{project}/secrets/{secret}/versions/{version}`
            #[prost(string, tag = "5")]
            pub secret_version_for_client_secret: ::prost::alloc::string::String,
            /// Required. The token endpoint provided by the 3rd party platform to
            /// exchange an access token.
            #[prost(string, tag = "3")]
            pub token_endpoint: ::prost::alloc::string::String,
            /// Optional. The OAuth scopes to grant.
            #[prost(string, repeated, tag = "4")]
            pub scopes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        }
        /// Configuration for authentication using a service account.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct ServiceAccountAuthConfig {
            /// Required. The email address of the service account used to authenticate
            /// the webhook call. Dialogflow uses this service account to exchange an
            /// access token and the access token is then sent in the `Authorization`
            /// header of the webhook request.
            ///
            /// The service account must have the
            /// `roles/iam.serviceAccountTokenCreator` role granted to the
            /// [Dialogflow service
            /// agent](<https://cloud.google.com/iam/docs/service-agents#dialogflow-service-agent>).
            #[prost(string, tag = "1")]
            pub service_account: ::prost::alloc::string::String,
        }
        /// Indicate the auth token type generated from the [Diglogflow service
        /// agent](<https://cloud.google.com/iam/docs/service-agents#dialogflow-service-agent>).
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum ServiceAgentAuth {
            /// Service agent auth type unspecified. Default to ID_TOKEN.
            Unspecified = 0,
            /// No token used.
            None = 1,
            /// Use [ID
            /// token](<https://cloud.google.com/docs/authentication/token-types#id>)
            /// generated from service agent. This can be used to access Cloud Function
            /// and Cloud Run after you grant Invoker role to
            /// `service-<PROJECT-NUMBER>@gcp-sa-dialogflow.iam.gserviceaccount.com`.
            IdToken = 2,
            /// Use [access
            /// token](<https://cloud.google.com/docs/authentication/token-types#access>)
            /// generated from service agent. This can be used to access other Google
            /// Cloud APIs after you grant required roles to
            /// `service-<PROJECT-NUMBER>@gcp-sa-dialogflow.iam.gserviceaccount.com`.
            AccessToken = 3,
        }
        impl ServiceAgentAuth {
            /// 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 => "SERVICE_AGENT_AUTH_UNSPECIFIED",
                    Self::None => "NONE",
                    Self::IdToken => "ID_TOKEN",
                    Self::AccessToken => "ACCESS_TOKEN",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "SERVICE_AGENT_AUTH_UNSPECIFIED" => Some(Self::Unspecified),
                    "NONE" => Some(Self::None),
                    "ID_TOKEN" => Some(Self::IdToken),
                    "ACCESS_TOKEN" => Some(Self::AccessToken),
                    _ => None,
                }
            }
        }
        /// Represents the type of webhook configuration.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum WebhookType {
            /// Default value. This value is unused.
            Unspecified = 0,
            /// Represents a standard webhook.
            Standard = 1,
            /// Represents a flexible webhook.
            Flexible = 2,
        }
        impl WebhookType {
            /// 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 => "WEBHOOK_TYPE_UNSPECIFIED",
                    Self::Standard => "STANDARD",
                    Self::Flexible => "FLEXIBLE",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "WEBHOOK_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                    "STANDARD" => Some(Self::Standard),
                    "FLEXIBLE" => Some(Self::Flexible),
                    _ => None,
                }
            }
        }
        /// HTTP method to use when calling webhooks.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum HttpMethod {
            /// HTTP method not specified.
            Unspecified = 0,
            /// HTTP POST Method.
            Post = 1,
            /// HTTP GET Method.
            Get = 2,
            /// HTTP HEAD Method.
            Head = 3,
            /// HTTP PUT Method.
            Put = 4,
            /// HTTP DELETE Method.
            Delete = 5,
            /// HTTP PATCH Method.
            Patch = 6,
            /// HTTP OPTIONS Method.
            Options = 7,
        }
        impl HttpMethod {
            /// 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 => "HTTP_METHOD_UNSPECIFIED",
                    Self::Post => "POST",
                    Self::Get => "GET",
                    Self::Head => "HEAD",
                    Self::Put => "PUT",
                    Self::Delete => "DELETE",
                    Self::Patch => "PATCH",
                    Self::Options => "OPTIONS",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "HTTP_METHOD_UNSPECIFIED" => Some(Self::Unspecified),
                    "POST" => Some(Self::Post),
                    "GET" => Some(Self::Get),
                    "HEAD" => Some(Self::Head),
                    "PUT" => Some(Self::Put),
                    "DELETE" => Some(Self::Delete),
                    "PATCH" => Some(Self::Patch),
                    "OPTIONS" => Some(Self::Options),
                    _ => None,
                }
            }
        }
    }
    /// Represents configuration for a [Service
    /// Directory](<https://cloud.google.com/service-directory>) service.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ServiceDirectoryConfig {
        /// Required. The name of [Service
        /// Directory](<https://cloud.google.com/service-directory>) service.
        /// Format:
        /// `projects/<ProjectID>/locations/<LocationID>/namespaces/<NamespaceID>/services/<ServiceID>`.
        /// `Location ID` of the service directory must be the same as the location
        /// of the agent.
        #[prost(string, tag = "1")]
        pub service: ::prost::alloc::string::String,
        /// Generic Service configuration of this webhook.
        #[prost(message, optional, tag = "2")]
        pub generic_web_service: ::core::option::Option<GenericWebService>,
    }
    /// Required. The webhook configuration.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Webhook {
        /// Configuration for a generic web service.
        #[prost(message, tag = "4")]
        GenericWebService(GenericWebService),
        /// Configuration for a [Service
        /// Directory](<https://cloud.google.com/service-directory>) service.
        #[prost(message, tag = "7")]
        ServiceDirectory(ServiceDirectoryConfig),
    }
}
/// The request message for
/// \[Webhooks.ListWebhooks\]\[google.cloud.dialogflow.cx.v3.Webhooks.ListWebhooks\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListWebhooksRequest {
    /// Required. The agent to list all webhooks for.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of items to return in a single page. By default 100 and
    /// at most 1000.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response message for
/// \[Webhooks.ListWebhooks\]\[google.cloud.dialogflow.cx.v3.Webhooks.ListWebhooks\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListWebhooksResponse {
    /// The list of webhooks. There will be a maximum number of items returned
    /// based on the page_size field in the request.
    #[prost(message, repeated, tag = "1")]
    pub webhooks: ::prost::alloc::vec::Vec<Webhook>,
    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request message for
/// \[Webhooks.GetWebhook\]\[google.cloud.dialogflow.cx.v3.Webhooks.GetWebhook\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetWebhookRequest {
    /// Required. The name of the webhook.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/webhooks/<WebhookID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for
/// \[Webhooks.CreateWebhook\]\[google.cloud.dialogflow.cx.v3.Webhooks.CreateWebhook\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateWebhookRequest {
    /// Required. The agent to create a webhook for.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The webhook to create.
    #[prost(message, optional, tag = "2")]
    pub webhook: ::core::option::Option<Webhook>,
}
/// The request message for
/// \[Webhooks.UpdateWebhook\]\[google.cloud.dialogflow.cx.v3.Webhooks.UpdateWebhook\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateWebhookRequest {
    /// Required. The webhook to update.
    #[prost(message, optional, tag = "1")]
    pub webhook: ::core::option::Option<Webhook>,
    /// The mask 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>,
}
/// The request message for
/// \[Webhooks.DeleteWebhook\]\[google.cloud.dialogflow.cx.v3.Webhooks.DeleteWebhook\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteWebhookRequest {
    /// Required. The name of the webhook to delete.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/webhooks/<WebhookID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// This field has no effect for webhook not being used.
    /// For webhooks that are used by pages/flows/transition route groups:
    ///
    /// * If `force` is set to false, an error will be returned with message
    ///   indicating the referenced resources.
    /// * If `force` is set to true, Dialogflow will remove the webhook, as well
    ///   as any references to the webhook (i.e.
    ///   \[Webhook\]\[google.cloud.dialogflow.cx.v3.Fulfillment.webhook\] and
    ///   \[tag\]\[google.cloud.dialogflow.cx.v3.Fulfillment.tag\]in fulfillments that
    ///   point to this webhook will be removed).
    #[prost(bool, tag = "2")]
    pub force: bool,
}
/// The request message for a webhook call. The request is sent as a JSON object
/// and the field names will be presented in camel cases.
///
/// You may see undocumented fields in an actual request. These fields are used
/// internally by Dialogflow and should be ignored.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WebhookRequest {
    /// Always present. The unique identifier of the
    /// \[DetectIntentResponse\]\[google.cloud.dialogflow.cx.v3.DetectIntentResponse\]
    /// that will be returned to the API caller.
    #[prost(string, tag = "1")]
    pub detect_intent_response_id: ::prost::alloc::string::String,
    /// The language code specified in the \[original
    /// request\]\[QueryInput.language_code\].
    #[prost(string, tag = "15")]
    pub language_code: ::prost::alloc::string::String,
    /// Always present. Information about the fulfillment that triggered this
    /// webhook call.
    #[prost(message, optional, tag = "6")]
    pub fulfillment_info: ::core::option::Option<webhook_request::FulfillmentInfo>,
    /// Information about the last matched intent.
    #[prost(message, optional, tag = "3")]
    pub intent_info: ::core::option::Option<webhook_request::IntentInfo>,
    /// Information about page status.
    #[prost(message, optional, tag = "4")]
    pub page_info: ::core::option::Option<PageInfo>,
    /// Information about session status.
    #[prost(message, optional, tag = "5")]
    pub session_info: ::core::option::Option<SessionInfo>,
    /// The list of rich message responses to present to the user. Webhook can
    /// choose to append or replace this list in
    /// \[WebhookResponse.fulfillment_response\]\[google.cloud.dialogflow.cx.v3.WebhookResponse.fulfillment_response\];
    #[prost(message, repeated, tag = "7")]
    pub messages: ::prost::alloc::vec::Vec<ResponseMessage>,
    /// Custom data set in
    /// \[QueryParameters.payload\]\[google.cloud.dialogflow.cx.v3.QueryParameters.payload\].
    #[prost(message, optional, tag = "8")]
    pub payload: ::core::option::Option<::prost_types::Struct>,
    /// The sentiment analysis result of the current user request. The field is
    /// filled when sentiment analysis is configured to be enabled for the request.
    #[prost(message, optional, tag = "9")]
    pub sentiment_analysis_result: ::core::option::Option<
        webhook_request::SentimentAnalysisResult,
    >,
    /// Information about the language of the request.
    #[prost(message, optional, tag = "18")]
    pub language_info: ::core::option::Option<LanguageInfo>,
    /// The original conversational query.
    #[prost(oneof = "webhook_request::Query", tags = "10, 11, 12, 14, 17")]
    pub query: ::core::option::Option<webhook_request::Query>,
}
/// Nested message and enum types in `WebhookRequest`.
pub mod webhook_request {
    /// Represents fulfillment information communicated to the webhook.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct FulfillmentInfo {
        /// Always present.
        /// The value of the
        /// \[Fulfillment.tag\]\[google.cloud.dialogflow.cx.v3.Fulfillment.tag\] field
        /// will be populated in this field by Dialogflow when the associated webhook
        /// is called. The tag is typically used by the webhook service to identify
        /// which fulfillment is being called, but it could be used for other
        /// purposes.
        #[prost(string, tag = "1")]
        pub tag: ::prost::alloc::string::String,
    }
    /// Represents intent information communicated to the webhook.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct IntentInfo {
        /// Always present. The unique identifier of the last matched
        /// \[intent\]\[google.cloud.dialogflow.cx.v3.Intent\].
        /// Format:
        /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/intents/<IntentID>`.
        #[prost(string, tag = "1")]
        pub last_matched_intent: ::prost::alloc::string::String,
        /// Always present. The display name of the last matched
        /// \[intent\]\[google.cloud.dialogflow.cx.v3.Intent\].
        #[prost(string, tag = "3")]
        pub display_name: ::prost::alloc::string::String,
        /// Parameters identified as a result of intent matching. This is a map of
        /// the name of the identified parameter to the value of the parameter
        /// identified from the user's utterance. All parameters defined in the
        /// matched intent that are identified will be surfaced here.
        #[prost(map = "string, message", tag = "2")]
        pub parameters: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            intent_info::IntentParameterValue,
        >,
        /// The confidence of the matched intent. Values range from 0.0 (completely
        /// uncertain) to 1.0 (completely certain).
        #[prost(float, tag = "4")]
        pub confidence: f32,
    }
    /// Nested message and enum types in `IntentInfo`.
    pub mod intent_info {
        /// Represents a value for an intent parameter.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct IntentParameterValue {
            /// Always present. Original text value extracted from user utterance.
            #[prost(string, tag = "1")]
            pub original_value: ::prost::alloc::string::String,
            /// Always present. Structured value for the parameter extracted from user
            /// utterance.
            #[prost(message, optional, tag = "2")]
            pub resolved_value: ::core::option::Option<::prost_types::Value>,
        }
    }
    /// Represents the result of sentiment analysis.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct SentimentAnalysisResult {
        /// Sentiment score between -1.0 (negative sentiment) and 1.0 (positive
        /// sentiment).
        #[prost(float, tag = "1")]
        pub score: f32,
        /// A non-negative number in the \[0, +inf) range, which represents the
        /// absolute magnitude of sentiment, regardless of score (positive or
        /// negative).
        #[prost(float, tag = "2")]
        pub magnitude: f32,
    }
    /// The original conversational query.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Query {
        /// If \[natural language text\]\[google.cloud.dialogflow.cx.v3.TextInput\] was
        /// provided as input, this field will contain a copy of the text.
        #[prost(string, tag = "10")]
        Text(::prost::alloc::string::String),
        /// If an \[intent\]\[google.cloud.dialogflow.cx.v3.IntentInput\] was provided as
        /// input, this field will contain a copy of the intent identifier. Format:
        /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/intents/<IntentID>`.
        #[prost(string, tag = "11")]
        TriggerIntent(::prost::alloc::string::String),
        /// If \[natural language speech
        /// audio\]\[google.cloud.dialogflow.cx.v3.AudioInput\] was provided as input,
        /// this field will contain the transcript for the audio.
        #[prost(string, tag = "12")]
        Transcript(::prost::alloc::string::String),
        /// If an \[event\]\[google.cloud.dialogflow.cx.v3.EventInput\] was provided as
        /// input, this field will contain the name of the event.
        #[prost(string, tag = "14")]
        TriggerEvent(::prost::alloc::string::String),
        /// If \[DTMF\]\[google.cloud.dialogflow.cx.v3.DtmfInput\] was provided as input,
        /// this field will contain the DTMF digits.
        #[prost(string, tag = "17")]
        DtmfDigits(::prost::alloc::string::String),
    }
}
/// The response message for a webhook call.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WebhookResponse {
    /// The fulfillment response to send to the user. This field can be omitted by
    /// the webhook if it does not intend to send any response to the user.
    #[prost(message, optional, tag = "1")]
    pub fulfillment_response: ::core::option::Option<
        webhook_response::FulfillmentResponse,
    >,
    /// Information about page status. This field can be omitted by the webhook if
    /// it does not intend to modify page status.
    #[prost(message, optional, tag = "2")]
    pub page_info: ::core::option::Option<PageInfo>,
    /// Information about session status. This field can be omitted by the webhook
    /// if it does not intend to modify session status.
    #[prost(message, optional, tag = "3")]
    pub session_info: ::core::option::Option<SessionInfo>,
    /// Value to append directly to
    /// \[QueryResult.webhook_payloads\]\[google.cloud.dialogflow.cx.v3.QueryResult.webhook_payloads\].
    #[prost(message, optional, tag = "4")]
    pub payload: ::core::option::Option<::prost_types::Struct>,
    /// The target to transition to. This can be set optionally to indicate an
    /// immediate transition to a different page in the same host flow, or a
    /// different flow in the same agent.
    #[prost(oneof = "webhook_response::Transition", tags = "5, 6")]
    pub transition: ::core::option::Option<webhook_response::Transition>,
}
/// Nested message and enum types in `WebhookResponse`.
pub mod webhook_response {
    /// Represents a fulfillment response to the user.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct FulfillmentResponse {
        /// The list of rich message responses to present to the user.
        #[prost(message, repeated, tag = "1")]
        pub messages: ::prost::alloc::vec::Vec<super::ResponseMessage>,
        /// Merge behavior for `messages`.
        #[prost(enumeration = "fulfillment_response::MergeBehavior", tag = "2")]
        pub merge_behavior: i32,
    }
    /// Nested message and enum types in `FulfillmentResponse`.
    pub mod fulfillment_response {
        /// Defines merge behavior for `messages`.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum MergeBehavior {
            /// Not specified. `APPEND` will be used.
            Unspecified = 0,
            /// `messages` will be appended to the list of messages waiting to be sent
            /// to the user.
            Append = 1,
            /// `messages` will replace the list of messages waiting to be sent to the
            /// user.
            Replace = 2,
        }
        impl MergeBehavior {
            /// 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 => "MERGE_BEHAVIOR_UNSPECIFIED",
                    Self::Append => "APPEND",
                    Self::Replace => "REPLACE",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "MERGE_BEHAVIOR_UNSPECIFIED" => Some(Self::Unspecified),
                    "APPEND" => Some(Self::Append),
                    "REPLACE" => Some(Self::Replace),
                    _ => None,
                }
            }
        }
    }
    /// The target to transition to. This can be set optionally to indicate an
    /// immediate transition to a different page in the same host flow, or a
    /// different flow in the same agent.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Transition {
        /// The target page to transition to.
        /// Format:
        /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/pages/<PageID>`.
        #[prost(string, tag = "5")]
        TargetPage(::prost::alloc::string::String),
        /// The target flow to transition to.
        /// Format:
        /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>`.
        #[prost(string, tag = "6")]
        TargetFlow(::prost::alloc::string::String),
    }
}
/// Represents page information communicated to and from the webhook.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PageInfo {
    /// Always present for
    /// \[WebhookRequest\]\[google.cloud.dialogflow.cx.v3.WebhookRequest\]. Ignored for
    /// \[WebhookResponse\]\[google.cloud.dialogflow.cx.v3.WebhookResponse\]. The
    /// unique identifier of the current page. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/pages/<PageID>`.
    #[prost(string, tag = "1")]
    pub current_page: ::prost::alloc::string::String,
    /// Always present for
    /// \[WebhookRequest\]\[google.cloud.dialogflow.cx.v3.WebhookRequest\]. Ignored for
    /// \[WebhookResponse\]\[google.cloud.dialogflow.cx.v3.WebhookResponse\]. The
    /// display name of the current page.
    #[prost(string, tag = "4")]
    pub display_name: ::prost::alloc::string::String,
    /// Optional for both
    /// \[WebhookRequest\]\[google.cloud.dialogflow.cx.v3.WebhookRequest\] and
    /// \[WebhookResponse\]\[google.cloud.dialogflow.cx.v3.WebhookResponse\].
    /// Information about the form.
    #[prost(message, optional, tag = "3")]
    pub form_info: ::core::option::Option<page_info::FormInfo>,
}
/// Nested message and enum types in `PageInfo`.
pub mod page_info {
    /// Represents form information.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct FormInfo {
        /// Optional for both
        /// \[WebhookRequest\]\[google.cloud.dialogflow.cx.v3.WebhookRequest\] and
        /// \[WebhookResponse\]\[google.cloud.dialogflow.cx.v3.WebhookResponse\]. The
        /// parameters contained in the form. Note that the webhook cannot add or
        /// remove any form parameter.
        #[prost(message, repeated, tag = "2")]
        pub parameter_info: ::prost::alloc::vec::Vec<form_info::ParameterInfo>,
    }
    /// Nested message and enum types in `FormInfo`.
    pub mod form_info {
        /// Represents parameter information.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct ParameterInfo {
            /// Always present for
            /// \[WebhookRequest\]\[google.cloud.dialogflow.cx.v3.WebhookRequest\].
            /// Required for
            /// \[WebhookResponse\]\[google.cloud.dialogflow.cx.v3.WebhookResponse\].
            /// The human-readable name of the parameter, unique within the form. This
            /// field cannot be modified by the webhook.
            #[prost(string, tag = "1")]
            pub display_name: ::prost::alloc::string::String,
            /// Optional for both
            /// \[WebhookRequest\]\[google.cloud.dialogflow.cx.v3.WebhookRequest\] and
            /// \[WebhookResponse\]\[google.cloud.dialogflow.cx.v3.WebhookResponse\].
            /// Indicates whether the parameter is required. Optional parameters will
            /// not trigger prompts; however, they are filled if the user specifies
            /// them. Required parameters must be filled before form filling concludes.
            #[prost(bool, tag = "2")]
            pub required: bool,
            /// Always present for
            /// \[WebhookRequest\]\[google.cloud.dialogflow.cx.v3.WebhookRequest\].
            /// Required for
            /// \[WebhookResponse\]\[google.cloud.dialogflow.cx.v3.WebhookResponse\]. The
            /// state of the parameter. This field can be set to
            /// \[INVALID\]\[google.cloud.dialogflow.cx.v3.PageInfo.FormInfo.ParameterInfo.ParameterState.INVALID\]
            /// by the webhook to invalidate the parameter; other values set by the
            /// webhook will be ignored.
            #[prost(enumeration = "parameter_info::ParameterState", tag = "3")]
            pub state: i32,
            /// Optional for both
            /// \[WebhookRequest\]\[google.cloud.dialogflow.cx.v3.WebhookRequest\] and
            /// \[WebhookResponse\]\[google.cloud.dialogflow.cx.v3.WebhookResponse\]. The
            /// value of the parameter. This field can be set by the webhook to change
            /// the parameter value.
            #[prost(message, optional, tag = "4")]
            pub value: ::core::option::Option<::prost_types::Value>,
            /// Optional for
            /// \[WebhookRequest\]\[google.cloud.dialogflow.cx.v3.WebhookRequest\]. Ignored
            /// for \[WebhookResponse\]\[google.cloud.dialogflow.cx.v3.WebhookResponse\].
            /// Indicates if the parameter value was just collected on the last
            /// conversation turn.
            #[prost(bool, tag = "5")]
            pub just_collected: bool,
        }
        /// Nested message and enum types in `ParameterInfo`.
        pub mod parameter_info {
            /// Represents the state of a parameter.
            #[derive(
                Clone,
                Copy,
                Debug,
                PartialEq,
                Eq,
                Hash,
                PartialOrd,
                Ord,
                ::prost::Enumeration
            )]
            #[repr(i32)]
            pub enum ParameterState {
                /// Not specified. This value should be never used.
                Unspecified = 0,
                /// Indicates that the parameter does not have a value.
                Empty = 1,
                /// Indicates that the parameter value is invalid. This field can be used
                /// by the webhook to invalidate the parameter and ask the server to
                /// collect it from the user again.
                Invalid = 2,
                /// Indicates that the parameter has a value.
                Filled = 3,
            }
            impl ParameterState {
                /// 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 => "PARAMETER_STATE_UNSPECIFIED",
                        Self::Empty => "EMPTY",
                        Self::Invalid => "INVALID",
                        Self::Filled => "FILLED",
                    }
                }
                /// Creates an enum from field names used in the ProtoBuf definition.
                pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                    match value {
                        "PARAMETER_STATE_UNSPECIFIED" => Some(Self::Unspecified),
                        "EMPTY" => Some(Self::Empty),
                        "INVALID" => Some(Self::Invalid),
                        "FILLED" => Some(Self::Filled),
                        _ => None,
                    }
                }
            }
        }
    }
}
/// Represents session information communicated to and from the webhook.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SessionInfo {
    /// Always present for
    /// \[WebhookRequest\]\[google.cloud.dialogflow.cx.v3.WebhookRequest\]. Ignored for
    /// \[WebhookResponse\]\[google.cloud.dialogflow.cx.v3.WebhookResponse\]. The
    /// unique identifier of the
    /// \[session\]\[google.cloud.dialogflow.cx.v3.DetectIntentRequest.session\]. This
    /// field can be used by the webhook to identify a session.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/sessions/<SessionID>`
    /// or
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>/sessions/<SessionID>`
    /// if environment is specified.
    #[prost(string, tag = "1")]
    pub session: ::prost::alloc::string::String,
    /// Optional for
    /// \[WebhookRequest\]\[google.cloud.dialogflow.cx.v3.WebhookRequest\]. Optional
    /// for \[WebhookResponse\]\[google.cloud.dialogflow.cx.v3.WebhookResponse\]. All
    /// parameters collected from forms and intents during the session. Parameters
    /// can be created, updated, or removed by the webhook. To remove a parameter
    /// from the session, the webhook should explicitly set the parameter value to
    /// null in \[WebhookResponse\]\[google.cloud.dialogflow.cx.v3.WebhookResponse\].
    /// The map is keyed by parameters' display names.
    #[prost(map = "string, message", tag = "2")]
    pub parameters: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost_types::Value,
    >,
}
/// Represents the language information of the request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LanguageInfo {
    /// The language code specified in the original
    /// \[request\]\[google.cloud.dialogflow.cx.v3.QueryInput.language_code\].
    #[prost(string, tag = "1")]
    pub input_language_code: ::prost::alloc::string::String,
    /// The language code detected for this request based on the user
    /// conversation.
    #[prost(string, tag = "2")]
    pub resolved_language_code: ::prost::alloc::string::String,
    /// The confidence score of the detected language between 0 and 1.
    #[prost(float, tag = "3")]
    pub confidence_score: f32,
}
/// Generated client implementations.
pub mod webhooks_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing \[Webhooks\]\[google.cloud.dialogflow.cx.v3.Webhook\].
    #[derive(Debug, Clone)]
    pub struct WebhooksClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl WebhooksClient<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> WebhooksClient<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,
        ) -> WebhooksClient<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,
        {
            WebhooksClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Returns the list of all webhooks in the specified agent.
        pub async fn list_webhooks(
            &mut self,
            request: impl tonic::IntoRequest<super::ListWebhooksRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListWebhooksResponse>,
            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.dialogflow.cx.v3.Webhooks/ListWebhooks",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Webhooks",
                        "ListWebhooks",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the specified webhook.
        pub async fn get_webhook(
            &mut self,
            request: impl tonic::IntoRequest<super::GetWebhookRequest>,
        ) -> std::result::Result<tonic::Response<super::Webhook>, 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.dialogflow.cx.v3.Webhooks/GetWebhook",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Webhooks",
                        "GetWebhook",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a webhook in the specified agent.
        pub async fn create_webhook(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateWebhookRequest>,
        ) -> std::result::Result<tonic::Response<super::Webhook>, 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.dialogflow.cx.v3.Webhooks/CreateWebhook",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Webhooks",
                        "CreateWebhook",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified webhook.
        pub async fn update_webhook(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateWebhookRequest>,
        ) -> std::result::Result<tonic::Response<super::Webhook>, 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.dialogflow.cx.v3.Webhooks/UpdateWebhook",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Webhooks",
                        "UpdateWebhook",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified webhook.
        pub async fn delete_webhook(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteWebhookRequest>,
        ) -> 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.dialogflow.cx.v3.Webhooks/DeleteWebhook",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Webhooks",
                        "DeleteWebhook",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Represents an environment for an agent. You can create multiple versions
/// of your agent and publish them to separate environments. When you edit an
/// agent, you are editing the draft agent. At any point, you can save the draft
/// agent as an agent version, which is an immutable snapshot of your agent. When
/// you save the draft agent, it is published to the default environment. When
/// you create agent versions, you can publish them to custom environments. You
/// can create a variety of custom environments for testing, development,
/// production, etc.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Environment {
    /// The name of the environment.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. The human-readable name of the environment (unique in an agent).
    /// Limit of 64 characters.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// The human-readable description of the environment. The maximum length is
    /// 500 characters. If exceeded, the request is rejected.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// A list of configurations for flow versions. You should include version
    /// configs for all flows that are reachable from \[`Start  Flow`\]\[Agent.start_flow\] in the agent. Otherwise, an error will be
    /// returned.
    #[prost(message, repeated, tag = "6")]
    pub version_configs: ::prost::alloc::vec::Vec<environment::VersionConfig>,
    /// Output only. Update time of this environment.
    #[prost(message, optional, tag = "5")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The test cases config for continuous tests of this environment.
    #[prost(message, optional, tag = "7")]
    pub test_cases_config: ::core::option::Option<environment::TestCasesConfig>,
    /// The webhook configuration for this environment.
    #[prost(message, optional, tag = "10")]
    pub webhook_config: ::core::option::Option<environment::WebhookConfig>,
}
/// Nested message and enum types in `Environment`.
pub mod environment {
    /// Configuration for the version.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct VersionConfig {
        /// Required. Flow, playbook and tool versions are supported.
        /// Format for flow version:
        /// projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/versions/<VersionID>.
        /// Format for playbook version:
        /// projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/playbooks/<PlaybookID>/versions/<VersionID>.
        /// Format for tool version:
        /// projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/tools/<ToolID>/versions/<VersionID>.
        #[prost(string, tag = "1")]
        pub version: ::prost::alloc::string::String,
    }
    /// The configuration for continuous tests.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct TestCasesConfig {
        /// A list of test case names to run. They should be under the same agent.
        /// Format of each test case name:
        /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/testCases/<TestCaseID>`
        #[prost(string, repeated, tag = "1")]
        pub test_cases: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        /// Whether to run test cases in
        /// \[TestCasesConfig.test_cases\]\[google.cloud.dialogflow.cx.v3.Environment.TestCasesConfig.test_cases\]
        /// periodically. Default false. If set to true, run once a day.
        #[prost(bool, tag = "2")]
        pub enable_continuous_run: bool,
        /// Whether to run test cases in
        /// \[TestCasesConfig.test_cases\]\[google.cloud.dialogflow.cx.v3.Environment.TestCasesConfig.test_cases\]
        /// before deploying a flow version to the environment. Default false.
        #[prost(bool, tag = "3")]
        pub enable_predeployment_run: bool,
    }
    /// Configuration for webhooks.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct WebhookConfig {
        /// The list of webhooks to override for the agent environment. The webhook
        /// must exist in the agent. You can override fields in
        /// \[`generic_web_service`\]\[google.cloud.dialogflow.cx.v3.Webhook.generic_web_service\]
        /// and
        /// \[`service_directory`\]\[google.cloud.dialogflow.cx.v3.Webhook.service_directory\].
        #[prost(message, repeated, tag = "1")]
        pub webhook_overrides: ::prost::alloc::vec::Vec<super::Webhook>,
    }
}
/// The request message for
/// \[Environments.ListEnvironments\]\[google.cloud.dialogflow.cx.v3.Environments.ListEnvironments\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListEnvironmentsRequest {
    /// Required. The \[Agent\]\[google.cloud.dialogflow.cx.v3.Agent\] to list all
    /// environments for. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of items to return in a single page. By default 20 and
    /// at most 100.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response message for
/// \[Environments.ListEnvironments\]\[google.cloud.dialogflow.cx.v3.Environments.ListEnvironments\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListEnvironmentsResponse {
    /// The list of environments. There will be a maximum number of items
    /// returned based on the page_size field in the request. The list may in some
    /// cases be empty or contain fewer entries than page_size even if this isn't
    /// the last page.
    #[prost(message, repeated, tag = "1")]
    pub environments: ::prost::alloc::vec::Vec<Environment>,
    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request message for
/// \[Environments.GetEnvironment\]\[google.cloud.dialogflow.cx.v3.Environments.GetEnvironment\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetEnvironmentRequest {
    /// Required. The name of the
    /// \[Environment\]\[google.cloud.dialogflow.cx.v3.Environment\]. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for
/// \[Environments.CreateEnvironment\]\[google.cloud.dialogflow.cx.v3.Environments.CreateEnvironment\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateEnvironmentRequest {
    /// Required. The \[Agent\]\[google.cloud.dialogflow.cx.v3.Agent\] to create an
    /// \[Environment\]\[google.cloud.dialogflow.cx.v3.Environment\] for. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The environment to create.
    #[prost(message, optional, tag = "2")]
    pub environment: ::core::option::Option<Environment>,
}
/// The request message for
/// \[Environments.UpdateEnvironment\]\[google.cloud.dialogflow.cx.v3.Environments.UpdateEnvironment\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateEnvironmentRequest {
    /// Required. The environment to update.
    #[prost(message, optional, tag = "1")]
    pub environment: ::core::option::Option<Environment>,
    /// Required. The mask to control which fields get updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// The request message for
/// \[Environments.DeleteEnvironment\]\[google.cloud.dialogflow.cx.v3.Environments.DeleteEnvironment\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteEnvironmentRequest {
    /// Required. The name of the
    /// \[Environment\]\[google.cloud.dialogflow.cx.v3.Environment\] to delete. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for
/// \[Environments.LookupEnvironmentHistory\]\[google.cloud.dialogflow.cx.v3.Environments.LookupEnvironmentHistory\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct LookupEnvironmentHistoryRequest {
    /// Required. Resource name of the environment to look up the history for.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The maximum number of items to return in a single page. By default 100 and
    /// at most 1000.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response message for
/// \[Environments.LookupEnvironmentHistory\]\[google.cloud.dialogflow.cx.v3.Environments.LookupEnvironmentHistory\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LookupEnvironmentHistoryResponse {
    /// Represents a list of snapshots for an environment. Time of the snapshots is
    /// stored in
    /// \[`update_time`\]\[google.cloud.dialogflow.cx.v3.Environment.update_time\].
    #[prost(message, repeated, tag = "1")]
    pub environments: ::prost::alloc::vec::Vec<Environment>,
    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Represents a result from running a test case in an agent environment.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ContinuousTestResult {
    /// The resource name for the continuous test result. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>/continuousTestResults/<ContinuousTestResultID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The result of this continuous test run, i.e. whether all the tests in this
    /// continuous test run pass or not.
    #[prost(enumeration = "continuous_test_result::AggregatedTestResult", tag = "2")]
    pub result: i32,
    /// A list of individual test case results names in this continuous test run.
    #[prost(string, repeated, tag = "3")]
    pub test_case_results: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Time when the continuous testing run starts.
    #[prost(message, optional, tag = "4")]
    pub run_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Nested message and enum types in `ContinuousTestResult`.
pub mod continuous_test_result {
    /// The overall result for a continuous test run in an agent environment.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum AggregatedTestResult {
        /// Not specified. Should never be used.
        Unspecified = 0,
        /// All the tests passed.
        Passed = 1,
        /// At least one test did not pass.
        Failed = 2,
    }
    impl AggregatedTestResult {
        /// 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 => "AGGREGATED_TEST_RESULT_UNSPECIFIED",
                Self::Passed => "PASSED",
                Self::Failed => "FAILED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "AGGREGATED_TEST_RESULT_UNSPECIFIED" => Some(Self::Unspecified),
                "PASSED" => Some(Self::Passed),
                "FAILED" => Some(Self::Failed),
                _ => None,
            }
        }
    }
}
/// The request message for
/// \[Environments.RunContinuousTest\]\[google.cloud.dialogflow.cx.v3.Environments.RunContinuousTest\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RunContinuousTestRequest {
    /// Required. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>`.
    #[prost(string, tag = "1")]
    pub environment: ::prost::alloc::string::String,
}
/// The response message for
/// \[Environments.RunContinuousTest\]\[google.cloud.dialogflow.cx.v3.Environments.RunContinuousTest\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RunContinuousTestResponse {
    /// The result for a continuous test run.
    #[prost(message, optional, tag = "1")]
    pub continuous_test_result: ::core::option::Option<ContinuousTestResult>,
}
/// Metadata returned for the
/// \[Environments.RunContinuousTest\]\[google.cloud.dialogflow.cx.v3.Environments.RunContinuousTest\]
/// long running operation.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RunContinuousTestMetadata {
    /// The test errors.
    #[prost(message, repeated, tag = "1")]
    pub errors: ::prost::alloc::vec::Vec<TestError>,
}
/// The request message for
/// \[Environments.ListContinuousTestResults\]\[google.cloud.dialogflow.cx.v3.Environments.ListContinuousTestResults\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListContinuousTestResultsRequest {
    /// Required. The environment to list results for.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of items to return in a single page. By default 100 and
    /// at most 1000.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response message for \[Environments.ListTestCaseResults\]\[\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListContinuousTestResultsResponse {
    /// The list of continuous test results.
    #[prost(message, repeated, tag = "1")]
    pub continuous_test_results: ::prost::alloc::vec::Vec<ContinuousTestResult>,
    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request message for
/// \[Environments.DeployFlow\]\[google.cloud.dialogflow.cx.v3.Environments.DeployFlow\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeployFlowRequest {
    /// Required. The environment to deploy the flow to.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>`.
    #[prost(string, tag = "1")]
    pub environment: ::prost::alloc::string::String,
    /// Required. The flow version to deploy.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/versions/<VersionID>`.
    #[prost(string, tag = "2")]
    pub flow_version: ::prost::alloc::string::String,
}
/// The response message for
/// \[Environments.DeployFlow\]\[google.cloud.dialogflow.cx.v3.Environments.DeployFlow\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeployFlowResponse {
    /// The updated environment where the flow is deployed.
    #[prost(message, optional, tag = "1")]
    pub environment: ::core::option::Option<Environment>,
    /// The name of the flow version
    /// \[Deployment\]\[google.cloud.dialogflow.cx.v3.Deployment\]. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>/deployments/<DeploymentID>`.
    #[prost(string, tag = "2")]
    pub deployment: ::prost::alloc::string::String,
}
/// Metadata returned for the
/// \[Environments.DeployFlow\]\[google.cloud.dialogflow.cx.v3.Environments.DeployFlow\]
/// long running operation.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeployFlowMetadata {
    /// Errors of running deployment tests.
    #[prost(message, repeated, tag = "1")]
    pub test_errors: ::prost::alloc::vec::Vec<TestError>,
}
/// Generated client implementations.
pub mod environments_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing
    /// \[Environments\]\[google.cloud.dialogflow.cx.v3.Environment\].
    #[derive(Debug, Clone)]
    pub struct EnvironmentsClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl EnvironmentsClient<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> EnvironmentsClient<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,
        ) -> EnvironmentsClient<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,
        {
            EnvironmentsClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Returns the list of all environments in the specified
        /// \[Agent\]\[google.cloud.dialogflow.cx.v3.Agent\].
        pub async fn list_environments(
            &mut self,
            request: impl tonic::IntoRequest<super::ListEnvironmentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListEnvironmentsResponse>,
            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.dialogflow.cx.v3.Environments/ListEnvironments",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Environments",
                        "ListEnvironments",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the specified
        /// \[Environment\]\[google.cloud.dialogflow.cx.v3.Environment\].
        pub async fn get_environment(
            &mut self,
            request: impl tonic::IntoRequest<super::GetEnvironmentRequest>,
        ) -> std::result::Result<tonic::Response<super::Environment>, 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.dialogflow.cx.v3.Environments/GetEnvironment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Environments",
                        "GetEnvironment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates an \[Environment\]\[google.cloud.dialogflow.cx.v3.Environment\] in the
        /// specified \[Agent\]\[google.cloud.dialogflow.cx.v3.Agent\].
        ///
        /// This method is a [long-running
        /// operation](https://cloud.google.com/dialogflow/cx/docs/how/long-running-operation).
        /// The returned `Operation` type has the following method-specific fields:
        ///
        /// * `metadata`: An empty [Struct
        ///  message](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#struct)
        /// * `response`: \[Environment\]\[google.cloud.dialogflow.cx.v3.Environment\]
        pub async fn create_environment(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateEnvironmentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.dialogflow.cx.v3.Environments/CreateEnvironment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Environments",
                        "CreateEnvironment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified
        /// \[Environment\]\[google.cloud.dialogflow.cx.v3.Environment\].
        ///
        /// This method is a [long-running
        /// operation](https://cloud.google.com/dialogflow/cx/docs/how/long-running-operation).
        /// The returned `Operation` type has the following method-specific fields:
        ///
        /// * `metadata`: An empty [Struct
        ///  message](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#struct)
        /// * `response`: \[Environment\]\[google.cloud.dialogflow.cx.v3.Environment\]
        pub async fn update_environment(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateEnvironmentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.dialogflow.cx.v3.Environments/UpdateEnvironment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Environments",
                        "UpdateEnvironment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified
        /// \[Environment\]\[google.cloud.dialogflow.cx.v3.Environment\].
        pub async fn delete_environment(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteEnvironmentRequest>,
        ) -> 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.dialogflow.cx.v3.Environments/DeleteEnvironment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Environments",
                        "DeleteEnvironment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Looks up the history of the specified
        /// \[Environment\]\[google.cloud.dialogflow.cx.v3.Environment\].
        pub async fn lookup_environment_history(
            &mut self,
            request: impl tonic::IntoRequest<super::LookupEnvironmentHistoryRequest>,
        ) -> std::result::Result<
            tonic::Response<super::LookupEnvironmentHistoryResponse>,
            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.dialogflow.cx.v3.Environments/LookupEnvironmentHistory",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Environments",
                        "LookupEnvironmentHistory",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Kicks off a continuous test under the specified
        /// \[Environment\]\[google.cloud.dialogflow.cx.v3.Environment\].
        ///
        /// This method is a [long-running
        /// operation](https://cloud.google.com/dialogflow/cx/docs/how/long-running-operation).
        /// The returned `Operation` type has the following method-specific fields:
        ///
        /// * `metadata`:
        ///  \[RunContinuousTestMetadata\]\[google.cloud.dialogflow.cx.v3.RunContinuousTestMetadata\]
        /// * `response`:
        ///  \[RunContinuousTestResponse\]\[google.cloud.dialogflow.cx.v3.RunContinuousTestResponse\]
        pub async fn run_continuous_test(
            &mut self,
            request: impl tonic::IntoRequest<super::RunContinuousTestRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.dialogflow.cx.v3.Environments/RunContinuousTest",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Environments",
                        "RunContinuousTest",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Fetches a list of continuous test results for a given environment.
        pub async fn list_continuous_test_results(
            &mut self,
            request: impl tonic::IntoRequest<super::ListContinuousTestResultsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListContinuousTestResultsResponse>,
            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.dialogflow.cx.v3.Environments/ListContinuousTestResults",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Environments",
                        "ListContinuousTestResults",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deploys a flow to the specified
        /// \[Environment\]\[google.cloud.dialogflow.cx.v3.Environment\].
        ///
        /// This method is a [long-running
        /// operation](https://cloud.google.com/dialogflow/cx/docs/how/long-running-operation).
        /// The returned `Operation` type has the following method-specific fields:
        ///
        /// * `metadata`:
        ///  \[DeployFlowMetadata\]\[google.cloud.dialogflow.cx.v3.DeployFlowMetadata\]
        /// * `response`:
        ///  \[DeployFlowResponse\]\[google.cloud.dialogflow.cx.v3.DeployFlowResponse\]
        pub async fn deploy_flow(
            &mut self,
            request: impl tonic::IntoRequest<super::DeployFlowRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.dialogflow.cx.v3.Environments/DeployFlow",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Environments",
                        "DeployFlow",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// The request message for
/// \[Examples.CreateExample\]\[google.cloud.dialogflow.cx.v3.Examples.CreateExample\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateExampleRequest {
    /// Required. The playbook to create an example for.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/playbooks/<PlaybookID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The example to create.
    #[prost(message, optional, tag = "2")]
    pub example: ::core::option::Option<Example>,
}
/// The request message for
/// \[Examples.DeleteExample\]\[google.cloud.dialogflow.cx.v3.Examples.DeleteExample\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteExampleRequest {
    /// Required. The name of the example to delete.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/playbooks/<PlaybookID>/examples/<ExampleID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for
/// \[Examples.ListExamples\]\[google.cloud.dialogflow.cx.v3.Examples.ListExamples\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListExamplesRequest {
    /// Required. The playbook to list the examples from.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/playbooks/<PlaybookID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The maximum number of items to return in a single page. By
    /// default 100 and at most 1000.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. The \[next_page_token\]\[ListExampleResponse.next_page_token\] value
    /// returned from a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. The language to list examples for.
    /// If not specified, list all examples under the playbook.
    /// Note: languages must be enabled in the agent before they can be used.
    #[prost(string, tag = "4")]
    pub language_code: ::prost::alloc::string::String,
}
/// The response message for
/// \[Examples.ListExamples\]\[google.cloud.dialogflow.cx.v3.Examples.ListExamples\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListExamplesResponse {
    /// The list of examples. There will be a maximum number of items returned
    /// based on the
    /// \[page_size\]\[google.cloud.dialogflow.cx.v3.ListExamplesRequest.page_size\]
    /// field in the request.
    #[prost(message, repeated, tag = "1")]
    pub examples: ::prost::alloc::vec::Vec<Example>,
    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request message for
/// \[Examples.GetExample\]\[google.cloud.dialogflow.cx.v3.Examples.GetExample\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetExampleRequest {
    /// Required. The name of the example.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/playbooks/<PlaybookID>/examples/<ExampleID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for
/// \[Examples.UpdateExample\]\[google.cloud.dialogflow.cx.v3.Examples.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. The mask 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>,
}
/// Example represents a sample execution of the playbook in the conversation.
///
/// An example consists of a list of ordered actions performed by end user
/// or Dialogflow agent according the playbook instructions to fulfill the task.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Example {
    /// The unique identifier of the playbook example.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/playbooks/<PlaybookID>/examples/<ExampleID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The input to the playbook in the example.
    #[prost(message, optional, tag = "3")]
    pub playbook_input: ::core::option::Option<PlaybookInput>,
    /// Optional. The output of the playbook in the example.
    #[prost(message, optional, tag = "4")]
    pub playbook_output: ::core::option::Option<PlaybookOutput>,
    /// Required. The ordered list of actions performed by the end user and the
    /// Dialogflow agent.
    #[prost(message, repeated, tag = "2")]
    pub actions: ::prost::alloc::vec::Vec<Action>,
    /// Required. The display name of the example.
    #[prost(string, tag = "6")]
    pub display_name: ::prost::alloc::string::String,
    /// Optional. The high level concise description of the example. The max number
    /// of characters is 200.
    #[prost(string, tag = "8")]
    pub description: ::prost::alloc::string::String,
    /// Output only. Estimated number of tokes current example takes when sent to
    /// the LLM.
    #[prost(int64, tag = "9")]
    pub token_count: i64,
    /// Output only. The timestamp of initial example creation.
    #[prost(message, optional, tag = "10")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Last time the example was updated.
    #[prost(message, optional, tag = "11")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Required. Example's output state.
    #[prost(enumeration = "OutputState", tag = "12")]
    pub conversation_state: i32,
    /// Optional. The language code of the example.
    /// If not specified, the agent's default language is used.
    /// Note: languages must be enabled in the agent before they can be used.
    /// Note: example's language code is not currently used in dialogflow agents.
    #[prost(string, tag = "13")]
    pub language_code: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod examples_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing \[Examples\]\[google.cloud.dialogflow.cx.v3.Example\].
    #[derive(Debug, Clone)]
    pub struct ExamplesClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ExamplesClient<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> ExamplesClient<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,
        ) -> ExamplesClient<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,
        {
            ExamplesClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Creates an example in the specified playbook.
        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.dialogflow.cx.v3.Examples/CreateExample",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Examples",
                        "CreateExample",
                    ),
                );
            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.dialogflow.cx.v3.Examples/DeleteExample",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Examples",
                        "DeleteExample",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns a list of examples in the specified playbook.
        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.dialogflow.cx.v3.Examples/ListExamples",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Examples",
                        "ListExamples",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves 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.dialogflow.cx.v3.Examples/GetExample",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Examples",
                        "GetExample",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Update 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.dialogflow.cx.v3.Examples/UpdateExample",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Examples",
                        "UpdateExample",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Represents an experiment in an environment.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Experiment {
    /// The name of the experiment.
    /// Format:
    /// projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>/experiments/<ExperimentID>.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. The human-readable name of the experiment (unique in an
    /// environment). Limit of 64 characters.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// The human-readable description of the experiment.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// The current state of the experiment.
    /// Transition triggered by Experiments.StartExperiment: DRAFT->RUNNING.
    /// Transition triggered by Experiments.CancelExperiment: DRAFT->DONE or
    /// RUNNING->DONE.
    #[prost(enumeration = "experiment::State", tag = "4")]
    pub state: i32,
    /// The definition of the experiment.
    #[prost(message, optional, tag = "5")]
    pub definition: ::core::option::Option<experiment::Definition>,
    /// The configuration for auto rollout. If set, there should be exactly two
    /// variants in the experiment (control variant being the default version of
    /// the flow), the traffic allocation for the non-control variant will
    /// gradually increase to 100% when conditions are met, and eventually
    /// replace the control variant to become the default version of the flow.
    #[prost(message, optional, tag = "14")]
    pub rollout_config: ::core::option::Option<RolloutConfig>,
    /// State of the auto rollout process.
    #[prost(message, optional, tag = "15")]
    pub rollout_state: ::core::option::Option<RolloutState>,
    /// The reason why rollout has failed. Should only be set when state is
    /// ROLLOUT_FAILED.
    #[prost(string, tag = "16")]
    pub rollout_failure_reason: ::prost::alloc::string::String,
    /// Inference result of the experiment.
    #[prost(message, optional, tag = "6")]
    pub result: ::core::option::Option<experiment::Result>,
    /// Creation time of this experiment.
    #[prost(message, optional, tag = "7")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Start time of this experiment.
    #[prost(message, optional, tag = "8")]
    pub start_time: ::core::option::Option<::prost_types::Timestamp>,
    /// End time of this experiment.
    #[prost(message, optional, tag = "9")]
    pub end_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Last update time of this experiment.
    #[prost(message, optional, tag = "10")]
    pub last_update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Maximum number of days to run the experiment/rollout. If auto-rollout is
    /// not enabled, default value and maximum will be 30 days. If auto-rollout is
    /// enabled, default value and maximum will be 6 days.
    #[prost(message, optional, tag = "11")]
    pub experiment_length: ::core::option::Option<::prost_types::Duration>,
    /// The history of updates to the experiment variants.
    #[prost(message, repeated, tag = "12")]
    pub variants_history: ::prost::alloc::vec::Vec<VariantsHistory>,
}
/// Nested message and enum types in `Experiment`.
pub mod experiment {
    /// Definition of the experiment.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Definition {
        /// The condition defines which subset of sessions are selected for
        /// this experiment. If not specified, all sessions are eligible. E.g.
        /// "query_input.language_code=en" See the [conditions
        /// reference](<https://cloud.google.com/dialogflow/cx/docs/reference/condition>).
        #[prost(string, tag = "1")]
        pub condition: ::prost::alloc::string::String,
        /// The variants of the experiment. We currently only support single variant
        /// experiment.
        #[prost(oneof = "definition::Variants", tags = "2")]
        pub variants: ::core::option::Option<definition::Variants>,
    }
    /// Nested message and enum types in `Definition`.
    pub mod definition {
        /// The variants of the experiment. We currently only support single variant
        /// experiment.
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Variants {
            /// The flow versions as the variants of this experiment.
            #[prost(message, tag = "2")]
            VersionVariants(super::super::VersionVariants),
        }
    }
    /// The inference result which includes an objective metric to optimize and the
    /// confidence interval.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Result {
        /// Version variants and metrics.
        #[prost(message, repeated, tag = "1")]
        pub version_metrics: ::prost::alloc::vec::Vec<result::VersionMetrics>,
        /// The last time the experiment's stats data was updated. Will have default
        /// value if stats have never been computed for this experiment.
        #[prost(message, optional, tag = "2")]
        pub last_update_time: ::core::option::Option<::prost_types::Timestamp>,
    }
    /// Nested message and enum types in `Result`.
    pub mod result {
        /// A confidence interval is a range of possible values for the experiment
        /// objective you are trying to measure.
        #[derive(Clone, Copy, PartialEq, ::prost::Message)]
        pub struct ConfidenceInterval {
            /// The confidence level used to construct the interval, i.e. there is X%
            /// chance that the true value is within this interval.
            #[prost(double, tag = "1")]
            pub confidence_level: f64,
            /// The percent change between an experiment metric's value and the value
            /// for its control.
            #[prost(double, tag = "2")]
            pub ratio: f64,
            /// Lower bound of the interval.
            #[prost(double, tag = "3")]
            pub lower_bound: f64,
            /// Upper bound of the interval.
            #[prost(double, tag = "4")]
            pub upper_bound: f64,
        }
        /// Metric and corresponding confidence intervals.
        #[derive(Clone, Copy, PartialEq, ::prost::Message)]
        pub struct Metric {
            /// Ratio-based metric type. Only one of type or count_type is specified in
            /// each Metric.
            #[prost(enumeration = "MetricType", tag = "1")]
            pub r#type: i32,
            /// Count-based metric type. Only one of type or count_type is specified in
            /// each Metric.
            #[prost(enumeration = "CountType", tag = "5")]
            pub count_type: i32,
            /// The probability that the treatment is better than all other treatments
            /// in the experiment
            #[prost(message, optional, tag = "3")]
            pub confidence_interval: ::core::option::Option<ConfidenceInterval>,
            /// The actual value of the metric.
            #[prost(oneof = "metric::Value", tags = "2, 4")]
            pub value: ::core::option::Option<metric::Value>,
        }
        /// Nested message and enum types in `Metric`.
        pub mod metric {
            /// The actual value of the metric.
            #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
            pub enum Value {
                /// Ratio value of a metric.
                #[prost(double, tag = "2")]
                Ratio(f64),
                /// Count value of a metric.
                #[prost(double, tag = "4")]
                Count(f64),
            }
        }
        /// Version variant and associated metrics.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct VersionMetrics {
            /// The name of the flow \[Version\]\[google.cloud.dialogflow.cx.v3.Version\].
            /// Format:
            /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/versions/<VersionID>`.
            #[prost(string, tag = "1")]
            pub version: ::prost::alloc::string::String,
            /// The metrics and corresponding confidence intervals in the inference
            /// result.
            #[prost(message, repeated, tag = "2")]
            pub metrics: ::prost::alloc::vec::Vec<Metric>,
            /// Number of sessions that were allocated to this version.
            #[prost(int32, tag = "3")]
            pub session_count: i32,
        }
        /// Types of ratio-based metric for Dialogflow experiment.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum MetricType {
            /// Metric unspecified.
            MetricUnspecified = 0,
            /// Percentage of contained sessions without user calling back in 24 hours.
            ContainedSessionNoCallbackRate = 1,
            /// Percentage of sessions that were handed to a human agent.
            LiveAgentHandoffRate = 2,
            /// Percentage of sessions with the same user calling back.
            CallbackSessionRate = 3,
            /// Percentage of sessions where user hung up.
            AbandonedSessionRate = 4,
            /// Percentage of sessions reached Dialogflow 'END_PAGE' or
            /// 'END_SESSION'.
            SessionEndRate = 5,
        }
        impl MetricType {
            /// 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::MetricUnspecified => "METRIC_UNSPECIFIED",
                    Self::ContainedSessionNoCallbackRate => {
                        "CONTAINED_SESSION_NO_CALLBACK_RATE"
                    }
                    Self::LiveAgentHandoffRate => "LIVE_AGENT_HANDOFF_RATE",
                    Self::CallbackSessionRate => "CALLBACK_SESSION_RATE",
                    Self::AbandonedSessionRate => "ABANDONED_SESSION_RATE",
                    Self::SessionEndRate => "SESSION_END_RATE",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "METRIC_UNSPECIFIED" => Some(Self::MetricUnspecified),
                    "CONTAINED_SESSION_NO_CALLBACK_RATE" => {
                        Some(Self::ContainedSessionNoCallbackRate)
                    }
                    "LIVE_AGENT_HANDOFF_RATE" => Some(Self::LiveAgentHandoffRate),
                    "CALLBACK_SESSION_RATE" => Some(Self::CallbackSessionRate),
                    "ABANDONED_SESSION_RATE" => Some(Self::AbandonedSessionRate),
                    "SESSION_END_RATE" => Some(Self::SessionEndRate),
                    _ => None,
                }
            }
        }
        /// Types of count-based metric for Dialogflow experiment.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum CountType {
            /// Count type unspecified.
            Unspecified = 0,
            /// Total number of occurrences of a 'NO_MATCH'.
            TotalNoMatchCount = 1,
            /// Total number of turn counts.
            TotalTurnCount = 2,
            /// Average turn count in a session.
            AverageTurnCount = 3,
        }
        impl CountType {
            /// 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 => "COUNT_TYPE_UNSPECIFIED",
                    Self::TotalNoMatchCount => "TOTAL_NO_MATCH_COUNT",
                    Self::TotalTurnCount => "TOTAL_TURN_COUNT",
                    Self::AverageTurnCount => "AVERAGE_TURN_COUNT",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "COUNT_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                    "TOTAL_NO_MATCH_COUNT" => Some(Self::TotalNoMatchCount),
                    "TOTAL_TURN_COUNT" => Some(Self::TotalTurnCount),
                    "AVERAGE_TURN_COUNT" => Some(Self::AverageTurnCount),
                    _ => None,
                }
            }
        }
    }
    /// The state of the experiment.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// State unspecified.
        Unspecified = 0,
        /// The experiment is created but not started yet.
        Draft = 1,
        /// The experiment is running.
        Running = 2,
        /// The experiment is done.
        Done = 3,
        /// The experiment with auto-rollout enabled has failed.
        RolloutFailed = 4,
    }
    impl State {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "STATE_UNSPECIFIED",
                Self::Draft => "DRAFT",
                Self::Running => "RUNNING",
                Self::Done => "DONE",
                Self::RolloutFailed => "ROLLOUT_FAILED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "DRAFT" => Some(Self::Draft),
                "RUNNING" => Some(Self::Running),
                "DONE" => Some(Self::Done),
                "ROLLOUT_FAILED" => Some(Self::RolloutFailed),
                _ => None,
            }
        }
    }
}
/// A list of flow version variants.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VersionVariants {
    /// A list of flow version variants.
    #[prost(message, repeated, tag = "1")]
    pub variants: ::prost::alloc::vec::Vec<version_variants::Variant>,
}
/// Nested message and enum types in `VersionVariants`.
pub mod version_variants {
    /// A single flow version with specified traffic allocation.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Variant {
        /// The name of the flow version.
        /// Format:
        /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/versions/<VersionID>`.
        #[prost(string, tag = "1")]
        pub version: ::prost::alloc::string::String,
        /// Percentage of the traffic which should be routed to this
        /// version of flow. Traffic allocation for a single flow must sum up to 1.0.
        #[prost(float, tag = "2")]
        pub traffic_allocation: f32,
        /// Whether the variant is for the control group.
        #[prost(bool, tag = "3")]
        pub is_control_group: bool,
    }
}
/// The history of variants update.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VariantsHistory {
    /// Update time of the variants.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The variants updated. We currently only support single variant
    /// experiment.
    #[prost(oneof = "variants_history::Variants", tags = "1")]
    pub variants: ::core::option::Option<variants_history::Variants>,
}
/// Nested message and enum types in `VariantsHistory`.
pub mod variants_history {
    /// The variants updated. We currently only support single variant
    /// experiment.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Variants {
        /// The flow versions as the variants.
        #[prost(message, tag = "1")]
        VersionVariants(super::VersionVariants),
    }
}
/// The configuration for auto rollout.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RolloutConfig {
    /// Steps to roll out a flow version. Steps should be sorted by percentage in
    /// ascending order.
    #[prost(message, repeated, tag = "1")]
    pub rollout_steps: ::prost::alloc::vec::Vec<rollout_config::RolloutStep>,
    /// The conditions that are used to evaluate the success of a rollout
    /// step. If not specified, all rollout steps will proceed to the next one
    /// unless failure conditions are met. E.g. "containment_rate > 60% AND
    /// callback_rate \< 20%". See the [conditions
    /// reference](<https://cloud.google.com/dialogflow/cx/docs/reference/condition>).
    #[prost(string, tag = "2")]
    pub rollout_condition: ::prost::alloc::string::String,
    /// The conditions that are used to evaluate the failure of a rollout
    /// step. If not specified, no rollout steps will fail. E.g. "containment_rate
    /// \< 10% OR average_turn_count \< 3". See the [conditions
    /// reference](<https://cloud.google.com/dialogflow/cx/docs/reference/condition>).
    #[prost(string, tag = "3")]
    pub failure_condition: ::prost::alloc::string::String,
}
/// Nested message and enum types in `RolloutConfig`.
pub mod rollout_config {
    /// A single rollout step with specified traffic allocation.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct RolloutStep {
        /// The name of the rollout step;
        #[prost(string, tag = "1")]
        pub display_name: ::prost::alloc::string::String,
        /// The percentage of traffic allocated to the flow version of this rollout
        /// step. (0%, 100%\].
        #[prost(int32, tag = "2")]
        pub traffic_percent: i32,
        /// The minimum time that this step should last. Should be longer than 1
        /// hour. If not set, the default minimum duration for each step will be 1
        /// hour.
        #[prost(message, optional, tag = "3")]
        pub min_duration: ::core::option::Option<::prost_types::Duration>,
    }
}
/// State of the auto-rollout process.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RolloutState {
    /// Display name of the current auto rollout step.
    #[prost(string, tag = "1")]
    pub step: ::prost::alloc::string::String,
    /// Index of the current step in the auto rollout steps list.
    #[prost(int32, tag = "3")]
    pub step_index: i32,
    /// Start time of the current step.
    #[prost(message, optional, tag = "2")]
    pub start_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// The request message for
/// \[Experiments.ListExperiments\]\[google.cloud.dialogflow.cx.v3.Experiments.ListExperiments\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListExperimentsRequest {
    /// Required. The \[Environment\]\[google.cloud.dialogflow.cx.v3.Environment\] to
    /// list all environments for. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of items to return in a single page. By default 20 and
    /// at most 100.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response message for
/// \[Experiments.ListExperiments\]\[google.cloud.dialogflow.cx.v3.Experiments.ListExperiments\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListExperimentsResponse {
    /// The list of experiments. There will be a maximum number of items
    /// returned based on the page_size field in the request. The list may in some
    /// cases be empty or contain fewer entries than page_size even if this isn't
    /// the last page.
    #[prost(message, repeated, tag = "1")]
    pub experiments: ::prost::alloc::vec::Vec<Experiment>,
    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request message for
/// \[Experiments.GetExperiment\]\[google.cloud.dialogflow.cx.v3.Experiments.GetExperiment\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetExperimentRequest {
    /// Required. The name of the
    /// \[Environment\]\[google.cloud.dialogflow.cx.v3.Environment\]. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>/experiments/<ExperimentID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for
/// \[Experiments.CreateExperiment\]\[google.cloud.dialogflow.cx.v3.Experiments.CreateExperiment\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateExperimentRequest {
    /// Required. The \[Agent\]\[google.cloud.dialogflow.cx.v3.Agent\] to create an
    /// \[Environment\]\[google.cloud.dialogflow.cx.v3.Environment\] for. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The experiment to create.
    #[prost(message, optional, tag = "2")]
    pub experiment: ::core::option::Option<Experiment>,
}
/// The request message for
/// \[Experiments.UpdateExperiment\]\[google.cloud.dialogflow.cx.v3.Experiments.UpdateExperiment\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateExperimentRequest {
    /// Required. The experiment to update.
    #[prost(message, optional, tag = "1")]
    pub experiment: ::core::option::Option<Experiment>,
    /// Required. The mask to control which fields get updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// The request message for
/// \[Experiments.DeleteExperiment\]\[google.cloud.dialogflow.cx.v3.Experiments.DeleteExperiment\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteExperimentRequest {
    /// Required. The name of the
    /// \[Environment\]\[google.cloud.dialogflow.cx.v3.Environment\] to delete. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>/experiments/<ExperimentID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for
/// \[Experiments.StartExperiment\]\[google.cloud.dialogflow.cx.v3.Experiments.StartExperiment\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StartExperimentRequest {
    /// Required. Resource name of the experiment to start.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>/experiments/<ExperimentID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for
/// \[Experiments.StopExperiment\]\[google.cloud.dialogflow.cx.v3.Experiments.StopExperiment\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StopExperimentRequest {
    /// Required. Resource name of the experiment to stop.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/environments/<EnvironmentID>/experiments/<ExperimentID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod experiments_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing \[Experiments\]\[google.cloud.dialogflow.cx.v3.Experiment\].
    #[derive(Debug, Clone)]
    pub struct ExperimentsClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ExperimentsClient<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> ExperimentsClient<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,
        ) -> ExperimentsClient<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,
        {
            ExperimentsClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Returns the list of all experiments in the specified
        /// \[Environment\]\[google.cloud.dialogflow.cx.v3.Environment\].
        pub async fn list_experiments(
            &mut self,
            request: impl tonic::IntoRequest<super::ListExperimentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListExperimentsResponse>,
            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.dialogflow.cx.v3.Experiments/ListExperiments",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Experiments",
                        "ListExperiments",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the specified
        /// \[Experiment\]\[google.cloud.dialogflow.cx.v3.Experiment\].
        pub async fn get_experiment(
            &mut self,
            request: impl tonic::IntoRequest<super::GetExperimentRequest>,
        ) -> std::result::Result<tonic::Response<super::Experiment>, 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.dialogflow.cx.v3.Experiments/GetExperiment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Experiments",
                        "GetExperiment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates an \[Experiment\]\[google.cloud.dialogflow.cx.v3.Experiment\] in the
        /// specified \[Environment\]\[google.cloud.dialogflow.cx.v3.Environment\].
        pub async fn create_experiment(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateExperimentRequest>,
        ) -> std::result::Result<tonic::Response<super::Experiment>, 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.dialogflow.cx.v3.Experiments/CreateExperiment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Experiments",
                        "CreateExperiment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified
        /// \[Experiment\]\[google.cloud.dialogflow.cx.v3.Experiment\].
        pub async fn update_experiment(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateExperimentRequest>,
        ) -> std::result::Result<tonic::Response<super::Experiment>, 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.dialogflow.cx.v3.Experiments/UpdateExperiment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Experiments",
                        "UpdateExperiment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified
        /// \[Experiment\]\[google.cloud.dialogflow.cx.v3.Experiment\].
        pub async fn delete_experiment(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteExperimentRequest>,
        ) -> 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.dialogflow.cx.v3.Experiments/DeleteExperiment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Experiments",
                        "DeleteExperiment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Starts the specified
        /// \[Experiment\]\[google.cloud.dialogflow.cx.v3.Experiment\]. This rpc only
        /// changes the state of experiment from PENDING to RUNNING.
        pub async fn start_experiment(
            &mut self,
            request: impl tonic::IntoRequest<super::StartExperimentRequest>,
        ) -> std::result::Result<tonic::Response<super::Experiment>, 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.dialogflow.cx.v3.Experiments/StartExperiment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Experiments",
                        "StartExperiment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Stops the specified \[Experiment\]\[google.cloud.dialogflow.cx.v3.Experiment\].
        /// This rpc only changes the state of experiment from RUNNING to DONE.
        pub async fn stop_experiment(
            &mut self,
            request: impl tonic::IntoRequest<super::StopExperimentRequest>,
        ) -> std::result::Result<tonic::Response<super::Experiment>, 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.dialogflow.cx.v3.Experiments/StopExperiment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Experiments",
                        "StopExperiment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Generators contain prompt to be sent to the LLM model to generate text. The
/// prompt can contain parameters which will be resolved before calling the
/// model. It can optionally contain banned phrases to ensure the model responses
/// are safe.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Generator {
    /// The unique identifier of the generator.
    /// Must be set for the
    /// \[Generators.UpdateGenerator\]\[google.cloud.dialogflow.cx.v3.Generators.UpdateGenerator\]
    /// method. \[Generators.CreateGenerate\]\[\] populates the name automatically.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/generators/<GeneratorID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. The human-readable name of the generator, unique within the
    /// agent. The prompt contains pre-defined parameters such as $conversation,
    /// $last-user-utterance, etc. populated by Dialogflow. It can also contain
    /// custom placeholders which will be resolved during fulfillment.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Required. Prompt for the LLM model.
    #[prost(message, optional, tag = "3")]
    pub prompt_text: ::core::option::Option<Phrase>,
    /// Optional. List of custom placeholders in the prompt text.
    #[prost(message, repeated, tag = "5")]
    pub placeholders: ::prost::alloc::vec::Vec<generator::Placeholder>,
    /// The LLM model settings.
    #[prost(message, optional, tag = "9")]
    pub llm_model_settings: ::core::option::Option<LlmModelSettings>,
    /// Parameters passed to the LLM to configure its behavior.
    #[prost(message, optional, tag = "8")]
    pub model_parameter: ::core::option::Option<generator::ModelParameter>,
}
/// Nested message and enum types in `Generator`.
pub mod generator {
    /// Represents a custom placeholder in the prompt text.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Placeholder {
        /// Unique ID used to map custom placeholder to parameters in fulfillment.
        #[prost(string, tag = "1")]
        pub id: ::prost::alloc::string::String,
        /// Custom placeholder value in the prompt text.
        #[prost(string, tag = "2")]
        pub name: ::prost::alloc::string::String,
    }
    /// Parameters to be passed to the LLM. If not set, default values will be
    /// used.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct ModelParameter {
        /// The temperature used for sampling. Temperature sampling occurs after both
        /// topP and topK have been applied.
        /// Valid range: \[0.0, 1.0\]
        /// Low temperature = less random. High temperature = more random.
        #[prost(float, optional, tag = "1")]
        pub temperature: ::core::option::Option<f32>,
        /// The maximum number of tokens to generate.
        #[prost(int32, optional, tag = "2")]
        pub max_decode_steps: ::core::option::Option<i32>,
        /// If set, only the tokens comprising the top top_p probability mass are
        /// considered. If both top_p and top_k are
        /// set, top_p will be used for further refining candidates selected with
        /// top_k.
        /// Valid range: (0.0, 1.0\].
        /// Small topP = less random. Large topP = more random.
        #[prost(float, optional, tag = "3")]
        pub top_p: ::core::option::Option<f32>,
        /// If set, the sampling process in each step is limited to the top_k tokens
        /// with highest probabilities.
        /// Valid range: \[1, 40\] or 1000+.
        /// Small topK = less random. Large topK = more random.
        #[prost(int32, optional, tag = "4")]
        pub top_k: ::core::option::Option<i32>,
    }
}
/// Text input which can be used for prompt or banned phrases.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Phrase {
    /// Required. Text input which can be used for prompt or banned phrases.
    #[prost(string, tag = "1")]
    pub text: ::prost::alloc::string::String,
}
/// The request message for
/// \[Generators.ListGenerators\]\[google.cloud.dialogflow.cx.v3.Generators.ListGenerators\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListGeneratorsRequest {
    /// Required. The agent to list all generators for.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The language to list generators for.
    #[prost(string, tag = "2")]
    pub language_code: ::prost::alloc::string::String,
    /// The maximum number of items to return in a single page. By default 100 and
    /// at most 1000.
    #[prost(int32, tag = "3")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous list request.
    #[prost(string, tag = "4")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response message for
/// \[Generators.ListGenerators\]\[google.cloud.dialogflow.cx.v3.Generators.ListGenerators\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListGeneratorsResponse {
    /// The list of generators. There will be a maximum number of items returned
    /// based on the page_size field in the request.
    #[prost(message, repeated, tag = "1")]
    pub generators: ::prost::alloc::vec::Vec<Generator>,
    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request message for
/// \[Generators.GetGenerator\]\[google.cloud.dialogflow.cx.v3.Generators.GetGenerator\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetGeneratorRequest {
    /// Required. The name of the generator.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/generators/<GeneratorID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The language to list generators for.
    #[prost(string, tag = "2")]
    pub language_code: ::prost::alloc::string::String,
}
/// The request message for
/// \[Generators.CreateGenerator\]\[google.cloud.dialogflow.cx.v3.Generators.CreateGenerator\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateGeneratorRequest {
    /// Required. The agent to create a generator for.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The generator to create.
    #[prost(message, optional, tag = "2")]
    pub generator: ::core::option::Option<Generator>,
    /// The language to create generators for the following fields:
    ///
    /// * `Generator.prompt_text.text`
    ///   If not specified, the agent's default language is used.
    #[prost(string, tag = "3")]
    pub language_code: ::prost::alloc::string::String,
}
/// The request message for
/// \[Generators.UpdateGenerator\]\[google.cloud.dialogflow.cx.v3.Generators.UpdateGenerator\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateGeneratorRequest {
    /// Required. The generator to update.
    #[prost(message, optional, tag = "1")]
    pub generator: ::core::option::Option<Generator>,
    /// The language to list generators for.
    #[prost(string, tag = "2")]
    pub language_code: ::prost::alloc::string::String,
    /// The mask to control which fields get updated. If the mask is not present,
    /// all fields will be updated.
    #[prost(message, optional, tag = "3")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// The request message for
/// \[Generators.DeleteGenerator\]\[google.cloud.dialogflow.cx.v3.Generators.DeleteGenerator\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteGeneratorRequest {
    /// Required. The name of the generator to delete.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/generators/<GeneratorID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// This field has no effect for generators not being used.
    /// For generators that are used by pages/flows/transition route groups:
    ///
    /// * If `force` is set to false, an error will be returned with message
    ///   indicating the referenced resources.
    /// * If `force` is set to true, Dialogflow will remove the generator, as well
    ///   as any references to the generator (i.e.
    ///   \[Generator\]\[Fulfillment.generator\]) in fulfillments.
    #[prost(bool, tag = "2")]
    pub force: bool,
}
/// Generated client implementations.
pub mod generators_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing \[Generators\]\[google.cloud.dialogflow.cx.v3.Generator\]
    #[derive(Debug, Clone)]
    pub struct GeneratorsClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl GeneratorsClient<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> GeneratorsClient<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,
        ) -> GeneratorsClient<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,
        {
            GeneratorsClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Returns the list of all generators in the specified agent.
        pub async fn list_generators(
            &mut self,
            request: impl tonic::IntoRequest<super::ListGeneratorsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListGeneratorsResponse>,
            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.dialogflow.cx.v3.Generators/ListGenerators",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Generators",
                        "ListGenerators",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the specified generator.
        pub async fn get_generator(
            &mut self,
            request: impl tonic::IntoRequest<super::GetGeneratorRequest>,
        ) -> std::result::Result<tonic::Response<super::Generator>, 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.dialogflow.cx.v3.Generators/GetGenerator",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Generators",
                        "GetGenerator",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a generator in the specified agent.
        pub async fn create_generator(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateGeneratorRequest>,
        ) -> std::result::Result<tonic::Response<super::Generator>, 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.dialogflow.cx.v3.Generators/CreateGenerator",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Generators",
                        "CreateGenerator",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Update the specified generator.
        pub async fn update_generator(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateGeneratorRequest>,
        ) -> std::result::Result<tonic::Response<super::Generator>, 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.dialogflow.cx.v3.Generators/UpdateGenerator",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Generators",
                        "UpdateGenerator",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified generators.
        pub async fn delete_generator(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteGeneratorRequest>,
        ) -> 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.dialogflow.cx.v3.Generators/DeleteGenerator",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Generators",
                        "DeleteGenerator",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// The request message for
/// \[Playbooks.CreatePlaybook\]\[google.cloud.dialogflow.cx.v3.Playbooks.CreatePlaybook\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreatePlaybookRequest {
    /// Required. The agent to create a playbook for.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The playbook to create.
    #[prost(message, optional, tag = "2")]
    pub playbook: ::core::option::Option<Playbook>,
}
/// The request message for
/// \[Playbooks.DeletePlaybook\]\[google.cloud.dialogflow.cx.v3.Playbooks.DeletePlaybook\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeletePlaybookRequest {
    /// Required. The name of the playbook to delete.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/playbooks/<PlaybookID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for
/// \[Playbooks.ListPlaybooks\]\[google.cloud.dialogflow.cx.v3.Playbooks.ListPlaybooks\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListPlaybooksRequest {
    /// Required. The agent to list playbooks from.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of items to return in a single page. By default 100 and
    /// at most 1000.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response message for
/// \[Playbooks.ListPlaybooks\]\[google.cloud.dialogflow.cx.v3.Playbooks.ListPlaybooks\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListPlaybooksResponse {
    /// The list of playbooks. There will be a maximum number of items returned
    /// based on the page_size field in the request.
    #[prost(message, repeated, tag = "1")]
    pub playbooks: ::prost::alloc::vec::Vec<Playbook>,
    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request message for
/// \[Playbooks.GetPlaybook\]\[google.cloud.dialogflow.cx.v3.Playbooks.GetPlaybook\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetPlaybookRequest {
    /// Required. The name of the playbook.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/playbooks/<PlaybookID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for
/// \[Playbooks.UpdatePlaybook\]\[google.cloud.dialogflow.cx.v3.Playbooks.UpdatePlaybook\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdatePlaybookRequest {
    /// Required. The playbook to update.
    #[prost(message, optional, tag = "1")]
    pub playbook: ::core::option::Option<Playbook>,
    /// The mask 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>,
}
/// Playbook is the basic building block to instruct the LLM how to execute a
/// certain task.
///
/// A playbook consists of a goal to accomplish, an optional list of step by step
/// instructions (the step instruction may refers to name of the custom or
/// default plugin tools to use) to perform the task,
/// a list of contextual input data to be passed in at the beginning of the
/// invoked, and a list of output parameters to store the playbook result.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Playbook {
    /// The unique identifier of the playbook.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/playbooks/<PlaybookID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. The human-readable name of the playbook, unique within an agent.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Required. High level description of the goal the playbook intend to
    /// accomplish. A goal should be concise since it's visible to other playbooks
    /// that may reference this playbook.
    #[prost(string, tag = "3")]
    pub goal: ::prost::alloc::string::String,
    /// Optional. Defined structured input parameters for this playbook.
    #[prost(message, repeated, tag = "5")]
    pub input_parameter_definitions: ::prost::alloc::vec::Vec<ParameterDefinition>,
    /// Optional. Defined structured output parameters for this playbook.
    #[prost(message, repeated, tag = "6")]
    pub output_parameter_definitions: ::prost::alloc::vec::Vec<ParameterDefinition>,
    /// Instruction to accomplish target goal.
    #[prost(message, optional, tag = "17")]
    pub instruction: ::core::option::Option<playbook::Instruction>,
    /// Output only. Estimated number of tokes current playbook takes when sent to
    /// the LLM.
    #[prost(int64, tag = "8")]
    pub token_count: i64,
    /// Output only. The timestamp of initial playbook creation.
    #[prost(message, optional, tag = "9")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Last time the playbook version was updated.
    #[prost(message, optional, tag = "10")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The resource name of other playbooks referenced by the current
    /// playbook in the instructions.
    #[prost(string, repeated, tag = "11")]
    pub referenced_playbooks: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Output only. The resource name of flows referenced by the current playbook
    /// in the instructions.
    #[prost(string, repeated, tag = "12")]
    pub referenced_flows: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. The resource name of tools referenced by the current playbook in
    /// the instructions. If not provided explicitly, they are will
    /// be implied using the tool being referenced in goal and steps.
    #[prost(string, repeated, tag = "13")]
    pub referenced_tools: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. Output only. Names of inline actions scoped to this playbook.
    /// These actions are in addition to those belonging to referenced tools, child
    /// playbooks, and flows, e.g. actions that are defined in the playbook's code
    /// block.
    #[prost(string, repeated, tag = "22")]
    pub inline_actions: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. The playbook's scoped code block, which may implement handlers
    /// and actions.
    #[prost(message, optional, tag = "21")]
    pub code_block: ::core::option::Option<CodeBlock>,
    /// Optional. Llm model settings for the playbook.
    #[prost(message, optional, tag = "14")]
    pub llm_model_settings: ::core::option::Option<LlmModelSettings>,
    /// Optional. A list of registered handlers to execuate based on the specified
    /// triggers.
    #[prost(message, repeated, tag = "16")]
    pub handlers: ::prost::alloc::vec::Vec<Handler>,
    /// Optional. Type of the playbook.
    #[prost(enumeration = "playbook::PlaybookType", tag = "19")]
    pub playbook_type: i32,
}
/// Nested message and enum types in `Playbook`.
pub mod playbook {
    /// Message of single step execution.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Step {
        /// Sub-processing needed to execute the current step.
        #[prost(message, repeated, tag = "2")]
        pub steps: ::prost::alloc::vec::Vec<Step>,
        /// Instruction on how to execute current step.
        #[prost(oneof = "step::Instruction", tags = "1")]
        pub instruction: ::core::option::Option<step::Instruction>,
    }
    /// Nested message and enum types in `Step`.
    pub mod step {
        /// Instruction on how to execute current step.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
        pub enum Instruction {
            /// Step instruction in text format.
            #[prost(string, tag = "1")]
            Text(::prost::alloc::string::String),
        }
    }
    /// Message of the Instruction of the playbook.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Instruction {
        /// General guidelines for the playbook. These are unstructured instructions
        /// that are not directly part of the goal, e.g. "Always be polite". It's
        /// valid for this text to be long and used instead of steps altogether.
        #[prost(string, tag = "1")]
        pub guidelines: ::prost::alloc::string::String,
        /// Ordered list of step by step execution instructions to accomplish
        /// target goal.
        #[prost(message, repeated, tag = "2")]
        pub steps: ::prost::alloc::vec::Vec<Step>,
    }
    /// Type of the playbook.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum PlaybookType {
        /// Unspecified type. Default to TASK.
        Unspecified = 0,
        /// Task playbook.
        Task = 1,
        /// Routine playbook.
        Routine = 3,
    }
    impl PlaybookType {
        /// 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 => "PLAYBOOK_TYPE_UNSPECIFIED",
                Self::Task => "TASK",
                Self::Routine => "ROUTINE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "PLAYBOOK_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "TASK" => Some(Self::Task),
                "ROUTINE" => Some(Self::Routine),
                _ => None,
            }
        }
    }
}
/// The request message for
/// \[Playbooks.CreatePlaybookVersion\]\[google.cloud.dialogflow.cx.v3.Playbooks.CreatePlaybookVersion\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreatePlaybookVersionRequest {
    /// Required. The playbook to create a version for.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/playbooks/<PlaybookID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The playbook version to create.
    #[prost(message, optional, tag = "2")]
    pub playbook_version: ::core::option::Option<PlaybookVersion>,
}
/// Playbook version is a snapshot of the playbook at certain timestamp.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PlaybookVersion {
    /// The unique identifier of the playbook version.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/playbooks/<PlaybookID>/versions/<VersionID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The description of the playbook version.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Output only. Snapshot of the playbook when the playbook version is created.
    #[prost(message, optional, tag = "3")]
    pub playbook: ::core::option::Option<Playbook>,
    /// Output only. Snapshot of the examples belonging to the playbook when the
    /// playbook version is created.
    #[prost(message, repeated, tag = "4")]
    pub examples: ::prost::alloc::vec::Vec<Example>,
    /// Output only. Last time the playbook version was created or modified.
    #[prost(message, optional, tag = "5")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// The request message for
/// \[Playbooks.GetPlaybookVersion\]\[google.cloud.dialogflow.cx.v3.Playbooks.GetPlaybookVersion\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetPlaybookVersionRequest {
    /// Required. The name of the playbook version.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/playbooks/<PlaybookID>/versions/<VersionID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for
/// \[Playbooks.RestorePlaybookVersion\]\[google.cloud.dialogflow.cx.v3.Playbooks.RestorePlaybookVersion\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RestorePlaybookVersionRequest {
    /// Required. The name of the playbook version.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/playbooks/<PlaybookID>/versions/<VersionID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The response message for
/// \[Playbooks.RestorePlaybookVersion\]\[google.cloud.dialogflow.cx.v3.Playbooks.RestorePlaybookVersion\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RestorePlaybookVersionResponse {
    /// The updated playbook.
    #[prost(message, optional, tag = "2")]
    pub playbook: ::core::option::Option<Playbook>,
}
/// The request message for
/// \[Playbooks.ListPlaybookVersions\]\[google.cloud.dialogflow.cx.v3.Playbooks.ListPlaybookVersions\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListPlaybookVersionsRequest {
    /// Required. The playbook to list versions for.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/playbooks/<PlaybookID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The maximum number of items to return in a single page. By
    /// default 100 and at most 1000.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. The next_page_token value returned from a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response message for
/// \[Playbooks.ListPlaybookVersions\]\[google.cloud.dialogflow.cx.v3.Playbooks.ListPlaybookVersions\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListPlaybookVersionsResponse {
    /// The list of playbook version. There will be a maximum number of items
    /// returned based on the page_size field in the request.
    #[prost(message, repeated, tag = "1")]
    pub playbook_versions: ::prost::alloc::vec::Vec<PlaybookVersion>,
    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request message for
/// \[Playbooks.DeletePlaybookVersion\]\[google.cloud.dialogflow.cx.v3.Playbooks.DeletePlaybookVersion\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeletePlaybookVersionRequest {
    /// Required. The name of the playbook version to delete.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/playbooks/<PlaybookID>/versions/<VersionID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for
/// \[Playbooks.ExportPlaybook\]\[google.cloud.dialogflow.cx.v3.Playbooks.ExportPlaybook\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExportPlaybookRequest {
    /// Required. The name of the playbook to export.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/playbooks/<PlaybookID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The [Google Cloud
    /// Storage](<https://cloud.google.com/storage/docs/>) URI to export the playbook
    /// to. The format of this URI must be `gs://<bucket-name>/<object-name>`. If
    /// left unspecified, the serialized playbook is returned inline.
    ///
    /// Dialogflow performs a write operation for the Cloud Storage object
    /// on the caller's behalf, so your request authentication must
    /// have write permissions for the object. For more information, see
    /// [Dialogflow access
    /// control](<https://cloud.google.com/dialogflow/cx/docs/concept/access-control#storage>).
    #[prost(string, tag = "2")]
    pub playbook_uri: ::prost::alloc::string::String,
    /// Optional. The data format of the exported agent. If not specified, `BLOB`
    /// is assumed.
    #[prost(enumeration = "export_playbook_request::DataFormat", tag = "3")]
    pub data_format: i32,
}
/// Nested message and enum types in `ExportPlaybookRequest`.
pub mod export_playbook_request {
    /// Data format of the exported playbook.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum DataFormat {
        /// Unspecified format.
        Unspecified = 0,
        /// Flow content will be exported as raw bytes.
        Blob = 1,
        /// Flow content will be exported in JSON format.
        Json = 2,
    }
    impl DataFormat {
        /// 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_FORMAT_UNSPECIFIED",
                Self::Blob => "BLOB",
                Self::Json => "JSON",
            }
        }
        /// 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_FORMAT_UNSPECIFIED" => Some(Self::Unspecified),
                "BLOB" => Some(Self::Blob),
                "JSON" => Some(Self::Json),
                _ => None,
            }
        }
    }
}
/// The request message for
/// \[Playbooks.ImportPlaybook\]\[google.cloud.dialogflow.cx.v3.Playbooks.ImportPlaybook\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ImportPlaybookRequest {
    /// Required. The agent to import the playbook into.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Specifies the import strategy used when resolving resource
    /// conflicts.
    #[prost(message, optional, tag = "4")]
    pub import_strategy: ::core::option::Option<PlaybookImportStrategy>,
    /// Required. The playbook to import.
    /// The [Google Cloud Storage](<https://cloud.google.com/storage/docs/>) URI
    /// to import playbook from. The format of this URI must be
    /// `gs://<bucket-name>/<object-name>`.
    ///
    /// Dialogflow performs a read operation for the Cloud Storage object
    /// on the caller's behalf, so your request authentication must
    /// have read permissions for the object. For more information, see
    #[prost(oneof = "import_playbook_request::Playbook", tags = "2, 3")]
    pub playbook: ::core::option::Option<import_playbook_request::Playbook>,
}
/// Nested message and enum types in `ImportPlaybookRequest`.
pub mod import_playbook_request {
    /// Required. The playbook to import.
    /// The [Google Cloud Storage](<https://cloud.google.com/storage/docs/>) URI
    /// to import playbook from. The format of this URI must be
    /// `gs://<bucket-name>/<object-name>`.
    ///
    /// Dialogflow performs a read operation for the Cloud Storage object
    /// on the caller's behalf, so your request authentication must
    /// have read permissions for the object. For more information, see
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Playbook {
        /// \[Dialogflow access
        /// control\]
        /// (<https://cloud.google.com/dialogflow/cx/docs/concept/access-control#storage>).
        #[prost(string, tag = "2")]
        PlaybookUri(::prost::alloc::string::String),
        /// Uncompressed raw byte content for playbook.
        #[prost(bytes, tag = "3")]
        PlaybookContent(::prost::alloc::vec::Vec<u8>),
    }
}
/// The playbook import strategy used for resource conflict resolution associated
/// with an
/// \[ImportPlaybookRequest\]\[google.cloud.dialogflow.cx.v3.ImportPlaybookRequest\].
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PlaybookImportStrategy {
    /// Optional. Specifies the import strategy used when resolving conflicts with
    /// the main playbook. If not specified, 'CREATE_NEW' is assumed.
    #[prost(enumeration = "ImportStrategy", tag = "4")]
    pub main_playbook_import_strategy: i32,
    /// Optional. Specifies the import strategy used when resolving referenced
    /// playbook/flow conflicts. If not specified, 'CREATE_NEW' is assumed.
    #[prost(enumeration = "ImportStrategy", tag = "5")]
    pub nested_resource_import_strategy: i32,
    /// Optional. Specifies the import strategy used when resolving tool conflicts.
    /// If not specified, 'CREATE_NEW' is assumed. This will be applied after the
    /// main playbook and nested resource import strategies, meaning if the
    /// playbook that references the tool is skipped, the tool will also be
    /// skipped.
    #[prost(enumeration = "ImportStrategy", tag = "6")]
    pub tool_import_strategy: i32,
}
/// The response message for
/// \[Playbooks.ImportPlaybook\]\[google.cloud.dialogflow.cx.v3.Playbooks.ImportPlaybook\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ImportPlaybookResponse {
    /// The unique identifier of the new playbook.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/playbooks/<PlaybookID>`.
    #[prost(string, tag = "1")]
    pub playbook: ::prost::alloc::string::String,
    /// Info which resources have conflicts when
    /// \[REPORT_CONFLICTS\]\[ImportPlaybookResponse.REPORT_CONFLICTS\] import strategy
    /// is set for all resources in ImportPlaybookRequest.
    #[prost(message, optional, tag = "2")]
    pub conflicting_resources: ::core::option::Option<
        import_playbook_response::ConflictingResources,
    >,
}
/// Nested message and enum types in `ImportPlaybookResponse`.
pub mod import_playbook_response {
    /// Conflicting resources detected during the import process. Only filled when
    /// \[REPORT_CONFLICTS\]\[ImportPlaybookResponse.REPORT_CONFLICTS\] is set in the
    /// request and there are conflicts in the display names.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ConflictingResources {
        /// Display name of conflicting main playbook.
        #[prost(string, tag = "1")]
        pub main_playbook_display_name: ::prost::alloc::string::String,
        /// Display names of conflicting nested playbooks.
        #[prost(string, repeated, tag = "2")]
        pub nested_playbook_display_names: ::prost::alloc::vec::Vec<
            ::prost::alloc::string::String,
        >,
        /// Display names of conflicting tools.
        #[prost(string, repeated, tag = "3")]
        pub tool_display_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    }
}
/// The response message for
/// \[Playbooks.ExportPlaybook\]\[google.cloud.dialogflow.cx.v3.Playbooks.ExportPlaybook\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExportPlaybookResponse {
    /// The exported playbook.
    #[prost(oneof = "export_playbook_response::Playbook", tags = "1, 2")]
    pub playbook: ::core::option::Option<export_playbook_response::Playbook>,
}
/// Nested message and enum types in `ExportPlaybookResponse`.
pub mod export_playbook_response {
    /// The exported playbook.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Playbook {
        /// The URI to a file containing the exported playbook. This field is
        /// populated only if `playbook_uri` is specified in
        /// \[ExportPlaybookRequest\]\[google.cloud.dialogflow.cx.v3.ExportPlaybookRequest\].
        #[prost(string, tag = "1")]
        PlaybookUri(::prost::alloc::string::String),
        /// Uncompressed raw byte content for playbook.
        #[prost(bytes, tag = "2")]
        PlaybookContent(::prost::alloc::vec::Vec<u8>),
    }
}
/// Handler can be used to define custom logic to be executed based on the
/// user-specified triggers.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Handler {
    /// Specifies the type of handler to invoke.
    #[prost(oneof = "handler::Handler", tags = "1, 3")]
    pub handler: ::core::option::Option<handler::Handler>,
}
/// Nested message and enum types in `Handler`.
pub mod handler {
    /// A handler that is triggered by the specified
    /// \[event\]\[google.cloud.dialogflow.cx.v3.Handler.EventHandler.event\].
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct EventHandler {
        /// Required. The name of the event that triggers this handler.
        #[prost(string, tag = "1")]
        pub event: ::prost::alloc::string::String,
        /// Optional. The condition that must be satisfied to trigger this handler.
        #[prost(string, tag = "3")]
        pub condition: ::prost::alloc::string::String,
        /// Required. The fulfillment to call when the event occurs.
        #[prost(message, optional, tag = "2")]
        pub fulfillment: ::core::option::Option<super::Fulfillment>,
    }
    /// A handler that is triggered on the specific
    /// \[lifecycle_stage\]\[google.cloud.dialogflow.cx.v3.Handler.LifecycleHandler.lifecycle_stage\]
    /// of the playbook execution.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct LifecycleHandler {
        /// Required. The name of the lifecycle stage that triggers this handler.
        /// Supported values:
        ///
        /// * `playbook-start`
        /// * `pre-action-selection`
        /// * `pre-action-execution`
        #[prost(string, tag = "1")]
        pub lifecycle_stage: ::prost::alloc::string::String,
        /// Optional. The condition that must be satisfied to trigger this handler.
        #[prost(string, tag = "2")]
        pub condition: ::prost::alloc::string::String,
        /// Required. The fulfillment to call when this handler is triggered.
        #[prost(message, optional, tag = "3")]
        pub fulfillment: ::core::option::Option<super::Fulfillment>,
    }
    /// Specifies the type of handler to invoke.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Handler {
        /// A handler triggered by event.
        #[prost(message, tag = "1")]
        EventHandler(EventHandler),
        /// A handler triggered during specific lifecycle of the playbook execution.
        #[prost(message, tag = "3")]
        LifecycleHandler(LifecycleHandler),
    }
}
/// Generated client implementations.
pub mod playbooks_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing \[Playbooks\]\[google.cloud.dialogflow.cx.v3.Playbook\].
    #[derive(Debug, Clone)]
    pub struct PlaybooksClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl PlaybooksClient<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> PlaybooksClient<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,
        ) -> PlaybooksClient<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,
        {
            PlaybooksClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Creates a playbook in a specified agent.
        pub async fn create_playbook(
            &mut self,
            request: impl tonic::IntoRequest<super::CreatePlaybookRequest>,
        ) -> std::result::Result<tonic::Response<super::Playbook>, 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.dialogflow.cx.v3.Playbooks/CreatePlaybook",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Playbooks",
                        "CreatePlaybook",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a specified playbook.
        pub async fn delete_playbook(
            &mut self,
            request: impl tonic::IntoRequest<super::DeletePlaybookRequest>,
        ) -> 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.dialogflow.cx.v3.Playbooks/DeletePlaybook",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Playbooks",
                        "DeletePlaybook",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns a list of playbooks in the specified agent.
        pub async fn list_playbooks(
            &mut self,
            request: impl tonic::IntoRequest<super::ListPlaybooksRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListPlaybooksResponse>,
            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.dialogflow.cx.v3.Playbooks/ListPlaybooks",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Playbooks",
                        "ListPlaybooks",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the specified Playbook.
        pub async fn get_playbook(
            &mut self,
            request: impl tonic::IntoRequest<super::GetPlaybookRequest>,
        ) -> std::result::Result<tonic::Response<super::Playbook>, 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.dialogflow.cx.v3.Playbooks/GetPlaybook",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Playbooks",
                        "GetPlaybook",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Exports the specified playbook to a binary file.
        ///
        /// Note that resources (e.g. examples, tools) that the playbook
        /// references will also be exported.
        pub async fn export_playbook(
            &mut self,
            request: impl tonic::IntoRequest<super::ExportPlaybookRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.dialogflow.cx.v3.Playbooks/ExportPlaybook",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Playbooks",
                        "ExportPlaybook",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Imports the specified playbook to the specified agent from a binary file.
        pub async fn import_playbook(
            &mut self,
            request: impl tonic::IntoRequest<super::ImportPlaybookRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.dialogflow.cx.v3.Playbooks/ImportPlaybook",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Playbooks",
                        "ImportPlaybook",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified Playbook.
        pub async fn update_playbook(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdatePlaybookRequest>,
        ) -> std::result::Result<tonic::Response<super::Playbook>, 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.dialogflow.cx.v3.Playbooks/UpdatePlaybook",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Playbooks",
                        "UpdatePlaybook",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a version for the specified Playbook.
        pub async fn create_playbook_version(
            &mut self,
            request: impl tonic::IntoRequest<super::CreatePlaybookVersionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::PlaybookVersion>,
            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.dialogflow.cx.v3.Playbooks/CreatePlaybookVersion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Playbooks",
                        "CreatePlaybookVersion",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the specified version of the Playbook.
        pub async fn get_playbook_version(
            &mut self,
            request: impl tonic::IntoRequest<super::GetPlaybookVersionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::PlaybookVersion>,
            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.dialogflow.cx.v3.Playbooks/GetPlaybookVersion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Playbooks",
                        "GetPlaybookVersion",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the specified version of the Playbook and stores it as the
        /// current playbook draft, returning the playbook with resources updated.
        pub async fn restore_playbook_version(
            &mut self,
            request: impl tonic::IntoRequest<super::RestorePlaybookVersionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::RestorePlaybookVersionResponse>,
            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.dialogflow.cx.v3.Playbooks/RestorePlaybookVersion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Playbooks",
                        "RestorePlaybookVersion",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists versions for the specified Playbook.
        pub async fn list_playbook_versions(
            &mut self,
            request: impl tonic::IntoRequest<super::ListPlaybookVersionsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListPlaybookVersionsResponse>,
            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.dialogflow.cx.v3.Playbooks/ListPlaybookVersions",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Playbooks",
                        "ListPlaybookVersions",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified version of the Playbook.
        pub async fn delete_playbook_version(
            &mut self,
            request: impl tonic::IntoRequest<super::DeletePlaybookVersionRequest>,
        ) -> 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.dialogflow.cx.v3.Playbooks/DeletePlaybookVersion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Playbooks",
                        "DeletePlaybookVersion",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// The request message for
/// \[SecuritySettingsService.GetSecuritySettings\]\[google.cloud.dialogflow.cx.v3.SecuritySettingsService.GetSecuritySettings\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetSecuritySettingsRequest {
    /// Required. Resource name of the settings.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/securitySettings/<securitysettingsID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for
/// \[SecuritySettingsService.UpdateSecuritySettings\]\[google.cloud.dialogflow.cx.v3.SecuritySettingsService.UpdateSecuritySettings\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateSecuritySettingsRequest {
    /// Required. \[SecuritySettings\] object that contains values for each of the
    /// fields to update.
    #[prost(message, optional, tag = "1")]
    pub security_settings: ::core::option::Option<SecuritySettings>,
    /// Required. The mask 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>,
}
/// The request message for \[SecuritySettings.ListSecuritySettings\]\[\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListSecuritySettingsRequest {
    /// Required. The location to list all security settings for.
    /// Format: `projects/<ProjectID>/locations/<LocationID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of items to return in a single page. By default 20 and
    /// at most 100.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response message for \[SecuritySettings.ListSecuritySettings\]\[\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSecuritySettingsResponse {
    /// The list of security settings.
    #[prost(message, repeated, tag = "1")]
    pub security_settings: ::prost::alloc::vec::Vec<SecuritySettings>,
    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request message for \[SecuritySettings.CreateSecuritySettings\]\[\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateSecuritySettingsRequest {
    /// Required. The location to create an
    /// \[SecuritySettings\]\[google.cloud.dialogflow.cx.v3.SecuritySettings\] for.
    /// Format: `projects/<ProjectID>/locations/<LocationID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The security settings to create.
    #[prost(message, optional, tag = "2")]
    pub security_settings: ::core::option::Option<SecuritySettings>,
}
/// The request message for \[SecuritySettings.DeleteSecuritySettings\]\[\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteSecuritySettingsRequest {
    /// Required. The name of the
    /// \[SecuritySettings\]\[google.cloud.dialogflow.cx.v3.SecuritySettings\] to
    /// delete. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/securitySettings/<SecuritySettingsID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Represents the settings related to security issues, such as data redaction
/// and data retention. It may take hours for updates on the settings to
/// propagate to all the related components and take effect.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SecuritySettings {
    /// Resource name of the settings.
    /// Required for the
    /// \[SecuritySettingsService.UpdateSecuritySettings\]\[google.cloud.dialogflow.cx.v3.SecuritySettingsService.UpdateSecuritySettings\]
    /// method.
    /// \[SecuritySettingsService.CreateSecuritySettings\]\[google.cloud.dialogflow.cx.v3.SecuritySettingsService.CreateSecuritySettings\]
    /// populates the name automatically. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/securitySettings/<SecuritySettingsID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. The human-readable name of the security settings, unique within
    /// the location.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Strategy that defines how we do redaction.
    #[prost(enumeration = "security_settings::RedactionStrategy", tag = "3")]
    pub redaction_strategy: i32,
    /// Defines the data for which Dialogflow applies redaction. Dialogflow does
    /// not redact data that it does not have access to – for example, Cloud
    /// logging.
    #[prost(enumeration = "security_settings::RedactionScope", tag = "4")]
    pub redaction_scope: i32,
    /// [DLP](<https://cloud.google.com/dlp/docs>) inspect template name. Use this
    /// template to define inspect base settings.
    ///
    /// The `DLP Inspect Templates Reader` role is needed on the Dialogflow
    /// service identity service account (has the form
    /// `service-PROJECT_NUMBER@gcp-sa-dialogflow.iam.gserviceaccount.com`)
    /// for your agent's project.
    ///
    /// If empty, we use the default DLP inspect config.
    ///
    /// The template name will have one of the following formats:
    /// `projects/<ProjectID>/locations/<LocationID>/inspectTemplates/<TemplateID>`
    /// OR
    /// `organizations/<OrganizationID>/locations/<LocationID>/inspectTemplates/<TemplateID>`
    ///
    /// Note: `inspect_template` must be located in the same region as the
    /// `SecuritySettings`.
    #[prost(string, tag = "9")]
    pub inspect_template: ::prost::alloc::string::String,
    /// [DLP](<https://cloud.google.com/dlp/docs>) deidentify template name. Use this
    /// template to define de-identification configuration for the content.
    ///
    /// The `DLP De-identify Templates Reader` role is needed on the Dialogflow
    /// service identity service account (has the form
    /// `service-PROJECT_NUMBER@gcp-sa-dialogflow.iam.gserviceaccount.com`)
    /// for your agent's project.
    ///
    /// If empty, Dialogflow replaces sensitive info with `\[redacted\]` text.
    ///
    /// The template name will have one of the following formats:
    /// `projects/<ProjectID>/locations/<LocationID>/deidentifyTemplates/<TemplateID>`
    /// OR
    /// `organizations/<OrganizationID>/locations/<LocationID>/deidentifyTemplates/<TemplateID>`
    ///
    /// Note: `deidentify_template` must be located in the same region as the
    /// `SecuritySettings`.
    #[prost(string, tag = "17")]
    pub deidentify_template: ::prost::alloc::string::String,
    /// List of types of data to remove when retention settings triggers purge.
    #[prost(enumeration = "security_settings::PurgeDataType", repeated, tag = "8")]
    pub purge_data_types: ::prost::alloc::vec::Vec<i32>,
    /// Controls audio export settings for post-conversation analytics when
    /// ingesting audio to conversations via \[Participants.AnalyzeContent\]\[\] or
    /// \[Participants.StreamingAnalyzeContent\]\[\].
    ///
    /// If
    /// \[retention_strategy\]\[google.cloud.dialogflow.cx.v3.SecuritySettings.retention_strategy\]
    /// is set to REMOVE_AFTER_CONVERSATION or \[audio_export_settings.gcs_bucket\]\[\]
    /// is empty, audio export is disabled.
    ///
    /// If audio export is enabled, audio is recorded and saved to
    /// \[audio_export_settings.gcs_bucket\]\[\], subject to retention policy of
    /// \[audio_export_settings.gcs_bucket\]\[\].
    ///
    /// This setting won't effect audio input for implicit sessions via
    /// \[Sessions.DetectIntent\]\[google.cloud.dialogflow.cx.v3.Sessions.DetectIntent\]
    /// or
    /// \[Sessions.StreamingDetectIntent\]\[google.cloud.dialogflow.cx.v3.Sessions.StreamingDetectIntent\].
    #[prost(message, optional, tag = "12")]
    pub audio_export_settings: ::core::option::Option<
        security_settings::AudioExportSettings,
    >,
    /// Controls conversation exporting settings to Insights after conversation is
    /// completed.
    ///
    /// If
    /// \[retention_strategy\]\[google.cloud.dialogflow.cx.v3.SecuritySettings.retention_strategy\]
    /// is set to REMOVE_AFTER_CONVERSATION, Insights export is disabled no matter
    /// what you configure here.
    #[prost(message, optional, tag = "13")]
    pub insights_export_settings: ::core::option::Option<
        security_settings::InsightsExportSettings,
    >,
    /// Specifies how data is retained. Note that even if the data is
    /// purged due to retention policy, we may still hold it in backup storage for
    /// a few days without allowing direct readings.
    #[prost(oneof = "security_settings::DataRetention", tags = "6, 7")]
    pub data_retention: ::core::option::Option<security_settings::DataRetention>,
}
/// Nested message and enum types in `SecuritySettings`.
pub mod security_settings {
    /// Settings for exporting audio.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct AudioExportSettings {
        /// Cloud Storage bucket to export audio record to.
        /// Setting this field would grant the Storage Object Creator role to
        /// the Dialogflow Service Agent.
        /// API caller that tries to modify this field should have the permission of
        /// storage.buckets.setIamPolicy.
        #[prost(string, tag = "1")]
        pub gcs_bucket: ::prost::alloc::string::String,
        /// Filename pattern for exported audio.
        /// {conversation} and {timestamp} are placeholders that will be replaced
        /// with the conversation ID and epoch micros of the conversation.
        /// For example, "{conversation}/recording\_{timestamp}.mulaw".
        #[prost(string, tag = "2")]
        pub audio_export_pattern: ::prost::alloc::string::String,
        /// Enable audio redaction if it is true.
        /// Note that this only redacts end-user audio data;
        /// Synthesised audio from the virtual agent is not redacted.
        #[prost(bool, tag = "3")]
        pub enable_audio_redaction: bool,
        /// File format for exported audio file. Currently only in telephony
        /// recordings.
        #[prost(enumeration = "audio_export_settings::AudioFormat", tag = "4")]
        pub audio_format: i32,
        /// Whether to store TTS audio. By default, TTS audio from the virtual agent
        /// is not exported.
        #[prost(bool, tag = "6")]
        pub store_tts_audio: bool,
    }
    /// Nested message and enum types in `AudioExportSettings`.
    pub mod audio_export_settings {
        /// File format for exported audio file. Currently only in telephony
        /// recordings.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum AudioFormat {
            /// Unspecified. Do not use.
            Unspecified = 0,
            /// G.711 mu-law PCM with 8kHz sample rate.
            Mulaw = 1,
            /// MP3 file format.
            Mp3 = 2,
            /// OGG Vorbis.
            Ogg = 3,
        }
        impl AudioFormat {
            /// 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_FORMAT_UNSPECIFIED",
                    Self::Mulaw => "MULAW",
                    Self::Mp3 => "MP3",
                    Self::Ogg => "OGG",
                }
            }
            /// 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_FORMAT_UNSPECIFIED" => Some(Self::Unspecified),
                    "MULAW" => Some(Self::Mulaw),
                    "MP3" => Some(Self::Mp3),
                    "OGG" => Some(Self::Ogg),
                    _ => None,
                }
            }
        }
    }
    /// Settings for exporting conversations to
    /// [Insights](<https://cloud.google.com/contact-center/insights/docs>).
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct InsightsExportSettings {
        /// If enabled, we will automatically exports
        /// conversations to Insights and Insights runs its analyzers.
        #[prost(bool, tag = "1")]
        pub enable_insights_export: bool,
    }
    /// Defines how we redact data.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum RedactionStrategy {
        /// Do not redact.
        Unspecified = 0,
        /// Call redaction service to clean up the data to be persisted.
        RedactWithService = 1,
    }
    impl RedactionStrategy {
        /// 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 => "REDACTION_STRATEGY_UNSPECIFIED",
                Self::RedactWithService => "REDACT_WITH_SERVICE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "REDACTION_STRATEGY_UNSPECIFIED" => Some(Self::Unspecified),
                "REDACT_WITH_SERVICE" => Some(Self::RedactWithService),
                _ => None,
            }
        }
    }
    /// Defines what types of data to redact.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum RedactionScope {
        /// Don't redact any kind of data.
        Unspecified = 0,
        /// On data to be written to disk or similar devices that are capable of
        /// holding data even if power is disconnected. This includes data that are
        /// temporarily saved on disk.
        RedactDiskStorage = 2,
    }
    impl RedactionScope {
        /// 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 => "REDACTION_SCOPE_UNSPECIFIED",
                Self::RedactDiskStorage => "REDACT_DISK_STORAGE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "REDACTION_SCOPE_UNSPECIFIED" => Some(Self::Unspecified),
                "REDACT_DISK_STORAGE" => Some(Self::RedactDiskStorage),
                _ => None,
            }
        }
    }
    /// Defines how long we retain persisted data that contains sensitive info.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum RetentionStrategy {
        /// Retains the persisted data with Dialogflow's internal default 365d TTLs.
        Unspecified = 0,
        /// Removes data when the conversation ends. If there is no \[Conversation\]\[\]
        /// explicitly established, a default conversation ends when the
        /// corresponding Dialogflow session ends.
        RemoveAfterConversation = 1,
    }
    impl RetentionStrategy {
        /// 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 => "RETENTION_STRATEGY_UNSPECIFIED",
                Self::RemoveAfterConversation => "REMOVE_AFTER_CONVERSATION",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "RETENTION_STRATEGY_UNSPECIFIED" => Some(Self::Unspecified),
                "REMOVE_AFTER_CONVERSATION" => Some(Self::RemoveAfterConversation),
                _ => None,
            }
        }
    }
    /// Type of data we purge after retention settings triggers purge.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum PurgeDataType {
        /// Unspecified. Do not use.
        Unspecified = 0,
        /// Dialogflow history. This does not include Cloud logging, which is
        /// owned by the user - not Dialogflow.
        DialogflowHistory = 1,
    }
    impl PurgeDataType {
        /// 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 => "PURGE_DATA_TYPE_UNSPECIFIED",
                Self::DialogflowHistory => "DIALOGFLOW_HISTORY",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "PURGE_DATA_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "DIALOGFLOW_HISTORY" => Some(Self::DialogflowHistory),
                _ => None,
            }
        }
    }
    /// Specifies how data is retained. Note that even if the data is
    /// purged due to retention policy, we may still hold it in backup storage for
    /// a few days without allowing direct readings.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum DataRetention {
        /// Retains the data for the specified number of days.
        /// User must set a value lower than Dialogflow's default 365d TTL (30 days
        /// for Agent Assist traffic), higher value will be ignored and use default.
        /// Setting a value higher than that has no effect. A missing value or
        /// setting to 0 also means we use default TTL.
        /// When data retention configuration is changed, it only applies to the data
        /// created after the change; the TTL of existing data created before the
        /// change stays intact.
        #[prost(int32, tag = "6")]
        RetentionWindowDays(i32),
        /// Specifies the retention behavior defined by
        /// \[SecuritySettings.RetentionStrategy\]\[google.cloud.dialogflow.cx.v3.SecuritySettings.RetentionStrategy\].
        #[prost(enumeration = "RetentionStrategy", tag = "7")]
        RetentionStrategy(i32),
    }
}
/// Generated client implementations.
pub mod security_settings_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing security settings for Dialogflow.
    #[derive(Debug, Clone)]
    pub struct SecuritySettingsServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl SecuritySettingsServiceClient<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> SecuritySettingsServiceClient<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,
        ) -> SecuritySettingsServiceClient<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,
        {
            SecuritySettingsServiceClient::new(
                InterceptedService::new(inner, interceptor),
            )
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Create security settings in the specified location.
        pub async fn create_security_settings(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateSecuritySettingsRequest>,
        ) -> 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.dialogflow.cx.v3.SecuritySettingsService/CreateSecuritySettings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.SecuritySettingsService",
                        "CreateSecuritySettings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the specified
        /// \[SecuritySettings\]\[google.cloud.dialogflow.cx.v3.SecuritySettings\]. The
        /// returned settings may be stale by up to 1 minute.
        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.dialogflow.cx.v3.SecuritySettingsService/GetSecuritySettings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.SecuritySettingsService",
                        "GetSecuritySettings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified
        /// \[SecuritySettings\]\[google.cloud.dialogflow.cx.v3.SecuritySettings\].
        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.dialogflow.cx.v3.SecuritySettingsService/UpdateSecuritySettings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.SecuritySettingsService",
                        "UpdateSecuritySettings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns the list of all security settings in the specified location.
        pub async fn list_security_settings(
            &mut self,
            request: impl tonic::IntoRequest<super::ListSecuritySettingsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListSecuritySettingsResponse>,
            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.dialogflow.cx.v3.SecuritySettingsService/ListSecuritySettings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.SecuritySettingsService",
                        "ListSecuritySettings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified
        /// \[SecuritySettings\]\[google.cloud.dialogflow.cx.v3.SecuritySettings\].
        pub async fn delete_security_settings(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteSecuritySettingsRequest>,
        ) -> 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.dialogflow.cx.v3.SecuritySettingsService/DeleteSecuritySettings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.SecuritySettingsService",
                        "DeleteSecuritySettings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// The request message for
/// \[Tools.CreateTool\]\[google.cloud.dialogflow.cx.v3.Tools.CreateTool\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateToolRequest {
    /// Required. The agent to create a Tool for.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The Tool to be created.
    #[prost(message, optional, tag = "2")]
    pub tool: ::core::option::Option<Tool>,
}
/// The request message for
/// \[Tools.ListTools\]\[google.cloud.dialogflow.cx.v3.Tools.ListTools\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListToolsRequest {
    /// Required. The agent to list the Tools from.
    /// Format: `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of items to return in a single page. By default 100 and
    /// at most 1000.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response message for
/// \[Tools.ListTools\]\[google.cloud.dialogflow.cx.v3.Tools.ListTools\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListToolsResponse {
    /// The list of Tools. There will be a maximum number of items returned
    /// based on the page_size field in the request.
    #[prost(message, repeated, tag = "1")]
    pub tools: ::prost::alloc::vec::Vec<Tool>,
    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request message for
/// \[Tools.GetTool\]\[google.cloud.dialogflow.cx.v3.Tools.GetTool\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetToolRequest {
    /// Required. The name of the Tool.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/tools/<ToolID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for
/// \[Tools.UpdateTool\]\[google.cloud.dialogflow.cx.v3.Tools.UpdateTool\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateToolRequest {
    /// Required. The Tool to be updated.
    #[prost(message, optional, tag = "1")]
    pub tool: ::core::option::Option<Tool>,
    /// The mask 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>,
}
/// The request message for
/// \[Tools.DeleteTool\]\[google.cloud.dialogflow.cx.v3.Tools.DeleteTool\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteToolRequest {
    /// Required. The name of the Tool to be deleted.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/tools/<ToolID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// This field has no effect for Tools not being used.
    /// For Tools that are used:
    ///
    /// * If `force` is set to false, an error will be returned with message
    ///   indicating the referenced resources.
    /// * If `force` is set to true, Dialogflow will remove the tool, as well
    ///   as any references to the tool.
    #[prost(bool, tag = "2")]
    pub force: bool,
}
/// A tool provides a list of actions which are available to the
/// \[Playbook\]\[google.cloud.dialogflow.cx.v3.Playbook\] to attain its goal. A Tool
/// consists of a description of the tool's usage and a specification of the tool
/// which contains the schema and authentication information.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Tool {
    /// The unique identifier of the Tool.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/tools/<ToolID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. The human-readable name of the Tool, unique within an agent.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Required. High level description of the Tool and its usage.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Output only. The tool type.
    #[prost(enumeration = "tool::ToolType", tag = "12")]
    pub tool_type: i32,
    /// Specification of the Tool.
    #[prost(oneof = "tool::Specification", tags = "4, 8, 13")]
    pub specification: ::core::option::Option<tool::Specification>,
}
/// Nested message and enum types in `Tool`.
pub mod tool {
    /// An OpenAPI tool is a way to provide the Tool specifications in the Open API
    /// schema format.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct OpenApiTool {
        /// Optional. Authentication information required by the API.
        #[prost(message, optional, tag = "2")]
        pub authentication: ::core::option::Option<Authentication>,
        /// Optional. TLS configuration for the HTTPS verification.
        #[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>,
        /// Schema representation.
        #[prost(oneof = "open_api_tool::Schema", tags = "1")]
        pub schema: ::core::option::Option<open_api_tool::Schema>,
    }
    /// Nested message and enum types in `OpenApiTool`.
    pub mod open_api_tool {
        /// Schema representation.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
        pub enum Schema {
            /// Required. The OpenAPI schema specified as a text.
            #[prost(string, tag = "1")]
            TextSchema(::prost::alloc::string::String),
        }
    }
    /// A DataStoreTool is a way to provide specifications needed to search a
    /// list of data stores.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct DataStoreTool {
        /// Required. List of data stores to search.
        #[prost(message, repeated, tag = "1")]
        pub data_store_connections: ::prost::alloc::vec::Vec<super::DataStoreConnection>,
        /// Required. Fallback prompt configurations to use.
        #[prost(message, optional, tag = "3")]
        pub fallback_prompt: ::core::option::Option<data_store_tool::FallbackPrompt>,
    }
    /// Nested message and enum types in `DataStoreTool`.
    pub mod data_store_tool {
        /// A FallbackPrompt is a way to provide specifications for the Data Store
        /// fallback prompt when generating responses.
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct FallbackPrompt {}
    }
    /// A Function tool describes the functions to be invoked on the client side.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct FunctionTool {
        /// Optional. The JSON schema is encapsulated in a
        /// \[google.protobuf.Struct\]\[google.protobuf.Struct\] to describe the input of
        /// the function. This input is a JSON object that contains the function's
        /// parameters as properties of the object.
        #[prost(message, optional, tag = "1")]
        pub input_schema: ::core::option::Option<::prost_types::Struct>,
        /// Optional. The JSON schema is encapsulated in a
        /// \[google.protobuf.Struct\]\[google.protobuf.Struct\] to describe the output
        /// of the function. This output is a JSON object that contains the
        /// function's parameters as properties of the object.
        #[prost(message, optional, tag = "2")]
        pub output_schema: ::core::option::Option<::prost_types::Struct>,
    }
    /// Authentication information required for API calls
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Authentication {
        /// The auth configuration.
        #[prost(oneof = "authentication::AuthConfig", tags = "1, 2, 3, 4, 5")]
        pub auth_config: ::core::option::Option<authentication::AuthConfig>,
    }
    /// Nested message and enum types in `Authentication`.
    pub mod authentication {
        /// Config 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,
            /// Optional. The API key. If the `secret_version_for_api_key` field is
            /// set, this field will be ignored.
            #[prost(string, tag = "2")]
            pub api_key: ::prost::alloc::string::String,
            /// Optional. The name of the SecretManager secret version resource storing
            /// the API key. If this field is set, the `api_key` field will be ignored.
            /// Format: `projects/{project}/secrets/{secret}/versions/{version}`
            #[prost(string, tag = "4")]
            pub secret_version_for_api_key: ::prost::alloc::string::String,
            /// Required. Key location in the request.
            #[prost(enumeration = "RequestLocation", tag = "3")]
            pub request_location: i32,
        }
        /// Config 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,
            /// Optional. The client secret from the OAuth provider. If the
            /// `secret_version_for_client_secret` field is set, this field will be
            /// ignored.
            #[prost(string, tag = "3")]
            pub client_secret: ::prost::alloc::string::String,
            /// Optional. The name of the SecretManager secret version resource storing
            /// the client secret. If this field is set, the `client_secret` field will
            /// be ignored. Format:
            /// `projects/{project}/secrets/{secret}/versions/{version}`
            #[prost(string, tag = "6")]
            pub secret_version_for_client_secret: ::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 {
                /// Default value. This value is unused.
                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,
                    }
                }
            }
        }
        /// Config for auth using [Diglogflow service
        /// agent](<https://cloud.google.com/iam/docs/service-agents#dialogflow-service-agent>).
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct ServiceAgentAuthConfig {
            /// Optional. Indicate the auth token type generated from the [Diglogflow
            /// service
            /// agent](<https://cloud.google.com/iam/docs/service-agents#dialogflow-service-agent>).
            /// The generated token is sent in the Authorization header.
            #[prost(
                enumeration = "service_agent_auth_config::ServiceAgentAuth",
                tag = "1"
            )]
            pub service_agent_auth: i32,
        }
        /// Nested message and enum types in `ServiceAgentAuthConfig`.
        pub mod service_agent_auth_config {
            /// Indicate the auth token type generated from the [Diglogflow service
            /// agent](<https://cloud.google.com/iam/docs/service-agents#dialogflow-service-agent>).
            #[derive(
                Clone,
                Copy,
                Debug,
                PartialEq,
                Eq,
                Hash,
                PartialOrd,
                Ord,
                ::prost::Enumeration
            )]
            #[repr(i32)]
            pub enum ServiceAgentAuth {
                /// Service agent auth type unspecified. Default to ID_TOKEN.
                Unspecified = 0,
                /// Use [ID
                /// token](<https://cloud.google.com/docs/authentication/token-types#id>)
                /// generated from service agent. This can be used to access Cloud
                /// Function and Cloud Run after you grant Invoker role to
                /// `service-<PROJECT-NUMBER>@gcp-sa-dialogflow.iam.gserviceaccount.com`.
                IdToken = 1,
                /// Use [access
                /// token](<https://cloud.google.com/docs/authentication/token-types#access>)
                /// generated from service agent. This can be used to access other Google
                /// Cloud APIs after you grant required roles to
                /// `service-<PROJECT-NUMBER>@gcp-sa-dialogflow.iam.gserviceaccount.com`.
                AccessToken = 2,
            }
            impl ServiceAgentAuth {
                /// 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 => "SERVICE_AGENT_AUTH_UNSPECIFIED",
                        Self::IdToken => "ID_TOKEN",
                        Self::AccessToken => "ACCESS_TOKEN",
                    }
                }
                /// Creates an enum from field names used in the ProtoBuf definition.
                pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                    match value {
                        "SERVICE_AGENT_AUTH_UNSPECIFIED" => Some(Self::Unspecified),
                        "ID_TOKEN" => Some(Self::IdToken),
                        "ACCESS_TOKEN" => Some(Self::AccessToken),
                        _ => None,
                    }
                }
            }
        }
        /// Config for authentication using bearer token.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct BearerTokenConfig {
            /// Optional. The text token appended to the text `Bearer` to the request
            /// Authorization header.
            /// [Session parameters
            /// reference](<https://cloud.google.com/dialogflow/cx/docs/concept/parameter#session-ref>)
            /// can be used to pass the token dynamically, e.g.
            /// `$session.params.parameter-id`.
            #[prost(string, tag = "1")]
            pub token: ::prost::alloc::string::String,
            /// Optional. The name of the SecretManager secret version resource storing
            /// the Bearer token. If this field is set, the `token` field will be
            /// ignored. Format:
            /// `projects/{project}/secrets/{secret}/versions/{version}`
            #[prost(string, tag = "2")]
            pub secret_version_for_token: ::prost::alloc::string::String,
        }
        /// Configuration for authentication using a service account.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct ServiceAccountAuthConfig {
            /// Required. The email address of the service account used to authenticate
            /// the tool call. Dialogflow uses this service account to exchange an
            /// access token and the access token is then sent in the `Authorization`
            /// header of the tool request.
            ///
            /// The service account must have the
            /// `roles/iam.serviceAccountTokenCreator` role granted to the
            /// [Dialogflow service
            /// agent](<https://cloud.google.com/iam/docs/service-agents#dialogflow-service-agent>).
            #[prost(string, tag = "1")]
            pub service_account: ::prost::alloc::string::String,
        }
        /// 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 {
            /// Default value. This value is unused.
            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,
                }
            }
        }
        /// The auth configuration.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
        pub enum AuthConfig {
            /// Config for API key auth.
            #[prost(message, tag = "1")]
            ApiKeyConfig(ApiKeyConfig),
            /// Config for OAuth.
            #[prost(message, tag = "2")]
            OauthConfig(OAuthConfig),
            /// Config for [Diglogflow service
            /// agent](<https://cloud.google.com/iam/docs/service-agents#dialogflow-service-agent>)
            /// auth.
            #[prost(message, tag = "3")]
            ServiceAgentAuthConfig(ServiceAgentAuthConfig),
            /// Config for bearer token auth.
            #[prost(message, tag = "4")]
            BearerTokenConfig(BearerTokenConfig),
            /// Configuration for service account authentication.
            #[prost(message, tag = "5")]
            ServiceAccountAuthConfig(ServiceAccountAuthConfig),
        }
    }
    /// 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, Dialogflow 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/<ProjectID>/locations/<LocationID>/namespaces/<NamespaceID>/services/<ServiceID>`.
        /// `LocationID` of the service directory must be the same as the location
        /// of the agent.
        #[prost(string, tag = "1")]
        pub service: ::prost::alloc::string::String,
    }
    /// Represents the type of the tool.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ToolType {
        /// Default value. This value is unused.
        Unspecified = 0,
        /// Customer provided tool.
        CustomizedTool = 1,
        /// First party built-in tool created by Dialogflow which cannot be modified.
        BuiltinTool = 2,
    }
    impl ToolType {
        /// 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_TYPE_UNSPECIFIED",
                Self::CustomizedTool => "CUSTOMIZED_TOOL",
                Self::BuiltinTool => "BUILTIN_TOOL",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TOOL_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "CUSTOMIZED_TOOL" => Some(Self::CustomizedTool),
                "BUILTIN_TOOL" => Some(Self::BuiltinTool),
                _ => None,
            }
        }
    }
    /// Specification of the Tool.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Specification {
        /// OpenAPI specification of the Tool.
        #[prost(message, tag = "4")]
        OpenApiSpec(OpenApiTool),
        /// Data store search tool specification.
        #[prost(message, tag = "8")]
        DataStoreSpec(DataStoreTool),
        /// Client side executed function specification.
        #[prost(message, tag = "13")]
        FunctionSpec(FunctionTool),
    }
}
/// The request message for
/// \[Tools.ListToolVersions\]\[google.cloud.dialogflow.cx.v3.Tools.ListToolVersions\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListToolVersionsRequest {
    /// Required. The parent of the tool versions.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/tools/<ToolID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The maximum number of items to return in a single page. By
    /// default 100 and at most 1000.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. The next_page_token value returned from a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response message for
/// \[Tools.ListToolVersions\]\[google.cloud.dialogflow.cx.v3.Tools.ListToolVersions\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListToolVersionsResponse {
    /// The list of tool versions. There will be a maximum number of items
    /// returned based on the page_size field in the request.
    #[prost(message, repeated, tag = "1")]
    pub tool_versions: ::prost::alloc::vec::Vec<ToolVersion>,
    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request message for
/// \[Tools.CreateToolVersion\]\[google.cloud.dialogflow.cx.v3.Tools.CreateToolVersion\].
/// The request message for
/// \[Tools.CreateToolVersion\]\[google.cloud.dialogflow.cx.v3.Tools.CreateToolVersion\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateToolVersionRequest {
    /// Required. The tool to create a version for.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/tools/<ToolID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The tool version to create.
    #[prost(message, optional, tag = "2")]
    pub tool_version: ::core::option::Option<ToolVersion>,
}
/// The request message for
/// \[Tools.GetToolVersion\]\[google.cloud.dialogflow.cx.v3.Tools.GetToolVersion\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetToolVersionRequest {
    /// Required. The name of the tool version.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/tools/<ToolID>/versions/<VersionID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for
/// \[Tools.DeleteToolVersion\]\[google.cloud.dialogflow.cx.v3.Tools.DeleteToolVersion\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteToolVersionRequest {
    /// Required. The name of the tool version to delete.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/tools/<ToolID>/versions/<VersionID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. This field has no effect for Tools not being used.
    /// For Tools that are used:
    ///
    /// * If `force` is set to false, an error will be returned with message
    ///   indicating the referenced resources.
    /// * If `force` is set to true, Dialogflow will remove the tool, as well
    ///   as any references to the tool.
    #[prost(bool, tag = "2")]
    pub force: bool,
}
/// The request message for
/// \[Tools.RestoreToolVersion\]\[google.cloud.dialogflow.cx.v3.Tools.RestoreToolVersion\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RestoreToolVersionRequest {
    /// Required. The name of the tool version.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/tools/<ToolID>/versions/<VersionID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The response message for
/// \[Tools.RestoreToolVersion\]\[google.cloud.dialogflow.cx.v3.Tools.RestoreToolVersion\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RestoreToolVersionResponse {
    /// The updated tool.
    #[prost(message, optional, tag = "2")]
    pub tool: ::core::option::Option<Tool>,
}
/// Tool version is a snapshot of the tool at certain timestamp.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ToolVersion {
    /// Identifier. The unique identifier of the tool version.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/tools/<ToolID>/versions/<VersionID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. The display name of the tool version.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Required. Snapshot of the tool to be associated with this version.
    #[prost(message, optional, tag = "3")]
    pub tool: ::core::option::Option<Tool>,
    /// Output only. Last time the tool version was created or modified.
    #[prost(message, optional, tag = "4")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Last time the tool version was created or modified.
    #[prost(message, optional, tag = "5")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Generated client implementations.
pub mod tools_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing \[Tools\]\[google.cloud.dialogflow.cx.v3.Tool\].
    #[derive(Debug, Clone)]
    pub struct ToolsClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ToolsClient<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> ToolsClient<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,
        ) -> ToolsClient<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,
        {
            ToolsClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Creates a \[Tool\]\[google.cloud.dialogflow.cx.v3.Tool\] in the specified
        /// agent.
        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.dialogflow.cx.v3.Tools/CreateTool",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.dialogflow.cx.v3.Tools", "CreateTool"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns a list of \[Tools\]\[google.cloud.dialogflow.cx.v3.Tool\] in the
        /// specified agent.
        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.dialogflow.cx.v3.Tools/ListTools",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.dialogflow.cx.v3.Tools", "ListTools"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the specified \[Tool\]\[google.cloud.dialogflow.cx.v3.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.dialogflow.cx.v3.Tools/GetTool",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.dialogflow.cx.v3.Tools", "GetTool"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Update the specified \[Tool\]\[google.cloud.dialogflow.cx.v3.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.dialogflow.cx.v3.Tools/UpdateTool",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.dialogflow.cx.v3.Tools", "UpdateTool"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a specified \[Tool\]\[google.cloud.dialogflow.cx.v3.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.dialogflow.cx.v3.Tools/DeleteTool",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.cloud.dialogflow.cx.v3.Tools", "DeleteTool"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// List versions of the specified \[Tool\]\[google.cloud.dialogflow.cx.v3.Tool\].
        pub async fn list_tool_versions(
            &mut self,
            request: impl tonic::IntoRequest<super::ListToolVersionsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListToolVersionsResponse>,
            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.dialogflow.cx.v3.Tools/ListToolVersions",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Tools",
                        "ListToolVersions",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a version for the specified
        /// \[Tool\]\[google.cloud.dialogflow.cx.v3.Tool\].
        pub async fn create_tool_version(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateToolVersionRequest>,
        ) -> std::result::Result<tonic::Response<super::ToolVersion>, 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.dialogflow.cx.v3.Tools/CreateToolVersion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Tools",
                        "CreateToolVersion",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the specified version of the
        /// \[Tool\]\[google.cloud.dialogflow.cx.v3.Tool\].
        pub async fn get_tool_version(
            &mut self,
            request: impl tonic::IntoRequest<super::GetToolVersionRequest>,
        ) -> std::result::Result<tonic::Response<super::ToolVersion>, 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.dialogflow.cx.v3.Tools/GetToolVersion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Tools",
                        "GetToolVersion",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified version of the
        /// \[Tool\]\[google.cloud.dialogflow.cx.v3.Tool\].
        pub async fn delete_tool_version(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteToolVersionRequest>,
        ) -> 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.dialogflow.cx.v3.Tools/DeleteToolVersion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Tools",
                        "DeleteToolVersion",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the specified version of the Tool and stores it as the
        /// current tool draft, returning the tool with resources updated.
        pub async fn restore_tool_version(
            &mut self,
            request: impl tonic::IntoRequest<super::RestoreToolVersionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::RestoreToolVersionResponse>,
            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.dialogflow.cx.v3.Tools/RestoreToolVersion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Tools",
                        "RestoreToolVersion",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Metadata associated with the long running operation for
/// \[Versions.CreateVersion\]\[google.cloud.dialogflow.cx.v3.Versions.CreateVersion\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateVersionOperationMetadata {
    /// Name of the created version.
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/versions/<VersionID>`.
    #[prost(string, tag = "1")]
    pub version: ::prost::alloc::string::String,
}
/// Represents a version of a flow.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Version {
    /// Format:
    /// projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/versions/<VersionID>.
    /// Version ID is a self-increasing number generated by Dialogflow upon version
    /// creation.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. The human-readable name of the version. Limit of 64 characters.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// The description of the version. The maximum length is 500 characters. If
    /// exceeded, the request is rejected.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Output only. The NLU settings of the flow at version creation.
    #[prost(message, optional, tag = "4")]
    pub nlu_settings: ::core::option::Option<NluSettings>,
    /// Output only. Create time of the version.
    #[prost(message, optional, tag = "5")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The state of this version. This field is read-only and cannot
    /// be set by create and update methods.
    #[prost(enumeration = "version::State", tag = "6")]
    pub state: i32,
}
/// Nested message and enum types in `Version`.
pub mod version {
    /// The state of the version.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// Not specified. This value is not used.
        Unspecified = 0,
        /// Version is not ready to serve (e.g. training is running).
        Running = 1,
        /// Training has succeeded and this version is ready to serve.
        Succeeded = 2,
        /// Version training failed.
        Failed = 3,
    }
    impl State {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "STATE_UNSPECIFIED",
                Self::Running => "RUNNING",
                Self::Succeeded => "SUCCEEDED",
                Self::Failed => "FAILED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "RUNNING" => Some(Self::Running),
                "SUCCEEDED" => Some(Self::Succeeded),
                "FAILED" => Some(Self::Failed),
                _ => None,
            }
        }
    }
}
/// The request message for
/// \[Versions.ListVersions\]\[google.cloud.dialogflow.cx.v3.Versions.ListVersions\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListVersionsRequest {
    /// Required. The \[Flow\]\[google.cloud.dialogflow.cx.v3.Flow\] to list all
    /// versions for. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of items to return in a single page. By default 20 and
    /// at most 100.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response message for
/// \[Versions.ListVersions\]\[google.cloud.dialogflow.cx.v3.Versions.ListVersions\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListVersionsResponse {
    /// A list of versions. There will be a maximum number of items returned based
    /// on the page_size field in the request. The list may in some cases be empty
    /// or contain fewer entries than page_size even if this isn't the last page.
    #[prost(message, repeated, tag = "1")]
    pub versions: ::prost::alloc::vec::Vec<Version>,
    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request message for
/// \[Versions.GetVersion\]\[google.cloud.dialogflow.cx.v3.Versions.GetVersion\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetVersionRequest {
    /// Required. The name of the \[Version\]\[google.cloud.dialogflow.cx.v3.Version\].
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/versions/<VersionID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for
/// \[Versions.CreateVersion\]\[google.cloud.dialogflow.cx.v3.Versions.CreateVersion\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateVersionRequest {
    /// Required. The \[Flow\]\[google.cloud.dialogflow.cx.v3.Flow\] to create an
    /// \[Version\]\[google.cloud.dialogflow.cx.v3.Version\] for. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The version to create.
    #[prost(message, optional, tag = "2")]
    pub version: ::core::option::Option<Version>,
}
/// The request message for
/// \[Versions.UpdateVersion\]\[google.cloud.dialogflow.cx.v3.Versions.UpdateVersion\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateVersionRequest {
    /// Required. The version to update.
    #[prost(message, optional, tag = "1")]
    pub version: ::core::option::Option<Version>,
    /// Required. The mask to control which fields get updated. Currently only
    /// `description` and `display_name` can be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// The request message for
/// \[Versions.DeleteVersion\]\[google.cloud.dialogflow.cx.v3.Versions.DeleteVersion\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteVersionRequest {
    /// Required. The name of the \[Version\]\[google.cloud.dialogflow.cx.v3.Version\]
    /// to delete. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/versions/<VersionID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request message for
/// \[Versions.LoadVersion\]\[google.cloud.dialogflow.cx.v3.Versions.LoadVersion\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct LoadVersionRequest {
    /// Required. The \[Version\]\[google.cloud.dialogflow.cx.v3.Version\] to be loaded
    /// to draft flow. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/versions/<VersionID>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// This field is used to prevent accidental overwrite of other agent
    /// resources, which can potentially impact other flow's behavior. If
    /// `allow_override_agent_resources` is false, conflicted agent-level resources
    /// will not be overridden (i.e. intents, entities, webhooks).
    #[prost(bool, tag = "2")]
    pub allow_override_agent_resources: bool,
}
/// The request message for
/// \[Versions.CompareVersions\]\[google.cloud.dialogflow.cx.v3.Versions.CompareVersions\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CompareVersionsRequest {
    /// Required. Name of the base flow version to compare with the target version.
    /// Use version ID `0` to indicate the draft version of the specified flow.
    ///
    /// Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/versions/<VersionID>`.
    #[prost(string, tag = "1")]
    pub base_version: ::prost::alloc::string::String,
    /// Required. Name of the target flow version to compare with the
    /// base version. Use version ID `0` to indicate the draft version of the
    /// specified flow. Format:
    /// `projects/<ProjectID>/locations/<LocationID>/agents/<AgentID>/flows/<FlowID>/versions/<VersionID>`.
    #[prost(string, tag = "2")]
    pub target_version: ::prost::alloc::string::String,
    /// The language to compare the flow versions for.
    ///
    /// If not specified, the agent's default language is used.
    /// [Many
    /// languages](<https://cloud.google.com/dialogflow/docs/reference/language>) are
    /// supported. Note: languages must be enabled in the agent before they can be
    /// used.
    #[prost(string, tag = "3")]
    pub language_code: ::prost::alloc::string::String,
}
/// The response message for
/// \[Versions.CompareVersions\]\[google.cloud.dialogflow.cx.v3.Versions.CompareVersions\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CompareVersionsResponse {
    /// JSON representation of the base version content.
    #[prost(string, tag = "1")]
    pub base_version_content_json: ::prost::alloc::string::String,
    /// JSON representation of the target version content.
    #[prost(string, tag = "2")]
    pub target_version_content_json: ::prost::alloc::string::String,
    /// The timestamp when the two version compares.
    #[prost(message, optional, tag = "3")]
    pub compare_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Generated client implementations.
pub mod versions_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing \[Versions\]\[google.cloud.dialogflow.cx.v3.Version\].
    #[derive(Debug, Clone)]
    pub struct VersionsClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl VersionsClient<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> VersionsClient<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,
        ) -> VersionsClient<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,
        {
            VersionsClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Returns the list of all versions in the specified
        /// \[Flow\]\[google.cloud.dialogflow.cx.v3.Flow\].
        pub async fn list_versions(
            &mut self,
            request: impl tonic::IntoRequest<super::ListVersionsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListVersionsResponse>,
            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.dialogflow.cx.v3.Versions/ListVersions",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Versions",
                        "ListVersions",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the specified \[Version\]\[google.cloud.dialogflow.cx.v3.Version\].
        pub async fn get_version(
            &mut self,
            request: impl tonic::IntoRequest<super::GetVersionRequest>,
        ) -> std::result::Result<tonic::Response<super::Version>, 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.dialogflow.cx.v3.Versions/GetVersion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Versions",
                        "GetVersion",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a \[Version\]\[google.cloud.dialogflow.cx.v3.Version\] in the specified
        /// \[Flow\]\[google.cloud.dialogflow.cx.v3.Flow\].
        ///
        /// This method is a [long-running
        /// operation](https://cloud.google.com/dialogflow/cx/docs/how/long-running-operation).
        /// The returned `Operation` type has the following method-specific fields:
        ///
        /// * `metadata`:
        ///  \[CreateVersionOperationMetadata\]\[google.cloud.dialogflow.cx.v3.CreateVersionOperationMetadata\]
        /// * `response`: \[Version\]\[google.cloud.dialogflow.cx.v3.Version\]
        pub async fn create_version(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateVersionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.dialogflow.cx.v3.Versions/CreateVersion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Versions",
                        "CreateVersion",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified \[Version\]\[google.cloud.dialogflow.cx.v3.Version\].
        pub async fn update_version(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateVersionRequest>,
        ) -> std::result::Result<tonic::Response<super::Version>, 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.dialogflow.cx.v3.Versions/UpdateVersion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Versions",
                        "UpdateVersion",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified \[Version\]\[google.cloud.dialogflow.cx.v3.Version\].
        pub async fn delete_version(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteVersionRequest>,
        ) -> 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.dialogflow.cx.v3.Versions/DeleteVersion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Versions",
                        "DeleteVersion",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Loads resources in the specified version to the draft flow.
        ///
        /// This method is a [long-running
        /// operation](https://cloud.google.com/dialogflow/cx/docs/how/long-running-operation).
        /// The returned `Operation` type has the following method-specific fields:
        ///
        /// * `metadata`: An empty [Struct
        ///  message](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#struct)
        /// * `response`: An [Empty
        ///  message](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#empty)
        pub async fn load_version(
            &mut self,
            request: impl tonic::IntoRequest<super::LoadVersionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.dialogflow.cx.v3.Versions/LoadVersion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Versions",
                        "LoadVersion",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Compares the specified base version with target version.
        pub async fn compare_versions(
            &mut self,
            request: impl tonic::IntoRequest<super::CompareVersionsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CompareVersionsResponse>,
            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.dialogflow.cx.v3.Versions/CompareVersions",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.dialogflow.cx.v3.Versions",
                        "CompareVersions",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
