yandex-cloud 2025.4.14

/// Options
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TextNormalizationOptions {
    #[prost(enumeration = "text_normalization_options::TextNormalization", tag = "1")]
    pub text_normalization: i32,
    /// Profanity filter (default: false).
    #[prost(bool, tag = "2")]
    pub profanity_filter: bool,
    /// Rewrite text in literature style (default: false).
    #[prost(bool, tag = "3")]
    pub literature_text: bool,
    /// Define phone formatting mode
    #[prost(enumeration = "text_normalization_options::PhoneFormattingMode", tag = "4")]
    pub phone_formatting_mode: i32,
}
/// Nested message and enum types in `TextNormalizationOptions`.
pub mod text_normalization_options {
    /// Normalization
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum TextNormalization {
        Unspecified = 0,
        /// Enable normalization
        Enabled = 1,
        /// Disable normalization
        Disabled = 2,
    }
    impl TextNormalization {
        /// 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 {
                TextNormalization::Unspecified => "TEXT_NORMALIZATION_UNSPECIFIED",
                TextNormalization::Enabled => "TEXT_NORMALIZATION_ENABLED",
                TextNormalization::Disabled => "TEXT_NORMALIZATION_DISABLED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TEXT_NORMALIZATION_UNSPECIFIED" => Some(Self::Unspecified),
                "TEXT_NORMALIZATION_ENABLED" => Some(Self::Enabled),
                "TEXT_NORMALIZATION_DISABLED" => Some(Self::Disabled),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum PhoneFormattingMode {
        Unspecified = 0,
        /// Disable phone formatting
        Disabled = 1,
    }
    impl PhoneFormattingMode {
        /// 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 {
                PhoneFormattingMode::Unspecified => "PHONE_FORMATTING_MODE_UNSPECIFIED",
                PhoneFormattingMode::Disabled => "PHONE_FORMATTING_MODE_DISABLED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "PHONE_FORMATTING_MODE_UNSPECIFIED" => Some(Self::Unspecified),
                "PHONE_FORMATTING_MODE_DISABLED" => Some(Self::Disabled),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DefaultEouClassifier {
    /// EOU sensitivity. Currently two levels, faster with more error and more conservative (our default).
    #[prost(enumeration = "default_eou_classifier::EouSensitivity", tag = "1")]
    pub r#type: i32,
    /// Hint for max pause between words. Our EOU detector could use this information to distinguish between end of utterance and slow speech (like one <long pause> two <long pause> three, etc).
    #[prost(int64, tag = "2")]
    pub max_pause_between_words_hint_ms: i64,
}
/// Nested message and enum types in `DefaultEouClassifier`.
pub mod default_eou_classifier {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum EouSensitivity {
        Unspecified = 0,
        Default = 1,
        High = 2,
    }
    impl EouSensitivity {
        /// 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 {
                EouSensitivity::Unspecified => "EOU_SENSITIVITY_UNSPECIFIED",
                EouSensitivity::Default => "DEFAULT",
                EouSensitivity::High => "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 {
                "EOU_SENSITIVITY_UNSPECIFIED" => Some(Self::Unspecified),
                "DEFAULT" => Some(Self::Default),
                "HIGH" => Some(Self::High),
                _ => None,
            }
        }
    }
}
/// Use EOU provided by user
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExternalEouClassifier {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EouClassifierOptions {
    /// Type of EOU classifier.
    #[prost(oneof = "eou_classifier_options::Classifier", tags = "1, 2")]
    pub classifier: ::core::option::Option<eou_classifier_options::Classifier>,
}
/// Nested message and enum types in `EouClassifierOptions`.
pub mod eou_classifier_options {
    /// Type of EOU classifier.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Classifier {
        /// EOU classifier provided by SpeechKit. Default.
        #[prost(message, tag = "1")]
        DefaultClassifier(super::DefaultEouClassifier),
        /// EOU is enforced by external messages from user.
        #[prost(message, tag = "2")]
        ExternalClassifier(super::ExternalEouClassifier),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RecognitionClassifier {
    /// Classifier name
    #[prost(string, tag = "1")]
    pub classifier: ::prost::alloc::string::String,
    /// Describes the types of responses to which the classification results will come
    #[prost(enumeration = "recognition_classifier::TriggerType", repeated, tag = "2")]
    pub triggers: ::prost::alloc::vec::Vec<i32>,
}
/// Nested message and enum types in `RecognitionClassifier`.
pub mod recognition_classifier {
    /// Type of recognition classifier trigger.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum TriggerType {
        Unspecified = 0,
        /// Apply classifier to utterance responses
        OnUtterance = 1,
        /// Apply classifier to final responses
        OnFinal = 2,
        /// Apply classifier to partial responses
        OnPartial = 3,
    }
    impl TriggerType {
        /// 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 {
                TriggerType::Unspecified => "TRIGGER_TYPE_UNSPECIFIED",
                TriggerType::OnUtterance => "ON_UTTERANCE",
                TriggerType::OnFinal => "ON_FINAL",
                TriggerType::OnPartial => "ON_PARTIAL",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TRIGGER_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "ON_UTTERANCE" => Some(Self::OnUtterance),
                "ON_FINAL" => Some(Self::OnFinal),
                "ON_PARTIAL" => Some(Self::OnPartial),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RecognitionClassifierOptions {
    /// List of classifiers to use
    #[prost(message, repeated, tag = "1")]
    pub classifiers: ::prost::alloc::vec::Vec<RecognitionClassifier>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SpeechAnalysisOptions {
    /// Analyse speech for every speaker
    #[prost(bool, tag = "1")]
    pub enable_speaker_analysis: bool,
    /// Analyse conversation of two speakers
    #[prost(bool, tag = "2")]
    pub enable_conversation_analysis: bool,
    /// Quantile levels in range (0, 1) for descriptive statistics
    #[prost(double, repeated, tag = "3")]
    pub descriptive_statistics_quantiles: ::prost::alloc::vec::Vec<f64>,
}
/// RAW Audio format spec (no container to infer type). Used in AudioFormat options.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RawAudio {
    /// Type of audio encoding
    #[prost(enumeration = "raw_audio::AudioEncoding", tag = "1")]
    pub audio_encoding: i32,
    /// PCM sample rate
    #[prost(int64, tag = "2")]
    pub sample_rate_hertz: i64,
    /// PCM channel count. Currently only single channel audio is supported in real-time recognition.
    #[prost(int64, tag = "3")]
    pub audio_channel_count: i64,
}
/// Nested message and enum types in `RawAudio`.
pub mod raw_audio {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum AudioEncoding {
        Unspecified = 0,
        /// Audio bit depth 16-bit signed little-endian (Linear PCM).
        Linear16Pcm = 1,
    }
    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 {
                AudioEncoding::Unspecified => "AUDIO_ENCODING_UNSPECIFIED",
                AudioEncoding::Linear16Pcm => "LINEAR16_PCM",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "AUDIO_ENCODING_UNSPECIFIED" => Some(Self::Unspecified),
                "LINEAR16_PCM" => Some(Self::Linear16Pcm),
                _ => None,
            }
        }
    }
}
/// Audio with fixed type in container. Used in AudioFormat options.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ContainerAudio {
    /// Type of audio container.
    #[prost(enumeration = "container_audio::ContainerAudioType", tag = "1")]
    pub container_audio_type: i32,
}
/// Nested message and enum types in `ContainerAudio`.
pub mod container_audio {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ContainerAudioType {
        Unspecified = 0,
        /// Audio bit depth 16-bit signed little-endian (Linear PCM).
        Wav = 1,
        /// Data is encoded using the OPUS audio codec and compressed using the OGG container format.
        OggOpus = 2,
        /// Data is encoded using MPEG-1/2 Layer III and compressed using the MP3 container format.
        Mp3 = 3,
    }
    impl ContainerAudioType {
        /// 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 {
                ContainerAudioType::Unspecified => "CONTAINER_AUDIO_TYPE_UNSPECIFIED",
                ContainerAudioType::Wav => "WAV",
                ContainerAudioType::OggOpus => "OGG_OPUS",
                ContainerAudioType::Mp3 => "MP3",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "CONTAINER_AUDIO_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "WAV" => Some(Self::Wav),
                "OGG_OPUS" => Some(Self::OggOpus),
                "MP3" => Some(Self::Mp3),
                _ => None,
            }
        }
    }
}
/// Audio format options.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AudioFormatOptions {
    #[prost(oneof = "audio_format_options::AudioFormat", tags = "1, 2")]
    pub audio_format: ::core::option::Option<audio_format_options::AudioFormat>,
}
/// Nested message and enum types in `AudioFormatOptions`.
pub mod audio_format_options {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum AudioFormat {
        /// Audio without container.
        #[prost(message, tag = "1")]
        RawAudio(super::RawAudio),
        /// Audio is wrapped in container.
        #[prost(message, tag = "2")]
        ContainerAudio(super::ContainerAudio),
    }
}
/// Type of restriction for the list of languages expected in the incoming speech stream.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LanguageRestrictionOptions {
    /// Language restriction type
    #[prost(
        enumeration = "language_restriction_options::LanguageRestrictionType",
        tag = "1"
    )]
    pub restriction_type: i32,
    /// The list of language codes to restrict recognition in the case of an auto model
    #[prost(string, repeated, tag = "2")]
    pub language_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Nested message and enum types in `LanguageRestrictionOptions`.
