// This file is @generated by prost-build.
/// Encoding of an input element such as an audio, video, or text track.
/// Elementary streams must be packaged before mapping and sharing between
/// different output formats.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ElementaryStream {
    /// A unique key for this elementary stream. The key must be 1-63
    /// characters in length. The key must begin and end with a letter (regardless
    /// of case) or a number, but can contain dashes or underscores in between.
    #[prost(string, tag = "4")]
    pub key: ::prost::alloc::string::String,
    /// Required. Encoding of an audio, video, or text track.
    #[prost(oneof = "elementary_stream::ElementaryStream", tags = "1, 2, 3")]
    pub elementary_stream: ::core::option::Option<elementary_stream::ElementaryStream>,
}
/// Nested message and enum types in `ElementaryStream`.
pub mod elementary_stream {
    /// Required. Encoding of an audio, video, or text track.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum ElementaryStream {
        /// Encoding of a video stream.
        #[prost(message, tag = "1")]
        VideoStream(super::VideoStream),
        /// Encoding of an audio stream.
        #[prost(message, tag = "2")]
        AudioStream(super::AudioStream),
        /// Encoding of a text stream. For example, closed captions or subtitles.
        #[prost(message, tag = "3")]
        TextStream(super::TextStream),
    }
}
/// Multiplexing settings for output stream.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct MuxStream {
    /// A unique key for this multiplexed stream. The key must be 1-63
    /// characters in length. The key must begin and end with a letter (regardless
    /// of case) or a number, but can contain dashes or underscores in between.
    #[prost(string, tag = "1")]
    pub key: ::prost::alloc::string::String,
    /// The container format. The default is `fmp4`.
    ///
    /// Supported container formats:
    ///
    /// * `fmp4` - the corresponding file extension is `.m4s`
    /// * `ts` - the corresponding file extension is `.ts`
    #[prost(string, tag = "3")]
    pub container: ::prost::alloc::string::String,
    /// List of `ElementaryStream`
    /// \[key\]\[google.cloud.video.livestream.v1.ElementaryStream.key\]s multiplexed
    /// in this stream.
    ///
    /// * For `fmp4` container, must contain either one video or one audio stream.
    /// * For `ts` container, must contain exactly one audio stream and up to one
    ///   video stream.
    #[prost(string, repeated, tag = "4")]
    pub elementary_streams: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Segment settings for `fmp4` and `ts`.
    #[prost(message, optional, tag = "5")]
    pub segment_settings: ::core::option::Option<SegmentSettings>,
    /// Identifier of the encryption configuration to use. If omitted, output
    /// will be unencrypted.
    #[prost(string, tag = "6")]
    pub encryption_id: ::prost::alloc::string::String,
}
/// Manifest configuration.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Manifest {
    /// The name of the generated file. The default is `manifest` with the
    /// extension suffix corresponding to the `Manifest`
    /// \[type\]\[google.cloud.video.livestream.v1.Manifest.type\]. If multiple
    /// manifests are added to the channel, each must have a unique file name.
    #[prost(string, tag = "1")]
    pub file_name: ::prost::alloc::string::String,
    /// Required. Type of the manifest, can be `HLS` or `DASH`.
    #[prost(enumeration = "manifest::ManifestType", tag = "2")]
    pub r#type: i32,
    /// Required. List of `MuxStream`
    /// \[key\]\[google.cloud.video.livestream.v1.MuxStream.key\]s that should appear
    /// in this manifest.
    ///
    /// * For HLS, either `fmp4` or `ts` mux streams can be specified but not
    ///   mixed.
    /// * For DASH, only `fmp4` mux streams can be specified.
    #[prost(string, repeated, tag = "3")]
    pub mux_streams: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Maximum number of segments that this manifest holds. Once the manifest
    /// reaches this maximum number of segments, whenever a new segment is added to
    /// the manifest, the oldest segment will be removed from the manifest.
    /// The minimum value is 3 and the default value is 5.
    #[prost(int32, tag = "4")]
    pub max_segment_count: i32,
    /// How long to keep a segment on the output Google Cloud Storage bucket after
    /// it is removed from the manifest. This field should be large enough to cover
    /// the manifest propagation delay. Otherwise, a player could receive 404
    /// errors while accessing segments which are listed in the manifest that the
    /// player has, but were already deleted from the output Google Cloud Storage
    /// bucket. Default value is `60s`.
    ///
    /// If both segment_keep_duration and
    /// \[RetentionConfig.retention_window_duration\]\[google.cloud.video.livestream.v1.RetentionConfig.retention_window_duration\]
    /// are set,
    /// \[RetentionConfig.retention_window_duration\]\[google.cloud.video.livestream.v1.RetentionConfig.retention_window_duration\]
    /// is used and segment_keep_duration is ignored.
    #[prost(message, optional, tag = "5")]
    pub segment_keep_duration: ::core::option::Option<::prost_types::Duration>,
    /// Whether to use the timecode, as specified in timecode config, when setting:
    ///
    /// * `availabilityStartTime` attribute in DASH manifests.
    /// * `#EXT-X-PROGRAM-DATE-TIME` tag in HLS manifests.
    ///
    /// If false, ignore the input timecode and use the time from system clock
    /// when the manifest is first generated. This is the default behavior.
    #[prost(bool, tag = "6")]
    pub use_timecode_as_timeline: bool,
    /// Optional. A unique key for this manifest.
    #[prost(string, tag = "7")]
    pub key: ::prost::alloc::string::String,
}
/// Nested message and enum types in `Manifest`.
pub mod manifest {
    /// The manifest type can be either `HLS` or `DASH`.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ManifestType {
        /// The manifest type is not specified.
        Unspecified = 0,
        /// Create an `HLS` manifest. The corresponding file extension is `.m3u8`.
        Hls = 1,
        /// Create a `DASH` manifest. The corresponding file extension is `.mpd`.
        Dash = 2,
    }
    impl ManifestType {
        /// 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 => "MANIFEST_TYPE_UNSPECIFIED",
                Self::Hls => "HLS",
                Self::Dash => "DASH",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "MANIFEST_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "HLS" => Some(Self::Hls),
                "DASH" => Some(Self::Dash),
                _ => None,
            }
        }
    }
}
/// Multiplexing settings for output streams used in
/// \[Distribution\]\[google.cloud.video.livestream.v1.Distribution\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DistributionStream {
    /// Required. A unique key for this distribution stream. The key must be 1-63
    /// characters in length. The key must begin and end with a letter (regardless
    /// of case) or a number, but can contain dashes or underscores in between.
    #[prost(string, tag = "1")]
    pub key: ::prost::alloc::string::String,
    /// Required. The container format.
    ///
    /// Supported container formats:
    ///
    /// * `ts`, must contain exactly one audio stream and up to one video stream.
    /// * `flv`, must contain at most one audio stream and at most one video
    ///   stream.
    #[prost(string, tag = "2")]
    pub container: ::prost::alloc::string::String,
    /// Required. List of `ElementaryStream`
    /// \[key\]\[google.cloud.video.livestream.v1.ElementaryStream.key\]s multiplexed
    /// in this stream. Must contain at least one audio stream and up to one video
    /// stream.
    #[prost(string, repeated, tag = "3")]
    pub elementary_streams: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Distribution configuration.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Distribution {
    /// Required. A unique key for this distribution. The key must be 1-63
    /// characters in length. The key must begin and end with a letter (regardless
    /// of case) or a number, but can contain dashes or underscores in between.
    #[prost(string, tag = "1")]
    pub key: ::prost::alloc::string::String,
    /// Required. `DistributionStream`
    /// \[key\]\[google.cloud.video.livestream.v1.DistributionStream.key\]s that should
    /// appear in this distribution output.
    ///
    /// * For SRT protocol, only `ts` distribution streams can be specified.
    /// * For RTMP protocol, only `flv` distribution streams can be specified.
    #[prost(string, tag = "2")]
    pub distribution_stream: ::prost::alloc::string::String,
    /// Output only. State of the distribution.
    #[prost(enumeration = "distribution::State", tag = "3")]
    pub state: i32,
    /// Output only. Only present when the `state` is `ERROR`. The reason for the
    /// error state of the distribution.
    #[prost(message, optional, tag = "4")]
    pub error: ::core::option::Option<super::super::super::super::rpc::Status>,
    /// Configurations for the output endpoint by streaming protocols.
    #[prost(oneof = "distribution::Endpoint", tags = "5, 6")]
    pub endpoint: ::core::option::Option<distribution::Endpoint>,
}
/// Nested message and enum types in `Distribution`.
pub mod distribution {
    /// State of this distribution.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// State is not specified.
        Unspecified = 0,
        /// Distribution has trouble to produce or deliver the output.
        Error = 5,
        /// Distribution is not ready to be started.
        NotReady = 6,
        /// Distribution is ready to be started.
        Ready = 7,
        /// Distribution is already started and is waiting for input.
        AwaitingInput = 8,
        /// Distribution is already started and is generating output.
        Distributing = 9,
    }
    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::Error => "ERROR",
                Self::NotReady => "NOT_READY",
                Self::Ready => "READY",
                Self::AwaitingInput => "AWAITING_INPUT",
                Self::Distributing => "DISTRIBUTING",
            }
        }
        /// 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),
                "ERROR" => Some(Self::Error),
                "NOT_READY" => Some(Self::NotReady),
                "READY" => Some(Self::Ready),
                "AWAITING_INPUT" => Some(Self::AwaitingInput),
                "DISTRIBUTING" => Some(Self::Distributing),
                _ => None,
            }
        }
    }
    /// Configurations for the output endpoint by streaming protocols.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Endpoint {
        /// Output endpoint using SRT_PUSH.
        #[prost(message, tag = "5")]
        SrtPush(super::SrtPushOutputEndpoint),
        /// Output endpoint using RTMP_PUSH.
        #[prost(message, tag = "6")]
        RtmpPush(super::RtmpPushOutputEndpoint),
    }
}
/// Configurations for an output endpoint using SRT_PUSH as the streaming
/// protocol.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SrtPushOutputEndpoint {
    /// Required. The full URI of the remote SRT server.
    #[prost(string, tag = "1")]
    pub uri: ::prost::alloc::string::String,
    /// Defines where SRT encryption passphrase are stored.
    #[prost(oneof = "srt_push_output_endpoint::PassphraseSource", tags = "2")]
    pub passphrase_source: ::core::option::Option<
        srt_push_output_endpoint::PassphraseSource,
    >,
}
/// Nested message and enum types in `SrtPushOutputEndpoint`.
pub mod srt_push_output_endpoint {
    /// Defines where SRT encryption passphrase are stored.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum PassphraseSource {
        /// The name of the Secret Version containing the SRT encryption passphrase,
        /// which is stored in Google Secret Manager. It should be in the format of
        /// `projects/{project}/secrets/{secret_id}/versions/{version_number}`.
        #[prost(string, tag = "2")]
        PassphraseSecretVersion(::prost::alloc::string::String),
    }
}
/// Configurations for an output endpoint using RTMP_PUSH as the streaming
/// protocol.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RtmpPushOutputEndpoint {
    /// Required. The full URI of the remote RTMP server. For example:
    /// `rtmp://192.168.123.321/live/my-stream` or `rtmp://somedomain.com/someapp`.
    #[prost(string, tag = "1")]
    pub uri: ::prost::alloc::string::String,
    /// Required. Stream key for RTMP protocol.
    #[prost(string, tag = "2")]
    pub stream_key: ::prost::alloc::string::String,
}
/// Sprite sheet configuration.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SpriteSheet {
    /// Format type. The default is `jpeg`.
    ///
    /// Supported formats:
    ///
    /// * `jpeg`
    #[prost(string, tag = "1")]
    pub format: ::prost::alloc::string::String,
    /// Required. File name prefix for the generated sprite sheets. If multiple
    /// sprite sheets are added to the channel, each must have a unique file
    /// prefix.
    /// Each sprite sheet has an incremental 10-digit zero-padded suffix starting
    /// from 0 before the extension, such as `sprite_sheet0000000123.jpeg`.
    #[prost(string, tag = "2")]
    pub file_prefix: ::prost::alloc::string::String,
    /// Required. The width of the sprite in pixels. Must be an even integer.
    #[prost(int32, tag = "3")]
    pub sprite_width_pixels: i32,
    /// Required. The height of the sprite in pixels. Must be an even integer.
    #[prost(int32, tag = "4")]
    pub sprite_height_pixels: i32,
    /// The maximum number of sprites per row in a sprite sheet. Valid range is
    /// \[1, 10\] and the default value is 1.
    #[prost(int32, tag = "5")]
    pub column_count: i32,
    /// The maximum number of rows per sprite sheet. When the sprite sheet is full,
    /// a new sprite sheet is created. Valid range is \[1, 10\] and the default value
    /// is 1.
    #[prost(int32, tag = "6")]
    pub row_count: i32,
    /// Create sprites at regular intervals. Valid range is \[1 second, 1 hour\] and
    /// the default value is `10s`.
    #[prost(message, optional, tag = "7")]
    pub interval: ::core::option::Option<::prost_types::Duration>,
    /// The quality of the generated sprite sheet. Enter a value between 1
    /// and 100, where 1 is the lowest quality and 100 is the highest quality.
    /// The default is 100. A high quality value corresponds to a low image data
    /// compression ratio.
    #[prost(int32, tag = "8")]
    pub quality: i32,
}
/// Preprocessing configurations.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct PreprocessingConfig {
    /// Audio preprocessing configuration.
    #[prost(message, optional, tag = "1")]
    pub audio: ::core::option::Option<preprocessing_config::Audio>,
    /// Specify the video cropping configuration.
    #[prost(message, optional, tag = "2")]
    pub crop: ::core::option::Option<preprocessing_config::Crop>,
    /// Specify the video pad filter configuration.
    #[prost(message, optional, tag = "3")]
    pub pad: ::core::option::Option<preprocessing_config::Pad>,
}
/// Nested message and enum types in `PreprocessingConfig`.
pub mod preprocessing_config {
    /// Audio preprocessing configuration.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct Audio {
        /// Specify audio loudness normalization in loudness units relative to full
        /// scale (LUFS). Enter a value between -24 and 0 according to the following:
        ///
        /// * -24 is the Advanced Television Systems Committee (ATSC A/85)
        /// * -23 is the EU R128 broadcast standard
        /// * -19 is the prior standard for online mono audio
        /// * -18 is the ReplayGain standard
        /// * -16 is the prior standard for stereo audio
        /// * -14 is the new online audio standard recommended by Spotify, as well as
        ///   Amazon Echo
        /// * 0 disables normalization. The default is 0.
        #[prost(double, tag = "1")]
        pub lufs: f64,
    }
    /// Video cropping configuration for the input video. The cropped input video
    /// is scaled to match the output resolution.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Crop {
        /// The number of pixels to crop from the top. The default is 0.
        #[prost(int32, tag = "1")]
        pub top_pixels: i32,
        /// The number of pixels to crop from the bottom. The default is 0.
        #[prost(int32, tag = "2")]
        pub bottom_pixels: i32,
        /// The number of pixels to crop from the left. The default is 0.
        #[prost(int32, tag = "3")]
        pub left_pixels: i32,
        /// The number of pixels to crop from the right. The default is 0.
        #[prost(int32, tag = "4")]
        pub right_pixels: i32,
    }
    /// Pad filter configuration for the input video. The padded input video
    /// is scaled after padding with black to match the output resolution.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Pad {
        /// The number of pixels to add to the top. The default is 0.
        #[prost(int32, tag = "1")]
        pub top_pixels: i32,
        /// The number of pixels to add to the bottom. The default is 0.
        #[prost(int32, tag = "2")]
        pub bottom_pixels: i32,
        /// The number of pixels to add to the left. The default is 0.
        #[prost(int32, tag = "3")]
        pub left_pixels: i32,
        /// The number of pixels to add to the right. The default is 0.
        #[prost(int32, tag = "4")]
        pub right_pixels: i32,
    }
}
/// Video stream resource.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VideoStream {
    /// Codec settings.
    #[prost(oneof = "video_stream::CodecSettings", tags = "20, 21")]
    pub codec_settings: ::core::option::Option<video_stream::CodecSettings>,
}
/// Nested message and enum types in `VideoStream`.
pub mod video_stream {
    /// H264 codec settings.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct H264CodecSettings {
        /// Required. The width of the video in pixels. Must be an even integer.
        /// Valid range is \[320, 4096\].
        #[prost(int32, tag = "1")]
        pub width_pixels: i32,
        /// Required. The height of the video in pixels. Must be an even integer.
        /// Valid range is \[180, 2160\].
        #[prost(int32, tag = "2")]
        pub height_pixels: i32,
        /// Required. The target video frame rate in frames per second (FPS). Must be
        /// less than or equal to 60. Will default to the input frame rate if larger
        /// than the input frame rate. The API will generate an output FPS that is
        /// divisible by the input FPS, and smaller or equal to the target FPS. See
        /// [Calculating frame
        /// rate](<https://cloud.google.com/transcoder/docs/concepts/frame-rate>) for
        /// more information.
        #[prost(double, tag = "3")]
        pub frame_rate: f64,
        /// Required. The video bitrate in bits per second. Minimum value is 10,000.
        ///
        /// * For SD resolution (\< 720p), must be \<= 3,000,000 (3 Mbps).
        /// * For HD resolution (\<= 1080p), must be \<= 15,000,000 (15 Mbps).
        /// * For UHD resolution (\<= 2160p), must be \<= 25,000,000 (25 Mbps).
        #[prost(int32, tag = "4")]
        pub bitrate_bps: i32,
        /// Specifies whether an open Group of Pictures (GOP) structure should be
        /// allowed or not. The default is `false`.
        #[prost(bool, tag = "6")]
        pub allow_open_gop: bool,
        /// Size of the Video Buffering Verifier (VBV) buffer in bits. Must be
        /// greater than zero. The default is equal to
        /// \[bitrate_bps\]\[google.cloud.video.livestream.v1.VideoStream.H264CodecSettings.bitrate_bps\].
        #[prost(int32, tag = "9")]
        pub vbv_size_bits: i32,
        /// Initial fullness of the Video Buffering Verifier (VBV) buffer in bits.
        /// Must be greater than zero. The default is equal to 90% of
        /// \[vbv_size_bits\]\[google.cloud.video.livestream.v1.VideoStream.H264CodecSettings.vbv_size_bits\].
        #[prost(int32, tag = "10")]
        pub vbv_fullness_bits: i32,
        /// The entropy coder to use. The default is `cabac`.
        ///
        /// Supported entropy coders:
        ///
        /// * `cavlc`
        /// * `cabac`
        #[prost(string, tag = "11")]
        pub entropy_coder: ::prost::alloc::string::String,
        /// Allow B-pyramid for reference frame selection. This may not be supported
        /// on all decoders. The default is `false`.
        #[prost(bool, tag = "12")]
        pub b_pyramid: bool,
        /// The number of consecutive B-frames. Must be greater than or equal to
        /// zero. Must be less than
        /// \[gop_frame_count\]\[google.cloud.video.livestream.v1.VideoStream.H264CodecSettings.gop_frame_count\]
        /// if set. The default is 0.
        #[prost(int32, tag = "13")]
        pub b_frame_count: i32,
        /// Specify the intensity of the adaptive quantizer (AQ). Must be between 0
        /// and 1, where 0 disables the quantizer and 1 maximizes the quantizer. A
        /// higher value equals a lower bitrate but smoother image. The default is 0.
        #[prost(double, tag = "14")]
        pub aq_strength: f64,
        /// Enforces the specified codec profile. The following profiles are
        /// supported:
        ///
        /// * `baseline`
        /// * `main` (default)
        /// * `high`
        ///
        /// The available options are [FFmpeg-compatible Profile
        /// Options](<https://trac.ffmpeg.org/wiki/Encode/H.264#Profile>).
        /// Note that certain values for this field may cause the
        /// transcoder to override other fields you set in the
        /// \[H264CodecSettings\]\[google.cloud.video.livestream.v1.VideoStream.H264CodecSettings\]
        /// message.
        #[prost(string, tag = "15")]
        pub profile: ::prost::alloc::string::String,
        /// Enforces the specified codec tune. The available options are
        /// [FFmpeg-compatible Encode
        /// Options](<https://trac.ffmpeg.org/wiki/Encode/H.264#Tune>)
        /// Note that certain values for this field may cause the transcoder to
        /// override other fields you set in the
        /// \[H264CodecSettings\]\[google.cloud.video.livestream.v1.VideoStream.H264CodecSettings\]
        /// message.
        #[prost(string, tag = "16")]
        pub tune: ::prost::alloc::string::String,
        /// GOP mode can be either by frame count or duration.
        #[prost(oneof = "h264_codec_settings::GopMode", tags = "7, 8")]
        pub gop_mode: ::core::option::Option<h264_codec_settings::GopMode>,
    }
    /// Nested message and enum types in `H264CodecSettings`.
    pub mod h264_codec_settings {
        /// GOP mode can be either by frame count or duration.
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)]
        pub enum GopMode {
            /// Select the GOP size based on the specified frame count.
            /// If GOP frame count is set instead of GOP duration, GOP duration will be
            /// calculated by `gopFrameCount`/`frameRate`. The calculated GOP duration
            /// must satisfy the limitations on `gopDuration` as well.
            /// Valid range is \[60, 600\].
            #[prost(int32, tag = "7")]
            GopFrameCount(i32),
            /// Select the GOP size based on the specified duration. The default is
            /// `2s`. Note that `gopDuration` must be less than or equal to
            /// \[segment_duration\]\[google.cloud.video.livestream.v1.SegmentSettings.segment_duration\],
            /// and
            /// \[segment_duration\]\[google.cloud.video.livestream.v1.SegmentSettings.segment_duration\]
            /// must be divisible by `gopDuration`. Valid range is \[2s, 20s\].
            ///
            /// All video streams in the same channel must have the same GOP size.
            #[prost(message, tag = "8")]
            GopDuration(::prost_types::Duration),
        }
    }
    /// H265 codec settings.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct H265CodecSettings {
        /// Optional. The width of the video in pixels. Must be an even integer.
        /// When not specified, the width is adjusted to match the specified height
        /// and input aspect ratio. If both are omitted, the input width is used.
        /// Valid range is \[320, 4096\].
        #[prost(int32, tag = "1")]
        pub width_pixels: i32,
        /// Optional. The height of the video in pixels. Must be an even integer.
        /// When not specified, the height is adjusted to match the specified width
        /// and input aspect ratio. If both are omitted, the input height is used.
        /// Valid range is \[180, 2160\].
        #[prost(int32, tag = "2")]
        pub height_pixels: i32,
        /// Required. The target video frame rate in frames per second (FPS). Must be
        /// less than or equal to 120. Will default to the input frame rate if larger
        /// than the input frame rate. The API will generate an output FPS that is
        /// divisible by the input FPS, and smaller or equal to the target FPS. See
        /// [Calculating frame
        /// rate](<https://cloud.google.com/transcoder/docs/concepts/frame-rate>) for
        /// more information.
        #[prost(double, tag = "3")]
        pub frame_rate: f64,
        /// Required. The video bitrate in bits per second. Minimum value is 10,000.
        ///
        /// * For SD resolution (\< 720p), must be \<= 3,000,000 (3 Mbps).
        /// * For HD resolution (\<= 1080p), must be \<= 15,000,000 (15 Mbps).
        /// * For UHD resolution (\<= 2160p), must be \<= 25,000,000 (25 Mbps).
        #[prost(int32, tag = "4")]
        pub bitrate_bps: i32,
        /// Optional. Size of the Video Buffering Verifier (VBV) buffer in bits. Must
        /// be greater than zero. The default is equal to
        /// \[bitrate_bps\]\[google.cloud.video.livestream.v1.VideoStream.H265CodecSettings.bitrate_bps\].
        #[prost(int32, tag = "9")]
        pub vbv_size_bits: i32,
        /// Optional. Initial fullness of the Video Buffering Verifier (VBV) buffer
        /// in bits. Must be greater than zero. The default is equal to 90% of
        /// \[vbv_size_bits\]\[google.cloud.video.livestream.v1.VideoStream.H265CodecSettings.vbv_size_bits\].
        #[prost(int32, tag = "10")]
        pub vbv_fullness_bits: i32,
        /// Optional. Allow B-pyramid for reference frame selection. This may not be
        /// supported on all decoders. The default is `false`.
        #[prost(bool, tag = "11")]
        pub b_pyramid: bool,
        /// Optional. The number of consecutive B-frames. Must be greater than or
        /// equal to zero. Must be less than
        /// \[gop_frame_count\]\[google.cloud.video.livestream.v1.VideoStream.H265CodecSettings.gop_frame_count\]
        /// if set. The default is 0.
        #[prost(int32, tag = "12")]
        pub b_frame_count: i32,
        /// Optional. Specify the intensity of the adaptive quantizer (AQ). Must be
        /// between 0 and 1, where 0 disables the quantizer and 1 maximizes the
        /// quantizer. A higher value equals a lower bitrate but smoother image. The
        /// default is 0.
        #[prost(double, tag = "13")]
        pub aq_strength: f64,
        /// GOP mode can be either by frame count or duration.
        #[prost(oneof = "h265_codec_settings::GopMode", tags = "7, 8")]
        pub gop_mode: ::core::option::Option<h265_codec_settings::GopMode>,
    }
    /// Nested message and enum types in `H265CodecSettings`.
    pub mod h265_codec_settings {
        /// GOP mode can be either by frame count or duration.
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)]
        pub enum GopMode {
            /// Optional. Select the GOP size based on the specified frame count.
            /// If GOP frame count is set instead of GOP duration, GOP duration will be
            /// calculated by `gopFrameCount`/`frameRate`. The calculated GOP duration
            /// must satisfy the limitations on `gopDuration` as well.
            /// Valid range is \[60, 600\].
            #[prost(int32, tag = "7")]
            GopFrameCount(i32),
            /// Optional. Select the GOP size based on the specified duration. The
            /// default is `2s`. Note that `gopDuration` must be less than or equal to
            /// \[segment_duration\]\[google.cloud.video.livestream.v1.SegmentSettings.segment_duration\],
            /// and
            /// \[segment_duration\]\[google.cloud.video.livestream.v1.SegmentSettings.segment_duration\]
            /// must be divisible by `gopDuration`. Valid range is \[2s, 20s\].
            ///
            /// All video streams in the same channel must have the same GOP size.
            #[prost(message, tag = "8")]
            GopDuration(::prost_types::Duration),
        }
    }
    /// Codec settings.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum CodecSettings {
        /// H264 codec settings.
        #[prost(message, tag = "20")]
        H264(H264CodecSettings),
        /// H265 codec settings.
        #[prost(message, tag = "21")]
        H265(H265CodecSettings),
    }
}
/// Audio stream resource.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AudioStream {
    /// Specifies whether pass through (transmuxing) is enabled or not.
    /// If set to `true`, the rest of the settings, other than `mapping`, will be
    /// ignored. The default is `false`.
    #[prost(bool, tag = "8")]
    pub transmux: bool,
    /// The codec for this audio stream. The default is `aac`.
    ///
    /// Supported audio codecs:
    ///
    /// * `aac`
    #[prost(string, tag = "1")]
    pub codec: ::prost::alloc::string::String,
    /// Required. Audio bitrate in bits per second. Must be between 1 and
    /// 10,000,000.
    #[prost(int32, tag = "2")]
    pub bitrate_bps: i32,
    /// Number of audio channels. Must be between 1 and 6. The default is 2.
    #[prost(int32, tag = "3")]
    pub channel_count: i32,
    /// A list of channel names specifying layout of the audio channels.
    /// This only affects the metadata embedded in the container headers, if
    /// supported by the specified format. The default is `\[fl, fr\]`.
    ///
    /// Supported channel names:
    ///
    /// * `fl` - Front left channel
    /// * `fr` - Front right channel
    /// * `sl` - Side left channel
    /// * `sr` - Side right channel
    /// * `fc` - Front center channel
    /// * `lfe` - Low frequency
    #[prost(string, repeated, tag = "4")]
    pub channel_layout: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// The mapping for the input streams and audio channels.
    #[prost(message, repeated, tag = "5")]
    pub mapping: ::prost::alloc::vec::Vec<audio_stream::AudioMapping>,
    /// The audio sample rate in Hertz. The default is 48000 Hertz.
    #[prost(int32, tag = "6")]
    pub sample_rate_hertz: i32,
}
/// Nested message and enum types in `AudioStream`.
pub mod audio_stream {
    /// The mapping for the input streams and audio channels.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct AudioMapping {
        /// Required. The `Channel`
        /// \[InputAttachment.key\]\[google.cloud.video.livestream.v1.InputAttachment.key\]
        /// that identifies the input that this audio mapping applies to. If an
        /// active input doesn't have an audio mapping, the primary audio track in
        /// the input stream will be selected.
        #[prost(string, tag = "6")]
        pub input_key: ::prost::alloc::string::String,
        /// Required. The zero-based index of the track in the input stream.
        /// All \[mapping\]\[google.cloud.video.livestream.v1.AudioStream.mapping\]s in
        /// the same \[AudioStream\]\[google.cloud.video.livestream.v1.AudioStream\] must
        /// have the same input track.
        #[prost(int32, tag = "2")]
        pub input_track: i32,
        /// Required. The zero-based index of the channel in the input stream.
        #[prost(int32, tag = "3")]
        pub input_channel: i32,
        /// Required. The zero-based index of the channel in the output audio stream.
        /// Must be consistent with the
        /// \[input_channel\]\[google.cloud.video.livestream.v1.AudioStream.AudioMapping.input_channel\].
        #[prost(int32, tag = "4")]
        pub output_channel: i32,
        /// Audio volume control in dB. Negative values decrease volume,
        /// positive values increase. The default is 0.
        #[prost(double, tag = "5")]
        pub gain_db: f64,
    }
}
/// Encoding of a text stream. For example, closed captions or subtitles.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TextStream {
    /// Required. The codec for this text stream.
    ///
    /// Supported text codecs:
    ///
    /// * `cea608`
    /// * `cea708`
    /// * `webvtt`
    #[prost(string, tag = "1")]
    pub codec: ::prost::alloc::string::String,
    /// Optional. The BCP-47 language code, such as `en-US` or `sr-Latn`. For more
    /// information, see
    /// <https://www.unicode.org/reports/tr35/#Unicode_locale_identifier.>
    #[prost(string, tag = "2")]
    pub language_code: ::prost::alloc::string::String,
    /// Optional. The name for this particular text stream that will be added to
    /// the HLS/DASH manifest.
    #[prost(string, tag = "4")]
    pub display_name: ::prost::alloc::string::String,
    /// Optional. The channel of the closed caption in the output stream.
    /// This field should only be set when textstream is used for partner
    /// distribution.
    /// Must be one of `CC1`, `CC2`, `CC3`, and `CC4`, if the
    /// \[codec\]\[google.cloud.video.livestream.v1.TextStream.codec\] is `cea608`;
    /// Must be one between `SERVICE1` and `SERVICE63`, if the
    /// \[codec\]\[google.cloud.video.livestream.v1.TextStream.codec\] is `cea708`.
    #[prost(string, tag = "5")]
    pub output_cea_channel: ::prost::alloc::string::String,
    /// Optional. The mapping for the input streams and text tracks.
    #[prost(message, repeated, tag = "3")]
    pub mapping: ::prost::alloc::vec::Vec<text_stream::TextMapping>,
}
/// Nested message and enum types in `TextStream`.
pub mod text_stream {
    /// The mapping for the input streams and text tracks.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct TextMapping {
        /// Optional. The `Channel`
        /// \[InputAttachment.key\]\[google.cloud.video.livestream.v1.InputAttachment.key\]
        /// that identifies the input that this text mapping applies to.
        #[prost(string, tag = "4")]
        pub input_key: ::prost::alloc::string::String,
        /// Optional. The zero-based index of the track in the input stream.
        #[prost(int32, tag = "2")]
        pub input_track: i32,
        /// Optional. The channel of the closed caption in the input stream.
        /// If this field is set, the output
        /// \[codec\]\[google.cloud.video.livestream.v1.TextStream.codec\] must be
        /// `webvtt`. Must be one of `CC1`, `CC2`, `CC3`, and `CC4`, if the codec of
        /// the input closed caption is `cea608`; Must be one between `SERVICE1` and
        /// `SERVICE64`, if the codec of the input closed caption is `cea708`.
        #[prost(string, tag = "5")]
        pub input_cea_channel: ::prost::alloc::string::String,
        /// Optional. The BCP-47 source language code, such as `en-US` or `sr-Latn`.
        /// If differ from the textStream's language code, enable translation. For
        /// more information on BCP-47 language codes, see
        /// <https://www.unicode.org/reports/tr35/#Unicode_locale_identifier.>
        #[prost(string, tag = "6")]
        pub from_language_code: ::prost::alloc::string::String,
    }
}
/// Segment settings for `fmp4` and `ts`.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SegmentSettings {
    /// Duration of the segments in seconds. The default is `6s`. Note that
    /// `segmentDuration` must be greater than or equal to
    /// \[gop_duration\]\[google.cloud.video.livestream.v1.VideoStream.H264CodecSettings.gop_duration\],
    /// and `segmentDuration` must be divisible by
    /// \[gop_duration\]\[google.cloud.video.livestream.v1.VideoStream.H264CodecSettings.gop_duration\].
    /// Valid range is \[2s, 20s\].
    ///
    /// All \[mux_streams\]\[google.cloud.video.livestream.v1.Manifest.mux_streams\] in
    /// the same manifest must have the same segment duration.
    #[prost(message, optional, tag = "1")]
    pub segment_duration: ::core::option::Option<::prost_types::Duration>,
}
/// Timecode configuration.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TimecodeConfig {
    /// The source of the timecode that will later be used in outputs/manifests.
    /// It determines the initial timecode/timestamp (first frame) of output
    /// streams.
    #[prost(enumeration = "timecode_config::TimecodeSource", tag = "1")]
    pub source: i32,
    /// For EMBEDDED_TIMECODE source only.
    /// Used to interpret the embedded timecode (which contains only the time part
    /// and no date). We assume all inputs are live.
    #[prost(oneof = "timecode_config::TimeOffset", tags = "2, 3")]
    pub time_offset: ::core::option::Option<timecode_config::TimeOffset>,
}
/// Nested message and enum types in `TimecodeConfig`.
pub mod timecode_config {
    /// The source of timecode.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum TimecodeSource {
        /// The timecode source is not specified.
        Unspecified = 0,
        /// Use input media timestamp.
        MediaTimestamp = 1,
        /// Use input embedded timecode e.g. picture timing SEI message.
        EmbeddedTimecode = 2,
    }
    impl TimecodeSource {
        /// 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 => "TIMECODE_SOURCE_UNSPECIFIED",
                Self::MediaTimestamp => "MEDIA_TIMESTAMP",
                Self::EmbeddedTimecode => "EMBEDDED_TIMECODE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TIMECODE_SOURCE_UNSPECIFIED" => Some(Self::Unspecified),
                "MEDIA_TIMESTAMP" => Some(Self::MediaTimestamp),
                "EMBEDDED_TIMECODE" => Some(Self::EmbeddedTimecode),
                _ => None,
            }
        }
    }
    /// For EMBEDDED_TIMECODE source only.
    /// Used to interpret the embedded timecode (which contains only the time part
    /// and no date). We assume all inputs are live.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum TimeOffset {
        /// UTC offset. Must be whole seconds, between -18 hours and +18 hours.
        #[prost(message, tag = "2")]
        UtcOffset(::prost_types::Duration),
        /// Time zone e.g. "America/Los_Angeles".
        #[prost(message, tag = "3")]
        TimeZone(super::super::super::super::super::r#type::TimeZone),
    }
}
/// Input resource represents the endpoint from which the channel ingests
/// the input stream.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Input {
    /// The resource name of the input, in the form of:
    /// `projects/{project}/locations/{location}/inputs/{inputId}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. The creation time.
    #[prost(message, optional, tag = "2")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The update time.
    #[prost(message, optional, tag = "3")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// User-defined key/value metadata.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Source type.
    #[prost(enumeration = "input::Type", tag = "5")]
    pub r#type: i32,
    /// Tier defines the maximum input specification that is accepted by the
    /// video pipeline. The billing is charged based on the tier specified here.
    /// See [Pricing](<https://cloud.google.com/livestream/pricing>) for more detail.
    /// The default is `HD`.
    #[prost(enumeration = "input::Tier", tag = "14")]
    pub tier: i32,
    /// Output only. URI to push the input stream to.
    /// Its format depends on the input
    /// \[type\]\[google.cloud.video.livestream.v1.Input.type\], for example:
    ///
    /// * `RTMP_PUSH`: `rtmp://1.2.3.4/live/{STREAM-ID}`
    /// * `SRT_PUSH`: `srt://1.2.3.4:4201?streamid={STREAM-ID}`
    #[prost(string, tag = "6")]
    pub uri: ::prost::alloc::string::String,
    /// Preprocessing configurations.
    #[prost(message, optional, tag = "9")]
    pub preprocessing_config: ::core::option::Option<PreprocessingConfig>,
    /// Security rule for access control.
    #[prost(message, optional, tag = "12")]
    pub security_rules: ::core::option::Option<input::SecurityRule>,
    /// Output only. The information for the input stream. This field will be
    /// present only when this input receives the input stream.
    #[prost(message, optional, tag = "15")]
    pub input_stream_property: ::core::option::Option<InputStreamProperty>,
}
/// Nested message and enum types in `Input`.
pub mod input {
    /// Security rules for access control. Each field represents one security rule.
    /// Only when the source of the input stream satisfies all the fields, this
    /// input stream can be accepted.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct SecurityRule {
        /// At least one ip range must match unless none specified. The IP range is
        /// defined by CIDR block: for example, `192.0.1.0/24` for a range and
        /// `192.0.1.0/32` for a single IP address.
        #[prost(string, repeated, tag = "1")]
        pub ip_ranges: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    }
    /// The type of the input.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Type {
        /// Input type is not specified.
        Unspecified = 0,
        /// Input will take an rtmp input stream.
        RtmpPush = 1,
        /// Input will take an srt (Secure Reliable Transport) input stream.
        SrtPush = 2,
    }
    impl Type {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "TYPE_UNSPECIFIED",
                Self::RtmpPush => "RTMP_PUSH",
                Self::SrtPush => "SRT_PUSH",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "RTMP_PUSH" => Some(Self::RtmpPush),
                "SRT_PUSH" => Some(Self::SrtPush),
                _ => None,
            }
        }
    }
    /// Tier of the input specification.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Tier {
        /// Tier is not specified.
        Unspecified = 0,
        /// Resolution \< 1280x720. Bitrate \<= 6 Mbps. FPS \<= 60.
        Sd = 1,
        /// Resolution \<= 1920x1080. Bitrate \<= 25 Mbps. FPS \<= 60.
        Hd = 2,
        /// Resolution \<= 4096x2160. Bitrate \<= 50 Mbps. FPS \<= 60.
        Uhd = 3,
        /// Resolution \<= 1280x720. Bitrate \<= 6 Mbps. FPS \<= 60. H265 codec.
        SdH265 = 4,
        /// Resolution \<= 1920x1080. Bitrate \<= 25 Mbps. FPS \<= 60. H265 codec.
        HdH265 = 5,
        /// Resolution \<= 4096x2160. Bitrate \<= 50 Mbps. FPS \<= 60. H265 codec.
        UhdH265 = 6,
    }
    impl Tier {
        /// 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 => "TIER_UNSPECIFIED",
                Self::Sd => "SD",
                Self::Hd => "HD",
                Self::Uhd => "UHD",
                Self::SdH265 => "SD_H265",
                Self::HdH265 => "HD_H265",
                Self::UhdH265 => "UHD_H265",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TIER_UNSPECIFIED" => Some(Self::Unspecified),
                "SD" => Some(Self::Sd),
                "HD" => Some(Self::Hd),
                "UHD" => Some(Self::Uhd),
                "SD_H265" => Some(Self::SdH265),
                "HD_H265" => Some(Self::HdH265),
                "UHD_H265" => Some(Self::UhdH265),
                _ => None,
            }
        }
    }
}
/// Channel resource represents the processor that does a user-defined
/// "streaming" operation, which includes getting an input stream through an
/// input, transcoding it to multiple renditions, and publishing output live
/// streams in certain formats (for example, HLS or DASH) to the specified
/// location.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Channel {
    /// The resource name of the channel, in the form of:
    /// `projects/{project}/locations/{location}/channels/{channelId}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. The creation time.
    #[prost(message, optional, tag = "2")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The update time.
    #[prost(message, optional, tag = "3")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// User-defined key/value metadata.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// A list of input attachments that this channel uses.
    /// One channel can have multiple inputs as the input sources. Only one
    /// input can be selected as the input source at one time.
    #[prost(message, repeated, tag = "16")]
    pub input_attachments: ::prost::alloc::vec::Vec<InputAttachment>,
    /// Output only. The
    /// \[InputAttachment.key\]\[google.cloud.video.livestream.v1.InputAttachment.key\]
    /// that serves as the current input source. The first input in the
    /// \[input_attachments\]\[google.cloud.video.livestream.v1.Channel.input_attachments\]
    /// is the initial input source.
    #[prost(string, tag = "6")]
    pub active_input: ::prost::alloc::string::String,
    /// Required. Information about the output (that is, the Cloud Storage bucket
    /// to store the generated live stream).
    #[prost(message, optional, tag = "9")]
    pub output: ::core::option::Option<channel::Output>,
    /// List of elementary streams.
    #[prost(message, repeated, tag = "10")]
    pub elementary_streams: ::prost::alloc::vec::Vec<ElementaryStream>,
    /// List of multiplexing settings for output streams.
    #[prost(message, repeated, tag = "11")]
    pub mux_streams: ::prost::alloc::vec::Vec<MuxStream>,
    /// List of output manifests.
    #[prost(message, repeated, tag = "12")]
    pub manifests: ::prost::alloc::vec::Vec<Manifest>,
    /// Optional. List of multiplexing settings of streams for distributions.
    #[prost(message, repeated, tag = "28")]
    pub distribution_streams: ::prost::alloc::vec::Vec<DistributionStream>,
    /// Optional. List of distributions.
    #[prost(message, repeated, tag = "29")]
    pub distributions: ::prost::alloc::vec::Vec<Distribution>,
    /// List of output sprite sheets.
    #[prost(message, repeated, tag = "13")]
    pub sprite_sheets: ::prost::alloc::vec::Vec<SpriteSheet>,
    /// Output only. State of the streaming operation.
    #[prost(enumeration = "channel::StreamingState", tag = "14")]
    pub streaming_state: i32,
    /// Output only. A description of the reason for the streaming error. This
    /// property is always present when
    /// \[streaming_state\]\[google.cloud.video.livestream.v1.Channel.streaming_state\]
    /// is
    /// \[STREAMING_ERROR\]\[google.cloud.video.livestream.v1.Channel.StreamingState.STREAMING_ERROR\].
    #[prost(message, optional, tag = "18")]
    pub streaming_error: ::core::option::Option<super::super::super::super::rpc::Status>,
    /// Configuration of platform logs for this channel.
    #[prost(message, optional, tag = "19")]
    pub log_config: ::core::option::Option<LogConfig>,
    /// Configuration of timecode for this channel.
    #[prost(message, optional, tag = "21")]
    pub timecode_config: ::core::option::Option<TimecodeConfig>,
    /// Optional. Encryption configurations for this channel. Each configuration
    /// has an ID which is referred to by each MuxStream to indicate which
    /// configuration is used for that output.
    #[prost(message, repeated, tag = "24")]
    pub encryptions: ::prost::alloc::vec::Vec<Encryption>,
    /// The configuration for input sources defined in
    /// \[input_attachments\]\[google.cloud.video.livestream.v1.Channel.input_attachments\].
    #[prost(message, optional, tag = "25")]
    pub input_config: ::core::option::Option<InputConfig>,
    /// Optional. Configuration for retention of output files for this channel.
    #[prost(message, optional, tag = "26")]
    pub retention_config: ::core::option::Option<RetentionConfig>,
    /// Optional. List of static overlay images. Those images display over the
    /// output content for the whole duration of the live stream.
    #[prost(message, repeated, tag = "27")]
    pub static_overlays: ::prost::alloc::vec::Vec<StaticOverlay>,
    /// Optional. Advanced configurations for auto-generated text streams.
    #[prost(message, optional, tag = "30")]
    pub auto_transcription_config: ::core::option::Option<AutoTranscriptionConfig>,
}
/// Nested message and enum types in `Channel`.
pub mod channel {
    /// Location of output file(s) in a Google Cloud Storage bucket.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Output {
        /// URI for the output file(s). For example, `gs://my-bucket/outputs/`.
        #[prost(string, tag = "1")]
        pub uri: ::prost::alloc::string::String,
    }
    /// State of streaming operation that the channel is running.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum StreamingState {
        /// Streaming state is not specified.
        Unspecified = 0,
        /// Channel is getting the input stream, generating the live streams to the
        /// specified output location.
        Streaming = 1,
        /// Channel is waiting for the input stream through the input.
        AwaitingInput = 2,
        /// Channel is running, but has trouble publishing the live streams onto the
        /// specified output location (for example, the specified Cloud Storage
        /// bucket is not writable).
        StreamingError = 4,
        /// Channel is generating live streams with no input stream. Live streams are
        /// filled out with black screen, while input stream is missing.
        /// Not supported yet.
        StreamingNoInput = 5,
        /// Channel is stopped, finishing live streams.
        Stopped = 6,
        /// Channel is starting.
        Starting = 7,
        /// Channel is stopping.
        Stopping = 8,
    }
    impl StreamingState {
        /// 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 => "STREAMING_STATE_UNSPECIFIED",
                Self::Streaming => "STREAMING",
                Self::AwaitingInput => "AWAITING_INPUT",
                Self::StreamingError => "STREAMING_ERROR",
                Self::StreamingNoInput => "STREAMING_NO_INPUT",
                Self::Stopped => "STOPPED",
                Self::Starting => "STARTING",
                Self::Stopping => "STOPPING",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STREAMING_STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "STREAMING" => Some(Self::Streaming),
                "AWAITING_INPUT" => Some(Self::AwaitingInput),
                "STREAMING_ERROR" => Some(Self::StreamingError),
                "STREAMING_NO_INPUT" => Some(Self::StreamingNoInput),
                "STOPPED" => Some(Self::Stopped),
                "STARTING" => Some(Self::Starting),
                "STOPPING" => Some(Self::Stopping),
                _ => None,
            }
        }
    }
}
/// 2D normalized coordinates.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct NormalizedCoordinate {
    /// Optional. Normalized x coordinate. Valid range is \[0.0, 1.0\]. Default is 0.
    #[prost(double, tag = "1")]
    pub x: f64,
    /// Optional. Normalized y coordinate. Valid range is \[0.0, 1.0\]. Default is 0.
    #[prost(double, tag = "2")]
    pub y: f64,
}
/// Normalized resolution.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct NormalizedResolution {
    /// Optional. Normalized width. Valid range is \[0.0, 1.0\]. Default is 0.
    #[prost(double, tag = "1")]
    pub w: f64,
    /// Optional. Normalized height. Valid range is \[0.0, 1.0\]. Default is 0.
    #[prost(double, tag = "2")]
    pub h: f64,
}
/// Configuration for the static overlay.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StaticOverlay {
    /// Required. Asset to use for the overlaid image.
    /// The asset must be represented in the form of:
    /// `projects/{project}/locations/{location}/assets/{assetId}`.
    /// The asset's resource type must be image.
    #[prost(string, tag = "1")]
    pub asset: ::prost::alloc::string::String,
    /// Optional. Normalized image resolution, based on output video resolution.
    /// Valid values are \[0.0, 1.0\]. To respect the original image aspect ratio,
    /// set either `w` or `h` to 0. To use the original image resolution, set both
    /// `w` and `h` to 0. The default is {0, 0}.
    #[prost(message, optional, tag = "2")]
    pub resolution: ::core::option::Option<NormalizedResolution>,
    /// Optional. Position of the image in terms of normalized coordinates of the
    /// upper-left corner of the image, based on output video resolution. For
    /// example, use the x and y coordinates {0, 0} to position the top-left corner
    /// of the overlay animation in the top-left corner of the output video.
    #[prost(message, optional, tag = "3")]
    pub position: ::core::option::Option<NormalizedCoordinate>,
    /// Optional. Target image opacity. Valid values are from `1.0` (solid,
    /// default) to `0.0` (transparent), exclusive. Set this to a value greater
    /// than `0.0`.
    #[prost(double, tag = "4")]
    pub opacity: f64,
}
/// Configuration for the input sources of a channel.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct InputConfig {
    /// Input switch mode. Default mode is `FAILOVER_PREFER_PRIMARY`.
    #[prost(enumeration = "input_config::InputSwitchMode", tag = "1")]
    pub input_switch_mode: i32,
}
/// Nested message and enum types in `InputConfig`.
pub mod input_config {
    /// Input switch mode.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum InputSwitchMode {
        /// The input switch mode is not specified.
        Unspecified = 0,
        /// Automatic failover is enabled. The primary input stream is always
        /// preferred over its backup input streams configured using the
        /// \[AutomaticFailover\]\[google.cloud.video.livestream.v1.InputAttachment.AutomaticFailover\]
        /// field.
        FailoverPreferPrimary = 1,
        /// Automatic failover is disabled. You must use the
        /// \[inputSwitch\]\[google.cloud.video.livestream.v1.Event.input_switch\] event
        /// to switch the active input source for the channel to stream from. When
        /// this mode is chosen, the
        /// \[AutomaticFailover\]\[google.cloud.video.livestream.v1.InputAttachment.AutomaticFailover\]
        /// field is ignored.
        Manual = 3,
    }
    impl InputSwitchMode {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "INPUT_SWITCH_MODE_UNSPECIFIED",
                Self::FailoverPreferPrimary => "FAILOVER_PREFER_PRIMARY",
                Self::Manual => "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 {
                "INPUT_SWITCH_MODE_UNSPECIFIED" => Some(Self::Unspecified),
                "FAILOVER_PREFER_PRIMARY" => Some(Self::FailoverPreferPrimary),
                "MANUAL" => Some(Self::Manual),
                _ => None,
            }
        }
    }
}
/// Configuration of platform logs.
/// See [Using and managing platform
/// logs](<https://cloud.google.com/logging/docs/api/platform-logs#managing-logs>)
/// for more information about how to view platform logs through Cloud Logging.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct LogConfig {
    /// The severity level of platform logging for this resource.
    #[prost(enumeration = "log_config::LogSeverity", tag = "1")]
    pub log_severity: i32,
}
/// Nested message and enum types in `LogConfig`.
pub mod log_config {
    /// The severity level of platform logging for this channel. Logs with a
    /// severity level higher than or equal to the chosen severity level will be
    /// logged and can be viewed through Cloud Logging.
    /// The severity level of a log is ranked as followed from low to high: DEBUG \<
    /// INFO \< NOTICE \< WARNING \< ERROR \< CRITICAL \< ALERT \< EMERGENCY.
    /// See
    /// [LogSeverity](<https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry#logseverity>)
    /// for more information.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum LogSeverity {
        /// Log severity is not specified. This is the same as log severity is OFF.
        Unspecified = 0,
        /// Log is turned off.
        Off = 1,
        /// Log with severity higher than or equal to DEBUG are logged.
        Debug = 100,
        /// Logs with severity higher than or equal to INFO are logged.
        Info = 200,
        /// Logs with severity higher than or equal to WARNING are logged.
        Warning = 400,
        /// Logs with severity higher than or equal to ERROR are logged.
        Error = 500,
    }
    impl LogSeverity {
        /// 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 => "LOG_SEVERITY_UNSPECIFIED",
                Self::Off => "OFF",
                Self::Debug => "DEBUG",
                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 {
                "LOG_SEVERITY_UNSPECIFIED" => Some(Self::Unspecified),
                "OFF" => Some(Self::Off),
                "DEBUG" => Some(Self::Debug),
                "INFO" => Some(Self::Info),
                "WARNING" => Some(Self::Warning),
                "ERROR" => Some(Self::Error),
                _ => None,
            }
        }
    }
}
/// Configuration for retention of output files.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RetentionConfig {
    /// The minimum duration for which the output files from the channel will
    /// remain in the output bucket. After this duration, output files are
    /// deleted asynchronously.
    ///
    /// When the channel is deleted, all output files are deleted from the output
    /// bucket asynchronously.
    ///
    /// If omitted or set to zero, output files will remain in the output bucket
    /// based on
    /// \[Manifest.segment_keep_duration\]\[google.cloud.video.livestream.v1.Manifest.segment_keep_duration\],
    /// which defaults to 60s.
    ///
    /// If both retention_window_duration and
    /// \[Manifest.segment_keep_duration\]\[google.cloud.video.livestream.v1.Manifest.segment_keep_duration\]
    /// are set, retention_window_duration is used and
    /// \[Manifest.segment_keep_duration\]\[google.cloud.video.livestream.v1.Manifest.segment_keep_duration\]
    /// is ignored.
    #[prost(message, optional, tag = "1")]
    pub retention_window_duration: ::core::option::Option<::prost_types::Duration>,
}
/// Properties of the input stream.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InputStreamProperty {
    /// The time that the current input stream is accepted and the connection is
    /// established.
    #[prost(message, optional, tag = "1")]
    pub last_establish_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Properties of the video streams.
    #[prost(message, repeated, tag = "2")]
    pub video_streams: ::prost::alloc::vec::Vec<VideoStreamProperty>,
    /// Properties of the audio streams.
    #[prost(message, repeated, tag = "3")]
    pub audio_streams: ::prost::alloc::vec::Vec<AudioStreamProperty>,
}
/// Properties of the video stream.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VideoStreamProperty {
    /// Index of this video stream.
    #[prost(int32, tag = "1")]
    pub index: i32,
    /// Properties of the video format.
    #[prost(message, optional, tag = "2")]
    pub video_format: ::core::option::Option<VideoFormat>,
}
/// Properties of the video format.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VideoFormat {
    /// Video codec used in this video stream.
    #[prost(string, tag = "1")]
    pub codec: ::prost::alloc::string::String,
    /// The width of the video stream in pixels.
    #[prost(int32, tag = "2")]
    pub width_pixels: i32,
    /// The height of the video stream in pixels.
    #[prost(int32, tag = "3")]
    pub height_pixels: i32,
    /// The frame rate of the input video stream.
    #[prost(double, tag = "4")]
    pub frame_rate: f64,
}
/// Properties of the audio stream.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AudioStreamProperty {
    /// Index of this audio stream.
    #[prost(int32, tag = "1")]
    pub index: i32,
    /// Properties of the audio format.
    #[prost(message, optional, tag = "2")]
    pub audio_format: ::core::option::Option<AudioFormat>,
}
/// Properties of the audio format.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AudioFormat {
    /// Audio codec used in this audio stream.
    #[prost(string, tag = "1")]
    pub codec: ::prost::alloc::string::String,
    /// The number of audio channels.
    #[prost(int32, tag = "2")]
    pub channel_count: i32,
    /// A list of channel names specifying the layout of the audio channels.
    #[prost(string, repeated, tag = "3")]
    pub channel_layout: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// A group of information for attaching an input resource to this channel.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct InputAttachment {
    /// A unique key for this input attachment. The key must be 1-63
    /// characters in length. The key must begin and end with a letter (regardless
    /// of case) or a number, but can contain dashes or underscores in between.
    #[prost(string, tag = "1")]
    pub key: ::prost::alloc::string::String,
    /// The resource name of an existing input, in the form of:
    /// `projects/{project}/locations/{location}/inputs/{inputId}`.
    #[prost(string, tag = "2")]
    pub input: ::prost::alloc::string::String,
    /// Automatic failover configurations.
    #[prost(message, optional, tag = "3")]
    pub automatic_failover: ::core::option::Option<input_attachment::AutomaticFailover>,
}
/// Nested message and enum types in `InputAttachment`.
pub mod input_attachment {
    /// Configurations to follow when automatic failover happens.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct AutomaticFailover {
        /// The
        /// \[InputAttachment.key\]\[google.cloud.video.livestream.v1.InputAttachment.key\]s
        /// of inputs to failover to when this input is disconnected. Currently, only
        /// up to one backup input is supported.
        #[prost(string, repeated, tag = "1")]
        pub input_keys: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    }
}
/// Advanced configurations for auto-generated text streams.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AutoTranscriptionConfig {
    /// Optional. Whether auto-generated text streams are displayed synchronously
    /// or asynchronously with the original audio.
    #[prost(enumeration = "auto_transcription_config::DisplayTiming", tag = "1")]
    pub display_timing: i32,
    /// Optional. Tunes the latency and quality of auto-generated captions.
    #[prost(enumeration = "auto_transcription_config::QualityPreset", tag = "2")]
    pub quality_preset: i32,
}
/// Nested message and enum types in `AutoTranscriptionConfig`.
pub mod auto_transcription_config {
    /// Whether auto-generated text streams are displayed synchronously or
    /// asynchronously with the original audio.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum DisplayTiming {
        /// Display timing is not specified. Caption display will be asynchronous by
        /// default.
        Unspecified = 0,
        /// Caption will be displayed asynchronous with audio.
        Async = 1,
        /// Caption will be displayed synchronous with audio. This option increases
        /// overall media output latency, and reduces viewing latency between audio
        /// and auto-generated captions.
        Sync = 2,
    }
    impl DisplayTiming {
        /// 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 => "DISPLAY_TIMING_UNSPECIFIED",
                Self::Async => "ASYNC",
                Self::Sync => "SYNC",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "DISPLAY_TIMING_UNSPECIFIED" => Some(Self::Unspecified),
                "ASYNC" => Some(Self::Async),
                "SYNC" => Some(Self::Sync),
                _ => None,
            }
        }
    }
    /// Presets to tune the latency and quality of auto-generated captions.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum QualityPreset {
        /// Quality Preset is not specified. By default, BALANCED_QUALITY will be
        /// used.
        Unspecified = 0,
        /// Reduce the latency of auto-generated captions. This may reduce the
        /// quality of the captions.
        LowLatency = 1,
        /// Default behavior when QualityPreset is not specified.
        BalancedQuality = 2,
        /// Increases the quality of the auto-generated captions at the cost of
        /// higher latency.
        ImprovedQuality = 3,
    }
    impl QualityPreset {
        /// 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 => "QUALITY_PRESET_UNSPECIFIED",
                Self::LowLatency => "LOW_LATENCY",
                Self::BalancedQuality => "BALANCED_QUALITY",
                Self::ImprovedQuality => "IMPROVED_QUALITY",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "QUALITY_PRESET_UNSPECIFIED" => Some(Self::Unspecified),
                "LOW_LATENCY" => Some(Self::LowLatency),
                "BALANCED_QUALITY" => Some(Self::BalancedQuality),
                "IMPROVED_QUALITY" => Some(Self::ImprovedQuality),
                _ => None,
            }
        }
    }
}
/// Event is a sub-resource of a channel, which can be scheduled by the user to
/// execute operations on a channel resource without having to stop the channel.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Event {
    /// The resource name of the event, in the form of:
    /// `projects/{project}/locations/{location}/channels/{channelId}/events/{eventId}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. The creation time.
    #[prost(message, optional, tag = "2")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The update time.
    #[prost(message, optional, tag = "3")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// User-defined key/value metadata.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// When this field is set to true, the event will be executed at the earliest
    /// time that the server can schedule the event and
    /// \[execution_time\]\[google.cloud.video.livestream.v1.Event.execution_time\]
    /// will be populated with the time that the server actually schedules the
    /// event.
    #[prost(bool, tag = "9")]
    pub execute_now: bool,
    /// The time to execute the event. If you set
    /// \[execute_now\]\[google.cloud.video.livestream.v1.Event.execute_now\] to
    /// `true`, then do not set this field in the `CreateEvent` request. In
    /// this case, the server schedules the event and populates this field. If you
    /// set \[execute_now\]\[google.cloud.video.livestream.v1.Event.execute_now\] to
    /// `false`, then you must set this field to at least 10 seconds in the future
    /// or else the event can't be created.
    #[prost(message, optional, tag = "10")]
    pub execution_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The state of the event.
    #[prost(enumeration = "event::State", tag = "11")]
    pub state: i32,
    /// Output only. An error object that describes the reason for the failure.
    /// This property is always present when `state` is `FAILED`.
    #[prost(message, optional, tag = "12")]
    pub error: ::core::option::Option<super::super::super::super::rpc::Status>,
    /// Required. Operation to be executed by this event.
    #[prost(oneof = "event::Task", tags = "5, 6, 13, 14, 15, 16, 17")]
    pub task: ::core::option::Option<event::Task>,
}
/// Nested message and enum types in `Event`.
pub mod event {
    /// Switches to another input stream. Automatic failover is then disabled.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct InputSwitchTask {
        /// The
        /// \[InputAttachment.key\]\[google.cloud.video.livestream.v1.InputAttachment.key\]
        /// of the input to switch to.
        #[prost(string, tag = "1")]
        pub input_key: ::prost::alloc::string::String,
    }
    /// Inserts a new ad opportunity.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct AdBreakTask {
        /// Duration of an ad opportunity. Must be greater than 0.
        #[prost(message, optional, tag = "1")]
        pub duration: ::core::option::Option<::prost_types::Duration>,
    }
    /// Inserts a slate.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct SlateTask {
        /// Optional. Duration of the slate. Must be greater than 0 if specified.
        /// Omit this field for a long running slate.
        #[prost(message, optional, tag = "1")]
        pub duration: ::core::option::Option<::prost_types::Duration>,
        /// Slate asset to use for the duration. If its duration is less than the
        /// duration of the SlateTask, then the slate loops. The slate must be
        /// represented in the form of:
        /// `projects/{project}/locations/{location}/assets/{assetId}`.
        #[prost(string, tag = "2")]
        pub asset: ::prost::alloc::string::String,
    }
    /// Stops any events which are currently running. This only applies to events
    /// with a duration.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ReturnToProgramTask {}
    /// Mutes the stream.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct MuteTask {
        /// Duration for which the stream should be muted. If omitted, the stream
        /// will be muted until an UnmuteTask event is sent.
        #[prost(message, optional, tag = "1")]
        pub duration: ::core::option::Option<::prost_types::Duration>,
    }
    /// Unmutes the stream. The task fails if the stream is not currently muted.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct UnmuteTask {}
    /// Update encryption settings.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct UpdateEncryptionsTask {
        /// Required. A list of
        /// \[EncryptionUpdate\]\[google.cloud.video.livestream.v1.EncryptionUpdate\]s
        /// that updates the existing encryption settings.
        #[prost(message, repeated, tag = "1")]
        pub encryptions: ::prost::alloc::vec::Vec<super::EncryptionUpdate>,
    }
    /// State of the event
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// Event state is not specified.
        Unspecified = 0,
        /// Event is scheduled but not executed yet.
        Scheduled = 1,
        /// Event is being executed.
        Running = 2,
        /// Event has been successfully executed.
        Succeeded = 3,
        /// Event fails to be executed.
        Failed = 4,
        /// Event has been created but not scheduled yet.
        Pending = 5,
        /// Event was stopped before running for its full duration.
        Stopped = 6,
    }
    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::Scheduled => "SCHEDULED",
                Self::Running => "RUNNING",
                Self::Succeeded => "SUCCEEDED",
                Self::Failed => "FAILED",
                Self::Pending => "PENDING",
                Self::Stopped => "STOPPED",
            }
        }
        /// 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),
                "SCHEDULED" => Some(Self::Scheduled),
                "RUNNING" => Some(Self::Running),
                "SUCCEEDED" => Some(Self::Succeeded),
                "FAILED" => Some(Self::Failed),
                "PENDING" => Some(Self::Pending),
                "STOPPED" => Some(Self::Stopped),
                _ => None,
            }
        }
    }
    /// Required. Operation to be executed by this event.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Task {
        /// Switches to another input stream.
        #[prost(message, tag = "5")]
        InputSwitch(InputSwitchTask),
        /// Inserts a new ad opportunity.
        #[prost(message, tag = "6")]
        AdBreak(AdBreakTask),
        /// Stops any running ad break.
        #[prost(message, tag = "13")]
        ReturnToProgram(ReturnToProgramTask),
        /// Inserts a slate.
        #[prost(message, tag = "14")]
        Slate(SlateTask),
        /// Mutes the stream.
        #[prost(message, tag = "15")]
        Mute(MuteTask),
        /// Unmutes the stream.
        #[prost(message, tag = "16")]
        Unmute(UnmuteTask),
        /// Updates encryption settings.
        #[prost(message, tag = "17")]
        UpdateEncryptions(UpdateEncryptionsTask),
    }
}
/// Clip is a sub-resource under channel. Each clip represents a clipping
/// operation that generates a VOD playlist from its channel given a set of
/// timestamp ranges.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Clip {
    /// The resource name of the clip, in the following format:
    /// `projects/{project}/locations/{location}/channels/{channelId}/clips/{clipId}`.
    /// `{clipId}` is a user-specified resource id that conforms to the following
    /// criteria:
    ///
    /// 1. 1 character minimum, 63 characters maximum
    /// 1. Only contains letters, digits, underscores, and hyphens
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. The creation timestamp of the clip resource.
    #[prost(message, optional, tag = "2")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The timestamp when the clip request starts to be processed.
    #[prost(message, optional, tag = "3")]
    pub start_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The update timestamp of the clip resource.
    #[prost(message, optional, tag = "4")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The labels associated with this resource. Each label is a key-value pair.
    #[prost(map = "string, string", tag = "5")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Output only. The state of the clip.
    #[prost(enumeration = "clip::State", tag = "6")]
    pub state: i32,
    /// Specify the `output_uri` to determine where to place the clip segments and
    /// clip manifest files in Cloud Storage. The manifests specified in
    /// `clip_manifests` fields will be placed under this URI. The exact URI of the
    /// generated manifests will be provided in `clip_manifests.output_uri` for
    /// each manifest.
    /// Example:
    /// "output_uri": "gs://my-bucket/clip-outputs"
    /// "clip_manifests.output_uri": "gs://my-bucket/clip-outputs/main.m3u8"
    #[prost(string, tag = "7")]
    pub output_uri: ::prost::alloc::string::String,
    /// Output only. An error object that describes the reason for the failure.
    /// This property only presents when `state` is `FAILED`.
    #[prost(message, optional, tag = "9")]
    pub error: ::core::option::Option<super::super::super::super::rpc::Status>,
    /// The specified ranges of segments to generate a clip.
    #[prost(message, repeated, tag = "10")]
    pub slices: ::prost::alloc::vec::Vec<clip::Slice>,
    /// Required. A list of clip manifests. Currently only one clip manifest is
    /// allowed.
    #[prost(message, repeated, tag = "12")]
    pub clip_manifests: ::prost::alloc::vec::Vec<clip::ClipManifest>,
    /// Optional. OutputType of the clip. If not specified, the default value is
    /// MANIFEST.
    #[prost(enumeration = "clip::OutputType", tag = "13")]
    pub output_type: i32,
}
/// Nested message and enum types in `Clip`.
pub mod clip {
    /// TimeSlice represents a tuple of Unix epoch timestamps that specifies a time
    /// range.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct TimeSlice {
        /// The mark-in Unix epoch time in the original live stream manifest.
        #[prost(message, optional, tag = "1")]
        pub markin_time: ::core::option::Option<::prost_types::Timestamp>,
        /// The mark-out Unix epoch time in the original live stream manifest.
        #[prost(message, optional, tag = "2")]
        pub markout_time: ::core::option::Option<::prost_types::Timestamp>,
    }
    /// Slice represents a slice of the requested clip.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Slice {
        /// The allowlist forms of a slice.
        #[prost(oneof = "slice::Kind", tags = "1")]
        pub kind: ::core::option::Option<slice::Kind>,
    }
    /// Nested message and enum types in `Slice`.
    pub mod slice {
        /// The allowlist forms of a slice.
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)]
        pub enum Kind {
            /// A slice in form of a tuple of Unix epoch time.
            #[prost(message, tag = "1")]
            TimeSlice(super::TimeSlice),
        }
    }
    /// ClipManifest identifies a source manifest for the generated clip manifest.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ClipManifest {
        /// Required. A unique key that identifies a manifest config in the parent
        /// channel. This key is the same as `channel.manifests.key` for the selected
        /// manifest.
        #[prost(string, tag = "1")]
        pub manifest_key: ::prost::alloc::string::String,
        /// Output only. The output URI of the generated clip manifest. This field
        /// will be populated when the CreateClip request is accepted. Current output
        /// format is provided below but may change in the future. Please read this
        /// field to get the uri to the generated clip manifest. Format:
        /// {clip.output_uri}/{channel.manifest.fileName} Example:
        /// gs://my-bucket/clip-outputs/main.m3u8
        #[prost(string, tag = "2")]
        pub output_uri: ::prost::alloc::string::String,
    }
    /// State of clipping operation.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// State is not specified.
        Unspecified = 0,
        /// The operation is pending to be picked up by the server.
        Pending = 1,
        /// The server admitted this create clip request, and
        /// outputs are under processing.
        Creating = 2,
        /// Outputs are available in the specified Cloud Storage bucket. For
        /// additional information, see the `outputs` field.
        Succeeded = 3,
        /// The operation has failed. For additional information, see the `error`
        /// field.
        Failed = 4,
    }
    impl State {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "STATE_UNSPECIFIED",
                Self::Pending => "PENDING",
                Self::Creating => "CREATING",
                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),
                "PENDING" => Some(Self::Pending),
                "CREATING" => Some(Self::Creating),
                "SUCCEEDED" => Some(Self::Succeeded),
                "FAILED" => Some(Self::Failed),
                _ => None,
            }
        }
    }
    /// OutputType represents the output type of the clip.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum OutputType {
        /// OutputType is not specified.
        Unspecified = 0,
        /// OutputType is a VOD manifest. This is the default value.
        Manifest = 1,
        /// OutputType is an MP4 file.
        Mp4 = 2,
    }
    impl OutputType {
        /// 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_TYPE_UNSPECIFIED",
                Self::Manifest => "MANIFEST",
                Self::Mp4 => "MP4",
            }
        }
        /// 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_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "MANIFEST" => Some(Self::Manifest),
                "MP4" => Some(Self::Mp4),
                _ => None,
            }
        }
    }
}
/// TimeInterval represents a time interval.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TimeInterval {
    /// Optional. The start time of the interval.
    #[prost(message, optional, tag = "1")]
    pub start_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Optional. The end time of the interval.
    #[prost(message, optional, tag = "2")]
    pub end_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// DvrSession is a sub-resource under channel. Each DvrSession represents a DVR
