yandex-cloud 2025.4.14

#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PurgeCacheRequest {
    /// ID of the resource to perform purge operation on.
    #[prost(string, tag = "1")]
    pub resource_id: ::prost::alloc::string::String,
    /// Set of paths:
    /// Paths of the files to remove from the cache.
    ///
    /// You may use asterisk (`*`) as a wildcard character that substitutes any number of characters.
    ///
    /// If an empty array of paths is specified (`"paths": []`), the cache is purged entirely.
    #[prost(string, repeated, tag = "2")]
    pub paths: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PurgeCacheMetadata {
    /// ID of the resource.
    #[prost(string, tag = "1")]
    pub resource_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PrefetchCacheRequest {
    /// ID of the resource to perform prefetch operation on.
    #[prost(string, tag = "1")]
    pub resource_id: ::prost::alloc::string::String,
    /// Set of paths to prefetch.
    #[prost(string, repeated, tag = "2")]
    pub paths: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PrefetchCacheMetadata {
    /// ID of the resource.
    #[prost(string, tag = "1")]
    pub resource_id: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod cache_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// A set of methods for managing Cache Service resources.
    #[derive(Debug, Clone)]
    pub struct CacheServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl CacheServiceClient<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> CacheServiceClient<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,
        ) -> CacheServiceClient<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,
        {
            CacheServiceClient::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
        }
        /// Removes specified files from the cache of the specified resource. For details about purging, see [documentation](/docs/cdn/concepts/caching#purge).
        ///
        /// Purging may take up to 15 minutes.
        pub async fn purge(
            &mut self,
            request: impl tonic::IntoRequest<super::PurgeCacheRequest>,
        ) -> 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.cdn.v1.CacheService/Purge",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.cdn.v1.CacheService", "Purge"));
            self.inner.unary(req, path, codec).await
        }
        /// Uploads specified files from origins to cache of the specified resource. For defails about prefetching, see [documentation](/docs/cdn/concepts/caching#prefetch).
        pub async fn prefetch(
            &mut self,
            request: impl tonic::IntoRequest<super::PrefetchCacheRequest>,
        ) -> 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.cdn.v1.CacheService/Prefetch",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.cdn.v1.CacheService", "Prefetch"));
            self.inner.unary(req, path, codec).await
        }
    }
}
/// An origin. For details about the concept, see \[documentation\](/docs/cdn/concepts/origins).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Origin {
    /// ID of the origin.
    #[prost(int64, tag = "1")]
    pub id: i64,
    /// ID of the parent origin group.
    #[prost(int64, tag = "2")]
    pub origin_group_id: i64,
    /// IP address or Domain name of your origin and the port (if custom).
    /// Used if \[meta\] variant is `common`.
    #[prost(string, tag = "3")]
    pub source: ::prost::alloc::string::String,
    /// The setting allows to enable or disable an Origin source in the Origins group.
    ///
    /// It has two possible values:
    ///
    /// True - The origin is enabled and used as a source for the CDN. An origins
    /// group must contain at least one enabled origin.
    /// False - The origin is disabled and the CDN is not using it to pull content.
    #[prost(bool, tag = "4")]
    pub enabled: bool,
    /// Specifies whether the origin is used in its origin group as backup.
    /// A backup origin is used when one of active origins becomes unavailable.
    #[prost(bool, tag = "5")]
    pub backup: bool,
    /// Set up origin of the content.
    #[prost(message, optional, tag = "6")]
    pub meta: ::core::option::Option<OriginMeta>,
}
/// Origin parameters. For details about the concept, see \[documentation\](/docs/cdn/concepts/origins).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OriginParams {
    /// Source: IP address or Domain name of your origin and the port (if custom).
    #[prost(string, tag = "1")]
    pub source: ::prost::alloc::string::String,
    /// The setting allows to enable or disable an Origin source in the Origins group.
    ///
    /// It has two possible values:
    ///
    /// True - The origin is enabled and used as a source for the CDN. An origins
    /// group must contain at least one enabled origins. False - The origin is disabled
    /// and the CDN is not using it to pull content.
    #[prost(bool, tag = "2")]
    pub enabled: bool,
    /// backup option has two possible values:
    ///
    ///    True - The option is active. The origin will not be used until one of
    ///           active origins become unavailable.
    ///    False - The option is disabled.
    #[prost(bool, tag = "3")]
    pub backup: bool,
    /// Set up origin of the content.
    #[prost(message, optional, tag = "4")]
    pub meta: ::core::option::Option<OriginMeta>,
}
/// Origin type. For details about the concept, see \[documentation\](/docs/cdn/concepts/origins).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OriginMeta {
    /// Type of the origin.
    #[prost(oneof = "origin_meta::OriginMetaVariant", tags = "1, 2, 3, 4")]
    pub origin_meta_variant: ::core::option::Option<origin_meta::OriginMetaVariant>,
}
/// Nested message and enum types in `OriginMeta`.
pub mod origin_meta {
    /// Type of the origin.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum OriginMetaVariant {
        /// A server with a domain name linked to it
        #[prost(message, tag = "1")]
        Common(super::OriginNamedMeta),
        /// An Object Storage bucket not configured as a static site hosting.
        #[prost(message, tag = "2")]
        Bucket(super::OriginNamedMeta),
        /// An Object Storage bucket configured as a static site hosting.
        #[prost(message, tag = "3")]
        Website(super::OriginNamedMeta),
        /// An L7 load balancer from Application Load Balancer.
        /// CDN servers will access the load balancer at one of its IP addresses that must be selected in the origin settings.
        #[prost(message, tag = "4")]
        Balancer(super::OriginBalancerMeta),
    }
}
/// Origin info. For details about the concept, see \[documentation\](/docs/cdn/concepts/origins).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OriginNamedMeta {
    /// Name of the origin.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Application Load Balancer origin info. For details about the concept, see \[documentation\](/docs/cdn/concepts/origins).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OriginBalancerMeta {
    /// ID of the origin.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
}
/// Origin group parameters. For details about the concept, see \[documentation\](/docs/cdn/concepts/origins#groups).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OriginGroup {
    /// ID of the origin group. Generated at creation time.
    #[prost(int64, tag = "1")]
    pub id: i64,
    /// ID of the folder that the origin group belongs to.
    #[prost(string, tag = "2")]
    pub folder_id: ::prost::alloc::string::String,
    /// Name of the origin group.
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    /// This option have two possible conditions:
    /// true - the option is active. In case the origin responds with 4XX or 5XX codes,
    ///         use the next origin from the list.
    /// false - the option is disabled.
    #[prost(bool, tag = "4")]
    pub use_next: bool,
    /// List of origins.
    #[prost(message, repeated, tag = "5")]
    pub origins: ::prost::alloc::vec::Vec<Origin>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetOriginGroupRequest {
    /// ID of the folder that the origin group belongs to.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// ID of the origin group to return.
    ///
    /// To get a origin group ID, make a \[OriginGroupService.List\] request.
    #[prost(int64, tag = "2")]
    pub origin_group_id: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListOriginGroupsRequest {
    /// ID of the folder that the origin group belongs to..
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\],
    /// the service returns a \[ListOriginGroupsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results,
    /// set \[page_token\] to the \[ListOriginGroupsResponse.next_page_token\]
    /// returned by a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListOriginGroupsResponse {
    /// List of all Origin Groups associated with folder.
    #[prost(message, repeated, tag = "1")]
    pub origin_groups: ::prost::alloc::vec::Vec<OriginGroup>,
    /// \[next_page_token\] token allows you to get the next page of results for list requests.
    /// If the number of results is larger than \[ListOriginGroupsRequest.page_size\], use
    /// the \[next_page_token\] as the value for the \[ListOriginGroupsRequest.page_token\] query parameter
    /// in the next list request. Each subsequent list request will have its own
    /// \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateOriginGroupRequest {
    /// ID of the folder that the origin group belongs to.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// Name of the origin group.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// This option have two possible conditions:
    ///   true - The option is active. In case the origin responds with 4XX or 5XX codes,
    ///          use the next origin from the list.
    ///   false - The option is disabled.
    ///
    ///   default value is true
    #[prost(message, optional, tag = "3")]
    pub use_next: ::core::option::Option<bool>,
    /// List of origins: IP addresses or Domain names of your origins and the port
    /// (if custom).
    #[prost(message, repeated, tag = "4")]
    pub origins: ::prost::alloc::vec::Vec<OriginParams>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateOriginGroupMetadata {
    /// ID of created origin group.
    #[prost(int64, tag = "1")]
    pub origin_group_id: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateOriginGroupRequest {
    /// ID of the folder that the origin group belongs to.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// ID of the origin group.
    #[prost(int64, tag = "2")]
    pub origin_group_id: i64,
    /// Name of the origin group.
    #[prost(message, optional, tag = "3")]
    pub group_name: ::core::option::Option<::prost::alloc::string::String>,
    /// This option have two possible values:
    ///
    ///    True - The option is active. In case the origin responds with 4XX or 5XX
    ///           codes, use the next origin from the list.
    ///    False - The option is disabled.
    #[prost(message, optional, tag = "4")]
    pub use_next: ::core::option::Option<bool>,
    /// List of origins: IP addresses or Domain names of your origins and the port
    /// (if custom).
    #[prost(message, repeated, tag = "5")]
    pub origins: ::prost::alloc::vec::Vec<OriginParams>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateOriginGroupMetadata {
    /// ID of the origin group.
    #[prost(int64, tag = "1")]
    pub origin_group_id: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteOriginGroupRequest {
    /// ID of the folder that the origin group belongs to.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// ID of the origin group.
    #[prost(int64, tag = "2")]
    pub origin_group_id: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteOriginGroupMetadata {
    /// ID of the origin group.
    #[prost(int64, tag = "1")]
    pub origin_group_id: i64,
}
/// Generated client implementations.
pub mod origin_group_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    ///
    /// Origin Groups management service.
    ///
    #[derive(Debug, Clone)]
    pub struct OriginGroupServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl OriginGroupServiceClient<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> OriginGroupServiceClient<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,
        ) -> OriginGroupServiceClient<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,
        {
            OriginGroupServiceClient::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
        }
        /// Gets origin group with specified origin group id.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetOriginGroupRequest>,
        ) -> std::result::Result<tonic::Response<super::OriginGroup>, 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.cdn.v1.OriginGroupService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.cdn.v1.OriginGroupService", "Get"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists origins of origin group.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListOriginGroupsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListOriginGroupsResponse>,
            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.cdn.v1.OriginGroupService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.cdn.v1.OriginGroupService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates origin group.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateOriginGroupRequest>,
        ) -> 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.cdn.v1.OriginGroupService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.cdn.v1.OriginGroupService", "Create"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified origin group.
        ///
        /// Changes may take up to 15 minutes to apply. Afterwards, it is recommended to purge cache of the resources that
        /// use the origin group via a [CacheService.Purge] request.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateOriginGroupRequest>,
        ) -> 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.cdn.v1.OriginGroupService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.cdn.v1.OriginGroupService", "Update"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes origin group with specified origin group id.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteOriginGroupRequest>,
        ) -> 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.cdn.v1.OriginGroupService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.cdn.v1.OriginGroupService", "Delete"),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetOriginRequest {
    /// ID of the folder that the origin belongs to.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// \[origin_id\] group ID to request origin from.
    #[prost(int64, tag = "2")]
    pub origin_id: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListOriginsRequest {
    /// ID of the folder that the origin belongs to.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// ID of the group to request origins from.
    #[prost(int64, tag = "2")]
    pub origin_group_id: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListOriginsResponse {
    /// Origin from response.
    #[prost(message, repeated, tag = "1")]
    pub origins: ::prost::alloc::vec::Vec<Origin>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateOriginRequest {
    /// ID of the folder that the origin belongs to.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// \[origin_group_id\] group ID to request origins from.
    #[prost(int64, tag = "2")]
    pub origin_group_id: i64,
    /// IP address or Domain name of your origin and the port (if custom).
    /// Used if \[meta\] variant is `common`.
    #[prost(string, tag = "3")]
    pub source: ::prost::alloc::string::String,
    /// The setting allows to enable or disable an Origin source in the Origins group.
    ///
    /// It has two possible values:
    ///
    /// True - The origin is enabled and used as a source for the CDN. An origins
    /// group must contain at least one enabled origin. Default value.
    /// False - The origin is disabled and the CDN is not using it to pull content.
    #[prost(message, optional, tag = "4")]
    pub enabled: ::core::option::Option<bool>,
    /// Specifies whether the origin is used in its origin group as backup.
    /// A backup origin is used when one of active origins becomes unavailable.
    ///
    /// Default value: False.
    #[prost(message, optional, tag = "5")]
    pub backup: ::core::option::Option<bool>,
    /// Set up origin of the content.
    #[prost(message, optional, tag = "6")]
    pub meta: ::core::option::Option<OriginMeta>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateOriginMetadata {
    /// ID of the origin.
    #[prost(int64, tag = "1")]
    pub origin_id: i64,
    /// ID pf the parent origins group.
    #[prost(int64, tag = "2")]
    pub origin_group_id: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateOriginRequest {
    /// ID of the folder that the origin belongs to.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// ID of the origin.
    #[prost(int64, tag = "2")]
    pub origin_id: i64,
    /// IP address or Domain name of your origin and the port (if custom).
    /// Used if \[meta\] variant is `common`.
    /// Required.
    #[prost(string, tag = "3")]
    pub source: ::prost::alloc::string::String,
    /// The setting allows to enable or disable an Origin source in the Origins group.
    ///
    /// It has two possible values:
    ///
    /// True - The origin is enabled and used as a source for the CDN. An origins
    /// group must contain at least one enabled origin. Default value.
    /// False - The origin is disabled and the CDN is not using it to pull content.
    ///
    /// Required.
    #[prost(bool, tag = "4")]
    pub enabled: bool,
    /// Specifies whether the origin is used in its origin group as backup.
    /// A backup origin is used when one of active origins becomes unavailable.
    ///
    /// Required.
    #[prost(bool, tag = "5")]
    pub backup: bool,
    /// Set up type of the origin.
    #[prost(message, optional, tag = "6")]
    pub meta: ::core::option::Option<OriginMeta>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateOriginMetadata {
    /// ID of the origin.
    #[prost(int64, tag = "1")]
    pub origin_id: i64,
    /// Parent origins group ID.
    #[prost(int64, tag = "2")]
    pub origin_group_id: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteOriginRequest {
    /// ID of the folder that the origin belongs to.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// ID of the origin.
    #[prost(int64, tag = "2")]
    pub origin_id: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteOriginMetadata {
    /// ID of the origin.
    #[prost(int64, tag = "1")]
    pub origin_id: i64,
}
/// Generated client implementations.
pub mod origin_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    ///
    /// Origin management service.
    /// Origin is not a standalone entity. It can live only within origin group.
    ///
    #[derive(Debug, Clone)]
    pub struct OriginServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl OriginServiceClient<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> OriginServiceClient<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,
        ) -> OriginServiceClient<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,
        {
            OriginServiceClient::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 origin in origin group.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetOriginRequest>,
        ) -> std::result::Result<tonic::Response<super::Origin>, 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.cdn.v1.OriginService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.cdn.v1.OriginService", "Get"));
            self.inner.unary(req, path, codec).await
        }
        /// Lists origins of origin group.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListOriginsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListOriginsResponse>,
            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.cdn.v1.OriginService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.cdn.v1.OriginService", "List"));
            self.inner.unary(req, path, codec).await
        }
        /// Creates origin inside origin group.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateOriginRequest>,
        ) -> 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.cdn.v1.OriginService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.cdn.v1.OriginService", "Create"));
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified origin from the origin group.
        ///
        /// Changes may take up to 15 minutes to apply. Afterwards, it is recommended to purge cache of the resources that
        /// use the origin via a [CacheService.Purge] request.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateOriginRequest>,
        ) -> 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.cdn.v1.OriginService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.cdn.v1.OriginService", "Update"));
            self.inner.unary(req, path, codec).await
        }
        /// Deletes origin from origin group.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteOriginRequest>,
        ) -> 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.cdn.v1.OriginService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.cdn.v1.OriginService", "Delete"));
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ActivateProviderRequest {
    /// ID of the folder that the activate provider belongs to.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// Specify provider brand/type.
    ///
    /// Possible values: `gcore`.
    #[prost(string, tag = "2")]
    pub provider_type: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ActivateProviderMetadata {
    /// ID of the folder that the activate provider belongs to.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListActivatedProvidersRequest {
    /// ID of the folder that the activate provider belongs to.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListActivatedProvidersResponse {
    /// Creates a list of providers.
    #[prost(string, repeated, tag = "1")]
    pub providers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Generated client implementations.
pub mod provider_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// A set of methods for managing Provider Service resources.
    #[derive(Debug, Clone)]
    pub struct ProviderServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ProviderServiceClient<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> ProviderServiceClient<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,
        ) -> ProviderServiceClient<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,
        {
            ProviderServiceClient::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
        }
        /// Activate provider for specified client.
        pub async fn activate(
            &mut self,
            request: impl tonic::IntoRequest<super::ActivateProviderRequest>,
        ) -> 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.cdn.v1.ProviderService/Activate",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.cdn.v1.ProviderService", "Activate"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// List activated providers for specified client.
        pub async fn list_activated(
            &mut self,
            request: impl tonic::IntoRequest<super::ListActivatedProvidersRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListActivatedProvidersResponse>,
            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.cdn.v1.ProviderService/ListActivated",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.cdn.v1.ProviderService",
                        "ListActivated",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// User settings for Raw logs.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RawLogsSettings {
    /// Destination S3 bucket name, note that the suer should be owner of the bucket.
    #[prost(string, tag = "1")]
    pub bucket_name: ::prost::alloc::string::String,
    /// Bucket region, unused for now, could be blank.
    #[prost(string, tag = "2")]
    pub bucket_region: ::prost::alloc::string::String,
    /// file_prefix: prefix each log object name with specified prefix.
    ///
    /// The prefix makes it simpler for you to locate the log objects.
    /// For example, if you specify the prefix value logs/, each log object that
    /// S3 creates begins with the logs/ prefix in its key, so pseudo S3 folders
    /// could be setup.
    #[prost(string, tag = "3")]
    pub file_prefix: ::prost::alloc::string::String,
}
/// Provider side statuses of Raw logs processing.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum RawLogsStatus {
    Unspecified = 0,
    /// Raw logs wasn't activated.
    NotActivated = 1,
    /// Raw logs was activated, and logs storing process works as expected.
    Ok = 2,
    /// Raw logs was activated, but CDN provider has been failed to store logs.
    Failed = 3,
    /// Raw logs was activated, but logs storing process is expected.
    Pending = 4,
}
impl RawLogsStatus {
    /// 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 {
            RawLogsStatus::Unspecified => "RAW_LOGS_STATUS_UNSPECIFIED",
            RawLogsStatus::NotActivated => "RAW_LOGS_STATUS_NOT_ACTIVATED",
            RawLogsStatus::Ok => "RAW_LOGS_STATUS_OK",
            RawLogsStatus::Failed => "RAW_LOGS_STATUS_FAILED",
            RawLogsStatus::Pending => "RAW_LOGS_STATUS_PENDING",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "RAW_LOGS_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
            "RAW_LOGS_STATUS_NOT_ACTIVATED" => Some(Self::NotActivated),
            "RAW_LOGS_STATUS_OK" => Some(Self::Ok),
            "RAW_LOGS_STATUS_FAILED" => Some(Self::Failed),
            "RAW_LOGS_STATUS_PENDING" => Some(Self::Pending),
            _ => None,
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ActivateRawLogsRequest {
    /// ID of CDN resource to switch logs storage for..
    #[prost(string, tag = "1")]
    pub resource_id: ::prost::alloc::string::String,
    /// Raw logs settings.
    #[prost(message, optional, tag = "2")]
    pub settings: ::core::option::Option<RawLogsSettings>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ActivateRawLogsMetadata {
    /// ID of resource with activated raw logs.
    #[prost(string, tag = "1")]
    pub resource_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ActivateRawLogsResponse {
    /// Raw logs status.
    #[prost(enumeration = "RawLogsStatus", tag = "1")]
    pub status: i32,
    /// Raw logs settings.
    #[prost(message, optional, tag = "2")]
    pub settings: ::core::option::Option<RawLogsSettings>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeactivateRawLogsRequest {
    /// ID of CDN resource to deactivate Raw Logs for.
    #[prost(string, tag = "1")]
    pub resource_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeactivateRawLogsMetadata {
    /// ID of CDN resource.
    #[prost(string, tag = "1")]
    pub resource_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetRawLogsRequest {
    /// ID of CDN resource to request status and settings.
    #[prost(string, tag = "1")]
    pub resource_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetRawLogsResponse {
    /// Raw logs status.
    #[prost(enumeration = "RawLogsStatus", tag = "1")]
    pub status: i32,
    /// Raw logs settings.
    #[prost(message, optional, tag = "2")]
    pub settings: ::core::option::Option<RawLogsSettings>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateRawLogsRequest {
    /// ID of CDN resource.
    #[prost(string, tag = "1")]
    pub resource_id: ::prost::alloc::string::String,
    /// Raw logs settings.
    #[prost(message, optional, tag = "2")]
    pub settings: ::core::option::Option<RawLogsSettings>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateRawLogsResponse {
    /// Raw logs status.
    #[prost(enumeration = "RawLogsStatus", tag = "1")]
    pub status: i32,
    /// Raw logs settings.
    #[prost(message, optional, tag = "2")]
    pub settings: ::core::option::Option<RawLogsSettings>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateRawLogsMetadata {
    /// ID of CDN resource.
    #[prost(string, tag = "1")]
    pub resource_id: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod raw_logs_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    #[derive(Debug, Clone)]
    pub struct RawLogsServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl RawLogsServiceClient<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> RawLogsServiceClient<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,
        ) -> RawLogsServiceClient<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,
        {
            RawLogsServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        pub async fn activate(
            &mut self,
            request: impl tonic::IntoRequest<super::ActivateRawLogsRequest>,
        ) -> 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.cdn.v1.RawLogsService/Activate",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.cdn.v1.RawLogsService", "Activate"),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn deactivate(
            &mut self,
            request: impl tonic::IntoRequest<super::DeactivateRawLogsRequest>,
        ) -> 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.cdn.v1.RawLogsService/Deactivate",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.cdn.v1.RawLogsService", "Deactivate"),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetRawLogsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetRawLogsResponse>,
            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.cdn.v1.RawLogsService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.cdn.v1.RawLogsService", "Get"));
            self.inner.unary(req, path, codec).await
        }
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateRawLogsRequest>,
        ) -> 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.cdn.v1.RawLogsService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.cdn.v1.RawLogsService", "Update"));
            self.inner.unary(req, path, codec).await
        }
    }
}
/// List of secondary (alternative) CNAMEs.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SecondaryHostnames {
    /// List of secondary hostname values.
    #[prost(string, repeated, tag = "1")]
    pub values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
///
/// A CDN resource - representation of providers resource.
///
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Resource {
    /// ID of the resource.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Folder id.
    #[prost(string, tag = "2")]
    pub folder_id: ::prost::alloc::string::String,
    /// CDN endpoint CNAME, must be unique among resources.
    #[prost(string, tag = "3")]
    pub cname: ::prost::alloc::string::String,
    /// Creation timestamp.
    #[prost(message, optional, tag = "4")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Update timestamp.
    #[prost(message, optional, tag = "5")]
    pub updated_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Flag to create Resource either in active or disabled state.
    /// True - the content from CDN is available to clients.
    /// False - the content from CDN isn't available to clients.
    #[prost(bool, tag = "6")]
    pub active: bool,
    /// Resource settings and options to tune CDN edge behavior.
    #[prost(message, optional, tag = "7")]
    pub options: ::core::option::Option<ResourceOptions>,
    /// List of secondary hostname strings.
    #[prost(string, repeated, tag = "8")]
    pub secondary_hostnames: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// ID of the origin group.
    #[prost(int64, tag = "9")]
    pub origin_group_id: i64,
    /// Name of the origin group.
    #[prost(string, tag = "10")]
    pub origin_group_name: ::prost::alloc::string::String,
    /// Specify the protocol schema to be used in communication with origin.
    #[prost(enumeration = "OriginProtocol", tag = "11")]
    pub origin_protocol: i32,
    /// SSL certificate options.
    #[prost(message, optional, tag = "12")]
    pub ssl_certificate: ::core::option::Option<SslCertificate>,
    /// Labels of the resource.
    #[prost(map = "string, string", tag = "13")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// A major set of various resource options.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResourceOptions {
    /// Set up a cache status.
    #[prost(message, optional, tag = "1")]
    pub disable_cache: ::core::option::Option<resource_options::BoolOption>,
    /// Set up \[EdgeCacheSettings\].
    #[prost(message, optional, tag = "2")]
    pub edge_cache_settings: ::core::option::Option<resource_options::EdgeCacheSettings>,
    /// Using \[Int64Option\]. Set up a cache period for the end-users browser.
    /// Content will be cached due to origin settings.
    /// If there are no cache settings on your origin, the content will not be cached.
    /// The list of HTTP response codes that can be cached in browsers: 200, 201, 204, 206, 301, 302, 303, 304, 307, 308.
    /// Other response codes will not be cached.
    /// The default value is 4 days.
    #[prost(message, optional, tag = "3")]
    pub browser_cache_settings: ::core::option::Option<resource_options::Int64Option>,
    /// List HTTP headers that must be included in responses to clients.
    #[prost(message, optional, tag = "4")]
    pub cache_http_headers: ::core::option::Option<resource_options::StringsListOption>,
    /// Set up \[QueryParamsOptions\].
    #[prost(message, optional, tag = "5")]
    pub query_params_options: ::core::option::Option<
        resource_options::QueryParamsOptions,
    >,
    /// Files larger than 10 MB will be requested and cached in parts (no larger than 10 MB each part). It reduces time to first byte.
    ///
    /// The origin must support HTTP Range requests.
    ///
    /// By default the option is disabled.
    #[prost(message, optional, tag = "6")]
    pub slice: ::core::option::Option<resource_options::BoolOption>,
    /// Set up compression variant.
    #[prost(message, optional, tag = "7")]
    pub compression_options: ::core::option::Option<
        resource_options::CompressionOptions,
    >,
    /// Set up redirects.
    #[prost(message, optional, tag = "8")]
    pub redirect_options: ::core::option::Option<resource_options::RedirectOptions>,
    /// Set up host parameters.
    #[prost(message, optional, tag = "9")]
    pub host_options: ::core::option::Option<resource_options::HostOptions>,
    /// Set up static headers that CDN servers send in responses to clients.
    #[prost(message, optional, tag = "10")]
    pub static_headers: ::core::option::Option<resource_options::StringsMapOption>,
    /// Parameter that lets browsers get access to selected resources from a domain
    /// different to a domain from which the request is received.
    /// [Read more](/docs/cdn/concepts/cors).
    #[prost(message, optional, tag = "11")]
    pub cors: ::core::option::Option<resource_options::StringsListOption>,
    /// List of errors which instruct CDN servers to serve stale content to clients.
    ///
    /// Possible values: `error`, `http_403`, `http_404`, `http_429`, `http_500`, `http_502`, `http_503`, `http_504`, `invalid_header`, `timeout`, `updating`.
    #[prost(message, optional, tag = "12")]
    pub stale: ::core::option::Option<resource_options::StringsListOption>,
    /// HTTP methods for your CDN content. By default the following methods
    /// are allowed: GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS.
    /// In case some methods are not allowed to the user, they will get the 405
    /// (Method Not Allowed) response. If the method is not supported,
    /// the user gets the 501 (Not Implemented) response.
    #[prost(message, optional, tag = "13")]
    pub allowed_http_methods: ::core::option::Option<
        resource_options::StringsListOption,
    >,
    /// Allows caching for GET, HEAD and POST requests.
    #[prost(message, optional, tag = "14")]
    pub proxy_cache_methods_set: ::core::option::Option<resource_options::BoolOption>,
    /// Disabling proxy force ranges.
    #[prost(message, optional, tag = "15")]
    pub disable_proxy_force_ranges: ::core::option::Option<resource_options::BoolOption>,
    /// Set up custom headers that CDN servers send in requests to origins.
    /// The Header name field can contain letters (A-Z, a-z), numbers (0-9), dashes (-) and underscores (_).
    /// The Value field can contain letters (A-Z, a-z), numbers (0-9), dashes (-),
    /// underscores (_), slashes (/), colons (:), equal (=), dots (.), and spaces.
    #[prost(message, optional, tag = "16")]
    pub static_request_headers: ::core::option::Option<
        resource_options::StringsMapOption,
    >,
    /// Wildcard additional CNAME.
    /// If a resource has a wildcard additional CNAME, you can use your own certificate for content delivery via HTTPS. Read-only.
    #[prost(message, optional, tag = "17")]
    pub custom_server_name: ::core::option::Option<resource_options::StringOption>,
    /// Using \[BoolOption\] for ignoring cookie.
    #[prost(message, optional, tag = "18")]
    pub ignore_cookie: ::core::option::Option<resource_options::BoolOption>,
    /// Changing or redirecting query paths.
    #[prost(message, optional, tag = "19")]
    pub rewrite: ::core::option::Option<resource_options::RewriteOption>,
    /// Secure token to protect contect and limit access by IP addresses and time limits.
    #[prost(message, optional, tag = "20")]
    pub secure_key: ::core::option::Option<resource_options::SecureKeyOption>,
    /// Manage the state of the IP access policy option.
    /// The option controls access to content from the specified IP addresses.
    #[prost(message, optional, tag = "21")]
    pub ip_address_acl: ::core::option::Option<resource_options::IpAddressAclOption>,
}
/// Nested message and enum types in `ResourceOptions`.
pub mod resource_options {
    /// Set up bool values.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct BoolOption {
        /// True - the option is enabled and its \[value\] is applied to the resource.
        /// False - the option is disabled and its default value is used for the resource.
        #[prost(bool, tag = "1")]
        pub enabled: bool,
        /// Value of the option.
        #[prost(bool, tag = "2")]
        pub value: bool,
    }
    /// A set of the string parameters.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct StringOption {
        /// True - the option is enabled and its \[value\] is applied to the resource.
        /// False - the option is disabled and its default value is used for the resource.
        #[prost(bool, tag = "1")]
        pub enabled: bool,
        /// Value of the option.
        #[prost(string, tag = "2")]
        pub value: ::prost::alloc::string::String,
    }
    /// A set of the numeric parameters.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Int64Option {
        /// True - the option is enabled and its \[value\] is applied to the resource.
        /// False - the option is disabled and its default value is used for the resource.
        #[prost(bool, tag = "1")]
        pub enabled: bool,
        /// Value of the option.
        #[prost(int64, tag = "2")]
        pub value: i64,
    }
    /// A set of the string list parameters.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct StringsListOption {
        /// True - the option is enabled and its \[value\] is applied to the resource.
        /// False - the option is disabled and its default value is used for the resource.
        #[prost(bool, tag = "1")]
        pub enabled: bool,
        /// Value of the option.
        #[prost(string, repeated, tag = "2")]
        pub value: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    }
    /// A set of the strings map parameters.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct StringsMapOption {
        /// True - the option is enabled and its \[value\] is applied to the resource.
        /// False - the option is disabled and its default value is used for the resource.
        #[prost(bool, tag = "1")]
        pub enabled: bool,
        /// Value of the option.
        #[prost(map = "string, string", tag = "2")]
        pub value: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            ::prost::alloc::string::String,
        >,
    }
    /// A set of the caching response time parameters.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct CachingTimes {
        /// Caching time for a response with codes 200, 206, 301, 302.
        /// Responses with codes 4xx, 5xx will not be cached. Use `0s` disable to caching.
        /// Use \[custom_values\] field to specify a custom caching time for a response with specific codes.
        #[prost(int64, tag = "1")]
        pub simple_value: i64,
        /// Caching time for a response with specific codes. These settings have a higher priority than the value field.
        /// Response code (`304`, `404` for example). Use `any` to specify caching time for all response codes.
        /// Caching time in seconds (`0s`, `600s` for example). Use `0s` to disable caching for a specific response code.
        #[prost(map = "string, int64", tag = "2")]
        pub custom_values: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            i64,
        >,
    }
    /// A set of the edge cache parameters.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct EdgeCacheSettings {
        /// True - the option is enabled and its `values_variant` is applied to the resource.
        /// False - the option is disabled and its default value is used for the resource.
        #[prost(bool, tag = "1")]
        pub enabled: bool,
        #[prost(oneof = "edge_cache_settings::ValuesVariant", tags = "2, 3")]
        pub values_variant: ::core::option::Option<edge_cache_settings::ValuesVariant>,
    }
    /// Nested message and enum types in `EdgeCacheSettings`.
    pub mod edge_cache_settings {
        #[allow(clippy::derive_partial_eq_without_eq)]
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum ValuesVariant {
            /// Value of the option.
            #[prost(message, tag = "2")]
            Value(super::CachingTimes),
            /// Content will be cached according to origin cache settings.
            /// The value applies for a response with codes 200, 201, 204, 206, 301, 302, 303, 304, 307, 308
            /// if an origin server does not have caching HTTP headers.
            /// Responses with other codes will not be cached.
            #[prost(int64, tag = "3")]
            DefaultValue(i64),
        }
    }
    /// A set of the string variable map parameters.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct StringVariableMapOption {
        /// True - the option is enabled and its \[value\] is applied to the resource.
        /// False - the option is disabled and its default value is used for the resource.
        #[prost(bool, tag = "1")]
        pub enabled: bool,
        /// Value of the option.
        #[prost(map = "string, message", tag = "2")]
        pub value: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            string_variable_map_option::OneofString,
        >,
    }
    /// Nested message and enum types in `StringVariableMapOption`.
    pub mod string_variable_map_option {
        #[allow(clippy::derive_partial_eq_without_eq)]
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct OneofString {
            #[prost(oneof = "oneof_string::StringOption", tags = "1, 2")]
            pub string_option: ::core::option::Option<oneof_string::StringOption>,
        }
        /// Nested message and enum types in `OneofString`.
        pub mod oneof_string {
            #[allow(clippy::derive_partial_eq_without_eq)]
            #[derive(Clone, PartialEq, ::prost::Oneof)]
            pub enum StringOption {
                /// Using \[StringOption\] to set value.
                #[prost(message, tag = "1")]
                Value(super::super::StringOption),
                /// Using \[StringsListOption\] to set values.
                #[prost(message, tag = "2")]
                Values(super::super::StringsListOption),
            }
        }
    }
    /// A set of the query parameters.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct QueryParamsOptions {
        #[prost(oneof = "query_params_options::QueryParamsVariant", tags = "1, 2, 3")]
        pub query_params_variant: ::core::option::Option<
            query_params_options::QueryParamsVariant,
        >,
    }
    /// Nested message and enum types in `QueryParamsOptions`.
    pub mod query_params_options {
        #[allow(clippy::derive_partial_eq_without_eq)]
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum QueryParamsVariant {
            /// Using \[BoolOption\]. Selected by default. Files with different query parameters are cached as objects with the same key regardless of the parameter value.
            #[prost(message, tag = "1")]
            IgnoreQueryString(super::BoolOption),
            /// Ignore All Except.
            /// Files with the specified query parameters are cached as objects with different keys,
            /// files with other parameters are cached as objects with the same key.
            #[prost(message, tag = "2")]
            QueryParamsWhitelist(super::StringsListOption),
            /// Ignore only. Files with the specified query parameters are cached as objects with the same key,
            /// files with other parameters are cached as objects with different keys.
            #[prost(message, tag = "3")]
            QueryParamsBlacklist(super::StringsListOption),
        }
    }
    /// A set of the redirect parameters.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RedirectOptions {
        #[prost(oneof = "redirect_options::RedirectVariant", tags = "1, 2")]
        pub redirect_variant: ::core::option::Option<redirect_options::RedirectVariant>,
    }
    /// Nested message and enum types in `RedirectOptions`.
    pub mod redirect_options {
        #[allow(clippy::derive_partial_eq_without_eq)]
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum RedirectVariant {
            /// Using \[BoolOption\]. Set up a redirect from HTTPS to HTTP.
            #[prost(message, tag = "1")]
            RedirectHttpToHttps(super::BoolOption),
            /// Using \[BoolOption\]. Set up a redirect from HTTP to HTTPS.
            #[prost(message, tag = "2")]
            RedirectHttpsToHttp(super::BoolOption),
        }
    }
    /// A set of the host parameters.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct HostOptions {
        #[prost(oneof = "host_options::HostVariant", tags = "1, 2")]
        pub host_variant: ::core::option::Option<host_options::HostVariant>,
    }
    /// Nested message and enum types in `HostOptions`.
    pub mod host_options {
        #[allow(clippy::derive_partial_eq_without_eq)]
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum HostVariant {
            /// Custom value for the Host header.
            ///
            /// Your server must be able to process requests with the chosen header.
            ///
            /// Default value (if \[StringOption.enabled\] is `false`) is \[Resource.cname\].
            #[prost(message, tag = "1")]
            Host(super::StringOption),
            /// Using \[BoolOption\]. Choose the Forward Host header option if is important to send in the request to the Origin
            /// the same Host header as was sent in the request to CDN server.
            #[prost(message, tag = "2")]
            ForwardHostHeader(super::BoolOption),
        }
    }
    /// A set of the compression variant parameters.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct CompressionOptions {
        #[prost(oneof = "compression_options::CompressionVariant", tags = "1, 2, 3")]
        pub compression_variant: ::core::option::Option<
            compression_options::CompressionVariant,
        >,
    }
    /// Nested message and enum types in `CompressionOptions`.
    pub mod compression_options {
        #[allow(clippy::derive_partial_eq_without_eq)]
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum CompressionVariant {
            /// The Fetch compressed option helps you to reduce
            /// the bandwidth between origin and CDN servers.
            /// Also, content delivery speed becomes higher because of reducing the time
            /// for compressing files in a CDN.
            #[prost(message, tag = "1")]
            FetchCompressed(super::BoolOption),
            /// Using \[BoolOption\]. GZip compression at CDN servers reduces file size by 70% and can be as high as 90%.
            #[prost(message, tag = "2")]
            GzipOn(super::BoolOption),
            /// The option allows to compress content with brotli on the CDN's end.
            ///
            /// Compression is performed on the Origin Shielding. If a pre-cache server doesn't active for a resource, compression does not occur even if the option is enabled.
            ///
            /// Specify the content-type for each type of content you wish to have compressed. CDN servers will request only uncompressed content from the origin.
            #[prost(message, tag = "3")]
            BrotliCompression(super::StringsListOption),
        }
    }
    /// An option for changing or redirecting query paths.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RewriteOption {
        /// True - the option is enabled and its \[flag\] is applied to the resource.
        /// False - the option is disabled and its default value of the \[flag\] is used for the resource.
        #[prost(bool, tag = "1")]
        pub enabled: bool,
        /// Pattern for rewrite.
        ///
        /// The value must have the following format: `<source path> <destination path>`, where both paths are regular expressions which use at least one group. E.g., `/foo/(.*) /bar/$1`.
        #[prost(string, tag = "2")]
        pub body: ::prost::alloc::string::String,
        /// Break flag is applied to the option by default.
        /// It is not shown in the field.
        #[prost(enumeration = "super::RewriteFlag", tag = "3")]
        pub flag: i32,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SecureKeyOption {
        /// True - the option is enabled and its \[flag\] is applied to the resource.
        /// False - the option is disabled and its default value of the \[flag\] is used for the resource.
        #[prost(bool, tag = "1")]
        pub enabled: bool,
        /// The key for the URL signing.
        #[prost(string, tag = "2")]
        pub key: ::prost::alloc::string::String,
        /// The type of the URL signing. The URL could be available for all IP addresses or for the only one IP.
        #[prost(enumeration = "super::SecureKeyUrlType", tag = "3")]
        pub r#type: i32,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct IpAddressAclOption {
        /// True - the option is enabled and its \[flag\] is applied to the resource.
        /// False - the option is disabled and its default value of the \[flag\] is used for the resource.
        #[prost(bool, tag = "1")]
        pub enabled: bool,
        /// The policy type. One of allow or deny value.
        #[prost(enumeration = "super::PolicyType", tag = "2")]
        pub policy_type: i32,
        /// The list of IP addresses to be allowed or denied.
        #[prost(string, repeated, tag = "3")]
        pub excepted_values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    }
}
/// A set of the personal SSL certificate parameters.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SslTargetCertificate {
    /// Type of the certificate.
    #[prost(enumeration = "SslCertificateType", tag = "1")]
    pub r#type: i32,
    /// Certificate data.
    #[prost(message, optional, tag = "2")]
    pub data: ::core::option::Option<SslCertificateData>,
}
/// A SSL certificate parameters.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SslCertificate {
    /// Type of the certificate.
    #[prost(enumeration = "SslCertificateType", tag = "1")]
    pub r#type: i32,
    /// Active status.
    #[prost(enumeration = "SslCertificateStatus", tag = "2")]
    pub status: i32,
    /// Certificate data.
    #[prost(message, optional, tag = "3")]
    pub data: ::core::option::Option<SslCertificateData>,
}
/// A certificate data parameters.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SslCertificateData {
    #[prost(oneof = "ssl_certificate_data::SslCertificateDataVariant", tags = "1")]
    pub ssl_certificate_data_variant: ::core::option::Option<
        ssl_certificate_data::SslCertificateDataVariant,
    >,
}
/// Nested message and enum types in `SSLCertificateData`.
pub mod ssl_certificate_data {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum SslCertificateDataVariant {
        /// Custom (add your SSL certificate by uploading the certificate
        /// in PEM format and your private key).
        #[prost(message, tag = "1")]
        Cm(super::SslCertificateCmData),
    }
}
/// A certificate data custom parameters.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SslCertificateCmData {
    /// ID of the custom certificate.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
}
/// This option defines the protocol that will be used by CDN servers to request
/// content from an origin source. If not specified, we will use HTTP to connect
/// to an origin server.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum OriginProtocol {
    Unspecified = 0,
    /// CDN servers will connect to your origin via HTTP.
    Http = 1,
    /// CDN servers will connect to your origin via HTTPS.
    Https = 2,
    /// Connection protocol will be chosen automatically (content on the
    /// origin source should be available for the CDN both through HTTP and HTTPS).
    Match = 3,
}
impl OriginProtocol {
    /// 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 {
            OriginProtocol::Unspecified => "ORIGIN_PROTOCOL_UNSPECIFIED",
            OriginProtocol::Http => "HTTP",
            OriginProtocol::Https => "HTTPS",
            OriginProtocol::Match => "MATCH",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "ORIGIN_PROTOCOL_UNSPECIFIED" => Some(Self::Unspecified),
            "HTTP" => Some(Self::Http),
            "HTTPS" => Some(Self::Https),
            "MATCH" => Some(Self::Match),
            _ => None,
        }
    }
}
/// RewriteFlag defines flag for the Rewrite option.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum RewriteFlag {
    Unspecified = 0,
    /// Stops processing of the current set of ngx_http_rewrite_module directives and
    /// starts a search for a new location matching changed URI.
    Last = 1,
    /// Stops processing of the current set of the Rewrite option.
    Break = 2,
    /// Returns a temporary redirect with the 302 code; It is used when a replacement string does not start
    /// with "<http://",> "<https://",> or "$scheme".
    Redirect = 3,
    /// Returns a permanent redirect with the 301 code.
    Permanent = 4,
}
impl RewriteFlag {
    /// 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 {
            RewriteFlag::Unspecified => "REWRITE_FLAG_UNSPECIFIED",
            RewriteFlag::Last => "LAST",
            RewriteFlag::Break => "BREAK",
            RewriteFlag::Redirect => "REDIRECT",
            RewriteFlag::Permanent => "PERMANENT",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "REWRITE_FLAG_UNSPECIFIED" => Some(Self::Unspecified),
            "LAST" => Some(Self::Last),
            "BREAK" => Some(Self::Break),
            "REDIRECT" => Some(Self::Redirect),
            "PERMANENT" => Some(Self::Permanent),
            _ => None,
        }
    }
}
/// SecureKeyURLType defines type of the URL signing.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SecureKeyUrlType {
    Unspecified = 0,
    /// Use scpecific IP address in URL signing. URL will be availible only for this IP.
    EnableIpSigning = 1,
    /// Sign URL without using IP address. URL will be available for all IP addresses.
    DisableIpSigning = 2,
}
impl SecureKeyUrlType {
    /// 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 {
            SecureKeyUrlType::Unspecified => "SECURE_KEY_URL_TYPE_UNSPECIFIED",
            SecureKeyUrlType::EnableIpSigning => "ENABLE_IP_SIGNING",
            SecureKeyUrlType::DisableIpSigning => "DISABLE_IP_SIGNING",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SECURE_KEY_URL_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "ENABLE_IP_SIGNING" => Some(Self::EnableIpSigning),
            "DISABLE_IP_SIGNING" => Some(Self::DisableIpSigning),
            _ => None,
        }
    }
}
/// PolicyType defines type of the policy in IP address acl rules.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum PolicyType {
    Unspecified = 0,
    /// Allow access to all IP addresses except the ones specified in the excepted_values field.
    Allow = 1,
    /// Block access to all IP addresses except the ones specified in the excepted_values field.
    Deny = 2,
}
impl PolicyType {
    /// 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 {
            PolicyType::Unspecified => "POLICY_TYPE_UNSPECIFIED",
            PolicyType::Allow => "POLICY_TYPE_ALLOW",
            PolicyType::Deny => "POLICY_TYPE_DENY",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "POLICY_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "POLICY_TYPE_ALLOW" => Some(Self::Allow),
            "POLICY_TYPE_DENY" => Some(Self::Deny),
            _ => None,
        }
    }
}
/// A certificate type parameters.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SslCertificateType {
    /// SSL certificate is unspecified.
    Unspecified = 0,
    /// No SSL certificate is added, the requests are sent via HTTP.
    DontUse = 1,
    /// The option is deprecated. Works only if you have already pointed your domain name to the protected IP address in your DNS.
    LetsEncryptGcore = 2,
    /// Add your SSL certificate by uploading the certificate in PEM format and your private key.
    Cm = 3,
}
impl SslCertificateType {
    /// 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 {
            SslCertificateType::Unspecified => "SSL_CERTIFICATE_TYPE_UNSPECIFIED",
            SslCertificateType::DontUse => "DONT_USE",
            SslCertificateType::LetsEncryptGcore => "LETS_ENCRYPT_GCORE",
            SslCertificateType::Cm => "CM",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SSL_CERTIFICATE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "DONT_USE" => Some(Self::DontUse),
            "LETS_ENCRYPT_GCORE" => Some(Self::LetsEncryptGcore),
            "CM" => Some(Self::Cm),
            _ => None,
        }
    }
}
/// A certificate status parameters.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SslCertificateStatus {
    /// SSL certificate is unspecified.
    Unspecified = 0,
    /// SSL certificate is ready to use.
    Ready = 1,
    /// The option is deprecated. SSL certificate is creating.
    Creating = 2,
}
impl SslCertificateStatus {
    /// 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 {
            SslCertificateStatus::Unspecified => "SSL_CERTIFICATE_STATUS_UNSPECIFIED",
            SslCertificateStatus::Ready => "READY",
            SslCertificateStatus::Creating => "CREATING",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SSL_CERTIFICATE_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
            "READY" => Some(Self::Ready),
            "CREATING" => Some(Self::Creating),
            _ => None,
        }
    }
}
/// A request to get a resource.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetResourceRequest {
    /// ID of the requested resource.
    #[prost(string, tag = "1")]
    pub resource_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListResourcesRequest {
    /// ID of the folder to request listing for.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\],
    /// the service returns a \[ListResourcesResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results,
    /// set \[page_token\] to the \[ListResourcesResponse.next_page_token\]
    /// returned by a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListResourcesResponse {
    /// List of the resources
    #[prost(message, repeated, tag = "1")]
    pub resources: ::prost::alloc::vec::Vec<Resource>,
    /// \[next_page_token\] token allows you to get the next page of results for list requests.
    /// If the number of results is larger than \[ListResourcesRequest.page_size\], use
    /// the \[next_page_token\] as the value for the \[ListResourcesRequest.page_token\] query parameter
    /// in the next list request. Each subsequent list request will have its own
    /// \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateResourceRequest {
    /// ID of the to bind with new resource.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// CDN endpoint CNAME, must be unique among clients's resources.
    #[prost(string, tag = "2")]
    pub cname: ::prost::alloc::string::String,
    /// Specify the origins to be used for CDN resources requests.
    #[prost(message, optional, tag = "3")]
    pub origin: ::core::option::Option<create_resource_request::Origin>,
    /// List of additional CNAMEs.
    #[prost(message, optional, tag = "4")]
    pub secondary_hostnames: ::core::option::Option<SecondaryHostnames>,
    /// Specify the protocol schema to be used in communication with origin.
    #[prost(enumeration = "OriginProtocol", tag = "5")]
    pub origin_protocol: i32,
    /// Flag to create Resource either in active or disabled state.
    /// In active state Origins payload could be transmitted from CDN CNAME requests.
    /// Default value: true
    #[prost(message, optional, tag = "6")]
    pub active: ::core::option::Option<bool>,
    /// Resource settings and options to tune CDN edge behavior. Most is unset.
    #[prost(message, optional, tag = "7")]
    pub options: ::core::option::Option<ResourceOptions>,
    /// SSL Certificate options.
    #[prost(message, optional, tag = "8")]
    pub ssl_certificate: ::core::option::Option<SslTargetCertificate>,
    /// Labels of the resource.
    #[prost(map = "string, string", tag = "9")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// Nested message and enum types in `CreateResourceRequest`.
pub mod create_resource_request {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Origin {
        #[prost(oneof = "origin::OriginVariant", tags = "1, 2, 3")]
        pub origin_variant: ::core::option::Option<origin::OriginVariant>,
    }
    /// Nested message and enum types in `Origin`.
    pub mod origin {
        #[allow(clippy::derive_partial_eq_without_eq)]
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum OriginVariant {
            /// ID of pre-created origin group.
            #[prost(int64, tag = "1")]
            OriginGroupId(i64),
            /// Create new Origins group with single source, it's id will be
            /// returned in result.
            #[prost(string, tag = "2")]
            OriginSource(::prost::alloc::string::String),
            /// Set up resource origin parameters.
            #[prost(message, tag = "3")]
            OriginSourceParams(super::super::ResourceOriginParams),
        }
    }
}
/// A set of resource origin parameters.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResourceOriginParams {
    /// Source of the content.
    #[prost(string, tag = "1")]
    pub source: ::prost::alloc::string::String,
    /// Set up type of the origin.
    #[prost(message, optional, tag = "2")]
    pub meta: ::core::option::Option<OriginMeta>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateResourceMetadata {
    /// ID of created resource.
    #[prost(string, tag = "1")]
    pub resource_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateResourceRequest {
    /// ID of updated resource.
    #[prost(string, tag = "1")]
    pub resource_id: ::prost::alloc::string::String,
    /// ID of updated origin group.
    #[prost(message, optional, tag = "2")]
    pub origin_group_id: ::core::option::Option<i64>,
    /// List of additional CNAMEs.
    #[prost(message, optional, tag = "3")]
    pub secondary_hostnames: ::core::option::Option<SecondaryHostnames>,
    /// Resource settings and options to tune CDN edge behavior.
    #[prost(message, optional, tag = "4")]
    pub options: ::core::option::Option<ResourceOptions>,
    /// Specify the protocol schema to be used in communication with origin.
    #[prost(enumeration = "OriginProtocol", tag = "5")]
    pub origin_protocol: i32,
    /// Flag to create Resource either in active or disabled state.
    /// In active state Origins payload could be transmitted from CDN CNAME requests.
    /// Default value: true
    #[prost(message, optional, tag = "6")]
    pub active: ::core::option::Option<bool>,
    /// SSL Certificate options.
    #[prost(message, optional, tag = "7")]
    pub ssl_certificate: ::core::option::Option<SslTargetCertificate>,
    /// Resource labels. At some point will be needed for granular detailing.
    #[prost(map = "string, string", tag = "8")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// If flag is set to true resource labels will be deleted.
    #[prost(bool, tag = "9")]
    pub remove_labels: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateResourceMetadata {
    /// ID of updated resource.
    #[prost(string, tag = "1")]
    pub resource_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteResourceRequest {
    /// ID of resource to delete.
    #[prost(string, tag = "1")]
    pub resource_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteResourceMetadata {
    /// ID of deleted resource.
    #[prost(string, tag = "1")]
    pub resource_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetProviderCNameRequest {
    /// Folder ID to get provider's CNAME.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetProviderCNameResponse {
    /// Provider's CNAME.
    #[prost(string, tag = "1")]
    pub cname: ::prost::alloc::string::String,
    /// ID of the folder that the provider belongs to.
    #[prost(string, tag = "2")]
    pub folder_id: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod resource_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Provider's resources management service.
    #[derive(Debug, Clone)]
    pub struct ResourceServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ResourceServiceClient<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> ResourceServiceClient<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,
        ) -> ResourceServiceClient<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,
        {
            ResourceServiceClient::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 client's CDN resource by resource id.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetResourceRequest>,
        ) -> std::result::Result<tonic::Response<super::Resource>, 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.cdn.v1.ResourceService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.cdn.v1.ResourceService", "Get"));
            self.inner.unary(req, path, codec).await
        }
        /// Lists CDN resources.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListResourcesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListResourcesResponse>,
            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.cdn.v1.ResourceService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.cdn.v1.ResourceService", "List"));
            self.inner.unary(req, path, codec).await
        }
        /// Creates a CDN resource in the specified folder.
        ///
        /// Creation may take up to 15 minutes.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateResourceRequest>,
        ) -> 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.cdn.v1.ResourceService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.cdn.v1.ResourceService", "Create"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified CDN resource.
        ///
        /// The method implements patch behaviour, i.e. only the fields specified in the request are updated in the resource.
        ///
        /// Changes may take up to 15 minutes to apply. Afterwards, it is recommended to purge the resource's cache via a
        /// [CacheService.Purge] request.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateResourceRequest>,
        ) -> 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.cdn.v1.ResourceService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.cdn.v1.ResourceService", "Update"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes client's CDN resource.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteResourceRequest>,
        ) -> 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.cdn.v1.ResourceService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.cdn.v1.ResourceService", "Delete"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get Provider's CNAME (edge endpoint) bind to specified folder id.
        /// Returns UNIMPLEMENTED error, if provider doesn't support CNAME request.
        pub async fn get_provider_c_name(
            &mut self,
            request: impl tonic::IntoRequest<super::GetProviderCNameRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetProviderCNameResponse>,
            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.cdn.v1.ResourceService/GetProviderCName",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.cdn.v1.ResourceService",
                        "GetProviderCName",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Resource rule.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Rule {
    /// Rule ID.
    #[prost(int64, tag = "1")]
    pub id: i64,
    /// Rule name.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Rule pattern.
    /// Must be a valid regular expression.
    #[prost(string, tag = "3")]
    pub rule_pattern: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "4")]
    pub options: ::core::option::Option<ResourceOptions>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListResourceRulesRequest {
    /// ID of resource.
    #[prost(string, tag = "1")]
    pub resource_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListResourceRulesResponse {
    /// List of the resource rules.
    #[prost(message, repeated, tag = "1")]
    pub rules: ::prost::alloc::vec::Vec<Rule>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateResourceRuleRequest {
    /// ID of resource.
    #[prost(string, tag = "1")]
    pub resource_id: ::prost::alloc::string::String,
    /// Name of created resource rule.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Resource rule pattern.
    #[prost(string, tag = "3")]
    pub rule_pattern: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "4")]
    pub options: ::core::option::Option<ResourceOptions>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateResourceRuleMetadata {
    /// ID of resource.
    #[prost(string, tag = "1")]
    pub resource_id: ::prost::alloc::string::String,
    /// ID of created resource rule.
    #[prost(int64, tag = "2")]
    pub rule_id: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetResourceRuleRequest {
    /// ID of resource.
    #[prost(string, tag = "1")]
    pub resource_id: ::prost::alloc::string::String,
    /// ID of the requested resource rule.
    #[prost(int64, tag = "2")]
    pub rule_id: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateResourceRuleRequest {
    /// ID of resource.
    #[prost(string, tag = "1")]
    pub resource_id: ::prost::alloc::string::String,
    /// ID of updated resource rule.
    #[prost(int64, tag = "2")]
    pub rule_id: i64,
    /// Name of updated resource rule.
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    /// Resource rule pattern.
    #[prost(string, tag = "4")]
    pub rule_pattern: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "5")]
    pub options: ::core::option::Option<ResourceOptions>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateResourceRuleMetadata {
    /// ID of resource.
    #[prost(string, tag = "1")]
    pub resource_id: ::prost::alloc::string::String,
    /// ID of updated resource rule.
    #[prost(int64, tag = "2")]
    pub rule_id: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteResourceRuleRequest {
    /// ID of resource.
    #[prost(string, tag = "1")]
    pub resource_id: ::prost::alloc::string::String,
    /// ID of deleted resource rule.
    #[prost(int64, tag = "2")]
    pub rule_id: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteResourceRuleMetadata {
    /// ID of resource.
    #[prost(string, tag = "1")]
    pub resource_id: ::prost::alloc::string::String,
    /// ID of deleted resource rule.
    #[prost(int64, tag = "2")]
    pub rule_id: i64,
}
/// Generated client implementations.
pub mod resource_rules_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    ///
    /// Rules management service.
    ///
    /// Used for Resources Rules management.
    ///
    #[derive(Debug, Clone)]
    pub struct ResourceRulesServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ResourceRulesServiceClient<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> ResourceRulesServiceClient<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,
        ) -> ResourceRulesServiceClient<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,
        {
            ResourceRulesServiceClient::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
        }
        /// List all rules for specified resource.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListResourceRulesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListResourceRulesResponse>,
            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.cdn.v1.ResourceRulesService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.cdn.v1.ResourceRulesService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Create new resource rule with specified unique name and rule patter.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateResourceRuleRequest>,
        ) -> 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.cdn.v1.ResourceRulesService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.cdn.v1.ResourceRulesService", "Create"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get specified by id resource rule.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetResourceRuleRequest>,
        ) -> std::result::Result<tonic::Response<super::Rule>, 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.cdn.v1.ResourceRulesService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.cdn.v1.ResourceRulesService", "Get"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Update specified by id resource rule.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateResourceRuleRequest>,
        ) -> 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.cdn.v1.ResourceRulesService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.cdn.v1.ResourceRulesService", "Update"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Delete specified by id resource rule.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteResourceRuleRequest>,
        ) -> 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.cdn.v1.ResourceRulesService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.cdn.v1.ResourceRulesService", "Delete"),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}