yandex-cloud 2025.4.14

/// Root entity for content separation.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Channel {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the organization where channel should be created.
    #[prost(string, tag = "2")]
    pub organization_id: ::prost::alloc::string::String,
    /// Channel title.
    #[prost(string, tag = "3")]
    pub title: ::prost::alloc::string::String,
    /// Channel description.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// Time when channel was created.
    #[prost(message, optional, tag = "100")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Time of last channel update.
    #[prost(message, optional, tag = "101")]
    pub updated_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Custom labels as `` key:value `` pairs. Maximum 64 per resource.
    #[prost(map = "string, string", tag = "200")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Channel settings.
    #[prost(message, optional, tag = "201")]
    pub settings: ::core::option::Option<ChannelSettings>,
}
/// Channel settings.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ChannelSettings {
    /// Advertisement settings.
    #[prost(message, optional, tag = "1")]
    pub advertisement: ::core::option::Option<AdvertisementSettings>,
    /// Referer verification settings
    #[prost(message, optional, tag = "3")]
    pub referer_verification: ::core::option::Option<RefererVerificationSettings>,
}
/// Advertisement settings.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AdvertisementSettings {
    /// Advertisement provider.
    #[prost(oneof = "advertisement_settings::Provider", tags = "100")]
    pub provider: ::core::option::Option<advertisement_settings::Provider>,
}
/// Nested message and enum types in `AdvertisementSettings`.
pub mod advertisement_settings {
    /// YandexDirect provider settings.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct YandexDirect {
        /// Enable Partner Ad for Live and VOD content.
        #[prost(bool, tag = "1")]
        pub enable: bool,
        /// Advertisement page ID.
        #[prost(int64, tag = "2")]
        pub page_id: i64,
        /// Advertisement category.
        #[prost(int64, tag = "3")]
        pub category: i64,
    }
    /// Advertisement provider.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Provider {
        #[prost(message, tag = "100")]
        YandexDirect(YandexDirect),
    }
}
/// Referer verification settings.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RefererVerificationSettings {
    /// Enable verification
    #[prost(bool, tag = "1")]
    pub enable: bool,
    /// List of available domains
    #[prost(string, repeated, tag = "2")]
    pub allowed_domains: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetChannelRequest {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub channel_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListChannelsRequest {
    /// ID of the organization.
    #[prost(string, tag = "1")]
    pub organization_id: ::prost::alloc::string::String,
    /// The maximum number of the results per page to return.
    /// Default value: 100.
    #[prost(int64, tag = "100")]
    pub page_size: i64,
    /// Page token for getting the next page of the result.
    #[prost(string, tag = "101")]
    pub page_token: ::prost::alloc::string::String,
    /// By which column the listing should be ordered and in which direction,
    /// format is "<field> <order>" (e.g. "createdAt desc").
    /// Default: "id asc".
    /// Possible fields: ["id", "title", "createdAt", "updatedAt"].
    /// Both snake_case and camelCase are supported for fields.
    #[prost(string, tag = "102")]
    pub order_by: ::prost::alloc::string::String,
    /// Filter expression that filters resources listed in the response.
    /// Expressions are composed of terms connected by logic operators.
    /// If value contains spaces or quotes,
    /// it should be in quotes (`'` or `"`) with the inner quotes being backslash escaped.
    /// Example: "key1='value' AND key2='value'".
    /// Supported operators: ["AND", "OR"].
    /// Supported fields: ["id", "title"].
    /// Both snake_case and camelCase are supported for fields.
    #[prost(string, tag = "103")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListChannelsResponse {
    /// List of channels for specific organization.
    #[prost(message, repeated, tag = "1")]
    pub channels: ::prost::alloc::vec::Vec<Channel>,
    /// Token for getting the next page.
    #[prost(string, tag = "100")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateChannelRequest {
    /// ID of the organization.
    #[prost(string, tag = "1")]
    pub organization_id: ::prost::alloc::string::String,
    /// Channel title.
    #[prost(string, tag = "2")]
    pub title: ::prost::alloc::string::String,
    /// Channel description.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Custom labels as `` key:value `` pairs. Maximum 64 per resource.
    #[prost(map = "string, string", tag = "200")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Channel settings.
    #[prost(message, optional, tag = "201")]
    pub settings: ::core::option::Option<ChannelSettings>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateChannelMetadata {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub channel_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateChannelRequest {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub channel_id: ::prost::alloc::string::String,
    /// Field mask that specifies which fields of the channel are going to be updated.
    #[prost(message, optional, tag = "2")]
    pub field_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Channel title.
    #[prost(string, tag = "3")]
    pub title: ::prost::alloc::string::String,
    /// Channel description.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// Custom labels as `` key:value `` pairs. Maximum 64 per resource.
    #[prost(map = "string, string", tag = "200")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Channel settings.
    #[prost(message, optional, tag = "201")]
    pub settings: ::core::option::Option<ChannelSettings>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateChannelMetadata {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub channel_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteChannelRequest {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub channel_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteChannelMetadata {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub channel_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchDeleteChannelsRequest {
    /// ID of the organization.
    #[prost(string, tag = "1")]
    pub organization_id: ::prost::alloc::string::String,
    /// List of channel IDs.
    #[prost(string, repeated, tag = "2")]
    pub channel_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchDeleteChannelsMetadata {
    /// List of channel IDs.
    #[prost(string, repeated, tag = "1")]
    pub channel_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Generated client implementations.
pub mod channel_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Channel management service.
    #[derive(Debug, Clone)]
    pub struct ChannelServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ChannelServiceClient<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> ChannelServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> ChannelServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            ChannelServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Get the specific channel.
        pub async fn get(
            &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::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.ChannelService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.video.v1.ChannelService", "Get"));
            self.inner.unary(req, path, codec).await
        }
        /// List channels for organization.
        pub async fn list(
            &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::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.ChannelService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.video.v1.ChannelService", "List"));
            self.inner.unary(req, path, codec).await
        }
        /// Create channel.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateChannelRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.ChannelService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.ChannelService", "Create"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Update channel.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateChannelRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.ChannelService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.ChannelService", "Update"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Delete channel.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteChannelRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.ChannelService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.ChannelService", "Delete"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Batch delete channels.
        pub async fn batch_delete(
            &mut self,
            request: impl tonic::IntoRequest<super::BatchDeleteChannelsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.ChannelService/BatchDelete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.video.v1.ChannelService",
                        "BatchDelete",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// List existing access bindings for the specified channel.
        pub async fn list_access_bindings(
            &mut self,
            request: impl tonic::IntoRequest<
                super::super::super::access::ListAccessBindingsRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::super::super::access::ListAccessBindingsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.ChannelService/ListAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.video.v1.ChannelService",
                        "ListAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Set access bindings for the channel.
        pub async fn set_access_bindings(
            &mut self,
            request: impl tonic::IntoRequest<
                super::super::super::access::SetAccessBindingsRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.ChannelService/SetAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.video.v1.ChannelService",
                        "SetAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Update access bindings for the specified channel.
        pub async fn update_access_bindings(
            &mut self,
            request: impl tonic::IntoRequest<
                super::super::super::access::UpdateAccessBindingsRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.ChannelService/UpdateAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.video.v1.ChannelService",
                        "UpdateAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Episode {
    /// ID of the episode.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the stream. Optional, empty if the episode is linked to the line
    #[prost(string, tag = "2")]
    pub stream_id: ::prost::alloc::string::String,
    /// ID of the line. Optional, empty if the episode is linked to the stream
    #[prost(string, tag = "3")]
    pub line_id: ::prost::alloc::string::String,
    /// Episode title.
    #[prost(string, tag = "4")]
    pub title: ::prost::alloc::string::String,
    /// Episode description.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
    /// ID of the thumbnail.
    #[prost(string, tag = "6")]
    pub thumbnail_id: ::prost::alloc::string::String,
    /// Episode start time.
    #[prost(message, optional, tag = "7")]
    pub start_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Episode finish time.
    #[prost(message, optional, tag = "8")]
    pub finish_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Enables episode DVR mode.
    /// Determines how many last seconds of the stream are available for watching.
    ///
    /// Possible values:
    ///   * `0`: infinite dvr size, the full length of the stream allowed to display
    ///   * `>0`: size of dvr window in seconds, the minimum value is 30s
    #[prost(int64, tag = "9")]
    pub dvr_seconds: i64,
    #[prost(enumeration = "episode::VisibilityStatus", tag = "10")]
    pub visibility_status: i32,
    /// Time when episode was created.
    #[prost(message, optional, tag = "100")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Time of last episode update.
    #[prost(message, optional, tag = "101")]
    pub updated_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Episode access rights.
    #[prost(oneof = "episode::AccessRights", tags = "1000, 1002, 1003")]
    pub access_rights: ::core::option::Option<episode::AccessRights>,
}
/// Nested message and enum types in `Episode`.
pub mod episode {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum VisibilityStatus {
        Unspecified = 0,
        Published = 1,
        Unpublished = 2,
    }
    impl VisibilityStatus {
        /// 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 {
                VisibilityStatus::Unspecified => "VISIBILITY_STATUS_UNSPECIFIED",
                VisibilityStatus::Published => "PUBLISHED",
                VisibilityStatus::Unpublished => "UNPUBLISHED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "VISIBILITY_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
                "PUBLISHED" => Some(Self::Published),
                "UNPUBLISHED" => Some(Self::Unpublished),
                _ => None,
            }
        }
    }
    /// Episode access rights.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum AccessRights {
        /// Episode is available to everyone.
        #[prost(message, tag = "1000")]
        PublicAccess(super::EpisodePublicAccessRights),
        /// Checking access rights using the authorization system.
        #[prost(message, tag = "1002")]
        AuthSystemAccess(super::EpisodeAuthSystemAccessRights),
        /// Checking access rights using url's signature.
        #[prost(message, tag = "1003")]
        SignUrlAccess(super::EpisodeSignUrlAccessRights),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EpisodePublicAccessRights {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EpisodeAuthSystemAccessRights {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EpisodeSignUrlAccessRights {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Manifest {
    #[prost(string, tag = "1")]
    pub url: ::prost::alloc::string::String,
    #[prost(enumeration = "manifest::ManifestType", tag = "2")]
    pub r#type: i32,
}
/// Nested message and enum types in `Manifest`.
pub mod manifest {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ManifestType {
        Unspecified = 0,
        Dash = 1,
        Hls = 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 {
                ManifestType::Unspecified => "MANIFEST_TYPE_UNSPECIFIED",
                ManifestType::Dash => "DASH",
                ManifestType::Hls => "HLS",
            }
        }
        /// 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),
                "DASH" => Some(Self::Dash),
                "HLS" => Some(Self::Hls),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetEpisodeRequest {
    /// ID of the episode.
    #[prost(string, tag = "1")]
    pub episode_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListEpisodesRequest {
    /// The maximum number of the results per page to return.
    /// Default value: 100.
    #[prost(int64, tag = "100")]
    pub page_size: i64,
    /// Page token for getting the next page of the result.
    #[prost(string, tag = "101")]
    pub page_token: ::prost::alloc::string::String,
    /// By which column the listing should be ordered and in which direction,
    /// format is "<field> <order>" (e.g. "createdAt desc").
    /// Default: "id asc".
    /// Possible fields: ["id", "createdAt", "updatedAt"].
    /// Both snake_case and camelCase are supported for fields.
    #[prost(string, tag = "102")]
    pub order_by: ::prost::alloc::string::String,
    /// Filter expression that filters resources listed in the response.
    /// Expressions are composed of terms connected by logic operators.
    /// If value contains spaces or quotes,
    /// it should be in quotes (`'` or `"`) with the inner quotes being backslash escaped.
    /// Example: "key1='value' AND key2='value'".
    /// Supported operators: ["AND", "OR"].
    /// Supported fields: ["id", "title"].
    /// Both snake_case and camelCase are supported for fields.
    #[prost(string, tag = "103")]
    pub filter: ::prost::alloc::string::String,
    #[prost(oneof = "list_episodes_request::ParentId", tags = "1, 2")]
    pub parent_id: ::core::option::Option<list_episodes_request::ParentId>,
}
/// Nested message and enum types in `ListEpisodesRequest`.
pub mod list_episodes_request {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum ParentId {
        /// ID of the stream.
        #[prost(string, tag = "1")]
        StreamId(::prost::alloc::string::String),
        /// ID of the line.
        #[prost(string, tag = "2")]
        LineId(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListEpisodesResponse {
    /// List of episodes for specific parent_id.
    #[prost(message, repeated, tag = "1")]
    pub episodes: ::prost::alloc::vec::Vec<Episode>,
    /// Token for getting the next page.
    #[prost(string, tag = "100")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchGetEpisodesRequest {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub channel_id: ::prost::alloc::string::String,
    /// List of requested episode IDs.
    #[prost(string, repeated, tag = "2")]
    pub episode_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchGetEpisodesResponse {
    /// List of episodes for specific channel.
    #[prost(message, repeated, tag = "1")]
    pub episodes: ::prost::alloc::vec::Vec<Episode>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateEpisodeRequest {
    /// Episode title.
    #[prost(string, tag = "2")]
    pub title: ::prost::alloc::string::String,
    /// Episode description.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// ID of the thumbnail.
    #[prost(string, tag = "4")]
    pub thumbnail_id: ::prost::alloc::string::String,
    /// Episode start time.
    #[prost(message, optional, tag = "5")]
    pub start_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Episode finish time.
    #[prost(message, optional, tag = "6")]
    pub finish_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Enables episode DVR mode.
    /// Determines how many last seconds of the stream are available.
    ///
    /// Possible values:
    ///   * `0`: infinite dvr size, the full length of the stream allowed to display
    ///   * `>0`: size of dvr window in seconds, the minimum value is 30s
    #[prost(int64, tag = "7")]
    pub dvr_seconds: i64,
    #[prost(oneof = "create_episode_request::ParentId", tags = "100, 101")]
    pub parent_id: ::core::option::Option<create_episode_request::ParentId>,
    /// Episode access rights.
    #[prost(oneof = "create_episode_request::AccessRights", tags = "1000, 1002, 1003")]
    pub access_rights: ::core::option::Option<create_episode_request::AccessRights>,
}
/// Nested message and enum types in `CreateEpisodeRequest`.
pub mod create_episode_request {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum ParentId {
        /// ID of the stream.
        #[prost(string, tag = "100")]
        StreamId(::prost::alloc::string::String),
        /// ID of the line.
        #[prost(string, tag = "101")]
        LineId(::prost::alloc::string::String),
    }
    /// Episode access rights.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum AccessRights {
        /// Episode is available to everyone.
        #[prost(message, tag = "1000")]
        PublicAccess(super::EpisodePublicAccessParams),
        /// Checking access rights using the authorization system.
        #[prost(message, tag = "1002")]
        AuthSystemAccess(super::EpisodeAuthSystemAccessParams),
        /// Checking access rights using url's signature.
        #[prost(message, tag = "1003")]
        SignUrlAccess(super::EpisodeSignUrlAccessParams),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EpisodePublicAccessParams {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EpisodeAuthSystemAccessParams {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EpisodeSignUrlAccessParams {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateEpisodeMetadata {
    /// ID of the episode.
    #[prost(string, tag = "1")]
    pub episode_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateEpisodeRequest {
    /// ID of the episode.
    #[prost(string, tag = "1")]
    pub episode_id: ::prost::alloc::string::String,
    /// Field mask that specifies which fields of the episode are going to be updated.
    #[prost(message, optional, tag = "2")]
    pub field_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Episode title.
    #[prost(string, tag = "3")]
    pub title: ::prost::alloc::string::String,
    /// Episode description.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// ID of the thumbnail.
    #[prost(string, tag = "5")]
    pub thumbnail_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "6")]
    pub start_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Episode finish time.
    #[prost(message, optional, tag = "7")]
    pub finish_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Enables episode DVR mode.
    /// Determines how many last seconds of the stream are available.
    ///
    /// Possible values:
    ///   * `0`: infinite dvr size, the full length of the stream allowed to display
    ///   * `>0`: size of dvr window in seconds, the minimum value is 30s
    #[prost(int64, tag = "8")]
    pub dvr_seconds: i64,
    /// Episode access rights.
    #[prost(oneof = "update_episode_request::AccessRights", tags = "1000, 1002, 1003")]
    pub access_rights: ::core::option::Option<update_episode_request::AccessRights>,
}
/// Nested message and enum types in `UpdateEpisodeRequest`.
pub mod update_episode_request {
    /// Episode access rights.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum AccessRights {
        /// Episode is available to everyone.
        #[prost(message, tag = "1000")]
        PublicAccess(super::EpisodePublicAccessParams),
        /// Checking access rights using the authorization system.
        #[prost(message, tag = "1002")]
        AuthSystemAccess(super::EpisodeAuthSystemAccessParams),
        /// Checking access rights using url's signature.
        #[prost(message, tag = "1003")]
        SignUrlAccess(super::EpisodeSignUrlAccessParams),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateEpisodeMetadata {
    /// ID of the episode.
    #[prost(string, tag = "1")]
    pub episode_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteEpisodeRequest {
    /// ID of the episode.
    #[prost(string, tag = "1")]
    pub episode_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteEpisodeMetadata {
    /// ID of the episode.
    #[prost(string, tag = "1")]
    pub episode_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchDeleteEpisodesRequest {
    #[prost(string, repeated, tag = "1")]
    pub episode_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(oneof = "batch_delete_episodes_request::Id", tags = "100, 101")]
    pub id: ::core::option::Option<batch_delete_episodes_request::Id>,
}
/// Nested message and enum types in `BatchDeleteEpisodesRequest`.
pub mod batch_delete_episodes_request {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Id {
        /// ID of the stream.
        #[prost(string, tag = "100")]
        StreamId(::prost::alloc::string::String),
        /// ID of the line.
        #[prost(string, tag = "101")]
        LineId(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchDeleteEpisodesMetadata {
    #[prost(string, repeated, tag = "1")]
    pub episode_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PerformEpisodeActionRequest {
    /// ID of the episode.
    #[prost(string, tag = "1")]
    pub episode_id: ::prost::alloc::string::String,
    #[prost(oneof = "perform_episode_action_request::Action", tags = "1002, 1003")]
    pub action: ::core::option::Option<perform_episode_action_request::Action>,
}
/// Nested message and enum types in `PerformEpisodeActionRequest`.
pub mod perform_episode_action_request {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Action {
        #[prost(message, tag = "1002")]
        Publish(super::PublishEpisodeAction),
        #[prost(message, tag = "1003")]
        Unpublish(super::UnpublishEpisodeAction),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PublishEpisodeAction {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UnpublishEpisodeAction {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PerformEpisodeActionMetadata {
    /// ID of the episode.
    #[prost(string, tag = "1")]
    pub episode_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetEpisodePlayerUrlRequest {
    /// ID of the episode.
    #[prost(string, tag = "1")]
    pub episode_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub params: ::core::option::Option<EpisodePlayerParams>,
    /// Optional field, used to set custom url expiration duration for episodes with sign_url_access
    #[prost(message, optional, tag = "3")]
    pub signed_url_expiration_duration: ::core::option::Option<::prost_types::Duration>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EpisodePlayerParams {
    /// If true, a player will be muted by default.
    #[prost(bool, tag = "1")]
    pub mute: bool,
    /// If true, playback will start automatically.
    #[prost(bool, tag = "2")]
    pub autoplay: bool,
    /// If true, a player interface will be hidden by default.
    #[prost(bool, tag = "3")]
    pub hidden: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetEpisodePlayerUrlResponse {
    /// Direct link to the episode.
    #[prost(string, tag = "1")]
    pub player_url: ::prost::alloc::string::String,
    /// HTML embed code in Iframe format.
    #[prost(string, tag = "2")]
    pub html: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetEpisodeManifestsRequest {
    /// ID of the episode.
    #[prost(string, tag = "1")]
    pub episode_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetEpisodeManifestsResponse {
    #[prost(message, repeated, tag = "1")]
    pub manifests: ::prost::alloc::vec::Vec<Manifest>,
}
/// Generated client implementations.
pub mod episode_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Episode management service.
    #[derive(Debug, Clone)]
    pub struct EpisodeServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl EpisodeServiceClient<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> EpisodeServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> EpisodeServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            EpisodeServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Get the specific channel.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetEpisodeRequest>,
        ) -> std::result::Result<tonic::Response<super::Episode>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.EpisodeService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.video.v1.EpisodeService", "Get"));
            self.inner.unary(req, path, codec).await
        }
        /// List episodes for stream or line.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListEpisodesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListEpisodesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.EpisodeService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.video.v1.EpisodeService", "List"));
            self.inner.unary(req, path, codec).await
        }
        /// Batch get episodes for channel.
        pub async fn batch_get(
            &mut self,
            request: impl tonic::IntoRequest<super::BatchGetEpisodesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::BatchGetEpisodesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.EpisodeService/BatchGet",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.EpisodeService", "BatchGet"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Create episode.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateEpisodeRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.EpisodeService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.EpisodeService", "Create"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Update episode.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateEpisodeRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.EpisodeService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.EpisodeService", "Update"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Delete episode.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteEpisodeRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.EpisodeService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.EpisodeService", "Delete"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Batch delete episodes.
        pub async fn batch_delete(
            &mut self,
            request: impl tonic::IntoRequest<super::BatchDeleteEpisodesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.EpisodeService/BatchDelete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.video.v1.EpisodeService",
                        "BatchDelete",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Perform an action on the episode.
        pub async fn perform_action(
            &mut self,
            request: impl tonic::IntoRequest<super::PerformEpisodeActionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.EpisodeService/PerformAction",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.video.v1.EpisodeService",
                        "PerformAction",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get player url.
        pub async fn get_player_url(
            &mut self,
            request: impl tonic::IntoRequest<super::GetEpisodePlayerUrlRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetEpisodePlayerUrlResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.EpisodeService/GetPlayerURL",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.video.v1.EpisodeService",
                        "GetPlayerURL",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get manifest urls.
        pub async fn get_manifests(
            &mut self,
            request: impl tonic::IntoRequest<super::GetEpisodeManifestsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetEpisodeManifestsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.EpisodeService/GetManifests",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.video.v1.EpisodeService",
                        "GetManifests",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Entity representing an ordered list of videos or episodes.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Playlist {
    /// ID of the playlist.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the channel to create the playlist in.
    #[prost(string, tag = "2")]
    pub channel_id: ::prost::alloc::string::String,
    /// Playlist title.
    #[prost(string, tag = "3")]
    pub title: ::prost::alloc::string::String,
    /// Playlist description.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// List of playlist items.
    #[prost(message, repeated, tag = "5")]
    pub items: ::prost::alloc::vec::Vec<PlaylistItem>,
    /// Time when playlist was created.
    #[prost(message, optional, tag = "100")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Time of last playlist update.
    #[prost(message, optional, tag = "101")]
    pub updated_at: ::core::option::Option<::prost_types::Timestamp>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PlaylistItem {
    /// Item position (zero-indexed).
    #[prost(int64, tag = "1")]
    pub position: i64,
    #[prost(oneof = "playlist_item::Id", tags = "100, 101")]
    pub id: ::core::option::Option<playlist_item::Id>,
}
/// Nested message and enum types in `PlaylistItem`.
pub mod playlist_item {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Id {
        /// ID of the video.
        #[prost(string, tag = "100")]
        VideoId(::prost::alloc::string::String),
        /// ID of the episode.
        #[prost(string, tag = "101")]
        EpisodeId(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetPlaylistRequest {
    /// ID of the playlist.
    #[prost(string, tag = "1")]
    pub playlist_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListPlaylistsRequest {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub channel_id: ::prost::alloc::string::String,
    /// The maximum number of the results per page to return.
    /// Default value: 100.
    #[prost(int64, tag = "100")]
    pub page_size: i64,
    /// Page token for getting the next page of the result.
    #[prost(string, tag = "101")]
    pub page_token: ::prost::alloc::string::String,
    /// By which column the listing should be ordered and in which direction,
    /// format is "<field> <order>" (e.g. "createdAt desc").
    /// Default: "id asc".
    /// Possible fields: ["id", "title", "createdAt", "updatedAt"].
    /// Both snake_case and camelCase are supported for fields.
    #[prost(string, tag = "102")]
    pub order_by: ::prost::alloc::string::String,
    /// Filter expression that filters resources listed in the response.
    /// Expressions are composed of terms connected by logic operators.
    /// If value contains spaces or quotes,
    /// it should be in quotes (`'` or `"`) with the inner quotes being backslash escaped.
    /// Example: "key1='value' AND key2='value'".
    /// Supported operators: ["AND", "OR"].
    /// Supported fields: ["id", "title"].
    /// Both snake_case and camelCase are supported for fields.
    #[prost(string, tag = "103")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListPlaylistsResponse {
    /// List of playlists for specific channel.
    #[prost(message, repeated, tag = "1")]
    pub playlists: ::prost::alloc::vec::Vec<Playlist>,
    /// Token for getting the next page.
    #[prost(string, tag = "100")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreatePlaylistRequest {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub channel_id: ::prost::alloc::string::String,
    /// Playlist title.
    #[prost(string, tag = "2")]
    pub title: ::prost::alloc::string::String,
    /// Playlist description.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// List of playlist items.
    #[prost(message, repeated, tag = "4")]
    pub items: ::prost::alloc::vec::Vec<PlaylistItem>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreatePlaylistMetadata {
    /// ID of the playlist.
    #[prost(string, tag = "1")]
    pub playlist_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdatePlaylistRequest {
    /// ID of the playlist.
    #[prost(string, tag = "1")]
    pub playlist_id: ::prost::alloc::string::String,
    /// Field mask that specifies which fields of the playlist are going to be updated.
    #[prost(message, optional, tag = "2")]
    pub field_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Playlist title.
    #[prost(string, tag = "3")]
    pub title: ::prost::alloc::string::String,
    /// Playlist description.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// List of playlist items.
    #[prost(message, repeated, tag = "5")]
    pub items: ::prost::alloc::vec::Vec<PlaylistItem>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdatePlaylistMetadata {
    /// ID of the playlist.
    #[prost(string, tag = "1")]
    pub playlist_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeletePlaylistRequest {
    /// ID of the playlist.
    #[prost(string, tag = "1")]
    pub playlist_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeletePlaylistMetadata {
    /// ID of the playlist.
    #[prost(string, tag = "1")]
    pub playlist_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchDeletePlaylistsRequest {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub channel_id: ::prost::alloc::string::String,
    /// List of playlist IDs.
    #[prost(string, repeated, tag = "2")]
    pub playlist_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchDeletePlaylistsMetadata {
    /// List of playlist IDs.
    #[prost(string, repeated, tag = "1")]
    pub playlist_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetPlaylistPlayerUrlRequest {
    /// ID of the playlist.
    #[prost(string, tag = "1")]
    pub playlist_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub params: ::core::option::Option<PlaylistPlayerParams>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PlaylistPlayerParams {
    /// If true, a player will be muted by default.
    #[prost(bool, tag = "1")]
    pub mute: bool,
    /// If true, playback will start automatically.
    #[prost(bool, tag = "2")]
    pub autoplay: bool,
    /// If true, a player interface will be hidden by default.
    #[prost(bool, tag = "3")]
    pub hidden: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetPlaylistPlayerUrlResponse {
    /// Direct link to the playlist.
    #[prost(string, tag = "1")]
    pub player_url: ::prost::alloc::string::String,
    /// HTML embed code in Iframe format.
    #[prost(string, tag = "2")]
    pub html: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod playlist_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Playlist management service.
    #[derive(Debug, Clone)]
    pub struct PlaylistServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl PlaylistServiceClient<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> PlaylistServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> PlaylistServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            PlaylistServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Get the specific playlist.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetPlaylistRequest>,
        ) -> std::result::Result<tonic::Response<super::Playlist>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.PlaylistService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.video.v1.PlaylistService", "Get"));
            self.inner.unary(req, path, codec).await
        }
        /// List playlists for a channel.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListPlaylistsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListPlaylistsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.PlaylistService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.PlaylistService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Create playlist.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreatePlaylistRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.PlaylistService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.PlaylistService", "Create"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Update playlist.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdatePlaylistRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.PlaylistService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.PlaylistService", "Update"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Delete playlist.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeletePlaylistRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.PlaylistService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.PlaylistService", "Delete"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Batch delete playlists.
        pub async fn batch_delete(
            &mut self,
            request: impl tonic::IntoRequest<super::BatchDeletePlaylistsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.PlaylistService/BatchDelete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.video.v1.PlaylistService",
                        "BatchDelete",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get player url.
        pub async fn get_player_url(
            &mut self,
            request: impl tonic::IntoRequest<super::GetPlaylistPlayerUrlRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetPlaylistPlayerUrlResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.PlaylistService/GetPlayerURL",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.video.v1.PlaylistService",
                        "GetPlayerURL",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Stream {
    /// ID of the stream.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the channel where the stream was created.
    #[prost(string, tag = "2")]
    pub channel_id: ::prost::alloc::string::String,
    /// ID of the line to which stream is linked.
    #[prost(string, tag = "3")]
    pub line_id: ::prost::alloc::string::String,
    /// Stream title.
    #[prost(string, tag = "4")]
    pub title: ::prost::alloc::string::String,
    /// Stream description.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
    /// ID of the thumbnail.
    #[prost(string, tag = "6")]
    pub thumbnail_id: ::prost::alloc::string::String,
    /// Stream status.
    #[prost(enumeration = "stream::StreamStatus", tag = "8")]
    pub status: i32,
    /// Stream start time.
    #[prost(message, optional, tag = "9")]
    pub start_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Stream publish time. Time when stream switched to ONAIR status.
    #[prost(message, optional, tag = "10")]
    pub publish_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Stream finish time.
    #[prost(message, optional, tag = "11")]
    pub finish_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Automatically publish stream when ready.
    /// Switches status from READY to ONAIR.
    #[prost(message, optional, tag = "12")]
    pub auto_publish: ::core::option::Option<bool>,
    /// Time when stream was created.
    #[prost(message, optional, tag = "100")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Time of last stream update.
    #[prost(message, optional, tag = "101")]
    pub updated_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Custom labels as `` key:value `` pairs. Maximum 64 per resource.
    #[prost(map = "string, string", tag = "200")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Stream type.
    #[prost(oneof = "stream::StreamType", tags = "1000, 1001")]
    pub stream_type: ::core::option::Option<stream::StreamType>,
}
/// Nested message and enum types in `Stream`.
pub mod stream {
    /// Stream status.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum StreamStatus {
        /// Stream status unspecified.
        Unspecified = 0,
        /// Stream offline.
        Offline = 1,
        /// Preparing the infrastructure for receiving video signal.
        Preparing = 2,
        /// Everything is ready to launch stream.
        Ready = 3,
        /// Stream onair.
        Onair = 4,
        /// Stream finished.
        Finished = 5,
    }
    impl StreamStatus {
        /// 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 {
                StreamStatus::Unspecified => "STREAM_STATUS_UNSPECIFIED",
                StreamStatus::Offline => "OFFLINE",
                StreamStatus::Preparing => "PREPARING",
                StreamStatus::Ready => "READY",
                StreamStatus::Onair => "ONAIR",
                StreamStatus::Finished => "FINISHED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STREAM_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
                "OFFLINE" => Some(Self::Offline),
                "PREPARING" => Some(Self::Preparing),
                "READY" => Some(Self::Ready),
                "ONAIR" => Some(Self::Onair),
                "FINISHED" => Some(Self::Finished),
                _ => None,
            }
        }
    }
    /// Stream type.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum StreamType {
        /// On-demand stream. Starts immediately when a signal appears.
        #[prost(message, tag = "1000")]
        OnDemand(super::OnDemand),
        /// Schedule stream. Starts or finished at the specified time.
        #[prost(message, tag = "1001")]
        Schedule(super::Schedule),
    }
}
/// On-demand stream type.
/// This type of streams should be started and finished explicitly.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OnDemand {}
/// Schedule stream type.
/// This type of streams start and finish automatically at the specified time.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Schedule {
    #[prost(message, optional, tag = "1")]
    pub start_time: ::core::option::Option<::prost_types::Timestamp>,
    #[prost(message, optional, tag = "2")]
    pub finish_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Entity that is responsible for the incoming video signal settings.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StreamLine {
    /// ID of the line.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the channel to which this stream line belongs.
    #[prost(string, tag = "2")]
    pub channel_id: ::prost::alloc::string::String,
    /// Title of the stream line.
    #[prost(string, tag = "3")]
    pub title: ::prost::alloc::string::String,
    /// ID of the thumbnail image associated with the stream line..
    #[prost(string, tag = "4")]
    pub thumbnail_id: ::prost::alloc::string::String,
    /// Time when the stream line was created.
    #[prost(message, optional, tag = "100")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Time when the stream line was last updated.
    #[prost(message, optional, tag = "101")]
    pub updated_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Custom labels as `` key:value `` pairs. Maximum 64 per resource.
    #[prost(map = "string, string", tag = "200")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Specifies the input type and settings for the video signal source.
    #[prost(oneof = "stream_line::InputType", tags = "1000, 1002")]
    pub input_type: ::core::option::Option<stream_line::InputType>,
    /// Specifies the control type of the stream line.
    #[prost(oneof = "stream_line::LineType", tags = "2000, 2001")]
    pub line_type: ::core::option::Option<stream_line::LineType>,
}
/// Nested message and enum types in `StreamLine`.
pub mod stream_line {
    /// Specifies the input type and settings for the video signal source.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum InputType {
        /// Real-Time Messaging Protocol (RTMP) push input settings.
        #[prost(message, tag = "1000")]
        RtmpPush(super::RtmpPushInput),
        /// Real-Time Messaging Protocol (RTMP) pull input type.
        #[prost(message, tag = "1002")]
        RtmpPull(super::RtmpPullInput),
    }
    /// Specifies the control type of the stream line.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum LineType {
        /// Manual control of stream.
        #[prost(message, tag = "2000")]
        ManualLine(super::ManualLine),
        /// Automatic control of stream.
        #[prost(message, tag = "2001")]
        AutoLine(super::AutoLine),
    }
}
/// Represents the stream key used for pushing video streams.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PushStreamKey {
    /// The unique stream key.
    #[prost(string, tag = "1")]
    pub key: ::prost::alloc::string::String,
}
/// Settings for an RTMP (Real-Time Messaging Protocol) push input.
/// Used when the video stream is pushed to an RTMP server.
/// @see <https://en.wikipedia.org/wiki/Real-Time_Messaging_Protocol>
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RtmpPushInput {
    /// RTMP server url.
    #[prost(string, tag = "1")]
    pub url: ::prost::alloc::string::String,
}
/// Settings for an RTMP pull input.
/// Used when the service pulls the video stream from an RTMP source.
/// @see <https://en.wikipedia.org/wiki/Real-Time_Messaging_Protocol>
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RtmpPullInput {
    /// RTMP url for receiving video signal.
    #[prost(string, tag = "1")]
    pub url: ::prost::alloc::string::String,
}
/// Represents a manual line type where the stream control is handled manually.
/// This means that stream start/stop actions are performed by the user.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ManualLine {}
/// Represents an automatic line type where the stream control is handled automatically.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AutoLine {
    /// The status of the automatic line.
    #[prost(enumeration = "auto_line::AutoLineStatus", tag = "1")]
    pub status: i32,
}
/// Nested message and enum types in `AutoLine`.
pub mod auto_line {
    /// Enum representing the status of an automatic stream line.
    /// Indicates whether the automatic line is active or deactivated.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum AutoLineStatus {
        /// Auto line status unspecified.
        Unspecified = 0,
        /// The automatic line is deactivated and not currently active.
        Deactivated = 1,
        /// The automatic line is active and operational.
        Active = 2,
    }
    impl AutoLineStatus {
        /// 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 {
                AutoLineStatus::Unspecified => "AUTO_LINE_STATUS_UNSPECIFIED",
                AutoLineStatus::Deactivated => "DEACTIVATED",
                AutoLineStatus::Active => "ACTIVE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "AUTO_LINE_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
                "DEACTIVATED" => Some(Self::Deactivated),
                "ACTIVE" => Some(Self::Active),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetStreamLineRequest {
    /// ID of the line.
    #[prost(string, tag = "1")]
    pub stream_line_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListStreamLinesRequest {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub channel_id: ::prost::alloc::string::String,
    /// The maximum number of the results per page to return.
    /// Default value: 100.
    #[prost(int64, tag = "100")]
    pub page_size: i64,
    /// Page token for getting the next page of the result.
    #[prost(string, tag = "101")]
    pub page_token: ::prost::alloc::string::String,
    /// By which column the listing should be ordered and in which direction,
    /// format is "<field> <order>" (e.g. "createdAt desc").
    /// Default: "id asc".
    /// Possible fields: ["id", "title", "createdAt", "updatedAt"].
    /// Both snake_case and camelCase are supported for fields.
    #[prost(string, tag = "102")]
    pub order_by: ::prost::alloc::string::String,
    /// Filter expression that filters resources listed in the response.
    /// Expressions are composed of terms connected by logic operators.
    /// If value contains spaces or quotes,
    /// it should be in quotes (`'` or `"`) with the inner quotes being backslash escaped.
    /// Example: "key1='value' AND key2='value'".
    /// Supported operators: ["AND", "OR"].
    /// Supported fields: ["id", "title"].
    /// Both snake_case and camelCase are supported for fields.
    #[prost(string, tag = "103")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListStreamLinesResponse {
    /// List of lines for channel.
    #[prost(message, repeated, tag = "1")]
    pub stream_lines: ::prost::alloc::vec::Vec<StreamLine>,
    /// Token for getting the next page.
    #[prost(string, tag = "100")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchGetStreamLinesRequest {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub channel_id: ::prost::alloc::string::String,
    /// List of requested stream line IDs.
    #[prost(string, repeated, tag = "2")]
    pub stream_line_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchGetStreamLinesResponse {
    /// List of lines for specific channel.
    #[prost(message, repeated, tag = "1")]
    pub stream_lines: ::prost::alloc::vec::Vec<StreamLine>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateStreamLineRequest {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub channel_id: ::prost::alloc::string::String,
    /// Line title.
    #[prost(string, tag = "2")]
    pub title: ::prost::alloc::string::String,
    /// ID of the thumbnail.
    #[prost(string, tag = "3")]
    pub thumbnail_id: ::prost::alloc::string::String,
    /// Custom labels as `` key:value `` pairs. Maximum 64 per resource.
    #[prost(map = "string, string", tag = "200")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Video signal settings.
    #[prost(oneof = "create_stream_line_request::InputParams", tags = "1000, 1002")]
    pub input_params: ::core::option::Option<create_stream_line_request::InputParams>,
    /// Line type.
    #[prost(oneof = "create_stream_line_request::LineTypeParams", tags = "2000, 2001")]
    pub line_type_params: ::core::option::Option<
        create_stream_line_request::LineTypeParams,
    >,
}
/// Nested message and enum types in `CreateStreamLineRequest`.
pub mod create_stream_line_request {
    /// Video signal settings.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum InputParams {
        /// RTMP push input type.
        #[prost(message, tag = "1000")]
        RtmpPush(super::RtmpPushParams),
        /// RTMP pull input type.
        #[prost(message, tag = "1002")]
        RtmpPull(super::RtmpPullParams),
    }
    /// Line type.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum LineTypeParams {
        /// Manual control of stream.
        #[prost(message, tag = "2000")]
        ManualLine(super::ManualLineParams),
        /// Automatic control of stream.
        #[prost(message, tag = "2001")]
        AutoLine(super::AutoLineParams),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateStreamLineMetadata {
    /// ID of the line.
    #[prost(string, tag = "1")]
    pub stream_line_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateStreamLineRequest {
    /// ID of the line.
    #[prost(string, tag = "1")]
    pub stream_line_id: ::prost::alloc::string::String,
    /// Field mask that specifies which fields of the line are going to be updated.
    #[prost(message, optional, tag = "2")]
    pub field_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Line title.
    #[prost(string, tag = "3")]
    pub title: ::prost::alloc::string::String,
    /// ID of the thumbnail.
    #[prost(string, tag = "4")]
    pub thumbnail_id: ::prost::alloc::string::String,
    /// Custom labels as `` key:value `` pairs. Maximum 64 per resource.
    #[prost(map = "string, string", tag = "200")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Video signal settings.
    #[prost(oneof = "update_stream_line_request::InputParams", tags = "1000, 1002")]
    pub input_params: ::core::option::Option<update_stream_line_request::InputParams>,
}
/// Nested message and enum types in `UpdateStreamLineRequest`.
pub mod update_stream_line_request {
    /// Video signal settings.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum InputParams {
        /// RTMP push input type.
        #[prost(message, tag = "1000")]
        RtmpPush(super::RtmpPushParams),
        /// RTMP pull input type.
        #[prost(message, tag = "1002")]
        RtmpPull(super::RtmpPullParams),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateStreamLineMetadata {
    /// ID of the line.
    #[prost(string, tag = "1")]
    pub stream_line_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteStreamLineRequest {
    /// ID of the line.
    #[prost(string, tag = "1")]
    pub stream_line_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteStreamLineMetadata {
    /// ID of the line.
    #[prost(string, tag = "1")]
    pub stream_line_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchDeleteStreamLinesRequest {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub channel_id: ::prost::alloc::string::String,
    /// List of line IDs.
    #[prost(string, repeated, tag = "2")]
    pub stream_line_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchDeleteStreamLinesMetadata {
    /// List of line IDs.
    #[prost(string, repeated, tag = "1")]
    pub stream_line_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PerformLineActionRequest {
    /// ID of the line.
    #[prost(string, tag = "1")]
    pub stream_line_id: ::prost::alloc::string::String,
    #[prost(oneof = "perform_line_action_request::Action", tags = "1000, 1001")]
    pub action: ::core::option::Option<perform_line_action_request::Action>,
}
/// Nested message and enum types in `PerformLineActionRequest`.
pub mod perform_line_action_request {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Action {
        #[prost(message, tag = "1000")]
        Activate(super::ActivateAction),
        #[prost(message, tag = "1001")]
        Deactivate(super::DeactivateAction),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PerformLineActionMetadata {
    /// ID of the line.
    #[prost(string, tag = "1")]
    pub stream_line_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RtmpPushParams {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RtmpPullParams {
    /// URL of a RTMP streaming server.
    #[prost(string, tag = "1")]
    pub url: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ManualLineParams {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AutoLineParams {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ActivateAction {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeactivateAction {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetStreamKeyRequest {
    /// ID of the line.
    #[prost(string, tag = "1")]
    pub stream_line_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateStreamKeyRequest {
    /// ID of the line.
    #[prost(string, tag = "1")]
    pub stream_line_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateStreamKeyMetadata {
    /// ID of the line.
    #[prost(string, tag = "1")]
    pub stream_line_id: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod stream_line_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Stream line management service.
    #[derive(Debug, Clone)]
    pub struct StreamLineServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl StreamLineServiceClient<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> StreamLineServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> StreamLineServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            StreamLineServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Get the specific stream line.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetStreamLineRequest>,
        ) -> std::result::Result<tonic::Response<super::StreamLine>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.StreamLineService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.StreamLineService", "Get"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// List lines for channel.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListStreamLinesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListStreamLinesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.StreamLineService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.StreamLineService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Batch get lines for channel.
        pub async fn batch_get(
            &mut self,
            request: impl tonic::IntoRequest<super::BatchGetStreamLinesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::BatchGetStreamLinesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.StreamLineService/BatchGet",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.video.v1.StreamLineService",
                        "BatchGet",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Create stream line.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateStreamLineRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.StreamLineService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.StreamLineService", "Create"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Update stream line.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateStreamLineRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.StreamLineService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.StreamLineService", "Update"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Delete stream line.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteStreamLineRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.StreamLineService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.StreamLineService", "Delete"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Batch delete stream lines.
        pub async fn batch_delete(
            &mut self,
            request: impl tonic::IntoRequest<super::BatchDeleteStreamLinesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.StreamLineService/BatchDelete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.video.v1.StreamLineService",
                        "BatchDelete",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Perform an action on the line.
        pub async fn perform_action(
            &mut self,
            request: impl tonic::IntoRequest<super::PerformLineActionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.StreamLineService/PerformAction",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.video.v1.StreamLineService",
                        "PerformAction",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get unique stream key.
        pub async fn get_stream_key(
            &mut self,
            request: impl tonic::IntoRequest<super::GetStreamKeyRequest>,
        ) -> std::result::Result<tonic::Response<super::PushStreamKey>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.StreamLineService/GetStreamKey",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.video.v1.StreamLineService",
                        "GetStreamKey",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Update stream key.
        pub async fn update_stream_key(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateStreamKeyRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.StreamLineService/UpdateStreamKey",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.video.v1.StreamLineService",
                        "UpdateStreamKey",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetStreamRequest {
    /// ID of the stream.
    #[prost(string, tag = "1")]
    pub stream_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListStreamsRequest {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub channel_id: ::prost::alloc::string::String,
    /// The maximum number of the results per page to return.
    /// Default value: 100.
    #[prost(int64, tag = "100")]
    pub page_size: i64,
    /// Page token for getting the next page of the result.
    #[prost(string, tag = "101")]
    pub page_token: ::prost::alloc::string::String,
    /// By which column the listing should be ordered and in which direction,
    /// format is "<field> <order>" (e.g. "createdAt desc").
    /// Default: "id asc".
    /// Possible fields: ["id", "title", "startTime", "finishTime", "createdAt", "updatedAt"].
    /// Both snake_case and camelCase are supported for fields.
    #[prost(string, tag = "102")]
    pub order_by: ::prost::alloc::string::String,
    /// Filter expression that filters resources listed in the response.
    /// Expressions are composed of terms connected by logic operators.
    /// If value contains spaces or quotes,
    /// it should be in quotes (`'` or `"`) with the inner quotes being backslash escaped.
    /// Example: "key1='value' AND key2='value'".
    /// Supported operators: ["AND", "OR"].
    /// Supported fields: ["id", "title", "lineId", "status"].
    /// Both snake_case and camelCase are supported for fields.
    #[prost(string, tag = "103")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListStreamsResponse {
    /// List of streams for channel.
    #[prost(message, repeated, tag = "1")]
    pub streams: ::prost::alloc::vec::Vec<Stream>,
    /// Token for getting the next page.
    #[prost(string, tag = "100")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchGetStreamsRequest {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub channel_id: ::prost::alloc::string::String,
    /// List of requested stream IDs.
    #[prost(string, repeated, tag = "2")]
    pub stream_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchGetStreamsResponse {
    /// List of streams for specific channel.
    #[prost(message, repeated, tag = "1")]
    pub streams: ::prost::alloc::vec::Vec<Stream>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateStreamRequest {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub channel_id: ::prost::alloc::string::String,
    /// ID of the line.
    #[prost(string, tag = "2")]
    pub line_id: ::prost::alloc::string::String,
    /// Stream title.
    #[prost(string, tag = "3")]
    pub title: ::prost::alloc::string::String,
    /// Stream description.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// ID of the thumbnail.
    #[prost(string, tag = "5")]
    pub thumbnail_id: ::prost::alloc::string::String,
    /// Automatically publish stream when ready.
    /// Switches status from READY to ONAIR.
    #[prost(message, optional, tag = "6")]
    pub auto_publish: ::core::option::Option<bool>,
    /// Custom labels as `` key:value `` pairs. Maximum 64 per resource.
    #[prost(map = "string, string", tag = "200")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Stream type.
    #[prost(oneof = "create_stream_request::StreamType", tags = "1000, 1001")]
    pub stream_type: ::core::option::Option<create_stream_request::StreamType>,
}
/// Nested message and enum types in `CreateStreamRequest`.
pub mod create_stream_request {
    /// Stream type.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum StreamType {
        /// On-demand stream. Starts immediately when a signal appears.
        #[prost(message, tag = "1000")]
        OnDemand(super::OnDemandParams),
        /// Schedule stream. Starts or finishes at the specified time.
        #[prost(message, tag = "1001")]
        Schedule(super::ScheduleParams),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OnDemandParams {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ScheduleParams {
    #[prost(message, optional, tag = "1")]
    pub start_time: ::core::option::Option<::prost_types::Timestamp>,
    #[prost(message, optional, tag = "2")]
    pub finish_time: ::core::option::Option<::prost_types::Timestamp>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateStreamMetadata {
    /// ID of the stream.
    #[prost(string, tag = "1")]
    pub stream_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateStreamRequest {
    /// ID of the stream.
    #[prost(string, tag = "1")]
    pub stream_id: ::prost::alloc::string::String,
    /// Field mask that specifies which fields of the stream are going to be updated.
    #[prost(message, optional, tag = "2")]
    pub field_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// ID of the line.
    #[prost(string, tag = "3")]
    pub line_id: ::prost::alloc::string::String,
    /// Stream title.
    #[prost(string, tag = "4")]
    pub title: ::prost::alloc::string::String,
    /// Stream description.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
    /// ID of the thumbnail.
    #[prost(string, tag = "6")]
    pub thumbnail_id: ::prost::alloc::string::String,
    /// Automatically publish stream when ready.
    /// Switches status from READY to ONAIR.
    #[prost(message, optional, tag = "7")]
    pub auto_publish: ::core::option::Option<bool>,
    /// Custom labels as `` key:value `` pairs. Maximum 64 per resource.
    #[prost(map = "string, string", tag = "200")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Stream type.
    #[prost(oneof = "update_stream_request::StreamType", tags = "1000, 1001")]
    pub stream_type: ::core::option::Option<update_stream_request::StreamType>,
}
/// Nested message and enum types in `UpdateStreamRequest`.
pub mod update_stream_request {
    /// Stream type.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum StreamType {
        /// On demand stream. It starts immediately when a signal appears.
        #[prost(message, tag = "1000")]
        OnDemand(super::OnDemandParams),
        /// Schedule stream. Determines when to start receiving the signal or finish time.
        #[prost(message, tag = "1001")]
        Schedule(super::ScheduleParams),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateStreamMetadata {
    /// ID of the stream.
    #[prost(string, tag = "1")]
    pub stream_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteStreamRequest {
    /// ID of the stream.
    #[prost(string, tag = "1")]
    pub stream_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteStreamMetadata {
    /// ID of the stream.
    #[prost(string, tag = "1")]
    pub stream_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchDeleteStreamsRequest {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub channel_id: ::prost::alloc::string::String,
    /// List of stream IDs.
    #[prost(string, repeated, tag = "2")]
    pub stream_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchDeleteStreamsMetadata {
    /// List of stream IDs.
    #[prost(string, repeated, tag = "1")]
    pub stream_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PerformStreamActionRequest {
    /// ID of the stream.
    #[prost(string, tag = "1")]
    pub stream_id: ::prost::alloc::string::String,
    #[prost(oneof = "perform_stream_action_request::Action", tags = "1000, 1002")]
    pub action: ::core::option::Option<perform_stream_action_request::Action>,
}
/// Nested message and enum types in `PerformStreamActionRequest`.
pub mod perform_stream_action_request {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Action {
        #[prost(message, tag = "1000")]
        Publish(super::PublishAction),
        #[prost(message, tag = "1002")]
        Stop(super::StopAction),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PublishAction {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StopAction {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PerformStreamActionMetadata {
    /// ID of the stream.
    #[prost(string, tag = "1")]
    pub stream_id: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod stream_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Stream management service.
    #[derive(Debug, Clone)]
    pub struct StreamServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl StreamServiceClient<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> StreamServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> StreamServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            StreamServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Get the specific stream.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetStreamRequest>,
        ) -> std::result::Result<tonic::Response<super::Stream>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.StreamService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.video.v1.StreamService", "Get"));
            self.inner.unary(req, path, codec).await
        }
        /// List streams for channel.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListStreamsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListStreamsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.StreamService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.video.v1.StreamService", "List"));
            self.inner.unary(req, path, codec).await
        }
        /// Batch get streams for channel.
        pub async fn batch_get(
            &mut self,
            request: impl tonic::IntoRequest<super::BatchGetStreamsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::BatchGetStreamsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.StreamService/BatchGet",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.StreamService", "BatchGet"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Create stream.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateStreamRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.StreamService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.StreamService", "Create"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Update stream.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateStreamRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.StreamService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.StreamService", "Update"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Delete stream.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteStreamRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.StreamService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.StreamService", "Delete"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Batch delete streams.
        pub async fn batch_delete(
            &mut self,
            request: impl tonic::IntoRequest<super::BatchDeleteStreamsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.StreamService/BatchDelete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.StreamService", "BatchDelete"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Perform an action on the stream.
        pub async fn perform_action(
            &mut self,
            request: impl tonic::IntoRequest<super::PerformStreamActionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.StreamService/PerformAction",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.video.v1.StreamService",
                        "PerformAction",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Subtitle {
    /// ID of the subtitle.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Subtitle language in any of the following formats:
    /// * three-letter code according to ISO 639-2/T, ISO 639-2/B, or ISO 639-3
    /// * two-letter code according to ISO 639-1
    #[prost(string, tag = "2")]
    pub language: ::prost::alloc::string::String,
    /// Subtitle caption to be displayed on screen during video playback.
    #[prost(string, tag = "3")]
    pub label: ::prost::alloc::string::String,
    /// Subtitle status.
    #[prost(enumeration = "subtitle::SubtitleStatus", tag = "4")]
    pub status: i32,
    /// Source type.
    #[prost(enumeration = "subtitle::SubtitleSourceType", tag = "6")]
    pub source_type: i32,
    /// Subtitle filename.
    #[prost(string, tag = "5")]
    pub filename: ::prost::alloc::string::String,
    /// Time when subtitle was created.
    #[prost(message, optional, tag = "100")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Time of last subtitle update.
    #[prost(message, optional, tag = "101")]
    pub updated_at: ::core::option::Option<::prost_types::Timestamp>,
    #[prost(oneof = "subtitle::ParentId", tags = "1000")]
    pub parent_id: ::core::option::Option<subtitle::ParentId>,
}
/// Nested message and enum types in `Subtitle`.
pub mod subtitle {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum SubtitleStatus {
        /// Subtitle status unspecified.
        Unspecified = 0,
        /// Waiting for all the bytes to be loaded.
        WaitUploading = 1,
        /// Uploading is complete.
        Uploaded = 2,
    }
    impl SubtitleStatus {
        /// 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 {
                SubtitleStatus::Unspecified => "SUBTITLE_STATUS_UNSPECIFIED",
                SubtitleStatus::WaitUploading => "WAIT_UPLOADING",
                SubtitleStatus::Uploaded => "UPLOADED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "SUBTITLE_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
                "WAIT_UPLOADING" => Some(Self::WaitUploading),
                "UPLOADED" => Some(Self::Uploaded),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum SubtitleSourceType {
        /// Subtitle source type unspecified.
        Unspecified = 0,
        /// Manually uploaded subtitle.
        Manual = 1,
        /// Automatically generated subtitle.
        Generated = 2,
    }
    impl SubtitleSourceType {
        /// 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 {
                SubtitleSourceType::Unspecified => "SUBTITLE_SOURCE_TYPE_UNSPECIFIED",
                SubtitleSourceType::Manual => "MANUAL",
                SubtitleSourceType::Generated => "GENERATED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "SUBTITLE_SOURCE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "MANUAL" => Some(Self::Manual),
                "GENERATED" => Some(Self::Generated),
                _ => None,
            }
        }
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum ParentId {
        /// ID of the video.
        #[prost(string, tag = "1000")]
        VideoId(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetSubtitleRequest {
    /// ID of the subtitle.
    #[prost(string, tag = "1")]
    pub subtitle_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSubtitlesRequest {
    /// The maximum number of the results per page to return.
    /// Default value: 100.
    #[prost(int64, tag = "100")]
    pub page_size: i64,
    /// Page token for getting the next page of the result.
    #[prost(string, tag = "101")]
    pub page_token: ::prost::alloc::string::String,
    #[prost(oneof = "list_subtitles_request::ParentId", tags = "1000")]
    pub parent_id: ::core::option::Option<list_subtitles_request::ParentId>,
}
/// Nested message and enum types in `ListSubtitlesRequest`.
pub mod list_subtitles_request {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum ParentId {
        /// ID of the video.
        #[prost(string, tag = "1000")]
        VideoId(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSubtitlesResponse {
    #[prost(message, repeated, tag = "1")]
    pub subtitles: ::prost::alloc::vec::Vec<Subtitle>,
    /// Token for getting the next page.
    #[prost(string, tag = "100")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateSubtitleRequest {
    /// Subtitle language in any of the following formats:
    /// * three-letter code according to ISO 639-2/T, ISO 639-2/B, or ISO 639-3
    /// * two-letter code according to ISO 639-1
    #[prost(string, tag = "1")]
    pub language: ::prost::alloc::string::String,
    /// Contains the subtitle label (or title) that will be displayed on screen during video playback.
    /// Should provide a concise and accurate representation of the spoken content.
    /// If not provided, it will be auto-generated based on the specified language.
    #[prost(string, tag = "2")]
    pub label: ::prost::alloc::string::String,
    #[prost(oneof = "create_subtitle_request::ParentId", tags = "1000")]
    pub parent_id: ::core::option::Option<create_subtitle_request::ParentId>,
    /// Source type.
    #[prost(oneof = "create_subtitle_request::Source", tags = "1100")]
    pub source: ::core::option::Option<create_subtitle_request::Source>,
}
/// Nested message and enum types in `CreateSubtitleRequest`.
pub mod create_subtitle_request {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum ParentId {
        /// ID of the video.
        #[prost(string, tag = "1000")]
        VideoId(::prost::alloc::string::String),
    }
    /// Source type.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Source {
        /// Upload subtitle.
        #[prost(message, tag = "1100")]
        Upload(super::SubtitleUploadParams),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SubtitleUploadParams {
    #[prost(string, tag = "1")]
    pub filename: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateSubtitleMetadata {
    /// ID of the subtitle.
    #[prost(string, tag = "1")]
    pub subtitle_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GenerateSubtitleUploadUrlRequest {
    /// ID of the subtitle.
    #[prost(string, tag = "1")]
    pub subtitle_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GenerateSubtitleUploadUrlResponse {
    /// Upload url.
    #[prost(string, tag = "1")]
    pub upload_url: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteSubtitleRequest {
    /// ID of the subtitle.
    #[prost(string, tag = "1")]
    pub subtitle_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteSubtitleMetadata {
    /// ID of the subtitle.
    #[prost(string, tag = "1")]
    pub subtitle_id: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod subtitle_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Subtitle management service.
    #[derive(Debug, Clone)]
    pub struct SubtitleServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl SubtitleServiceClient<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> SubtitleServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> SubtitleServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            SubtitleServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Get a specific subtitle.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetSubtitleRequest>,
        ) -> std::result::Result<tonic::Response<super::Subtitle>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.SubtitleService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.video.v1.SubtitleService", "Get"));
            self.inner.unary(req, path, codec).await
        }
        /// List subtitles.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListSubtitlesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListSubtitlesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.SubtitleService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.SubtitleService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Create a new subtitle.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateSubtitleRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.SubtitleService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.SubtitleService", "Create"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Generate an upload URL to add a new subtitle file.
        pub async fn generate_upload_url(
            &mut self,
            request: impl tonic::IntoRequest<super::GenerateSubtitleUploadUrlRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GenerateSubtitleUploadUrlResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.SubtitleService/GenerateUploadURL",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.video.v1.SubtitleService",
                        "GenerateUploadURL",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Delete a specific subtitle.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteSubtitleRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.SubtitleService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.SubtitleService", "Delete"),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Thumbnail {
    /// ID of the thumbnail.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the channel where the thumbnail was created.
    #[prost(string, tag = "2")]
    pub channel_id: ::prost::alloc::string::String,
    /// Time when thumbnail was created.
    #[prost(message, optional, tag = "100")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetThumbnailRequest {
    /// ID of the thumbnail.
    #[prost(string, tag = "1")]
    pub thumbnail_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListThumbnailRequest {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub channel_id: ::prost::alloc::string::String,
    /// The maximum number of the results per page to return.
    /// Default value: 100.
    #[prost(int64, tag = "100")]
    pub page_size: i64,
    /// Page token for getting the next page of the result.
    #[prost(string, tag = "101")]
    pub page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListThumbnailResponse {
    /// List of thumbnails.
    #[prost(message, repeated, tag = "1")]
    pub thumbnails: ::prost::alloc::vec::Vec<Thumbnail>,
    /// Token for getting the next page.
    #[prost(string, tag = "100")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateThumbnailRequest {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub channel_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateThumbnailMetadata {
    /// ID of the thumbnail.
    #[prost(string, tag = "1")]
    pub thumbnail_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchGenerateDownloadUrLsRequest {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub channel_id: ::prost::alloc::string::String,
    /// List of thumbnails IDs.
    #[prost(string, repeated, tag = "2")]
    pub thumbnail_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchGenerateDownloadUrLsResponse {
    /// List of download urls.
    #[prost(message, repeated, tag = "1")]
    pub download_urls: ::prost::alloc::vec::Vec<ThumbnailDownloadUrl>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ThumbnailDownloadUrl {
    /// ID of the thumbnail.
    #[prost(string, tag = "1")]
    pub thumbnail_id: ::prost::alloc::string::String,
    /// Original download url.
    #[prost(string, tag = "2")]
    pub original_url: ::prost::alloc::string::String,
    /// List of download urls, one per each available image size.
    #[prost(message, repeated, tag = "3")]
    pub scaled_urls: ::prost::alloc::vec::Vec<thumbnail_download_url::ScaledUrl>,
}
/// Nested message and enum types in `ThumbnailDownloadURL`.
pub mod thumbnail_download_url {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ScaledUrl {
        /// Download url.
        #[prost(string, tag = "1")]
        pub url: ::prost::alloc::string::String,
        /// Maximum width of the rectangle to inscribe the thumbnail into.
        #[prost(int64, tag = "2")]
        pub max_width: i64,
        /// Maximum height of the rectangle to inscribe the thumbnail into.
        #[prost(int64, tag = "3")]
        pub max_height: i64,
        /// Image format.
        #[prost(enumeration = "ImageFormat", tag = "4")]
        pub image_format: i32,
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ImageFormat {
        /// Image format unspecified.
        Unspecified = 0,
        /// JPEG image format.
        Jpeg = 1,
        /// WebP image format.
        Webp = 2,
    }
    impl ImageFormat {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                ImageFormat::Unspecified => "IMAGE_FORMAT_UNSPECIFIED",
                ImageFormat::Jpeg => "JPEG",
                ImageFormat::Webp => "WEBP",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "IMAGE_FORMAT_UNSPECIFIED" => Some(Self::Unspecified),
                "JPEG" => Some(Self::Jpeg),
                "WEBP" => Some(Self::Webp),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GenerateThumbnailUploadUrlRequest {
    /// ID of the thumbnail.
    #[prost(string, tag = "1")]
    pub thumbnail_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GenerateThumbnailUploadUrlResponse {
    /// Upload url.
    #[prost(string, tag = "1")]
    pub upload_url: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteThumbnailRequest {
    /// ID of the thumbnail.
    #[prost(string, tag = "1")]
    pub thumbnail_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteThumbnailMetadata {
    /// ID of the thumbnail.
    #[prost(string, tag = "1")]
    pub thumbnail_id: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod thumbnail_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Thumbnail management service.
    #[derive(Debug, Clone)]
    pub struct ThumbnailServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ThumbnailServiceClient<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> ThumbnailServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> ThumbnailServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            ThumbnailServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Get the specific thumbnail.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetThumbnailRequest>,
        ) -> std::result::Result<tonic::Response<super::Thumbnail>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.ThumbnailService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.ThumbnailService", "Get"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// List thumbnails for channel.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListThumbnailRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListThumbnailResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.ThumbnailService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.ThumbnailService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Create thumbnail.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateThumbnailRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.ThumbnailService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.ThumbnailService", "Create"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Generate urls for downloading images.
        pub async fn batch_generate_download_ur_ls(
            &mut self,
            request: impl tonic::IntoRequest<super::BatchGenerateDownloadUrLsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::BatchGenerateDownloadUrLsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.ThumbnailService/BatchGenerateDownloadURLs",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.video.v1.ThumbnailService",
                        "BatchGenerateDownloadURLs",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Generate url for uploading an image.
        pub async fn generate_upload_url(
            &mut self,
            request: impl tonic::IntoRequest<super::GenerateThumbnailUploadUrlRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GenerateThumbnailUploadUrlResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.ThumbnailService/GenerateUploadURL",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.video.v1.ThumbnailService",
                        "GenerateUploadURL",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Delete thumbnail.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteThumbnailRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.ThumbnailService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.ThumbnailService", "Delete"),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Video {
    /// ID of the video.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the channel where the video was created.
    #[prost(string, tag = "2")]
    pub channel_id: ::prost::alloc::string::String,
    /// Video title displayed to users.
    #[prost(string, tag = "3")]
    pub title: ::prost::alloc::string::String,
    /// Detailed description of the video.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// ID of the video's thumbnail image.
    #[prost(string, tag = "5")]
    pub thumbnail_id: ::prost::alloc::string::String,
    /// Video status.
    #[prost(enumeration = "video::VideoStatus", tag = "6")]
    pub status: i32,
    /// Error message describing the reason for video processing failure, if any.
    #[prost(string, tag = "18")]
    pub error_message: ::prost::alloc::string::String,
    /// Visibility status of the video.
    #[prost(enumeration = "video::VisibilityStatus", tag = "9")]
    pub visibility_status: i32,
    /// Video duration. Optional, may be empty until the transcoding result is ready.
    #[prost(message, optional, tag = "8")]
    pub duration: ::core::option::Option<::prost_types::Duration>,
    /// Auto-transcoding setting.
    /// Set ENABLE to automatically initiate transcoding after upload,
    /// or DISABLE for manual initiation via the Transcode() method.
    #[prost(enumeration = "AutoTranscode", tag = "11")]
    pub auto_transcode: i32,
    /// Enable advertisement for this video.
    /// Default: true.
    /// Set explicitly to false to disable advertisements for a specific video.
    #[prost(message, optional, tag = "17")]
    pub enable_ad: ::core::option::Option<bool>,
    /// List of IDs defining the active subtitles for the video.
    #[prost(string, repeated, tag = "12")]
    pub subtitle_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Additional video processing features and their results.
    #[prost(message, optional, tag = "13")]
    pub features: ::core::option::Option<VideoFeatures>,
    /// Time when video was created.
    #[prost(message, optional, tag = "100")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Time of last video update.
    #[prost(message, optional, tag = "101")]
    pub updated_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Custom labels as `` key:value `` pairs. Maximum 64 per resource.
    #[prost(map = "string, string", tag = "200")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Video upload source definition (one source variant must be chosen).
    #[prost(oneof = "video::Source", tags = "1000")]
    pub source: ::core::option::Option<video::Source>,
    /// Video access permission settings.
    #[prost(oneof = "video::AccessRights", tags = "2000, 2003")]
    pub access_rights: ::core::option::Option<video::AccessRights>,
}
/// Nested message and enum types in `Video`.
pub mod video {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum VideoStatus {
        /// Video status unspecified.
        Unspecified = 0,
        /// Waiting for all the bytes to be loaded.
        WaitUploading = 1,
        /// Fully uploaded, ready to be transcoded.
        Uploaded = 2,
        /// Video is being processed.
        Processing = 4,
        /// Successfully processed and ready for use.
        Ready = 5,
        /// Video processing has failed.
        Error = 7,
    }
    impl VideoStatus {
        /// 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 {
                VideoStatus::Unspecified => "VIDEO_STATUS_UNSPECIFIED",
                VideoStatus::WaitUploading => "WAIT_UPLOADING",
                VideoStatus::Uploaded => "UPLOADED",
                VideoStatus::Processing => "PROCESSING",
                VideoStatus::Ready => "READY",
                VideoStatus::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 {
                "VIDEO_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
                "WAIT_UPLOADING" => Some(Self::WaitUploading),
                "UPLOADED" => Some(Self::Uploaded),
                "PROCESSING" => Some(Self::Processing),
                "READY" => Some(Self::Ready),
                "ERROR" => Some(Self::Error),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum VisibilityStatus {
        /// Visibility status unspecified.
        Unspecified = 0,
        /// Video published and available for public viewing.
        Published = 1,
        /// Video unpublished, available only to administrators.
        Unpublished = 2,
    }
    impl VisibilityStatus {
        /// 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 {
                VisibilityStatus::Unspecified => "VISIBILITY_STATUS_UNSPECIFIED",
                VisibilityStatus::Published => "PUBLISHED",
                VisibilityStatus::Unpublished => "UNPUBLISHED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "VISIBILITY_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
                "PUBLISHED" => Some(Self::Published),
                "UNPUBLISHED" => Some(Self::Unpublished),
                _ => None,
            }
        }
    }
    /// Video upload source definition (one source variant must be chosen).
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Source {
        /// Upload video using the tus protocol.
        #[prost(message, tag = "1000")]
        Tusd(super::VideoTusdSource),
    }
    /// Video access permission settings.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum AccessRights {
        /// Publicly accessible video available for viewing by anyone with the direct link.
        /// No additional authorization or access control is applied.
        #[prost(message, tag = "2000")]
        PublicAccess(super::VideoPublicAccessRights),
        /// Checking access rights using url's signature.
        #[prost(message, tag = "2003")]
        SignUrlAccess(super::VideoSignUrlAccessRights),
    }
}
/// Video upload source via tus protocol.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VideoTusdSource {
    /// URL for uploading video via the tus protocol.
    #[prost(string, tag = "1")]
    pub url: ::prost::alloc::string::String,
    /// Size of the uploaded file, in bytes.
    #[prost(int64, tag = "2")]
    pub file_size: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VideoPublicAccessRights {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VideoSignUrlAccessRights {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VideoFeatures {
    /// Summarization result.
    #[prost(message, optional, tag = "1")]
    pub summary: ::core::option::Option<video_features::Summary>,
}
/// Nested message and enum types in `VideoFeatures`.
pub mod video_features {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Summary {
        #[prost(enumeration = "FeatureResult", tag = "1")]
        pub result: i32,
        #[prost(message, repeated, tag = "3")]
        pub urls: ::prost::alloc::vec::Vec<summary::SummaryUrl>,
    }
    /// Nested message and enum types in `Summary`.
    pub mod summary {
        #[allow(clippy::derive_partial_eq_without_eq)]
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct SummaryUrl {
            #[prost(string, tag = "1")]
            pub url: ::prost::alloc::string::String,
            /// Input audio track index (one-based).
            #[prost(int64, tag = "2")]
            pub track_index: i64,
            /// Source track language (three-letter code according to ISO 639-2/T, ISO 639-2/B, or ISO 639-3).
            /// Either provided in transcoding settings earlier or automatically deduced.
            #[prost(string, tag = "3")]
            pub src_lang: ::prost::alloc::string::String,
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum FeatureResult {
        Unspecified = 0,
        /// Feature has not been requested.
        NotRequested = 1,
        /// Feature is being processed.
        Processing = 2,
        /// Feature processing completed successfully.
        Success = 3,
        /// Feature processing has failed.
        Failed = 4,
    }
    impl FeatureResult {
        /// 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 {
                FeatureResult::Unspecified => "FEATURE_RESULT_UNSPECIFIED",
                FeatureResult::NotRequested => "NOT_REQUESTED",
                FeatureResult::Processing => "PROCESSING",
                FeatureResult::Success => "SUCCESS",
                FeatureResult::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 {
                "FEATURE_RESULT_UNSPECIFIED" => Some(Self::Unspecified),
                "NOT_REQUESTED" => Some(Self::NotRequested),
                "PROCESSING" => Some(Self::Processing),
                "SUCCESS" => Some(Self::Success),
                "FAILED" => Some(Self::Failed),
                _ => None,
            }
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum AutoTranscode {
    /// Unspecified auto transcoding value.
    Unspecified = 0,
    /// Enable auto transcoding.
    Enable = 1,
    /// Disable auto transcoding.
    Disable = 2,
}
impl AutoTranscode {
    /// 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 {
            AutoTranscode::Unspecified => "AUTO_TRANSCODE_UNSPECIFIED",
            AutoTranscode::Enable => "ENABLE",
            AutoTranscode::Disable => "DISABLE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "AUTO_TRANSCODE_UNSPECIFIED" => Some(Self::Unspecified),
            "ENABLE" => Some(Self::Enable),
            "DISABLE" => Some(Self::Disable),
            _ => None,
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetVideoRequest {
    /// ID of the video.
    #[prost(string, tag = "1")]
    pub video_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListVideoRequest {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub channel_id: ::prost::alloc::string::String,
    /// The maximum number of the results per page to return.
    /// Default value: 100.
    #[prost(int64, tag = "100")]
    pub page_size: i64,
    /// Page token for getting the next page of the result.
    #[prost(string, tag = "101")]
    pub page_token: ::prost::alloc::string::String,
    /// By which column the listing should be ordered and in which direction,
    /// format is "<field> <order>" (e.g. "createdAt desc").
    /// Default: "id asc".
    /// Possible fields: ["id", "title", "createdAt", "updatedAt"].
    /// Both snake_case and camelCase are supported for fields.
    #[prost(string, tag = "102")]
    pub order_by: ::prost::alloc::string::String,
    /// Filter expression that filters resources listed in the response.
    /// Expressions are composed of terms connected by logic operators.
    /// If value contains spaces or quotes,
    /// it should be in quotes (`'` or `"`) with the inner quotes being backslash escaped.
    /// Example: "key1='value' AND key2='value'".
    /// Supported operators: ["AND", "OR"].
    /// Supported fields: ["id", "title", "status", "visibilityStatus"].
    /// Both snake_case and camelCase are supported for fields.
    #[prost(string, tag = "103")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListVideoResponse {
    #[prost(message, repeated, tag = "1")]
    pub videos: ::prost::alloc::vec::Vec<Video>,
    /// Token for getting the next page.
    #[prost(string, tag = "100")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchGetVideosRequest {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub channel_id: ::prost::alloc::string::String,
    /// List of requested video IDs.
    #[prost(string, repeated, tag = "2")]
    pub video_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchGetVideosResponse {
    /// List of videos for channel.
    #[prost(message, repeated, tag = "1")]
    pub videos: ::prost::alloc::vec::Vec<Video>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateVideoRequest {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub channel_id: ::prost::alloc::string::String,
    /// Video title.
    #[prost(string, tag = "2")]
    pub title: ::prost::alloc::string::String,
    /// Video description.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// ID of the thumbnail.
    #[prost(string, tag = "4")]
    pub thumbnail_id: ::prost::alloc::string::String,
    /// Auto start transcoding.
    #[prost(enumeration = "AutoTranscode", tag = "5")]
    pub auto_transcode: i32,
    /// Automatically publish video after transcoding.
    /// Switches visibility status to PUBLISHED.
    #[prost(message, optional, tag = "7")]
    pub auto_publish: ::core::option::Option<bool>,
    /// Enable advertisement for this video.
    /// Default: true.
    /// Set explicitly to false to disable advertisements for a specific video.
    #[prost(message, optional, tag = "8")]
    pub enable_ad: ::core::option::Option<bool>,
    /// Custom labels as `` key:value `` pairs. Maximum 64 per resource.
    #[prost(map = "string, string", tag = "200")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Source type.
    #[prost(oneof = "create_video_request::Source", tags = "1000")]
    pub source: ::core::option::Option<create_video_request::Source>,
    /// Video access permission settings.
    #[prost(oneof = "create_video_request::AccessRights", tags = "2000, 2003")]
    pub access_rights: ::core::option::Option<create_video_request::AccessRights>,
}
/// Nested message and enum types in `CreateVideoRequest`.
pub mod create_video_request {
    /// Source type.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Source {
        /// Upload video using the tus protocol.
        #[prost(message, tag = "1000")]
        Tusd(super::VideoTusdParams),
    }
    /// Video access permission settings.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum AccessRights {
        /// Publicly accessible video available for viewing by anyone with the direct link.
        /// No additional authorization or access control is applied.
        #[prost(message, tag = "2000")]
        PublicAccess(super::VideoPublicAccessParams),
        /// Checking access rights using url's signature.
        #[prost(message, tag = "2003")]
        SignUrlAccess(super::VideoSignUrlAccessParams),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VideoTusdParams {
    /// File size.
    #[prost(int64, tag = "1")]
    pub file_size: i64,
    /// File name.
    #[prost(string, tag = "2")]
    pub file_name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VideoPublicAccessParams {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VideoSignUrlAccessParams {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateVideoMetadata {
    /// ID of the video.
    #[prost(string, tag = "1")]
    pub video_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateVideoRequest {
    /// ID of the video.
    #[prost(string, tag = "1")]
    pub video_id: ::prost::alloc::string::String,
    /// Field mask that specifies which fields of the video are going to be updated.
    #[prost(message, optional, tag = "2")]
    pub field_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Video title.
    #[prost(string, tag = "3")]
    pub title: ::prost::alloc::string::String,
    /// Video description.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// ID of the thumbnail.
    #[prost(string, tag = "5")]
    pub thumbnail_id: ::prost::alloc::string::String,
    /// Auto start transcoding.
    #[prost(enumeration = "AutoTranscode", tag = "6")]
    pub auto_transcode: i32,
    /// Enable advertisement for this video.
    /// Default: true.
    /// Use this to disable advertisement for a specific video.
    #[prost(message, optional, tag = "8")]
    pub enable_ad: ::core::option::Option<bool>,
    /// Custom labels as `` key:value `` pairs. Maximum 64 per resource.
    #[prost(map = "string, string", tag = "200")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Video access permission settings.
    #[prost(oneof = "update_video_request::AccessRights", tags = "2000, 2003")]
    pub access_rights: ::core::option::Option<update_video_request::AccessRights>,
}
/// Nested message and enum types in `UpdateVideoRequest`.
pub mod update_video_request {
    /// Video access permission settings.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum AccessRights {
        /// Publicly accessible video available for viewing by anyone with the direct link.
        /// No additional authorization or access control is applied.
        #[prost(message, tag = "2000")]
        PublicAccess(super::VideoPublicAccessParams),
        /// Checking access rights using url's signature.
        #[prost(message, tag = "2003")]
        SignUrlAccess(super::VideoSignUrlAccessParams),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateVideoMetadata {
    /// ID of the video.
    #[prost(string, tag = "1")]
    pub video_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TranscodeVideoRequest {
    /// ID of the video.
    #[prost(string, tag = "1")]
    pub video_id: ::prost::alloc::string::String,
    /// Field mask that specifies which transcoding specific fields of the video
    /// are going to be updated.
    #[prost(message, optional, tag = "2")]
    pub field_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// IDs of active manually uploaded video subtitles.
    #[prost(string, repeated, tag = "3")]
    pub subtitle_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Video translation settings.
    #[prost(message, optional, tag = "4")]
    pub translation_settings: ::core::option::Option<VideoTranslationSettings>,
    /// Video summarization settings.
    #[prost(message, optional, tag = "5")]
    pub summarization_settings: ::core::option::Option<VideoSummarizationSettings>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VideoTranslationSettings {
    /// Translation settings for each track.
    #[prost(message, repeated, tag = "1")]
    pub tracks: ::prost::alloc::vec::Vec<video_translation_settings::TranslationTrack>,
}
/// Nested message and enum types in `VideoTranslationSettings`.
pub mod video_translation_settings {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct TranslationTrack {
        /// Input track settings.
        #[prost(message, optional, tag = "1")]
        pub input_track: ::core::option::Option<InputTrack>,
        /// Settings for target subtitle tracks.
        #[prost(message, repeated, tag = "2")]
        pub subtitles: ::prost::alloc::vec::Vec<SubtitleTrack>,
        /// Settings for target audio tracks.
        #[prost(message, repeated, tag = "3")]
        pub audio: ::prost::alloc::vec::Vec<AudioTrack>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct InputTrack {
        /// Input audio track index (one-based).
        #[prost(int64, tag = "1")]
        pub track_index: i64,
        /// Source track language in any of the following formats:
        /// * three-letter code according to ISO 639-2/T, ISO 639-2/B, or ISO 639-3
        /// * two-letter code according to ISO 639-1
        /// Track language will be deduced automatically if not provided.
        /// In the latter case the deduction accuracy is not guaranteed.
        /// For better performance please do specify the source track language when possible.
        #[prost(string, tag = "2")]
        pub src_lang: ::prost::alloc::string::String,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SubtitleTrack {
        /// Target language in any of the following formats:
        /// * three-letter code according to ISO 639-2/T, ISO 639-2/B, or ISO 639-3
        /// * two-letter code according to ISO 639-1
        #[prost(string, tag = "1")]
        pub dst_lang: ::prost::alloc::string::String,
        /// Track label to be displayed on the screen during video playback.
        #[prost(string, tag = "2")]
        pub label: ::prost::alloc::string::String,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct AudioTrack {
        /// Target language in any of the following formats:
        /// * three-letter code according to ISO 639-2/T, ISO 639-2/B, or ISO 639-3
        /// * two-letter code according to ISO 639-1
        #[prost(string, tag = "1")]
        pub dst_lang: ::prost::alloc::string::String,
        /// Track label to be displayed on the screen during video playback.
        #[prost(string, tag = "2")]
        pub label: ::prost::alloc::string::String,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VideoSummarizationSettings {
    /// Summarization settings for each track.
    #[prost(message, repeated, tag = "2")]
    pub tracks: ::prost::alloc::vec::Vec<
        video_summarization_settings::SummarizationTrack,
    >,
    /// Summarize all available tracks.
    /// If enabled, `tracks` parameter is ignored.
    /// Enables automatic source language deduction for each track
    /// and thus may lead to performance degradation.
    #[prost(bool, tag = "3")]
    pub process_all_tracks: bool,
}
/// Nested message and enum types in `VideoSummarizationSettings`.
pub mod video_summarization_settings {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SummarizationTrack {
        /// Input track settings.
        #[prost(message, optional, tag = "1")]
        pub input_track: ::core::option::Option<InputTrack>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct InputTrack {
        /// Input audio track index (one-based).
        #[prost(int64, tag = "1")]
        pub track_index: i64,
        /// Source track language (three-letter code according to ISO 639-2/T, ISO 639-2/B, or ISO 639-3).
        /// It will be deduced automatically if not provided.
        /// In the latter case the deduction accuracy is not guaranteed.
        /// For better performance please do specify the source track language when possible.
        #[prost(string, tag = "2")]
        pub src_lang: ::prost::alloc::string::String,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TranscodeVideoMetadata {
    /// ID of the video.
    #[prost(string, tag = "1")]
    pub video_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteVideoRequest {
    /// ID of the video.
    #[prost(string, tag = "1")]
    pub video_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteVideoMetadata {
    /// ID of the video.
    #[prost(string, tag = "1")]
    pub video_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchDeleteVideosRequest {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub channel_id: ::prost::alloc::string::String,
    /// List of video IDs.
    #[prost(string, repeated, tag = "2")]
    pub video_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchDeleteVideosMetadata {
    /// List of video IDs.
    #[prost(string, repeated, tag = "1")]
    pub video_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PerformVideoActionRequest {
    /// ID of the video.
    #[prost(string, tag = "1")]
    pub video_id: ::prost::alloc::string::String,
    #[prost(oneof = "perform_video_action_request::Action", tags = "1000, 1001")]
    pub action: ::core::option::Option<perform_video_action_request::Action>,
}
/// Nested message and enum types in `PerformVideoActionRequest`.
pub mod perform_video_action_request {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Action {
        #[prost(message, tag = "1000")]
        Publish(super::PublishVideoAction),
        #[prost(message, tag = "1001")]
        Unpublish(super::UnpublishVideoAction),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PublishVideoAction {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UnpublishVideoAction {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PerformVideoActionMetadata {
    /// ID of the video.
    #[prost(string, tag = "1")]
    pub video_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetVideoPlayerUrlRequest {
    /// ID of the video.
    #[prost(string, tag = "1")]
    pub video_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub params: ::core::option::Option<VideoPlayerParams>,
    /// Optional field, used to set custom url expiration duration for videos with sign_url_access
    #[prost(message, optional, tag = "3")]
    pub signed_url_expiration_duration: ::core::option::Option<::prost_types::Duration>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VideoPlayerParams {
    /// If true, a player will be muted by default.
    #[prost(bool, tag = "1")]
    pub mute: bool,
    /// If true, playback will start automatically.
    #[prost(bool, tag = "2")]
    pub autoplay: bool,
    /// If true, a player interface will be hidden by default.
    #[prost(bool, tag = "3")]
    pub hidden: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetVideoPlayerUrlResponse {
    /// Direct link to the video.
    #[prost(string, tag = "1")]
    pub player_url: ::prost::alloc::string::String,
    /// HTML embed code in Iframe format.
    #[prost(string, tag = "2")]
    pub html: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchGetVideoPlayerUrLsRequest {
    /// ID of the channel.
    #[prost(string, tag = "1")]
    pub channel_id: ::prost::alloc::string::String,
    /// List of requested video IDs.
    #[prost(string, repeated, tag = "2")]
    pub video_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "3")]
    pub params: ::core::option::Option<VideoPlayerParams>,
    /// Optional field, used to set custom url expiration duration for videos with sign_url_access
    #[prost(message, optional, tag = "4")]
    pub signed_url_expiration_duration: ::core::option::Option<::prost_types::Duration>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchGetVideoPlayerUrLsResponse {
    #[prost(string, repeated, tag = "1")]
    pub player_urls: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetVideoManifestsRequest {
    /// ID of the video.
    #[prost(string, tag = "1")]
    pub video_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetVideoManifestsResponse {
    #[prost(message, repeated, tag = "1")]
    pub manifests: ::prost::alloc::vec::Vec<Manifest>,
}
/// Generated client implementations.
pub mod video_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Video management service.
    #[derive(Debug, Clone)]
    pub struct VideoServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl VideoServiceClient<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> VideoServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> VideoServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            VideoServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Get the specific video.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetVideoRequest>,
        ) -> std::result::Result<tonic::Response<super::Video>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.VideoService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.video.v1.VideoService", "Get"));
            self.inner.unary(req, path, codec).await
        }
        /// List videos for channel.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListVideoRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListVideoResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.VideoService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.video.v1.VideoService", "List"));
            self.inner.unary(req, path, codec).await
        }
        /// Batch get videos in specific channel.
        pub async fn batch_get(
            &mut self,
            request: impl tonic::IntoRequest<super::BatchGetVideosRequest>,
        ) -> std::result::Result<
            tonic::Response<super::BatchGetVideosResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.VideoService/BatchGet",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.VideoService", "BatchGet"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Create video.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateVideoRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.VideoService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.video.v1.VideoService", "Create"));
            self.inner.unary(req, path, codec).await
        }
        /// Update video.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateVideoRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.VideoService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.video.v1.VideoService", "Update"));
            self.inner.unary(req, path, codec).await
        }
        /// Transcode video.
        pub async fn transcode(
            &mut self,
            request: impl tonic::IntoRequest<super::TranscodeVideoRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.VideoService/Transcode",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.VideoService", "Transcode"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Delete video.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteVideoRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.VideoService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.video.v1.VideoService", "Delete"));
            self.inner.unary(req, path, codec).await
        }
        /// Batch delete videos.
        pub async fn batch_delete(
            &mut self,
            request: impl tonic::IntoRequest<super::BatchDeleteVideosRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.VideoService/BatchDelete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.VideoService", "BatchDelete"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Perform an action on the video.
        pub async fn perform_action(
            &mut self,
            request: impl tonic::IntoRequest<super::PerformVideoActionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.VideoService/PerformAction",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.video.v1.VideoService",
                        "PerformAction",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get player url.
        pub async fn get_player_url(
            &mut self,
            request: impl tonic::IntoRequest<super::GetVideoPlayerUrlRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetVideoPlayerUrlResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.VideoService/GetPlayerURL",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.VideoService", "GetPlayerURL"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Batch get player urls.
        pub async fn batch_get_player_ur_ls(
            &mut self,
            request: impl tonic::IntoRequest<super::BatchGetVideoPlayerUrLsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::BatchGetVideoPlayerUrLsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.VideoService/BatchGetPlayerURLs",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.video.v1.VideoService",
                        "BatchGetPlayerURLs",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get manifest urls.
        pub async fn get_manifests(
            &mut self,
            request: impl tonic::IntoRequest<super::GetVideoManifestsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetVideoManifestsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.video.v1.VideoService/GetManifests",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.video.v1.VideoService", "GetManifests"),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}