pub mod language_restriction_options {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum LanguageRestrictionType {
        Unspecified = 0,
        /// The allowing list. The incoming audio can contain only the listed languages.
        Whitelist = 1,
        /// The forbidding list. The incoming audio cannot contain the listed languages.
        Blacklist = 2,
    }
    impl LanguageRestrictionType {
        /// 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 {
                LanguageRestrictionType::Unspecified => {
                    "LANGUAGE_RESTRICTION_TYPE_UNSPECIFIED"
                }
                LanguageRestrictionType::Whitelist => "WHITELIST",
                LanguageRestrictionType::Blacklist => "BLACKLIST",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "LANGUAGE_RESTRICTION_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "WHITELIST" => Some(Self::Whitelist),
                "BLACKLIST" => Some(Self::Blacklist),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RecognitionModelOptions {
    /// Sets the recognition model for the cloud version of SpeechKit. Possible values: 'general', 'general:rc', 'general:deprecated'.
    /// The model is ignored for SpeechKit Hybrid.
    #[prost(string, tag = "1")]
    pub model: ::prost::alloc::string::String,
    /// Specified input audio.
    #[prost(message, optional, tag = "2")]
    pub audio_format: ::core::option::Option<AudioFormatOptions>,
    /// Text normalization options.
    #[prost(message, optional, tag = "3")]
    pub text_normalization: ::core::option::Option<TextNormalizationOptions>,
    /// Possible languages in audio.
    #[prost(message, optional, tag = "4")]
    pub language_restriction: ::core::option::Option<LanguageRestrictionOptions>,
    /// How to deal with audio data (in real time, after all data is received, etc). Default is REAL_TIME.
    #[prost(enumeration = "recognition_model_options::AudioProcessingType", tag = "5")]
    pub audio_processing_type: i32,
}
/// Nested message and enum types in `RecognitionModelOptions`.
pub mod recognition_model_options {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum AudioProcessingType {
        Unspecified = 0,
        /// Process audio in mode optimized for real-time recognition, i.e. send partials and final responses as soon as possible
        RealTime = 1,
        /// Process audio after all data was received
        FullData = 2,
    }
    impl AudioProcessingType {
        /// 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 {
                AudioProcessingType::Unspecified => "AUDIO_PROCESSING_TYPE_UNSPECIFIED",
                AudioProcessingType::RealTime => "REAL_TIME",
                AudioProcessingType::FullData => "FULL_DATA",
            }
        }
        /// 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_PROCESSING_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "REAL_TIME" => Some(Self::RealTime),
                "FULL_DATA" => Some(Self::FullData),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SpeakerLabelingOptions {
    /// Specifies the execution of speaker labeling. Default is SPEAKER_LABELING_DISABLED.
    #[prost(enumeration = "speaker_labeling_options::SpeakerLabeling", tag = "1")]
    pub speaker_labeling: i32,
}
/// Nested message and enum types in `SpeakerLabelingOptions`.
pub mod speaker_labeling_options {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum SpeakerLabeling {
        Unspecified = 0,
        /// Enable speaker labeling
        Enabled = 1,
        /// Disable speaker labeling
        Disabled = 2,
    }
    impl SpeakerLabeling {
        /// 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 {
                SpeakerLabeling::Unspecified => "SPEAKER_LABELING_UNSPECIFIED",
                SpeakerLabeling::Enabled => "SPEAKER_LABELING_ENABLED",
                SpeakerLabeling::Disabled => "SPEAKER_LABELING_DISABLED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "SPEAKER_LABELING_UNSPECIFIED" => Some(Self::Unspecified),
                "SPEAKER_LABELING_ENABLED" => Some(Self::Enabled),
                "SPEAKER_LABELING_DISABLED" => Some(Self::Disabled),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StreamingOptions {
    /// Configuration for speech recognition model.
    #[prost(message, optional, tag = "1")]
    pub recognition_model: ::core::option::Option<RecognitionModelOptions>,
    /// Configuration for end of utterance detection model.
    #[prost(message, optional, tag = "2")]
    pub eou_classifier: ::core::option::Option<EouClassifierOptions>,
    /// Configuration for classifiers over speech recognition.
    #[prost(message, optional, tag = "3")]
    pub recognition_classifier: ::core::option::Option<RecognitionClassifierOptions>,
    /// Configuration for speech analysis over speech recognition.
    #[prost(message, optional, tag = "4")]
    pub speech_analysis: ::core::option::Option<SpeechAnalysisOptions>,
    /// Configuration for speaker labeling
    #[prost(message, optional, tag = "5")]
    pub speaker_labeling: ::core::option::Option<SpeakerLabelingOptions>,
}
/// Data chunk with audio.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AudioChunk {
    /// Bytes with audio data.
    #[prost(bytes = "vec", tag = "1")]
    pub data: ::prost::alloc::vec::Vec<u8>,
}
/// Data chunk with silence.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SilenceChunk {
    /// Duration of silence chunk in ms.
    #[prost(int64, tag = "1")]
    pub duration_ms: i64,
}
/// Force EOU
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Eou {}
/// Streaming audio request
/// Events are control messages from user.
/// First message should be session options.
/// The next messages are audio data chunks or control messages.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StreamingRequest {
    #[prost(oneof = "streaming_request::Event", tags = "1, 2, 3, 4")]
    pub event: ::core::option::Option<streaming_request::Event>,
}
/// Nested message and enum types in `StreamingRequest`.
pub mod streaming_request {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Event {
        /// Session options. Should be the first message from user.
        #[prost(message, tag = "1")]
        SessionOptions(super::StreamingOptions),
        /// Chunk with audio data.
        #[prost(message, tag = "2")]
        Chunk(super::AudioChunk),
        /// Chunk with silence.
        #[prost(message, tag = "3")]
        SilenceChunk(super::SilenceChunk),
        /// Request to end current utterance. Works only with external EOU detector.
        #[prost(message, tag = "4")]
        Eou(super::Eou),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RecognizeFileRequest {
    /// Configuration for speech recognition model.
    #[prost(message, optional, tag = "3")]
    pub recognition_model: ::core::option::Option<RecognitionModelOptions>,
    /// Configuration for classifiers over speech recognition.
    #[prost(message, optional, tag = "4")]
    pub recognition_classifier: ::core::option::Option<RecognitionClassifierOptions>,
    /// Configuration for speech analysis over speech recognition.
    #[prost(message, optional, tag = "5")]
    pub speech_analysis: ::core::option::Option<SpeechAnalysisOptions>,
    /// Configuration for speaker labeling
    #[prost(message, optional, tag = "6")]
    pub speaker_labeling: ::core::option::Option<SpeakerLabelingOptions>,
    #[prost(oneof = "recognize_file_request::AudioSource", tags = "1, 2")]
    pub audio_source: ::core::option::Option<recognize_file_request::AudioSource>,
}
/// Nested message and enum types in `RecognizeFileRequest`.
pub mod recognize_file_request {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum AudioSource {
        /// Bytes with data
        #[prost(bytes, tag = "1")]
        Content(::prost::alloc::vec::Vec<u8>),
        /// S3 data url
        #[prost(string, tag = "2")]
        Uri(::prost::alloc::string::String),
    }
}
/// Recognized word.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Word {
    /// Word text.
    #[prost(string, tag = "1")]
    pub text: ::prost::alloc::string::String,
    /// Estimation of word start time in ms.
    #[prost(int64, tag = "2")]
    pub start_time_ms: i64,
    /// Estimation of word end time in ms.
    #[prost(int64, tag = "3")]
    pub end_time_ms: i64,
}
/// Estimation of language and its probability.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LanguageEstimation {
    /// Language code in ISO 639-1 format.
    #[prost(string, tag = "1")]
    pub language_code: ::prost::alloc::string::String,
    /// Estimation of language probability.
    #[prost(double, tag = "2")]
    pub probability: f64,
}
/// Recognition of specific time frame.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Alternative {
    /// Words in time frame.
    #[prost(message, repeated, tag = "1")]
    pub words: ::prost::alloc::vec::Vec<Word>,
    /// Text in time frame.
    #[prost(string, tag = "2")]
    pub text: ::prost::alloc::string::String,
    /// Start of time frame.
    #[prost(int64, tag = "3")]
    pub start_time_ms: i64,
    /// End of time frame.
    #[prost(int64, tag = "4")]
    pub end_time_ms: i64,
    /// The hypothesis confidence. Currently is not used.
    #[prost(double, tag = "5")]
    pub confidence: f64,
    /// Distribution over possible languages.
    #[prost(message, repeated, tag = "6")]
    pub languages: ::prost::alloc::vec::Vec<LanguageEstimation>,
}
/// Update information for external End of Utterance.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EouUpdate {
    /// EOU estimated time.
    #[prost(int64, tag = "2")]
    pub time_ms: i64,
}
/// Update of hypothesis.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AlternativeUpdate {
    /// List of hypothesis for timeframes.
    #[prost(message, repeated, tag = "1")]
    pub alternatives: ::prost::alloc::vec::Vec<Alternative>,
    #[deprecated]
    #[prost(string, tag = "2")]
    pub channel_tag: ::prost::alloc::string::String,
}
/// AudioCursors are state of ASR recognition stream.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AudioCursors {
    /// Amount of audio chunks server received. This cursor is moved after each audio chunk was received by server.
    #[prost(int64, tag = "1")]
    pub received_data_ms: i64,
    /// Input stream reset data.
    #[prost(int64, tag = "2")]
    pub reset_time_ms: i64,
    /// How much audio was processed. This time includes trimming silences as well. This cursor is moved after server received enough data
    /// to update recognition results (includes silence as well).
    #[prost(int64, tag = "3")]
    pub partial_time_ms: i64,
    /// Time of last final. This cursor is moved when server decides that recognition from start of audio until final_time_ms will not change anymore
    /// usually this even is followed by EOU detection (but this could change in future).
    #[prost(int64, tag = "4")]
    pub final_time_ms: i64,
    /// This is index of last final server send. Incremented after each new final.
    #[prost(int64, tag = "5")]
    pub final_index: i64,
    /// Estimated time of EOU. Cursor is updated after each new EOU is sent.
    /// For external classifier this equals to received_data_ms at the moment EOU event arrives.
    /// For internal classifier this is estimation of time. The time is not exact and has the same guarantees as word timings.
    #[prost(int64, tag = "6")]
    pub eou_time_ms: i64,
}
/// Refinement for final hypo. For example, text normalization is refinement.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FinalRefinement {
    /// Index of final for which server sends additional information.
    #[prost(int64, tag = "1")]
    pub final_index: i64,
    /// Type of refinement.
    #[prost(oneof = "final_refinement::Type", tags = "2")]
    pub r#type: ::core::option::Option<final_refinement::Type>,
}
/// Nested message and enum types in `FinalRefinement`.
pub mod final_refinement {
    /// Type of refinement.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Type {
        /// Normalized text instead of raw one.
        #[prost(message, tag = "2")]
        NormalizedText(super::AlternativeUpdate),
    }
}
/// Status message
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StatusCode {
    /// Code type.
    #[prost(enumeration = "CodeType", tag = "1")]
    pub code_type: i32,
    /// Human readable message.
    #[prost(string, tag = "2")]
    pub message: ::prost::alloc::string::String,
}
/// Session identifier.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SessionUuid {
    /// Internal session identifier.
    #[prost(string, tag = "1")]
    pub uuid: ::prost::alloc::string::String,
    /// User session identifier.
    #[prost(string, tag = "2")]
    pub user_request_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PhraseHighlight {
    /// Text transcription of the highlighted audio segment
    #[prost(string, tag = "1")]
    pub text: ::prost::alloc::string::String,
    /// Start time of the highlighted audio segment
    #[prost(int64, tag = "2")]
    pub start_time_ms: i64,
    /// End time of the highlighted audio segment
    #[prost(int64, tag = "3")]
    pub end_time_ms: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RecognitionClassifierLabel {
    /// The label of the class predicted by the classifier
    #[prost(string, tag = "1")]
    pub label: ::prost::alloc::string::String,
    /// The prediction confidence
    #[prost(double, tag = "2")]
    pub confidence: f64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RecognitionClassifierResult {
    /// Name of the triggered classifier
    #[prost(string, tag = "1")]
    pub classifier: ::prost::alloc::string::String,
    /// List of highlights, i.e. parts of phrase that determine the result of the classification
    #[prost(message, repeated, tag = "2")]
    pub highlights: ::prost::alloc::vec::Vec<PhraseHighlight>,
    /// Classifier predictions
    #[prost(message, repeated, tag = "3")]
    pub labels: ::prost::alloc::vec::Vec<RecognitionClassifierLabel>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RecognitionClassifierUpdate {
    /// Response window type
    #[prost(enumeration = "recognition_classifier_update::WindowType", tag = "1")]
    pub window_type: i32,
    /// Start time of the audio segment used for classification
    #[prost(int64, tag = "2")]
    pub start_time_ms: i64,
    /// End time of the audio segment used for classification
    #[prost(int64, tag = "3")]
    pub end_time_ms: i64,
    /// Result for dictionary-based classifier
    #[prost(message, optional, tag = "4")]
    pub classifier_result: ::core::option::Option<RecognitionClassifierResult>,
}
/// Nested message and enum types in `RecognitionClassifierUpdate`.
pub mod recognition_classifier_update {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum WindowType {
        Unspecified = 0,
        /// The result of applying the classifier to the last utterance response
        LastUtterance = 1,
        /// The result of applying the classifier to the last final response
        LastFinal = 2,
        /// The result of applying the classifier to the last partial response
        LastPartial = 3,
    }
    impl WindowType {
        /// 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 {
                WindowType::Unspecified => "WINDOW_TYPE_UNSPECIFIED",
                WindowType::LastUtterance => "LAST_UTTERANCE",
                WindowType::LastFinal => "LAST_FINAL",
                WindowType::LastPartial => "LAST_PARTIAL",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "WINDOW_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "LAST_UTTERANCE" => Some(Self::LastUtterance),
                "LAST_FINAL" => Some(Self::LastFinal),
                "LAST_PARTIAL" => Some(Self::LastPartial),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DescriptiveStatistics {
    /// Minimum observed value
    #[prost(double, tag = "1")]
    pub min: f64,
    /// Maximum observed value
    #[prost(double, tag = "2")]
    pub max: f64,
    /// Estimated mean of distribution
    #[prost(double, tag = "3")]
    pub mean: f64,
    /// Estimated standard deviation of distribution
    #[prost(double, tag = "4")]
    pub std: f64,
    /// List of evaluated quantiles
    #[prost(message, repeated, tag = "5")]
    pub quantiles: ::prost::alloc::vec::Vec<descriptive_statistics::Quantile>,
}
/// Nested message and enum types in `DescriptiveStatistics`.
pub mod descriptive_statistics {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Quantile {
        /// Quantile level in range (0, 1)
        #[prost(double, tag = "1")]
        pub level: f64,
        /// Quantile value
        #[prost(double, tag = "2")]
        pub value: f64,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AudioSegmentBoundaries {
    /// Audio segment start time
    #[prost(int64, tag = "1")]
    pub start_time_ms: i64,
    /// Audio segment end time
    #[prost(int64, tag = "2")]
    pub end_time_ms: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SpeakerAnalysis {
    /// Speaker tag
    #[prost(string, tag = "1")]
    pub speaker_tag: ::prost::alloc::string::String,
    /// Response window type
    #[prost(enumeration = "speaker_analysis::WindowType", tag = "2")]
    pub window_type: i32,
    /// Audio segment boundaries
    #[prost(message, optional, tag = "3")]
    pub speech_boundaries: ::core::option::Option<AudioSegmentBoundaries>,
    /// Total speech duration
    #[prost(int64, tag = "4")]
    pub total_speech_ms: i64,
    /// Speech ratio within audio segment
    #[prost(double, tag = "5")]
    pub speech_ratio: f64,
    /// Total silence duration
    #[prost(int64, tag = "6")]
    pub total_silence_ms: i64,
    /// Silence ratio within audio segment
    #[prost(double, tag = "7")]
    pub silence_ratio: f64,
    /// Number of words in recognized speech
    #[prost(int64, tag = "8")]
    pub words_count: i64,
    /// Number of letters in recognized speech
    #[prost(int64, tag = "9")]
    pub letters_count: i64,
    /// Descriptive statistics for words per second distribution
    #[prost(message, optional, tag = "10")]
    pub words_per_second: ::core::option::Option<DescriptiveStatistics>,
    /// Descriptive statistics for letters per second distribution
    #[prost(message, optional, tag = "11")]
    pub letters_per_second: ::core::option::Option<DescriptiveStatistics>,
    /// Descriptive statistics for words per utterance distribution
    #[prost(message, optional, tag = "12")]
    pub words_per_utterance: ::core::option::Option<DescriptiveStatistics>,
    /// Descriptive statistics for letters per utterance distribution
    #[prost(message, optional, tag = "13")]
    pub letters_per_utterance: ::core::option::Option<DescriptiveStatistics>,
    /// Number of utterances
    #[prost(int64, tag = "14")]
    pub utterance_count: i64,
    /// Descriptive statistics for utterance duration distribution
    #[prost(message, optional, tag = "15")]
    pub utterance_duration_estimation: ::core::option::Option<DescriptiveStatistics>,
}
/// Nested message and enum types in `SpeakerAnalysis`.
pub mod speaker_analysis {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum WindowType {
        Unspecified = 0,
        /// Stats for all received audio.
        Total = 1,
        /// Stats for last utterance.
        LastUtterance = 2,
    }
    impl WindowType {
        /// 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 {
                WindowType::Unspecified => "WINDOW_TYPE_UNSPECIFIED",
                WindowType::Total => "TOTAL",
                WindowType::LastUtterance => "LAST_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 {
                "WINDOW_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "TOTAL" => Some(Self::Total),
                "LAST_UTTERANCE" => Some(Self::LastUtterance),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConversationAnalysis {
    /// Audio segment boundaries
    #[prost(message, optional, tag = "1")]
    pub conversation_boundaries: ::core::option::Option<AudioSegmentBoundaries>,
    /// Total simultaneous silence duration
    #[prost(int64, tag = "2")]
    pub total_simultaneous_silence_duration_ms: i64,
    /// Simultaneous silence ratio within audio segment
    #[prost(double, tag = "3")]
    pub total_simultaneous_silence_ratio: f64,
    /// Descriptive statistics for simultaneous silence duration distribution
    #[prost(message, optional, tag = "4")]
    pub simultaneous_silence_duration_estimation: ::core::option::Option<
        DescriptiveStatistics,
    >,
    /// Total simultaneous speech duration
    #[prost(int64, tag = "5")]
    pub total_simultaneous_speech_duration_ms: i64,
    /// Simultaneous speech ratio within audio segment
    #[prost(double, tag = "6")]
    pub total_simultaneous_speech_ratio: f64,
    /// Descriptive statistics for simultaneous speech duration distribution
    #[prost(message, optional, tag = "7")]
    pub simultaneous_speech_duration_estimation: ::core::option::Option<
        DescriptiveStatistics,
    >,
    /// Interrupts description for every speaker
    #[prost(message, repeated, tag = "8")]
    pub speaker_interrupts: ::prost::alloc::vec::Vec<
        conversation_analysis::InterruptsEvaluation,
    >,
    /// Total speech duration, including both simultaneous and separate speech
    #[prost(int64, tag = "9")]
    pub total_speech_duration_ms: i64,
    /// Total speech ratio within audio segment
    #[prost(double, tag = "10")]
    pub total_speech_ratio: f64,
}
/// Nested message and enum types in `ConversationAnalysis`.
pub mod conversation_analysis {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct InterruptsEvaluation {
        /// Speaker tag
        #[prost(string, tag = "1")]
        pub speaker_tag: ::prost::alloc::string::String,
        /// Number of interrupts made by the speaker
        #[prost(int64, tag = "2")]
        pub interrupts_count: i64,
        /// Total duration of all interrupts
        #[prost(int64, tag = "3")]
        pub interrupts_duration_ms: i64,
        /// Boundaries for every interrupt
        #[prost(message, repeated, tag = "4")]
        pub interrupts: ::prost::alloc::vec::Vec<super::AudioSegmentBoundaries>,
    }
}
/// Responses from server.
/// Each response contains session uuid
/// AudioCursors
/// plus specific event
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StreamingResponse {
    /// Session identifier
    #[prost(message, optional, tag = "1")]
    pub session_uuid: ::core::option::Option<SessionUuid>,
    /// Progress bar for stream session recognition: how many data we obtained; final and partial times; etc.
    #[prost(message, optional, tag = "2")]
    pub audio_cursors: ::core::option::Option<AudioCursors>,
    /// Wall clock on server side. This is time when server wrote results to stream
    #[prost(int64, tag = "3")]
    pub response_wall_time_ms: i64,
    /// Tag for distinguish audio channels.
    #[prost(string, tag = "9")]
    pub channel_tag: ::prost::alloc::string::String,
    #[prost(oneof = "streaming_response::Event", tags = "4, 5, 6, 7, 8, 10, 11, 12")]
    pub event: ::core::option::Option<streaming_response::Event>,
}
/// Nested message and enum types in `StreamingResponse`.
pub mod streaming_response {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Event {
        /// Partial results, server will send them regularly after enough audio data was received from user. This are current text estimation
        /// from final_time_ms to partial_time_ms. Could change after new data will arrive.
        #[prost(message, tag = "4")]
        Partial(super::AlternativeUpdate),
        /// Final results, the recognition is now fixed until final_time_ms. For now, final is sent only if the EOU event was triggered. This could be change in future releases.
        #[prost(message, tag = "5")]
        Final(super::AlternativeUpdate),
        /// After EOU classifier, send the message with final, send the EouUpdate with time of EOU
        /// before eou_update we send final with the same time. there could be several finals before eou update.
        #[prost(message, tag = "6")]
        EouUpdate(super::EouUpdate),
        /// For each final, if normalization is enabled, sent the normalized text (or some other advanced post-processing).
        /// Final normalization will introduce additional latency.
        #[prost(message, tag = "7")]
        FinalRefinement(super::FinalRefinement),
        /// Status messages, send by server with fixed interval (keep-alive).
        #[prost(message, tag = "8")]
        StatusCode(super::StatusCode),
        /// Result of the triggered classifier
        #[prost(message, tag = "10")]
        ClassifierUpdate(super::RecognitionClassifierUpdate),
        /// Speech statistics for every speaker
        #[prost(message, tag = "11")]
        SpeakerAnalysis(super::SpeakerAnalysis),
        /// Conversation statistics
        #[prost(message, tag = "12")]
        ConversationAnalysis(super::ConversationAnalysis),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteRecognitionRequest {
    #[prost(string, tag = "1")]
    pub operation_id: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum CodeType {
    Unspecified = 0,
    /// All good.
    Working = 1,
    /// For example, if speech is sent not in real time or context is unknown and we've made fallback.
    Warning = 2,
    /// After session was closed.
    Closed = 3,
}
impl CodeType {
    /// 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 {
            CodeType::Unspecified => "CODE_TYPE_UNSPECIFIED",
            CodeType::Working => "WORKING",
            CodeType::Warning => "WARNING",
            CodeType::Closed => "CLOSED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "CODE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "WORKING" => Some(Self::Working),
            "WARNING" => Some(Self::Warning),
            "CLOSED" => Some(Self::Closed),
            _ => None,
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetRecognitionRequest {
    #[prost(string, tag = "1")]
    pub operation_id: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod recognizer_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// A set of methods for voice recognition.
    #[derive(Debug, Clone)]
    pub struct RecognizerClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl RecognizerClient<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> RecognizerClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + 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,
        ) -> RecognizerClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            RecognizerClient::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
        }
        /// Expects audio in real-time
        pub async fn recognize_streaming(
            &mut self,
            request: impl tonic::IntoStreamingRequest<Message = super::StreamingRequest>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::StreamingResponse>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/speechkit.stt.v3.Recognizer/RecognizeStreaming",
            );
            let mut req = request.into_streaming_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("speechkit.stt.v3.Recognizer", "RecognizeStreaming"),
                );
            self.inner.streaming(req, path, codec).await
        }
    }
}
/// Generated client implementations.
pub mod async_recognizer_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// A set of methods for async voice recognition.
    #[derive(Debug, Clone)]
    pub struct AsyncRecognizerClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl AsyncRecognizerClient<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> AsyncRecognizerClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + 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,
        ) -> AsyncRecognizerClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            AsyncRecognizerClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        pub async fn recognize_file(
            &mut self,
            request: impl tonic::IntoRequest<super::RecognizeFileRequest>,
        ) -> std::result::Result<
            tonic::Response<
                super::super::super::super::yandex::cloud::operation::Operation,
            >,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/speechkit.stt.v3.AsyncRecognizer/RecognizeFile",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("speechkit.stt.v3.AsyncRecognizer", "RecognizeFile"),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_recognition(
            &mut self,
            request: impl tonic::IntoRequest<super::GetRecognitionRequest>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::StreamingResponse>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/speechkit.stt.v3.AsyncRecognizer/GetRecognition",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("speechkit.stt.v3.AsyncRecognizer", "GetRecognition"),
                );
            self.inner.server_streaming(req, path, codec).await
        }
        pub async fn delete_recognition(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteRecognitionRequest>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/speechkit.stt.v3.AsyncRecognizer/DeleteRecognition",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "speechkit.stt.v3.AsyncRecognizer",
                        "DeleteRecognition",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}