/// recording of the live stream for a specific time range.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DvrSession {
    /// Identifier. The resource name of the DVR session, in the following format:
    /// `projects/{project}/locations/{location}/channels/{channelId}/dvrSessions/{dvrSessionId}`.
    /// `{dvrSessionId}` is a user-specified resource id that conforms to the
    /// following criteria:
    ///
    /// 1. 1 character minimum, 63 characters maximum
    /// 1. Only contains letters, digits, underscores, and hyphens
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. The creation time.
    #[prost(message, optional, tag = "2")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The update time.
    #[prost(message, optional, tag = "3")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Optional. User-defined key/value metadata.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Output only. The state of the clip.
    #[prost(enumeration = "dvr_session::State", tag = "5")]
    pub state: i32,
    /// Output only. An error object that describes the reason for the failure.
    /// This property only presents when `state` is `FAILED`.
    #[prost(message, optional, tag = "6")]
    pub error: ::core::option::Option<super::super::super::super::rpc::Status>,
    /// Required. A list of DVR manifests. Currently only one DVR manifest is
    /// allowed.
    #[prost(message, repeated, tag = "7")]
    pub dvr_manifests: ::prost::alloc::vec::Vec<dvr_session::DvrManifest>,
    /// Required. The specified ranges of segments to generate a DVR recording.
    #[prost(message, repeated, tag = "8")]
    pub dvr_windows: ::prost::alloc::vec::Vec<dvr_session::DvrWindow>,
}
/// Nested message and enum types in `DvrSession`.
pub mod dvr_session {
    /// DvrManifest identifies a source manifest and specifies a file name for the
    /// generated DVR manifest.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct DvrManifest {
        /// Required. A unique key that identifies a manifest config in the parent
        /// channel. This key is the same as `channel.manifests.key` for the selected
        /// manifest.
        #[prost(string, tag = "1")]
        pub manifest_key: ::prost::alloc::string::String,
        /// Output only. The output URI of the DVR manifest. The DVR output will be
        /// placed in a directory named `dvr/dvrSessionId/` under the parent
        /// channel's output uri. Format:
        /// {channel.output.uri}/dvr/{dvrSessionId}/{channel.manifests.fileName}
        /// Example: gs://my-bucket/outputs/dvr/my-dvr-session/main.m3u8
        #[prost(string, tag = "2")]
        pub output_uri: ::prost::alloc::string::String,
    }
    /// DvrWindow represents a DVR window.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct DvrWindow {
        /// The allowlist forms of a DVR window.
        #[prost(oneof = "dvr_window::Kind", tags = "1")]
        pub kind: ::core::option::Option<dvr_window::Kind>,
    }
    /// Nested message and enum types in `DvrWindow`.
    pub mod dvr_window {
        /// The allowlist forms of a DVR window.
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)]
        pub enum Kind {
            /// A time interval in the form of a tuple of Unix epoch time.
            #[prost(message, tag = "1")]
            TimeInterval(super::super::TimeInterval),
        }
    }
    /// State of the DVR session.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// State is not specified.
        Unspecified = 0,
        /// The operation is pending to be picked up by the server.
        Pending = 1,
        /// The session is being updated.
        Updating = 2,
        /// The session is scheduled and waiting for the start time.
        Scheduled = 3,
        /// The session is currently in progress and the outputs are available in the
        /// specified Cloud Storage bucket. For additional information, see the
        /// `dvr_manifests.output_uri` field.
        Live = 4,
        /// Outputs are available in the specified Cloud Storage bucket. For
        /// additional information, see the `dvr_manifests.output_uri` field.
        Finished = 5,
        /// The operation has failed. For additional information, see the `error`
        /// field.
        Failed = 6,
        /// The session is being deleted.
        Deleting = 7,
        /// The session is being post processed.
        PostProcessing = 8,
        /// The session is in cooldown. The cooldown period lasts for 60 seconds.
        /// When the DVR session is updated by the user to have a new end time that
        /// is likely already in the past, the DVR manifest will end as soon as
        /// possible and the DVR session will move to this state. This is done to
        /// prevent the players to receive a manifest update that removes a segment
        /// that has already been played. After the cooldown period ends, a new
        /// manifest is generated that honors the new end time.
        Cooldown = 9,
        /// The session is being stopped. The session will move to STOPPING state, if
        /// the parent channel is updated.
        Stopping = 10,
    }
    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::Pending => "PENDING",
                Self::Updating => "UPDATING",
                Self::Scheduled => "SCHEDULED",
                Self::Live => "LIVE",
                Self::Finished => "FINISHED",
                Self::Failed => "FAILED",
                Self::Deleting => "DELETING",
                Self::PostProcessing => "POST_PROCESSING",
                Self::Cooldown => "COOLDOWN",
                Self::Stopping => "STOPPING",
            }
        }
        /// 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),
                "PENDING" => Some(Self::Pending),
                "UPDATING" => Some(Self::Updating),
                "SCHEDULED" => Some(Self::Scheduled),
                "LIVE" => Some(Self::Live),
                "FINISHED" => Some(Self::Finished),
                "FAILED" => Some(Self::Failed),
                "DELETING" => Some(Self::Deleting),
                "POST_PROCESSING" => Some(Self::PostProcessing),
                "COOLDOWN" => Some(Self::Cooldown),
                "STOPPING" => Some(Self::Stopping),
                _ => None,
            }
        }
    }
}
/// An asset represents a video or an image.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Asset {
    /// The resource name of the asset, in the form of:
    /// `projects/{project}/locations/{location}/assets/{assetId}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. The creation time.
    #[prost(message, optional, tag = "2")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The update time.
    #[prost(message, optional, tag = "3")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// User-defined key/value metadata.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Based64-encoded CRC32c checksum of the asset file. For more information,
    /// see the crc32c checksum of the [Cloud Storage Objects
    /// resource](<https://cloud.google.com/storage/docs/json_api/v1/objects>).
    /// If crc32c is omitted or left empty when the asset is created, this field is
    /// filled by the crc32c checksum of the Cloud Storage object indicated by
    /// \[VideoAsset.uri\]\[google.cloud.video.livestream.v1.Asset.VideoAsset.uri\] or
    /// \[ImageAsset.uri\]\[google.cloud.video.livestream.v1.Asset.ImageAsset.uri\]. If
    /// crc32c is set, the asset can't be created if the crc32c value does not
    /// match with the crc32c checksum of the Cloud Storage object indicated by
    /// \[VideoAsset.uri\]\[google.cloud.video.livestream.v1.Asset.VideoAsset.uri\] or
    /// \[ImageAsset.uri\]\[google.cloud.video.livestream.v1.Asset.ImageAsset.uri\].
    #[prost(string, tag = "7")]
    pub crc32c: ::prost::alloc::string::String,
    /// Output only. The state of the asset resource.
    #[prost(enumeration = "asset::State", tag = "8")]
    pub state: i32,
    /// Output only. Only present when `state` is `ERROR`. The reason for the error
    /// state of the asset.
    #[prost(message, optional, tag = "9")]
    pub error: ::core::option::Option<super::super::super::super::rpc::Status>,
    /// The reference to the asset.
    /// The maximum size of the resource is 250 MB.
    #[prost(oneof = "asset::Resource", tags = "5, 6")]
    pub resource: ::core::option::Option<asset::Resource>,
}
/// Nested message and enum types in `Asset`.
pub mod asset {
    /// VideoAsset represents a video. The supported formats are MP4, MPEG-TS, and
    /// FLV. The supported video codec is H264. The supported audio codecs are
    /// AAC, AC3, MP2, and MP3.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct VideoAsset {
        /// Cloud Storage URI of the video. The format is `gs://my-bucket/my-object`.
        #[prost(string, tag = "1")]
        pub uri: ::prost::alloc::string::String,
    }
    /// Image represents an image. The supported formats are JPEG, PNG.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ImageAsset {
        /// Cloud Storage URI of the image. The format is `gs://my-bucket/my-object`.
        #[prost(string, tag = "1")]
        pub uri: ::prost::alloc::string::String,
    }
    /// State of the asset resource.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// State is not specified.
        Unspecified = 0,
        /// The asset is being created.
        Creating = 1,
        /// The asset is ready for use.
        Active = 2,
        /// The asset is being deleted.
        Deleting = 3,
        /// The asset has an error.
        Error = 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::Creating => "CREATING",
                Self::Active => "ACTIVE",
                Self::Deleting => "DELETING",
                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 {
                "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "CREATING" => Some(Self::Creating),
                "ACTIVE" => Some(Self::Active),
                "DELETING" => Some(Self::Deleting),
                "ERROR" => Some(Self::Error),
                _ => None,
            }
        }
    }
    /// The reference to the asset.
    /// The maximum size of the resource is 250 MB.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Resource {
        /// VideoAsset represents a video.
        #[prost(message, tag = "5")]
        Video(VideoAsset),
        /// ImageAsset represents an image.
        #[prost(message, tag = "6")]
        Image(ImageAsset),
    }
}
/// Encryption settings.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Encryption {
    /// Required. Identifier for this set of encryption options. The ID must be
    /// 1-63 characters in length. The ID must begin and end with a letter
    /// (regardless of case) or a number, but can contain dashes or underscores in
    /// between.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Required. Configuration for DRM systems.
    #[prost(message, optional, tag = "3")]
    pub drm_systems: ::core::option::Option<encryption::DrmSystems>,
    /// Defines where content keys are stored.
    #[prost(oneof = "encryption::SecretSource", tags = "7")]
    pub secret_source: ::core::option::Option<encryption::SecretSource>,
    /// Encryption modes for HLS and MPEG-Dash.
    #[prost(oneof = "encryption::EncryptionMode", tags = "4, 5, 6")]
    pub encryption_mode: ::core::option::Option<encryption::EncryptionMode>,
}
/// Nested message and enum types in `Encryption`.
pub mod encryption {
    /// Configuration for secrets stored in Google Secret Manager.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct SecretManagerSource {
        /// Required. The name of the Secret Version containing the encryption key.
        /// `projects/{project}/secrets/{secret_id}/versions/{version_number}`
        #[prost(string, tag = "1")]
        pub secret_version: ::prost::alloc::string::String,
    }
    /// Widevine configuration.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Widevine {}
    /// Fairplay configuration.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Fairplay {}
    /// Playready configuration.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Playready {}
    /// Clearkey configuration.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Clearkey {}
    /// Defines configuration for DRM systems in use. If a field is omitted,
    /// that DRM system will be considered to be disabled.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct DrmSystems {
        /// Optional. Widevine configuration.
        #[prost(message, optional, tag = "1")]
        pub widevine: ::core::option::Option<Widevine>,
        /// Optional. Fairplay configuration.
        #[prost(message, optional, tag = "2")]
        pub fairplay: ::core::option::Option<Fairplay>,
        /// Optional. Playready configuration.
        #[prost(message, optional, tag = "3")]
        pub playready: ::core::option::Option<Playready>,
        /// Optional. Clearkey configuration.
        #[prost(message, optional, tag = "4")]
        pub clearkey: ::core::option::Option<Clearkey>,
    }
    /// Configuration for HLS AES-128 encryption.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Aes128Encryption {}
    /// Configuration for HLS SAMPLE-AES encryption.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct SampleAesEncryption {}
    /// Configuration for MPEG-Dash Common Encryption (MPEG-CENC).
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct MpegCommonEncryption {
        /// Required. Specify the encryption scheme, supported schemes:
        ///
        /// * `cenc` - AES-CTR subsample
        /// * `cbcs`- AES-CBC subsample pattern
        #[prost(string, tag = "1")]
        pub scheme: ::prost::alloc::string::String,
    }
    /// Defines where content keys are stored.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum SecretSource {
        /// For keys stored in Google Secret Manager.
        #[prost(message, tag = "7")]
        SecretManagerKeySource(SecretManagerSource),
    }
    /// Encryption modes for HLS and MPEG-Dash.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum EncryptionMode {
        /// Configuration for HLS AES-128 encryption.
        #[prost(message, tag = "4")]
        Aes128(Aes128Encryption),
        /// Configuration for HLS SAMPLE-AES encryption.
        #[prost(message, tag = "5")]
        SampleAes(SampleAesEncryption),
        /// Configuration for MPEG-Dash Common Encryption (MPEG-CENC).
        #[prost(message, tag = "6")]
        MpegCenc(MpegCommonEncryption),
    }
}
/// Encryption setting when updating encryption.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct EncryptionUpdate {
    /// Required. Identifier for the encryption option to be updated.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Defines where new content keys are stored.
    #[prost(oneof = "encryption_update::SecretSource", tags = "2")]
    pub secret_source: ::core::option::Option<encryption_update::SecretSource>,
}
/// Nested message and enum types in `EncryptionUpdate`.
pub mod encryption_update {
    /// Defines where new content keys are stored.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum SecretSource {
        /// For keys stored in Google Secret Manager.
        #[prost(message, tag = "2")]
        SecretManagerKeySource(super::encryption::SecretManagerSource),
    }
}
/// Pool resource defines the configuration of Live Stream pools for a specific
/// location. Currently we support only one pool resource per project per
/// location. After the creation of the first input, a default pool is created
/// automatically at "projects/{project}/locations/{location}/pools/default".
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Pool {
    /// The resource name of the pool, in the form of:
    /// `projects/{project}/locations/{location}/pools/{poolId}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. The creation time.
    #[prost(message, optional, tag = "2")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The update time.
    #[prost(message, optional, tag = "3")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// User-defined key/value metadata.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Network configuration for the pool.
    #[prost(message, optional, tag = "5")]
    pub network_config: ::core::option::Option<pool::NetworkConfig>,
}
/// Nested message and enum types in `Pool`.
pub mod pool {
    /// Defines the network configuration for the pool.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct NetworkConfig {
        /// peered_network is the network resource URL of the network that is peered
        /// to the service provider network. Must be of the format
        /// projects/NETWORK_PROJECT_NUMBER/global/networks/NETWORK_NAME, where
        /// NETWORK_PROJECT_NUMBER is the project number of the Cloud project that
        /// holds your VPC network and NETWORK_NAME is the name of your VPC network.
        /// If peered_network is omitted or empty, the pool will use endpoints that
        /// are publicly available.
        #[prost(string, tag = "1")]
        pub peered_network: ::prost::alloc::string::String,
    }
}
/// Request message for "LivestreamService.CreateAsset".
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateAssetRequest {
    /// Required. The parent location for the resource, in the form of:
    /// `projects/{project}/locations/{location}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The asset resource to be created.
    #[prost(message, optional, tag = "2")]
    pub asset: ::core::option::Option<Asset>,
    /// Required. The ID of the asset resource to be created.
    ///
    /// This value must be 1-63 characters, begin and end with a lower-case letter
    /// or a number, and consist of only lower-case letters, numbers, and hyphens.
    /// In other words, it must match the following regex:
    /// `^[a-z0-9](\[a-z0-9-\]{0,61}\[a-z0-9\])?$`.
    #[prost(string, tag = "3")]
    pub asset_id: ::prost::alloc::string::String,
    /// A request ID to identify requests. Specify a unique request ID
    /// so that if you must retry your request, the server will know to ignore
    /// the request if it has already been completed. The server will guarantee
    /// that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and the
    /// request times out. If you make the request again with the same request ID,
    /// the server can check if original operation with the same request ID was
    /// received, and if so, will ignore the second request. This prevents clients
    /// from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported `(00000000-0000-0000-0000-000000000000)`.
    #[prost(string, tag = "4")]
    pub request_id: ::prost::alloc::string::String,
}
/// Request message for "LivestreamService.DeleteAsset".
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteAssetRequest {
    /// Required. The name of the asset resource, in the form of:
    /// `projects/{project}/locations/{location}/assets/{assetId}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// A request ID to identify requests. Specify a unique request ID
    /// so that if you must retry your request, the server will know to ignore
    /// the request if it has already been completed. The server will guarantee
    /// that for at least 60 minutes after the first request.
    ///
    /// For example, consider a situation where you make an initial request and the
    /// request times out. If you make the request again with the same request ID,
    /// the server can check if original operation with the same request ID was
    /// received, and if so, will ignore the second request. This prevents clients
    /// from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported `(00000000-0000-0000-0000-000000000000)`.
    #[prost(string, tag = "2")]
    pub request_id: ::prost::alloc::string::String,
}
/// Request message for "LivestreamService.ListAssets".
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListAssetsRequest {
    /// Required. The parent location for the resource, in the form of:
    /// `projects/{project}/locations/{location}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Requested page size. Server may return fewer items than requested.
    /// If unspecified, server will pick an appropriate default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// A token identifying a page of results the server should return.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Filtering results
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Hint for how to order the results
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Response message for "LivestreamService.ListAssets".
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListAssetsResponse {
    /// The list of Assets
    #[prost(message, repeated, tag = "1")]
    pub assets: ::prost::alloc::vec::Vec<Asset>,
    /// The next_page_token value returned from a previous List request, if any.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
    /// Locations that could not be reached.
    #[prost(string, repeated, tag = "3")]
    pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Request message for "LivestreamService.GetAsset".
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetAssetRequest {
    /// Required. Name of the resource, in the following form:
    /// `projects/{project}/locations/{location}/assets/{asset}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for "LivestreamService.CreateChannel".
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateChannelRequest {
    /// Required. The parent location for the resource, in the form of:
    /// `projects/{project}/locations/{location}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The channel resource to be created.
    #[prost(message, optional, tag = "2")]
    pub channel: ::core::option::Option<Channel>,
    /// Required. The ID of the channel resource to be created.
    ///
    /// This value must be 1-63 characters, begin and end with a lower-case letter
    /// or a number, and consist of only lower-case letters, numbers, and hyphens.
    /// In other words, it must match the following regex:
    /// `^[a-z0-9](\[a-z0-9-\]{0,61}\[a-z0-9\])?$`.
    #[prost(string, tag = "3")]
    pub channel_id: ::prost::alloc::string::String,
    /// A request ID to identify requests. Specify a unique request ID
    /// so that if you must retry your request, the server will know to ignore
    /// the request if it has already been completed. The server will guarantee
    /// that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and the
    /// request times out. If you make the request again with the same request ID,
    /// the server can check if original operation with the same request ID was
    /// received, and if so, will ignore the second request. This prevents clients
    /// from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported `(00000000-0000-0000-0000-000000000000)`.
    #[prost(string, tag = "4")]
    pub request_id: ::prost::alloc::string::String,
}
/// Request message for "LivestreamService.ListChannels".
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListChannelsRequest {
    /// Required. The parent location for the resource, in the form of:
    /// `projects/{project}/locations/{location}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of items to return. If unspecified, server
    /// will pick an appropriate default. Server may return fewer items than
    /// requested. A caller should only rely on response's
    /// \[next_page_token\]\[google.cloud.video.livestream.v1.ListChannelsResponse.next_page_token\]
    /// to determine if there are more items left to be queried.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous List request, if any.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// The filter to apply to list results.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Specifies the ordering of results following syntax at
    /// <https://cloud.google.com/apis/design/design_patterns#sorting_order.>
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Response message for "LivestreamService.ListChannels".
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListChannelsResponse {
    /// A list of channels.
    #[prost(message, repeated, tag = "1")]
    pub channels: ::prost::alloc::vec::Vec<Channel>,
    /// 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,
    /// Locations that could not be reached.
    #[prost(string, repeated, tag = "3")]
    pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Request message for "LivestreamService.GetChannel".
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetChannelRequest {
    /// Required. The name of the channel resource, in the form of:
    /// `projects/{project}/locations/{location}/channels/{channelId}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for "LivestreamService.DeleteChannel".
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteChannelRequest {
    /// Required. The name of the channel resource, in the form of:
    /// `projects/{project}/locations/{location}/channels/{channelId}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// A request ID to identify requests. Specify a unique request ID
    /// so that if you must retry your request, the server will know to ignore
    /// the request if it has already been completed. The server will guarantee
    /// that for at least 60 minutes after the first request.
    ///
    /// For example, consider a situation where you make an initial request and the
    /// request times out. If you make the request again with the same request ID,
    /// the server can check if original operation with the same request ID was
    /// received, and if so, will ignore the second request. This prevents clients
    /// from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported `(00000000-0000-0000-0000-000000000000)`.
    #[prost(string, tag = "2")]
    pub request_id: ::prost::alloc::string::String,
    /// If the `force` field is set to the default value of `false`, you must
    /// delete all of a channel's events before you can delete the channel itself.
    /// If the field is set to `true`, requests to delete a channel also delete
    /// associated channel events.
    #[prost(bool, tag = "3")]
    pub force: bool,
}
/// Request message for "LivestreamService.UpdateChannel".
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateChannelRequest {
    /// Field mask is used to specify the fields to be overwritten in the Channel
    /// resource by the update. You can only update the following fields:
    ///
    /// * [`inputAttachments`](<https://cloud.google.com/livestream/docs/reference/rest/v1/projects.locations.channels#inputattachment>)
    /// * [`inputConfig`](<https://cloud.google.com/livestream/docs/reference/rest/v1/projects.locations.channels#inputconfig>)
    /// * [`output`](<https://cloud.google.com/livestream/docs/reference/rest/v1/projects.locations.channels#output>)
    /// * [`elementaryStreams`](<https://cloud.google.com/livestream/docs/reference/rest/v1/projects.locations.channels#elementarystream>)
    /// * [`muxStreams`](<https://cloud.google.com/livestream/docs/reference/rest/v1/projects.locations.channels#muxstream>)
    /// * [`manifests`](<https://cloud.google.com/livestream/docs/reference/rest/v1/projects.locations.channels#manifest>)
    /// * [`spriteSheets`](<https://cloud.google.com/livestream/docs/reference/rest/v1/projects.locations.channels#spritesheet>)
    /// * [`logConfig`](<https://cloud.google.com/livestream/docs/reference/rest/v1/projects.locations.channels#logconfig>)
    /// * [`timecodeConfig`](<https://cloud.google.com/livestream/docs/reference/rest/v1/projects.locations.channels#timecodeconfig>)
    /// * [`encryptions`](<https://cloud.google.com/livestream/docs/reference/rest/v1/projects.locations.channels#encryption>)
    ///
    /// The fields specified in the update_mask are relative to the resource, not
    /// the full request. A field will be overwritten if it is in the mask.
    ///
    /// If the mask is not present, then each field from the list above is updated
    /// if the field appears in the request payload. To unset a field, add the
    /// field to the update mask and remove it from the request payload.
    #[prost(message, optional, tag = "1")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Required. The channel resource to be updated.
    #[prost(message, optional, tag = "2")]
    pub channel: ::core::option::Option<Channel>,
    /// A request ID to identify requests. Specify a unique request ID
    /// so that if you must retry your request, the server will know to ignore
    /// the request if it has already been completed. The server will guarantee
    /// that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and the
    /// request times out. If you make the request again with the same request ID,
    /// the server can check if original operation with the same request ID was
    /// received, and if so, will ignore the second request. This prevents clients
    /// from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported `(00000000-0000-0000-0000-000000000000)`.
    #[prost(string, tag = "3")]
    pub request_id: ::prost::alloc::string::String,
}
/// Request message for "LivestreamService.StartChannel".
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StartChannelRequest {
    /// Required. The name of the channel resource, in the form of:
    /// `projects/{project}/locations/{location}/channels/{channelId}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// A request ID to identify requests. Specify a unique request ID
    /// so that if you must retry your request, the server will know to ignore
    /// the request if it has already been completed. The server will guarantee
    /// that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and the
    /// request times out. If you make the request again with the same request ID,
    /// the server can check if original operation with the same request ID was
    /// received, and if so, will ignore the second request. This prevents clients
    /// from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported `(00000000-0000-0000-0000-000000000000)`.
    #[prost(string, tag = "2")]
    pub request_id: ::prost::alloc::string::String,
}
/// Request message for "LivestreamService.StopChannel".
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StopChannelRequest {
    /// Required. The name of the channel resource, in the form of:
    /// `projects/{project}/locations/{location}/channels/{channelId}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// A request ID to identify requests. Specify a unique request ID
    /// so that if you must retry your request, the server will know to ignore
    /// the request if it has already been completed. The server will guarantee
    /// that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and the
    /// request times out. If you make the request again with the same request ID,
    /// the server can check if original operation with the same request ID was
    /// received, and if so, will ignore the second request. This prevents clients
    /// from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported `(00000000-0000-0000-0000-000000000000)`.
    #[prost(string, tag = "2")]
    pub request_id: ::prost::alloc::string::String,
}
/// Request message for "LivestreamService.StartDistribution".
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StartDistributionRequest {
    /// Required. The name of the channel resource, in the form of:
    /// `projects/{project}/locations/{location}/channels/{channelId}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. A list of keys to identify the distribution configuration in the
    /// channel resource. If left empty, all the distributions in the channel
    /// specification will be started.
    #[prost(string, repeated, tag = "2")]
    pub distribution_keys: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. A request ID to identify requests. Specify a unique request ID
    /// so that if you must retry your request, the server will know to ignore
    /// the request if it has already been completed. The server will guarantee
    /// that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and the
    /// request times out. If you make the request again with the same request ID,
    /// the server can check if original operation with the same request ID was
    /// received, and if so, will ignore the second request. This prevents clients
    /// from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported `(00000000-0000-0000-0000-000000000000)`.
    #[prost(string, tag = "3")]
    pub request_id: ::prost::alloc::string::String,
}
/// Request message for "LivestreamService.StopDistribution".
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StopDistributionRequest {
    /// Required. The name of the channel resource, in the form of:
    /// `projects/{project}/locations/{location}/channels/{channelId}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. A list of key to identify the distribution configuration in the
    /// channel resource. If left empty, all the distributions in the channel
    /// specification will be stopped.
    #[prost(string, repeated, tag = "2")]
    pub distribution_keys: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. A request ID to identify requests. Specify a unique request ID
    /// so that if you must retry your request, the server will know to ignore
    /// the request if it has already been completed. The server will guarantee
    /// that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and the
    /// request times out. If you make the request again with the same request ID,
    /// the server can check if original operation with the same request ID was
    /// received, and if so, will ignore the second request. This prevents clients
    /// from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported `(00000000-0000-0000-0000-000000000000)`.
    #[prost(string, tag = "3")]
    pub request_id: ::prost::alloc::string::String,
}
/// Request message for "LivestreamService.CreateInput".
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateInputRequest {
    /// Required. The parent location for the resource, in the form of:
    /// `projects/{project}/locations/{location}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The input resource to be created.
    #[prost(message, optional, tag = "2")]
    pub input: ::core::option::Option<Input>,
    /// Required. The ID of the input resource to be created.
    ///
    /// This value must be 1-63 characters, begin and end with a lower-case letter
    /// or a number, and consist of only lower-case letters, numbers, and hyphens.
    /// In other words, it must match the following regex:
    /// `^[a-z0-9](\[a-z0-9-\]{0,61}\[a-z0-9\])?$`.
    #[prost(string, tag = "3")]
    pub input_id: ::prost::alloc::string::String,
    /// A request ID to identify requests. Specify a unique request ID
    /// so that if you must retry your request, the server will know to ignore
    /// the request if it has already been completed. The server will guarantee
    /// that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and the
    /// request times out. If you make the request again with the same request ID,
    /// the server can check if original operation with the same request ID was
    /// received, and if so, will ignore the second request. This prevents clients
    /// from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported `(00000000-0000-0000-0000-000000000000)`.
    #[prost(string, tag = "4")]
    pub request_id: ::prost::alloc::string::String,
}
/// Request message for "LivestreamService.ListInputs".
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListInputsRequest {
    /// Required. The parent location for the resource, in the form of:
    /// `projects/{project}/locations/{location}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of items to return. If unspecified, server
    /// will pick an appropriate default. Server may return fewer items than
    /// requested. A caller should only rely on response's
    /// \[next_page_token\]\[google.cloud.video.livestream.v1.ListInputsResponse.next_page_token\]
    /// to determine if there are more items left to be queried.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous List request, if any.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// The filter to apply to list results.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Specifies the ordering of results following syntax at [Sorting
    /// Order](<https://cloud.google.com/apis/design/design_patterns#sorting_order>).
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Response message for "LivestreamService.ListInputs".
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListInputsResponse {
    /// A list of inputs.
    #[prost(message, repeated, tag = "1")]
    pub inputs: ::prost::alloc::vec::Vec<Input>,
    /// 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,
    /// Locations that could not be reached.
    #[prost(string, repeated, tag = "3")]
    pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Request message for "LivestreamService.GetInput".
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetInputRequest {
    /// Required. The name of the input resource, in the form of:
    /// `projects/{project}/locations/{location}/inputs/{inputId}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for "LivestreamService.DeleteInput".
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteInputRequest {
    /// Required. The name of the input resource, in the form of:
    /// `projects/{project}/locations/{location}/inputs/{inputId}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// A request ID to identify requests. Specify a unique request ID
    /// so that if you must retry your request, the server will know to ignore
    /// the request if it has already been completed. The server will guarantee
    /// that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and the
    /// request times out. If you make the request again with the same request ID,
    /// the server can check if original operation with the same request ID was
    /// received, and if so, will ignore the second request. This prevents clients
    /// from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported `(00000000-0000-0000-0000-000000000000)`.
    #[prost(string, tag = "2")]
    pub request_id: ::prost::alloc::string::String,
}
/// Request message for "LivestreamService.UpdateInput".
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateInputRequest {
    /// Field mask is used to specify the fields to be overwritten in the Input
    /// resource by the update. You can only update the following fields:
    ///
    /// * [`tier`](<https://cloud.google.com/livestream/docs/reference/rest/v1/projects.locations.inputs#Tier>)
    /// * [`preprocessingConfig`](<https://cloud.google.com/livestream/docs/reference/rest/v1/projects.locations.inputs#PreprocessingConfig>)
    /// * [`securityRules`](<https://cloud.google.com/livestream/docs/reference/rest/v1/projects.locations.inputs#SecurityRule>)
    ///
    /// The fields specified in the update_mask are relative to the resource, not
    /// the full request. A field will be overwritten if it is in the mask.
    ///
    /// If the mask is not present, then each field from the list above is updated
    /// if the field appears in the request payload. To unset a field, add the
    /// field to the update mask and remove it from the request payload.
    #[prost(message, optional, tag = "1")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Required. The input resource to be updated.
    #[prost(message, optional, tag = "2")]
    pub input: ::core::option::Option<Input>,
    /// A request ID to identify requests. Specify a unique request ID
    /// so that if you must retry your request, the server will know to ignore
    /// the request if it has already been completed. The server will guarantee
    /// that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and the
    /// request times out. If you make the request again with the same request ID,
    /// the server can check if original operation with the same request ID was
    /// received, and if so, will ignore the second request. This prevents clients
    /// from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported `(00000000-0000-0000-0000-000000000000)`.
    #[prost(string, tag = "3")]
    pub request_id: ::prost::alloc::string::String,
}
/// Request message for "LivestreamService.CreateEvent".
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateEventRequest {
    /// Required. The parent channel for the resource, in the form of:
    /// `projects/{project}/locations/{location}/channels/{channelId}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The event resource to be created.
    #[prost(message, optional, tag = "2")]
    pub event: ::core::option::Option<Event>,
    /// Required. The ID of the event resource to be created.
    ///
    /// This value must be 1-63 characters, begin and end with a lower-case letter
    /// or a number, and consist of only lower-case letters, numbers, and hyphens.
    /// In other words, it must match the following regex:
    /// `^[a-z0-9](\[a-z0-9-\]{0,61}\[a-z0-9\])?$`.
    #[prost(string, tag = "3")]
    pub event_id: ::prost::alloc::string::String,
    /// A request ID to identify requests. Specify a unique request ID
    /// so that if you must retry your request, the server will know to ignore
    /// the request if it has already been completed. The server will guarantee
    /// that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and the
    /// request times out. If you make the request again with the same request ID,
    /// the server can check if original operation with the same request ID was
    /// received, and if so, will ignore the second request. This prevents clients
    /// from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported `(00000000-0000-0000-0000-000000000000)`.
    #[prost(string, tag = "4")]
    pub request_id: ::prost::alloc::string::String,
}
/// Request message for "LivestreamService.ListEvents".
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListEventsRequest {
    /// Required. The parent channel for the resource, in the form of:
    /// `projects/{project}/locations/{location}/channels/{channelId}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of items to return. If unspecified, server
    /// will pick an appropriate default. Server may return fewer items than
    /// requested. A caller should only rely on response's
    /// \[next_page_token\]\[google.cloud.video.livestream.v1.ListEventsResponse.next_page_token\]
    /// to determine if there are more items left to be queried.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous List request, if any.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// The filter to apply to list results.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Specifies the ordering of results following syntax at
    /// <https://cloud.google.com/apis/design/design_patterns#sorting_order.>
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Response message for "LivestreamService.ListEvents".
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListEventsResponse {
    /// A list of events.
    #[prost(message, repeated, tag = "1")]
    pub events: ::prost::alloc::vec::Vec<Event>,
    /// 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,
    /// Locations that could not be reached.
    #[prost(string, repeated, tag = "3")]
    pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Request message for "LivestreamService.GetEvent".
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetEventRequest {
    /// Required. The name of the event resource, in the form of:
    /// `projects/{project}/locations/{location}/channels/{channelId}/events/{eventId}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for "LivestreamService.DeleteEvent".
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteEventRequest {
    /// Required. The name of the event resource, in the form of:
    /// `projects/{project}/locations/{location}/channels/{channelId}/events/{eventId}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// A request ID to identify requests. Specify a unique request ID
    /// so that if you must retry your request, the server will know to ignore
    /// the request if it has already been completed. The server will guarantee
    /// that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and the
    /// request times out. If you make the request again with the same request ID,
    /// the server can check if original operation with the same request ID was
    /// received, and if so, will ignore the second request. This prevents clients
    /// from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported `(00000000-0000-0000-0000-000000000000)`.
    #[prost(string, tag = "2")]
    pub request_id: ::prost::alloc::string::String,
}
/// Response message for Start/Stop Channel long-running operations.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ChannelOperationResponse {}
/// Request message for "LivestreamService.ListClips".
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListClipsRequest {
    /// Required. Parent value for ListClipsRequest
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Requested page size. Server may return fewer items than requested.
    /// If unspecified, server will pick an appropriate default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// A token identifying a page of results the server should return.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Filtering results
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Hint for how to order the results
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Response message for "LivestreamService.ListClips".
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListClipsResponse {
    /// The list of Clip
    #[prost(message, repeated, tag = "1")]
    pub clips: ::prost::alloc::vec::Vec<Clip>,
    /// A token identifying a page of results the server should return.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
    /// Locations that could not be reached.
    #[prost(string, repeated, tag = "3")]
    pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Request message for "LivestreamService.GetClip".
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetClipRequest {
    /// Required. Name of the resource, in the following form:
    /// `projects/{project}/locations/{location}/channels/{channel}/clips/{clip}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for "LivestreamService.CreateClip".
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateClipRequest {
    /// Required. The parent resource name, in the following form:
    /// `projects/{project}/locations/{location}/channels/{channel}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The ID of the clip resource to be created.
    ///
    /// This value must be 1-63 characters, begin and end with a lower-case letter
    /// or a number, and consist of only lower-case letters, numbers, and hyphens.
    /// In other words, it must match the following regex:
    /// `^[a-z0-9](\[a-z0-9-\]{0,61}\[a-z0-9\])?$`.
    #[prost(string, tag = "2")]
    pub clip_id: ::prost::alloc::string::String,
    /// Required. The resource being created
    #[prost(message, optional, tag = "3")]
    pub clip: ::core::option::Option<Clip>,
    /// Optional. An optional request ID to identify requests. Specify a unique
    /// request ID so that if you must retry your request, the server will know to
    /// ignore the request if it has already been completed. The server will
    /// guarantee that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and
    /// the request times out. If you make the request again with the same request
    /// ID, the server can check if original operation with the same request ID
    /// was received, and if so, will ignore the second request. This prevents
    /// clients from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported (00000000-0000-0000-0000-000000000000).
    #[prost(string, tag = "4")]
    pub request_id: ::prost::alloc::string::String,
}
/// Request message for "LivestreamService.DeleteClip".
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteClipRequest {
    /// Required. The name of the clip resource, in the form of:
    /// `projects/{project}/locations/{location}/channels/{channelId}/clips/{clipId}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. A request ID to identify requests. Specify a unique request ID
    /// so that if you must retry your request, the server will know to ignore
    /// the request if it has already been completed. The server will guarantee
    /// that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and the
    /// request times out. If you make the request again with the same request ID,
    /// the server can check if original operation with the same request ID was
    /// received, and if so, will ignore the second request. This prevents clients
    /// from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported `(00000000-0000-0000-0000-000000000000)`.
    #[prost(string, tag = "2")]
    pub request_id: ::prost::alloc::string::String,
}
/// Request message for "LivestreamService.ListDvrSessions".
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListDvrSessionsRequest {
    /// Required. Parent value for ListDvrSessionsRequest
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Requested page size. Server may return fewer items than
    /// requested. If unspecified, server will pick an appropriate default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. A token identifying a page of results the server should return.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. Filtering results
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Optional. Hint for how to order the results
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Response message for "LivestreamService.ListDvrSessions".
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListDvrSessionsResponse {
    /// The list of DVR sessions
    #[prost(message, repeated, tag = "1")]
    pub dvr_sessions: ::prost::alloc::vec::Vec<DvrSession>,
    /// A token identifying a page of results the server should return.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
    /// Locations that could not be reached.
    #[prost(string, repeated, tag = "3")]
    pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Request message for "LivestreamService.GetDvrSession".
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetDvrSessionRequest {
    /// Required. Name of the resource, in the following form:
    /// `projects/{project}/locations/{location}/channels/{channelId}/dvrSessions/{dvrSessionId}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for "LivestreamService.CreateDvrSession".
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateDvrSessionRequest {
    /// Required. The parent resource name, in the following form:
    /// `projects/{project}/locations/{location}/channels/{channelId}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The ID of the DVR session resource to be created.
    ///
    /// This value must be 1-63 characters, begin and end with a lower-case letter
    /// or a number, and consist of only lower-case letters, numbers, and hyphens.
    /// In other words, it must match the following regex:
    /// `^[a-z0-9](\[a-z0-9-\]{0,61}\[a-z0-9\])?$`.
    #[prost(string, tag = "2")]
    pub dvr_session_id: ::prost::alloc::string::String,
    /// Required. The resource being created
    #[prost(message, optional, tag = "3")]
    pub dvr_session: ::core::option::Option<DvrSession>,
    /// Optional. An optional request ID to identify requests. Specify a unique
    /// request ID so that if you must retry your request, the server will know to
    /// ignore the request if it has already been completed. The server will
    /// guarantee that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and
    /// the request times out. If you make the request again with the same request
    /// ID, the server can check if original operation with the same request ID
    /// was received, and if so, will ignore the second request. This prevents
    /// clients from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported (00000000-0000-0000-0000-000000000000).
    #[prost(string, tag = "4")]
    pub request_id: ::prost::alloc::string::String,
}
/// Request message for "LivestreamService.DeleteDvrSession".
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteDvrSessionRequest {
    /// Required. The name of the event resource, in the form of:
    /// `projects/{project}/locations/{location}/channels/{channelId}/dvrSessions/{dvrSessionId}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. A request ID to identify requests. Specify a unique request ID
    /// so that if you must retry your request, the server will know to ignore
    /// the request if it has already been completed. The server will guarantee
    /// that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and the
    /// request times out. If you make the request again with the same request ID,
    /// the server can check if original operation with the same request ID was
    /// received, and if so, will ignore the second request. This prevents clients
    /// from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported `(00000000-0000-0000-0000-000000000000)`.
    #[prost(string, tag = "2")]
    pub request_id: ::prost::alloc::string::String,
}
/// Request message for "LivestreamService.UpdateDvrSession".
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateDvrSessionRequest {
    /// Required. Field mask is used to specify the fields to be overwritten in the
    /// DvrSession resource by the update. You can only update the following
    /// fields:
    ///
    /// * `dvrWindows`
    ///
    /// The fields specified in the update_mask are relative to the resource, not
    /// the full request. A field will be overwritten if it is in the mask.
    #[prost(message, optional, tag = "1")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Required. The DVR session resource to be updated.
    #[prost(message, optional, tag = "2")]
    pub dvr_session: ::core::option::Option<DvrSession>,
    /// Optional. A request ID to identify requests. Specify a unique request ID
    /// so that if you must retry your request, the server will know to ignore
    /// the request if it has already been completed. The server will guarantee
    /// that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and the
    /// request times out. If you make the request again with the same request ID,
    /// the server can check if original operation with the same request ID was
    /// received, and if so, will ignore the second request. This prevents clients
    /// from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported `(00000000-0000-0000-0000-000000000000)`.
    #[prost(string, tag = "3")]
    pub request_id: ::prost::alloc::string::String,
}
/// Represents the metadata of the long-running operation.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct OperationMetadata {
    /// Output only. The time the operation was created.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The time the operation finished running.
    #[prost(message, optional, tag = "2")]
    pub end_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Server-defined resource path for the target of the operation.
    #[prost(string, tag = "3")]
    pub target: ::prost::alloc::string::String,
    /// Output only. Name of the verb executed by the operation.
    #[prost(string, tag = "4")]
    pub verb: ::prost::alloc::string::String,
    /// Output only. Identifies whether the user has requested cancellation
    /// of the operation. Operations that have successfully been cancelled
    /// have
    /// \[google.longrunning.Operation.error\]\[google.longrunning.Operation.error\]
    /// value with a \[google.rpc.Status.code\]\[google.rpc.Status.code\] of 1,
    /// corresponding to `Code.CANCELLED`.
    #[prost(bool, tag = "5")]
    pub requested_cancellation: bool,
    /// Output only. API version used to start the operation.
    #[prost(string, tag = "6")]
    pub api_version: ::prost::alloc::string::String,
}
/// Request message for "LivestreamService.GetPool".
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetPoolRequest {
    /// Required. The name of the pool resource, in the form of:
    /// `projects/{project}/locations/{location}/pools/{poolId}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for "LivestreamService.UpdatePool".
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdatePoolRequest {
    /// Field mask is used to specify the fields to be overwritten in the Pool
    /// resource by the update. You can only update the following fields:
    ///
    /// * `networkConfig`
    ///
    /// The fields specified in the update_mask are relative to the resource, not
    /// the full request. A field will be overwritten if it is in the mask.
    #[prost(message, optional, tag = "1")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Required. The pool resource to be updated.
    #[prost(message, optional, tag = "2")]
    pub pool: ::core::option::Option<Pool>,
    /// A request ID to identify requests. Specify a unique request ID
    /// so that if you must retry your request, the server will know to ignore
    /// the request if it has already been completed. The server will guarantee
    /// that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and the
    /// request times out. If you make the request again with the same request ID,
    /// the server can check if original operation with the same request ID was
    /// received, and if so, will ignore the second request. This prevents clients
    /// from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported `(00000000-0000-0000-0000-000000000000)`.
    #[prost(string, tag = "3")]
    pub request_id: ::prost::alloc::string::String,
}
/// Request message for "LivestreamService.PreviewInput"
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PreviewInputRequest {
    /// Required. The name of the input resource, in the form of:
    /// `projects/{project}/locations/{location}/inputs/{inputId}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Response message for "LivestreamService.PreviewInput"
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PreviewInputResponse {
    /// URI to display the preview content.
    #[prost(string, tag = "1")]
    pub uri: ::prost::alloc::string::String,
    /// A bearer token used to authenticate connections that display the preview
    /// content. The token expires after one hour. For HTTP connections, this token
    /// should be included as a bearer token inside the Authorization header.
    #[prost(string, tag = "2")]
    pub bearer_token: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod livestream_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Using Live Stream API, you can generate live streams in the various
    /// renditions and streaming formats. The streaming format include HTTP Live
    /// Streaming (HLS) and Dynamic Adaptive Streaming over HTTP (DASH). You can send
    /// a source stream in the various ways, including Real-Time Messaging
    /// Protocol (RTMP) and Secure Reliable Transport (SRT).
    #[derive(Debug, Clone)]
    pub struct LivestreamServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl LivestreamServiceClient<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> LivestreamServiceClient<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,
        ) -> LivestreamServiceClient<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,
        {
            LivestreamServiceClient::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 channel with the provided unique ID in the specified
        /// region.
        pub async fn create_channel(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateChannelRequest>,
        ) -> 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.video.livestream.v1.LivestreamService/CreateChannel",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "CreateChannel",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns a list of all channels in the specified region.
        pub async fn list_channels(
            &mut self,
            request: impl tonic::IntoRequest<super::ListChannelsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListChannelsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|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.video.livestream.v1.LivestreamService/ListChannels",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "ListChannels",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns the specified channel.
        pub async fn get_channel(
            &mut self,
            request: impl tonic::IntoRequest<super::GetChannelRequest>,
        ) -> std::result::Result<tonic::Response<super::Channel>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|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.video.livestream.v1.LivestreamService/GetChannel",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "GetChannel",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified channel.
        pub async fn delete_channel(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteChannelRequest>,
        ) -> 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.video.livestream.v1.LivestreamService/DeleteChannel",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "DeleteChannel",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified channel.
        pub async fn update_channel(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateChannelRequest>,
        ) -> 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.video.livestream.v1.LivestreamService/UpdateChannel",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "UpdateChannel",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Starts the specified channel. Part of the video pipeline will be created
        /// only when the StartChannel request is received by the server.
        pub async fn start_channel(
            &mut self,
            request: impl tonic::IntoRequest<super::StartChannelRequest>,
        ) -> 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.video.livestream.v1.LivestreamService/StartChannel",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "StartChannel",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Stops the specified channel. Part of the video pipeline will be released
        /// when the StopChannel request is received by the server.
        pub async fn stop_channel(
            &mut self,
            request: impl tonic::IntoRequest<super::StopChannelRequest>,
        ) -> 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.video.livestream.v1.LivestreamService/StopChannel",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "StopChannel",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Starts distribution which delivers outputs to the destination indicated by
        /// the Distribution configuration.
        pub async fn start_distribution(
            &mut self,
            request: impl tonic::IntoRequest<super::StartDistributionRequest>,
        ) -> 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.video.livestream.v1.LivestreamService/StartDistribution",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "StartDistribution",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Stops the specified distribution.
        pub async fn stop_distribution(
            &mut self,
            request: impl tonic::IntoRequest<super::StopDistributionRequest>,
        ) -> 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.video.livestream.v1.LivestreamService/StopDistribution",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "StopDistribution",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates an input with the provided unique ID in the specified region.
        pub async fn create_input(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateInputRequest>,
        ) -> 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.video.livestream.v1.LivestreamService/CreateInput",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "CreateInput",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns a list of all inputs in the specified region.
        pub async fn list_inputs(
            &mut self,
            request: impl tonic::IntoRequest<super::ListInputsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListInputsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|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.video.livestream.v1.LivestreamService/ListInputs",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "ListInputs",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns the specified input.
        pub async fn get_input(
            &mut self,
            request: impl tonic::IntoRequest<super::GetInputRequest>,
        ) -> std::result::Result<tonic::Response<super::Input>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|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.video.livestream.v1.LivestreamService/GetInput",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "GetInput",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified input.
        pub async fn delete_input(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteInputRequest>,
        ) -> 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.video.livestream.v1.LivestreamService/DeleteInput",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "DeleteInput",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified input.
        pub async fn update_input(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateInputRequest>,
        ) -> 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.video.livestream.v1.LivestreamService/UpdateInput",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "UpdateInput",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Preview the streaming content of the specified input.
        pub async fn preview_input(
            &mut self,
            request: impl tonic::IntoRequest<super::PreviewInputRequest>,
        ) -> std::result::Result<
            tonic::Response<super::PreviewInputResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|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.video.livestream.v1.LivestreamService/PreviewInput",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "PreviewInput",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates an event with the provided unique ID in the specified channel.
        pub async fn create_event(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateEventRequest>,
        ) -> std::result::Result<tonic::Response<super::Event>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|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.video.livestream.v1.LivestreamService/CreateEvent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "CreateEvent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns a list of all events in the specified channel.
        pub async fn list_events(
            &mut self,
            request: impl tonic::IntoRequest<super::ListEventsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListEventsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|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.video.livestream.v1.LivestreamService/ListEvents",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "ListEvents",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns the specified event.
        pub async fn get_event(
            &mut self,
            request: impl tonic::IntoRequest<super::GetEventRequest>,
        ) -> std::result::Result<tonic::Response<super::Event>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|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.video.livestream.v1.LivestreamService/GetEvent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "GetEvent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified event.
        pub async fn delete_event(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteEventRequest>,
        ) -> 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.video.livestream.v1.LivestreamService/DeleteEvent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "DeleteEvent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns a list of all clips in the specified channel.
        pub async fn list_clips(
            &mut self,
            request: impl tonic::IntoRequest<super::ListClipsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListClipsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|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.video.livestream.v1.LivestreamService/ListClips",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "ListClips",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns the specified clip.
        pub async fn get_clip(
            &mut self,
            request: impl tonic::IntoRequest<super::GetClipRequest>,
        ) -> std::result::Result<tonic::Response<super::Clip>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|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.video.livestream.v1.LivestreamService/GetClip",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "GetClip",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a clip with the provided clip ID in the specified channel.
        pub async fn create_clip(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateClipRequest>,
        ) -> 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.video.livestream.v1.LivestreamService/CreateClip",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "CreateClip",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified clip job resource. This method only deletes the clip
        /// job and does not delete the VOD clip stored in Cloud Storage.
        pub async fn delete_clip(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteClipRequest>,
        ) -> 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.video.livestream.v1.LivestreamService/DeleteClip",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "DeleteClip",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a DVR session with the provided unique ID in the specified channel.
        pub async fn create_dvr_session(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateDvrSessionRequest>,
        ) -> 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.video.livestream.v1.LivestreamService/CreateDvrSession",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "CreateDvrSession",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns a list of all DVR sessions in the specified channel.
        pub async fn list_dvr_sessions(
            &mut self,
            request: impl tonic::IntoRequest<super::ListDvrSessionsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListDvrSessionsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|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.video.livestream.v1.LivestreamService/ListDvrSessions",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "ListDvrSessions",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns the specified DVR session.
        pub async fn get_dvr_session(
            &mut self,
            request: impl tonic::IntoRequest<super::GetDvrSessionRequest>,
        ) -> std::result::Result<tonic::Response<super::DvrSession>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|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.video.livestream.v1.LivestreamService/GetDvrSession",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "GetDvrSession",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified DVR session.
        pub async fn delete_dvr_session(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteDvrSessionRequest>,
        ) -> 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.video.livestream.v1.LivestreamService/DeleteDvrSession",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "DeleteDvrSession",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified DVR session.
        pub async fn update_dvr_session(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateDvrSessionRequest>,
        ) -> 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.video.livestream.v1.LivestreamService/UpdateDvrSession",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "UpdateDvrSession",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a Asset with the provided unique ID in the specified
        /// region.
        pub async fn create_asset(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateAssetRequest>,
        ) -> 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.video.livestream.v1.LivestreamService/CreateAsset",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "CreateAsset",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified asset if it is not used.
        pub async fn delete_asset(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteAssetRequest>,
        ) -> 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.video.livestream.v1.LivestreamService/DeleteAsset",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "DeleteAsset",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns the specified asset.
        pub async fn get_asset(
            &mut self,
            request: impl tonic::IntoRequest<super::GetAssetRequest>,
        ) -> std::result::Result<tonic::Response<super::Asset>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|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.video.livestream.v1.LivestreamService/GetAsset",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "GetAsset",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns a list of all assets in the specified region.
        pub async fn list_assets(
            &mut self,
            request: impl tonic::IntoRequest<super::ListAssetsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListAssetsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|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.video.livestream.v1.LivestreamService/ListAssets",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "ListAssets",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns the specified pool.
        pub async fn get_pool(
            &mut self,
            request: impl tonic::IntoRequest<super::GetPoolRequest>,
        ) -> std::result::Result<tonic::Response<super::Pool>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|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.video.livestream.v1.LivestreamService/GetPool",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "GetPool",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified pool.
        pub async fn update_pool(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdatePoolRequest>,
        ) -> 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.video.livestream.v1.LivestreamService/UpdatePool",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.video.livestream.v1.LivestreamService",
                        "UpdatePool",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
