yandex_cloud/

yandex.cloud.logging.v1.rs

/// Log entry resource specification.
///
/// May be used either by services and by user.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LogEntryResource {
    /// Resource type, i.e., `serverless.function`
    #[prost(string, tag = "1")]
    pub r#type: ::prost::alloc::string::String,
    /// Resource ID, i.e., ID of the function producing logs.
    #[prost(string, tag = "2")]
    pub id: ::prost::alloc::string::String,
}
/// Log group resource.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LogGroupResource {
    /// Resource type.
    ///
    /// Collected from log entries inside log group.
    #[prost(string, tag = "1")]
    pub r#type: ::prost::alloc::string::String,
    /// List of resource IDs with the same resource type.
    #[prost(string, repeated, tag = "2")]
    pub ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LogEntry {
    /// Unique entry ID.
    ///
    /// Useful for logs deduplication.
    #[prost(string, tag = "1")]
    pub uid: ::prost::alloc::string::String,
    /// Entry resource specification.
    ///
    /// May contain information about source service and resource ID.
    /// Also may be provided by the user.
    #[prost(message, optional, tag = "2")]
    pub resource: ::core::option::Option<LogEntryResource>,
    /// Timestamp of the entry.
    #[prost(message, optional, tag = "3")]
    pub timestamp: ::core::option::Option<::prost_types::Timestamp>,
    /// Entry ingestion time observed by \[LogIngestionService\].
    #[prost(message, optional, tag = "4")]
    pub ingested_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Entry save time.
    ///
    /// Entry is ready to be read since this moment.
    #[prost(message, optional, tag = "5")]
    pub saved_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Entry severity.
    ///
    /// See \[LogLevel.Level\] for details.
    #[prost(enumeration = "log_level::Level", tag = "6")]
    pub level: i32,
    /// Entry text message.
    #[prost(string, tag = "7")]
    pub message: ::prost::alloc::string::String,
    /// Entry annotation.
    #[prost(message, optional, tag = "8")]
    pub json_payload: ::core::option::Option<::prost_types::Struct>,
    /// Entry stream name.
    #[prost(string, tag = "9")]
    pub stream_name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IncomingLogEntry {
    /// Timestamp of the entry.
    #[prost(message, optional, tag = "1")]
    pub timestamp: ::core::option::Option<::prost_types::Timestamp>,
    /// Entry severity.
    ///
    /// See \[LogLevel.Level\] for details.
    #[prost(enumeration = "log_level::Level", tag = "2")]
    pub level: i32,
    /// Entry text message.
    #[prost(string, tag = "3")]
    pub message: ::prost::alloc::string::String,
    /// Entry annotation.
    #[prost(message, optional, tag = "4")]
    pub json_payload: ::core::option::Option<::prost_types::Struct>,
    /// Entry stream name.
    #[prost(string, tag = "5")]
    pub stream_name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LogEntryDefaults {
    /// Default entry severity.
    /// Will be applied if entry level is unspecified.
    ///
    /// See \[LogLevel.Level\] for details.
    #[prost(enumeration = "log_level::Level", tag = "2")]
    pub level: i32,
    /// Default entry annotation.
    /// Will be merged with entry annotation.
    /// Any conflict will be resolved in favor of entry own annotation.
    #[prost(message, optional, tag = "4")]
    pub json_payload: ::core::option::Option<::prost_types::Struct>,
    /// Entry stream name.
    #[prost(string, tag = "5")]
    pub stream_name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Destination {
    /// Entry destination.
    #[prost(oneof = "destination::Destination", tags = "1, 2")]
    pub destination: ::core::option::Option<destination::Destination>,
}
/// Nested message and enum types in `Destination`.
pub mod destination {
    /// Entry destination.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Destination {
        /// Entry should be written to log group resolved by ID.
        #[prost(string, tag = "1")]
        LogGroupId(::prost::alloc::string::String),
        /// Entry should be written to default log group for the folder.
        #[prost(string, tag = "2")]
        FolderId(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LogLevel {
    /// Entry level.
    ///
    /// See \[Level\] for possible values.
    #[prost(enumeration = "log_level::Level", tag = "1")]
    pub level: i32,
}
/// Nested message and enum types in `LogLevel`.
pub mod log_level {
    /// Possible log levels for entries.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Level {
        /// Default log level.
        ///
        /// Equivalent to not specifying log level at all.
        Unspecified = 0,
        /// Trace log level.
        ///
        /// Possible use case: verbose logging of some business logic.
        Trace = 1,
        /// Debug log level.
        ///
        /// Possible use case: debugging special cases in application logic.
        Debug = 2,
        /// Info log level.
        ///
        /// Mostly used for information messages.
        Info = 3,
        /// Warn log level.
        ///
        /// May be used to alert about significant events.
        Warn = 4,
        /// Error log level.
        ///
        /// May be used to alert about errors in infrastructure, logic, etc.
        Error = 5,
        /// Fatal log level.
        ///
        /// May be used to alert about unrecoverable failures and events.
        Fatal = 6,
    }
    impl Level {
        /// 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 {
                Level::Unspecified => "LEVEL_UNSPECIFIED",
                Level::Trace => "TRACE",
                Level::Debug => "DEBUG",
                Level::Info => "INFO",
                Level::Warn => "WARN",
                Level::Error => "ERROR",
                Level::Fatal => "FATAL",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "LEVEL_UNSPECIFIED" => Some(Self::Unspecified),
                "TRACE" => Some(Self::Trace),
                "DEBUG" => Some(Self::Debug),
                "INFO" => Some(Self::Info),
                "WARN" => Some(Self::Warn),
                "ERROR" => Some(Self::Error),
                "FATAL" => Some(Self::Fatal),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Export {
    /// Export ID.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Export folder ID.
    #[prost(string, tag = "2")]
    pub folder_id: ::prost::alloc::string::String,
    /// Export cloud ID.
    #[prost(string, tag = "3")]
    pub cloud_id: ::prost::alloc::string::String,
    /// Export creation time.
    #[prost(message, optional, tag = "4")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Export name.
    #[prost(string, tag = "5")]
    pub name: ::prost::alloc::string::String,
    /// Export description.
    #[prost(string, tag = "6")]
    pub description: ::prost::alloc::string::String,
    /// Export lables.
    #[prost(map = "string, string", tag = "7")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Group logs are exported from.
    #[prost(string, tag = "8")]
    pub group_id: ::prost::alloc::string::String,
    /// Sink logs are exported to.
    #[prost(string, tag = "9")]
    pub sink_id: ::prost::alloc::string::String,
    /// Parameters of logs filtration.
    #[prost(message, optional, tag = "10")]
    pub params: ::core::option::Option<ExportParams>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExportParams {
    #[prost(string, repeated, tag = "1")]
    pub resource_types: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(string, repeated, tag = "2")]
    pub resource_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(string, repeated, tag = "3")]
    pub stream_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(enumeration = "log_level::Level", repeated, packed = "false", tag = "4")]
    pub levels: ::prost::alloc::vec::Vec<i32>,
    #[prost(string, tag = "5")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RunExportRequest {
    #[prost(string, tag = "1")]
    pub group_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub sink_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub params: ::core::option::Option<ExportParams>,
    #[prost(string, tag = "4")]
    pub result_filename: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "5")]
    pub since: ::core::option::Option<::prost_types::Timestamp>,
    #[prost(message, optional, tag = "6")]
    pub until: ::core::option::Option<::prost_types::Timestamp>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RunExportDetails {
    #[prost(string, tag = "1")]
    pub group_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub sink_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub params: ::core::option::Option<ExportParams>,
    #[prost(string, tag = "4")]
    pub result_filename: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "5")]
    pub since: ::core::option::Option<::prost_types::Timestamp>,
    #[prost(message, optional, tag = "6")]
    pub until: ::core::option::Option<::prost_types::Timestamp>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RunExportMetadata {
    #[prost(string, tag = "1")]
    pub group_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub sink_id: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub result_filename: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetExportRequest {
    /// ID of the export to return.
    ///
    /// To get a export ID make a \[ExportService.List\] request.
    #[prost(string, tag = "1")]
    pub export_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListExportsRequest {
    /// Folder ID of the exports to return.
    ///
    /// To get a folder ID make a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
    #[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 \[ListExportssResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    ///
    /// Default value: 100.
    #[prost(int64, tag = "3")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set `page_token` to the
    /// \[ListExportsResponse.next_page_token\] returned by a previous list request.
    #[prost(string, tag = "4")]
    pub page_token: ::prost::alloc::string::String,
    /// A filter expression that filters exports listed in the response.
    ///
    /// The expression must specify:
    /// 1. The field name. Currently filtering can only be applied to the \[Export.name\] field.
    /// 2. An `=` operator.
    /// 3. The value in double quotes (`"`). Must be 3-63 characters long and match the regular expression `\[a-z][-a-z0-9]{1,61}[a-z0-9\]`.
    /// Example of a filter: `name="my-export"`.
    #[prost(string, tag = "5")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListExportsResponse {
    /// List of exports in the specified folder.
    #[prost(message, repeated, tag = "1")]
    pub exports: ::prost::alloc::vec::Vec<Export>,
    /// Token for getting the next page of the list. If the number of results is greater than
    /// the specified \[ListExportsRequest.page_size\], use `next_page_token` as the value
    /// for the \[ListExportsRequest.page_token\] parameter in the next list request.
    ///
    /// Each subsequent page 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 CreateExportRequest {
    /// ID of the folder to create a export in.
    ///
    /// To get a folder ID make a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// Name of the export.
    /// The name must be unique within the folder.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Description of the export.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Export labels as `key:value` pairs.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Logging Group ID logs exported from
    #[prost(string, tag = "5")]
    pub group_id: ::prost::alloc::string::String,
    /// Logging Sink ID logs exported to
    #[prost(string, tag = "6")]
    pub sink_id: ::prost::alloc::string::String,
    /// Parameters for logs filtration
    #[prost(message, optional, tag = "7")]
    pub params: ::core::option::Option<ExportParams>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateExportMetadata {
    /// ID of the export being created.
    #[prost(string, tag = "1")]
    pub export_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateExportRequest {
    /// ID of the export to update.
    ///
    /// To get a export ID make a \[ExportService.List\] request.
    #[prost(string, tag = "1")]
    pub export_id: ::prost::alloc::string::String,
    /// Field mask that specifies which attributes of the function should be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// New name of the export.
    /// The name must be unique within the folder.
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    /// New Description of the export.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// New export labels as `key:value` pairs.
    #[prost(map = "string, string", tag = "5")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// New logging Group ID logs exported from
    #[prost(string, tag = "6")]
    pub group_id: ::prost::alloc::string::String,
    /// New logging Sink ID logs exported to
    #[prost(string, tag = "7")]
    pub sink_id: ::prost::alloc::string::String,
    /// New parameters for logs filtration
    #[prost(message, optional, tag = "8")]
    pub params: ::core::option::Option<ExportParams>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateExportMetadata {
    /// ID of the export being updated.
    #[prost(string, tag = "1")]
    pub export_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteExportRequest {
    /// ID of the export to delete.
    ///
    /// To get a export ID make a \[ExportService.List\] request.
    #[prost(string, tag = "1")]
    pub export_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteExportMetadata {
    /// ID of the export being deleted.
    #[prost(string, tag = "1")]
    pub export_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListExportOperationsRequest {
    /// ID of the export to list operations for.
    ///
    /// To get a export ID make a \[ExportService.List\] request.
    #[prost(string, tag = "1")]
    pub export_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 \[ListExportOperationsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    ///
    /// Default value: 100.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set `page_token` to the
    /// \[ListExportOperationsResponse.next_page_token\] returned by a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// A filter expression that filters resources listed in the response.
    ///
    /// The expression must specify:
    /// 1. The field name. Currently filtering can be applied to the \[operation.Operation.description\], \[operation.Operation.created_at\], \[operation.Operation.modified_at\], \[operation.Operation.created_by\], \[operation.Operation.done\] fields.
    /// 2. An `=` operator.
    /// 3. The value in double quotes (`"`). Must be 3-63 characters long and match the regular expression `\[a-z][-a-z0-9]{1,61}[a-z0-9\]`.
    /// Examples of a filter: `done=false`, `created_by='John.Doe'`.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListExportOperationsResponse {
    /// List of operations for the specified export.
    #[prost(message, repeated, tag = "1")]
    pub operations: ::prost::alloc::vec::Vec<super::super::operation::Operation>,
    /// Token for getting the next page of the list. If the number of results is greater than
    /// the specified \[ListOExportperationsRequest.page_size\], use `next_page_token` as the value
    /// for the \[ListExportOperationsRequest.page_token\] parameter in the next list request.
    ///
    /// Each subsequent page 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,
}
/// Generated client implementations.
pub mod export_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 log exports.
    #[derive(Debug, Clone)]
    pub struct ExportServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ExportServiceClient<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> ExportServiceClient<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,
        ) -> ExportServiceClient<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,
        {
            ExportServiceClient::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
        }
        /// Run new logs export from log group to sink
        pub async fn run(
            &mut self,
            request: impl tonic::IntoRequest<super::RunExportRequest>,
        ) -> 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.logging.v1.ExportService/Run",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.logging.v1.ExportService", "Run"));
            self.inner.unary(req, path, codec).await
        }
        /// Returns the specified export.
        ///
        /// To get the list of all available exports, make a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetExportRequest>,
        ) -> std::result::Result<tonic::Response<super::Export>, 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.logging.v1.ExportService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.logging.v1.ExportService", "Get"));
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of exports in the specified folder.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListExportsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListExportsResponse>,
            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.logging.v1.ExportService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.logging.v1.ExportService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a export in the specified folder.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateExportRequest>,
        ) -> 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.logging.v1.ExportService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.logging.v1.ExportService", "Create"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified export.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateExportRequest>,
        ) -> 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.logging.v1.ExportService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.logging.v1.ExportService", "Update"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified export.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteExportRequest>,
        ) -> 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.logging.v1.ExportService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.logging.v1.ExportService", "Delete"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists operations for the specified export.
        pub async fn list_operations(
            &mut self,
            request: impl tonic::IntoRequest<super::ListExportOperationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListExportOperationsResponse>,
            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.logging.v1.ExportService/ListOperations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.logging.v1.ExportService",
                        "ListOperations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists existing access bindings for the specified export.
        pub async fn list_access_bindings(
            &mut self,
            request: impl tonic::IntoRequest<
                super::super::super::access::ListAccessBindingsRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::super::super::access::ListAccessBindingsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.logging.v1.ExportService/ListAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.logging.v1.ExportService",
                        "ListAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Sets access bindings for the specified export.
        pub async fn set_access_bindings(
            &mut self,
            request: impl tonic::IntoRequest<
                super::super::super::access::SetAccessBindingsRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.logging.v1.ExportService/SetAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.logging.v1.ExportService",
                        "SetAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates access bindings for the specified export.
        pub async fn update_access_bindings(
            &mut self,
            request: impl tonic::IntoRequest<
                super::super::super::access::UpdateAccessBindingsRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.logging.v1.ExportService/UpdateAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.logging.v1.ExportService",
                        "UpdateAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LogGroup {
    /// Log group ID.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Log group folder ID.
    #[prost(string, tag = "2")]
    pub folder_id: ::prost::alloc::string::String,
    /// Log group cloud ID.
    #[prost(string, tag = "3")]
    pub cloud_id: ::prost::alloc::string::String,
    /// Log group creation time.
    #[prost(message, optional, tag = "4")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Log group name.
    #[prost(string, tag = "5")]
    pub name: ::prost::alloc::string::String,
    /// Log group description.
    #[prost(string, tag = "6")]
    pub description: ::prost::alloc::string::String,
    /// Log group labels.
    #[prost(map = "string, string", tag = "7")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Status of the log group.
    #[prost(enumeration = "log_group::Status", tag = "8")]
    pub status: i32,
    /// Log group entry retention period.
    ///
    /// Entries will be present in group during this period.
    #[prost(message, optional, tag = "9")]
    pub retention_period: ::core::option::Option<::prost_types::Duration>,
    /// Data stream name
    #[prost(string, tag = "10")]
    pub data_stream: ::prost::alloc::string::String,
}
/// Nested message and enum types in `LogGroup`.
pub mod log_group {
    /// Possible log group statuses.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Status {
        /// Unknown status.
        ///
        /// Should never occur.
        Unspecified = 0,
        /// Log group is creating.
        Creating = 1,
        /// Log group is ready to accept messages,
        Active = 2,
        /// Log group is being deleted.
        ///
        /// No messages will be accepted.
        Deleting = 3,
        /// Log group is in failed state.
        Error = 4,
    }
    impl Status {
        /// 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 {
                Status::Unspecified => "STATUS_UNSPECIFIED",
                Status::Creating => "CREATING",
                Status::Active => "ACTIVE",
                Status::Deleting => "DELETING",
                Status::Error => "ERROR",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATUS_UNSPECIFIED" => Some(Self::Unspecified),
                "CREATING" => Some(Self::Creating),
                "ACTIVE" => Some(Self::Active),
                "DELETING" => Some(Self::Deleting),
                "ERROR" => Some(Self::Error),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetLogGroupRequest {
    /// ID of the log group to return.
    ///
    /// To get a log group ID make a \[LogGroupService.List\] request.
    #[prost(string, tag = "1")]
    pub log_group_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetLogGroupStatsRequest {
    /// ID of the log group to return stats for.
    ///
    /// To get a log group ID make a \[LogGroupService.List\] request.
    #[prost(string, tag = "1")]
    pub log_group_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListLogGroupsRequest {
    /// Folder ID of the log groups to return.
    ///
    /// To get a folder ID make a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
    #[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 \[ListLogGroupsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    ///
    /// Default value: 100.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set `page_token` to the
    /// \[ListLogGroupsResponse.next_page_token\] returned by a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// A filter expression that filters log groups listed in the response.
    ///
    /// The expression must specify:
    /// 1. The field name. Currently filtering can only be applied to the \[LogGroup.name\] field.
    /// 2. An `=` operator.
    /// 3. The value in double quotes (`"`). Must be 3-63 characters long and match the regular expression `\[a-z][-a-z0-9]{1,61}[a-z0-9\]`.
    /// Example of a filter: `name=my-log-group`.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListLogGroupsResponse {
    /// List of log groups in the specified folder.
    #[prost(message, repeated, tag = "1")]
    pub groups: ::prost::alloc::vec::Vec<LogGroup>,
    /// Token for getting the next page of the list. If the number of results is greater than
    /// the specified \[ListLogGroupsRequest.page_size\], use `next_page_token` as the value
    /// for the \[ListLogGroupsRequest.page_token\] parameter in the next list request.
    ///
    /// Each subsequent page 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 CreateLogGroupRequest {
    /// ID of the folder to create a log group in.
    ///
    /// To get a folder ID make a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// Name of the log group.
    /// The name must be unique within the folder.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Description of the log group.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Log group labels as `key:value` pairs.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Log group entry retention period.
    ///
    /// Entries will be present in group during this period.
    /// If specified, must be non-negative.
    /// Empty or zero value is treated as no limit.
    ///
    /// Data stream name
    #[prost(message, optional, tag = "5")]
    pub retention_period: ::core::option::Option<::prost_types::Duration>,
    /// If specified, all log records will be written to this data stream
    #[prost(string, tag = "6")]
    pub data_stream: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateLogGroupMetadata {
    /// ID of the log group being created.
    #[prost(string, tag = "1")]
    pub log_group_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateLogGroupRequest {
    /// ID of the log group to update.
    ///
    /// To get a log group ID make a \[LogGroupService.List\] request.
    #[prost(string, tag = "1")]
    pub log_group_id: ::prost::alloc::string::String,
    /// Field mask that specifies which attributes of the function should be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// New name of the log group.
    /// The name must be unique within the folder.
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    /// New Description of the log group.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// New log group labels as `key:value` pairs.
    #[prost(map = "string, string", tag = "5")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// New log group entry retention period.
    ///
    /// Entries will be present in group during this period.
    /// If specified, must be non-negative.
    /// Empty or zero value is treated as no limit.
    #[prost(message, optional, tag = "6")]
    pub retention_period: ::core::option::Option<::prost_types::Duration>,
    /// If specified, log records will be written to this data stream
    #[prost(string, tag = "7")]
    pub data_stream: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateLogGroupMetadata {
    /// ID of the log group being updated.
    #[prost(string, tag = "1")]
    pub log_group_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteLogGroupRequest {
    /// ID of the log group to delete.
    ///
    /// To get a log group ID make a \[LogGroupService.List\] request.
    #[prost(string, tag = "1")]
    pub log_group_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteLogGroupMetadata {
    /// ID of the log group being deleted.
    #[prost(string, tag = "1")]
    pub log_group_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListResourcesRequest {
    /// ID of the log group to list resources for.
    ///
    /// To get a log group ID make a \[LogGroupService.List\] request.
    #[prost(string, tag = "1")]
    pub log_group_id: ::prost::alloc::string::String,
    /// Resource type to return resources for.
    ///
    /// If not specified, \[ListResourcesResponse\] will contain information about all resource types.
    #[prost(string, tag = "2")]
    pub r#type: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListResourcesResponse {
    /// List of resources present in log group.
    #[prost(message, repeated, tag = "1")]
    pub resources: ::prost::alloc::vec::Vec<LogGroupResource>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListOperationsRequest {
    /// ID of the log group to list operations for.
    ///
    /// To get a log group ID make a \[LogGroupService.List\] request.
    #[prost(string, tag = "1")]
    pub log_group_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 \[ListOperationsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    ///
    /// Default value: 100.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set `page_token` to the
    /// \[ListOperationsResponse.next_page_token\] returned by a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// A filter expression that filters resources listed in the response.
    ///
    /// The expression must specify:
    /// 1. The field name. Currently filtering can be applied to the \[operation.Operation.description\], \[operation.Operation.created_at\], \[operation.Operation.modified_at\], \[operation.Operation.created_by\], \[operation.Operation.done\] fields.
    /// 2. An `=` operator.
    /// 3. The value in double quotes (`"`). Must be 3-63 characters long and match the regular expression `\[a-z][-a-z0-9]{1,61}[a-z0-9\]`.
    /// Examples of a filter: `done=false`, `created_by='John.Doe'`.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListOperationsResponse {
    /// List of operations for the specified log group.
    #[prost(message, repeated, tag = "1")]
    pub operations: ::prost::alloc::vec::Vec<super::super::operation::Operation>,
    /// Token for getting the next page of the list. If the number of results is greater than
    /// the specified \[ListOperationsRequest.page_size\], use `next_page_token` as the value
    /// for the \[ListOperationsRequest.page_token\] parameter in the next list request.
    ///
    /// Each subsequent page 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 GetLogGroupStatsResponse {
    /// Log group ID the stats are returned for.
    #[prost(string, tag = "1")]
    pub log_group_id: ::prost::alloc::string::String,
    /// Size of data in log group in bytes.
    #[prost(int64, tag = "2")]
    pub bytes: i64,
    /// Amount of records in log group.
    #[prost(int64, tag = "3")]
    pub records: i64,
}
/// Generated client implementations.
pub mod log_group_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 log groups.
    #[derive(Debug, Clone)]
    pub struct LogGroupServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl LogGroupServiceClient<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> LogGroupServiceClient<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,
        ) -> LogGroupServiceClient<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,
        {
            LogGroupServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Returns the specified log group.
        ///
        /// To get the list of all available log groups, make a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetLogGroupRequest>,
        ) -> std::result::Result<tonic::Response<super::LogGroup>, 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.logging.v1.LogGroupService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.logging.v1.LogGroupService", "Get"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns stats for the specified log group.
        pub async fn stats(
            &mut self,
            request: impl tonic::IntoRequest<super::GetLogGroupStatsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetLogGroupStatsResponse>,
            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.logging.v1.LogGroupService/Stats",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.logging.v1.LogGroupService", "Stats"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of log groups in the specified folder.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListLogGroupsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListLogGroupsResponse>,
            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.logging.v1.LogGroupService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.logging.v1.LogGroupService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a log group in the specified folder.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateLogGroupRequest>,
        ) -> 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.logging.v1.LogGroupService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.logging.v1.LogGroupService", "Create"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified log group.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateLogGroupRequest>,
        ) -> 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.logging.v1.LogGroupService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.logging.v1.LogGroupService", "Update"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified log group.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteLogGroupRequest>,
        ) -> 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.logging.v1.LogGroupService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.logging.v1.LogGroupService", "Delete"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the resources (type and IDs) in the specified log group.
        pub async fn list_resources(
            &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.logging.v1.LogGroupService/ListResources",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.logging.v1.LogGroupService",
                        "ListResources",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists operations for the specified log group.
        pub async fn list_operations(
            &mut self,
            request: impl tonic::IntoRequest<super::ListOperationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListOperationsResponse>,
            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.logging.v1.LogGroupService/ListOperations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.logging.v1.LogGroupService",
                        "ListOperations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists existing access bindings for the specified log group.
        pub async fn list_access_bindings(
            &mut self,
            request: impl tonic::IntoRequest<
                super::super::super::access::ListAccessBindingsRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::super::super::access::ListAccessBindingsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.logging.v1.LogGroupService/ListAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.logging.v1.LogGroupService",
                        "ListAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Sets access bindings for the specified log group.
        pub async fn set_access_bindings(
            &mut self,
            request: impl tonic::IntoRequest<
                super::super::super::access::SetAccessBindingsRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.logging.v1.LogGroupService/SetAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.logging.v1.LogGroupService",
                        "SetAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates access bindings for the specified log group.
        pub async fn update_access_bindings(
            &mut self,
            request: impl tonic::IntoRequest<
                super::super::super::access::UpdateAccessBindingsRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.logging.v1.LogGroupService/UpdateAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.logging.v1.LogGroupService",
                        "UpdateAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WriteRequest {
    /// Log entries destination.
    ///
    /// See \[Destination\] for details.
    #[prost(message, optional, tag = "1")]
    pub destination: ::core::option::Option<Destination>,
    /// Common resource (type, ID) specification for log entries.
    #[prost(message, optional, tag = "2")]
    pub resource: ::core::option::Option<LogEntryResource>,
    /// List of log entries.
    #[prost(message, repeated, tag = "3")]
    pub entries: ::prost::alloc::vec::Vec<IncomingLogEntry>,
    /// Log entries defaults.
    ///
    /// See \[LogEntryDefaults\] for details.
    #[prost(message, optional, tag = "4")]
    pub defaults: ::core::option::Option<LogEntryDefaults>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WriteResponse {
    /// Map<idx, status> of ingest failures.
    ///
    /// If entry with idx N is absent, it was ingested successfully.
    #[prost(map = "int64, message", tag = "1")]
    pub errors: ::std::collections::HashMap<
        i64,
        super::super::super::super::google::rpc::Status,
    >,
}
/// Generated client implementations.
pub mod log_ingestion_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 writing to log groups.
    #[derive(Debug, Clone)]
    pub struct LogIngestionServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl LogIngestionServiceClient<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> LogIngestionServiceClient<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,
        ) -> LogIngestionServiceClient<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,
        {
            LogIngestionServiceClient::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
        }
        /// Write log entries to specified destination.
        pub async fn write(
            &mut self,
            request: impl tonic::IntoRequest<super::WriteRequest>,
        ) -> std::result::Result<tonic::Response<super::WriteResponse>, 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.logging.v1.LogIngestionService/Write",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.logging.v1.LogIngestionService",
                        "Write",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReadRequest {
    /// Read selector.
    #[prost(oneof = "read_request::Selector", tags = "1, 2")]
    pub selector: ::core::option::Option<read_request::Selector>,
}
/// Nested message and enum types in `ReadRequest`.
pub mod read_request {
    /// Read selector.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Selector {
        /// Page token. To get the next page of results, set `page_token` to the
        /// \[ReadResponse.next_page_token\] or \[ReadResponse.previous_page_token\] returned by a previous read request.
        #[prost(string, tag = "1")]
        PageToken(::prost::alloc::string::String),
        /// Read criteria.
        ///
        /// See \[Criteria\] for details.
        #[prost(message, tag = "2")]
        Criteria(super::Criteria),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReadResponse {
    /// Log group ID the read was performed from.
    #[prost(string, tag = "1")]
    pub log_group_id: ::prost::alloc::string::String,
    /// List of matching log entries.
    #[prost(message, repeated, tag = "2")]
    pub entries: ::prost::alloc::vec::Vec<LogEntry>,
    /// Token for getting the next page of the log entries.
    ///
    /// After getting log entries initially with \[Criteria\], you can use `next_page_token` as the value
    /// for the \[ReadRequest.page_token\] parameter in the next read request.
    ///
    /// Each subsequent page will have its own `next_page_token` to continue paging through the results.
    #[prost(string, tag = "3")]
    pub next_page_token: ::prost::alloc::string::String,
    /// Token for getting the previous page of the log entries.
    ///
    /// After getting log entries initially with \[Criteria\], you can use `previous_page_token` as the value
    /// for the \[ReadRequest.page_token\] parameter in the next read request.
    ///
    /// Each subsequent page will have its own `next_page_token` to continue paging through the results.
    #[prost(string, tag = "4")]
    pub previous_page_token: ::prost::alloc::string::String,
}
/// Read criteria. Should be used in initial \[ReadRequest\].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Criteria {
    /// ID of the log group to return.
    ///
    /// To get a log group ID make a \[LogGroupService.List\] request.
    #[prost(string, tag = "1")]
    pub log_group_id: ::prost::alloc::string::String,
    /// List of resource types to limit log entries to.
    ///
    /// Empty list disables filter.
    #[prost(string, repeated, tag = "2")]
    pub resource_types: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// List of resource IDs to limit log entries to.
    ///
    /// Empty list disables filter.
    #[prost(string, repeated, tag = "3")]
    pub resource_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Lower bound of log entries timestamps.
    #[prost(message, optional, tag = "4")]
    pub since: ::core::option::Option<::prost_types::Timestamp>,
    /// Upper bound of log entries timestamps.
    #[prost(message, optional, tag = "5")]
    pub until: ::core::option::Option<::prost_types::Timestamp>,
    /// List of log levels to limit log entries to.
    ///
    /// Empty list disables filter.
    #[prost(enumeration = "log_level::Level", repeated, packed = "false", tag = "6")]
    pub levels: ::prost::alloc::vec::Vec<i32>,
    /// Filter expression. For details about filtering, see \[documentation\](/docs/logging/concepts/filter).
    #[prost(string, tag = "7")]
    pub filter: ::prost::alloc::string::String,
    /// List of stream names to limit log entries to.
    ///
    /// Empty list disables filter.
    #[prost(string, repeated, tag = "10")]
    pub stream_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// The maximum number of results per page to return.
    #[prost(int64, tag = "8")]
    pub page_size: i64,
    /// Limits response to maximum size in bytes. Prevents gRPC resource exhaustion.
    ///
    /// Default value for max response size is 3.5 MiB
    #[prost(int64, tag = "9")]
    pub max_response_size: i64,
}
/// Generated client implementations.
pub mod log_reading_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 reading from log groups.
    #[derive(Debug, Clone)]
    pub struct LogReadingServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl LogReadingServiceClient<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> LogReadingServiceClient<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,
        ) -> LogReadingServiceClient<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,
        {
            LogReadingServiceClient::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
        }
        /// Read log entries from the specified log group.
        pub async fn read(
            &mut self,
            request: impl tonic::IntoRequest<super::ReadRequest>,
        ) -> std::result::Result<tonic::Response<super::ReadResponse>, 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.logging.v1.LogReadingService/Read",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.logging.v1.LogReadingService", "Read"),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Sink {
    /// Sink ID.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Sink folder ID.
    #[prost(string, tag = "2")]
    pub folder_id: ::prost::alloc::string::String,
    /// Sink cloud ID.
    #[prost(string, tag = "3")]
    pub cloud_id: ::prost::alloc::string::String,
    /// Sink creation time.
    #[prost(message, optional, tag = "4")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Sink name.
    #[prost(string, tag = "5")]
    pub name: ::prost::alloc::string::String,
    /// Sink description.
    #[prost(string, tag = "6")]
    pub description: ::prost::alloc::string::String,
    /// Sink labels.
    #[prost(map = "string, string", tag = "7")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Logs will be written to the sink on behalf of this service account
    #[prost(string, tag = "8")]
    pub service_account_id: ::prost::alloc::string::String,
    /// Logs destination
    #[prost(oneof = "sink::Sink", tags = "9, 10")]
    pub sink: ::core::option::Option<sink::Sink>,
}
/// Nested message and enum types in `Sink`.
pub mod sink {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Yds {
        /// Fully qualified name of data stream
        #[prost(string, tag = "1")]
        pub stream_name: ::prost::alloc::string::String,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct S3 {
        /// Object storage bucket
        #[prost(string, tag = "1")]
        pub bucket: ::prost::alloc::string::String,
        /// Prefix to use for saved log object names
        #[prost(string, tag = "2")]
        pub prefix: ::prost::alloc::string::String,
    }
    /// Logs destination
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Sink {
        /// Yandex data stream
        #[prost(message, tag = "9")]
        Yds(Yds),
        /// Object storage
        #[prost(message, tag = "10")]
        S3(S3),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetSinkRequest {
    /// ID of the sink to return.
    ///
    /// To get a sink ID make a \[SinkService.List\] request.
    #[prost(string, tag = "1")]
    pub sink_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSinksRequest {
    /// Folder ID of the sinks to return.
    ///
    /// To get a folder ID make a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
    #[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 \[ListSinkssResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    ///
    /// Default value: 100.
    #[prost(int64, tag = "3")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set `page_token` to the
    /// \[ListSinksResponse.next_page_token\] returned by a previous list request.
    #[prost(string, tag = "4")]
    pub page_token: ::prost::alloc::string::String,
    /// A filter expression that filters sinks listed in the response.
    ///
    /// The expression must specify:
    /// 1. The field name. Currently filtering can only be applied to the \[Sink.name\] field.
    /// 2. An `=` operator.
    /// 3. The value in double quotes (`"`). Must be 3-63 characters long and match the regular expression `\[a-z][-a-z0-9]{1,61}[a-z0-9\]`.
    /// Example of a filter: `name="my-sink"`.
    #[prost(string, tag = "5")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSinksResponse {
    /// List of sinks in the specified folder.
    #[prost(message, repeated, tag = "1")]
    pub sinks: ::prost::alloc::vec::Vec<Sink>,
    /// Token for getting the next page of the list. If the number of results is greater than
    /// the specified \[ListSinksRequest.page_size\], use `next_page_token` as the value
    /// for the \[ListSinksRequest.page_token\] parameter in the next list request.
    ///
    /// Each subsequent page 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 CreateSinkRequest {
    /// ID of the folder to create a sink in.
    ///
    /// To get a folder ID make a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// Name of the sink.
    /// The name must be unique within the folder.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Description of the sink.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Sink labels as `key:value` pairs.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Logs will be written to the sink on behalf of this service account
    #[prost(string, tag = "5")]
    pub service_account_id: ::prost::alloc::string::String,
    /// Logs destination
    #[prost(oneof = "create_sink_request::Sink", tags = "6, 7")]
    pub sink: ::core::option::Option<create_sink_request::Sink>,
}
/// Nested message and enum types in `CreateSinkRequest`.
pub mod create_sink_request {
    /// Logs destination
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Sink {
        /// Yandex data stream
        #[prost(message, tag = "6")]
        Yds(super::sink::Yds),
        /// Object storage
        #[prost(message, tag = "7")]
        S3(super::sink::S3),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateSinkMetadata {
    /// ID of the sink being created.
    #[prost(string, tag = "1")]
    pub sink_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateSinkRequest {
    /// ID of the sink to update.
    ///
    /// To get a sink ID make a \[SinkService.List\] request.
    #[prost(string, tag = "1")]
    pub sink_id: ::prost::alloc::string::String,
    /// Field mask that specifies which attributes of the function should be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// New name of the sink.
    /// The name must be unique within the folder.
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    /// New Description of the sink.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// New sink labels as `key:value` pairs.
    #[prost(map = "string, string", tag = "5")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// new service account to use for logs writing to the sink.
    #[prost(string, tag = "6")]
    pub service_account_id: ::prost::alloc::string::String,
    /// New logs destination
    #[prost(oneof = "update_sink_request::Sink", tags = "7, 8")]
    pub sink: ::core::option::Option<update_sink_request::Sink>,
}
/// Nested message and enum types in `UpdateSinkRequest`.
pub mod update_sink_request {
    /// New logs destination
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Sink {
        /// Yandex data stream
        #[prost(message, tag = "7")]
        Yds(super::sink::Yds),
        /// Object storage
        #[prost(message, tag = "8")]
        S3(super::sink::S3),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateSinkMetadata {
    /// ID of the sink being updated.
    #[prost(string, tag = "1")]
    pub sink_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteSinkRequest {
    /// ID of the sink to delete.
    ///
    /// To get a sink ID make a \[SinkService.List\] request.
    #[prost(string, tag = "1")]
    pub sink_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteSinkMetadata {
    /// ID of the sink being deleted.
    #[prost(string, tag = "1")]
    pub sink_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSinkOperationsRequest {
    /// ID of the sink to list operations for.
    ///
    /// To get a sink ID make a \[SinkService.List\] request.
    #[prost(string, tag = "1")]
    pub sink_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 \[ListSinkOperationsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    ///
    /// Default value: 100.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set `page_token` to the
    /// \[ListSinkOperationsResponse.next_page_token\] returned by a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// A filter expression that filters resources listed in the response.
    ///
    /// The expression must specify:
    /// 1. The field name. Currently filtering can be applied to the \[operation.Operation.description\], \[operation.Operation.created_at\], \[operation.Operation.modified_at\], \[operation.Operation.created_by\], \[operation.Operation.done\] fields.
    /// 2. An `=` operator.
    /// 3. The value in double quotes (`"`). Must be 3-63 characters long and match the regular expression `\[a-z][-a-z0-9]{1,61}[a-z0-9\]`.
    /// Examples of a filter: `done=false`, `created_by='John.Doe'`.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSinkOperationsResponse {
    /// List of operations for the specified sink.
    #[prost(message, repeated, tag = "1")]
    pub operations: ::prost::alloc::vec::Vec<super::super::operation::Operation>,
    /// Token for getting the next page of the list. If the number of results is greater than
    /// the specified \[ListOSinkperationsRequest.page_size\], use `next_page_token` as the value
    /// for the \[ListSinkOperationsRequest.page_token\] parameter in the next list request.
    ///
    /// Each subsequent page 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,
}
/// Generated client implementations.
pub mod sink_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 log sinks.
    #[derive(Debug, Clone)]
    pub struct SinkServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl SinkServiceClient<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> SinkServiceClient<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,
        ) -> SinkServiceClient<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,
        {
            SinkServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Returns the specified sink.
        ///
        /// To get the list of all available sinks, make a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetSinkRequest>,
        ) -> std::result::Result<tonic::Response<super::Sink>, 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.logging.v1.SinkService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.logging.v1.SinkService", "Get"));
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of sinks in the specified folder.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListSinksRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListSinksResponse>,
            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.logging.v1.SinkService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.logging.v1.SinkService", "List"));
            self.inner.unary(req, path, codec).await
        }
        /// Creates a sink in the specified folder.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateSinkRequest>,
        ) -> 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.logging.v1.SinkService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.logging.v1.SinkService", "Create"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified sink.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateSinkRequest>,
        ) -> 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.logging.v1.SinkService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.logging.v1.SinkService", "Update"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified sink.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteSinkRequest>,
        ) -> 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.logging.v1.SinkService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.logging.v1.SinkService", "Delete"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists operations for the specified sink.
        pub async fn list_operations(
            &mut self,
            request: impl tonic::IntoRequest<super::ListSinkOperationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListSinkOperationsResponse>,
            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.logging.v1.SinkService/ListOperations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.logging.v1.SinkService",
                        "ListOperations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists existing access bindings for the specified sink.
        pub async fn list_access_bindings(
            &mut self,
            request: impl tonic::IntoRequest<
                super::super::super::access::ListAccessBindingsRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::super::super::access::ListAccessBindingsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.logging.v1.SinkService/ListAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.logging.v1.SinkService",
                        "ListAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Sets access bindings for the specified sink.
        pub async fn set_access_bindings(
            &mut self,
            request: impl tonic::IntoRequest<
                super::super::super::access::SetAccessBindingsRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.logging.v1.SinkService/SetAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.logging.v1.SinkService",
                        "SetAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates access bindings for the specified sink.
        pub async fn update_access_bindings(
            &mut self,
            request: impl tonic::IntoRequest<
                super::super::super::access::UpdateAccessBindingsRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.logging.v1.SinkService/UpdateAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.logging.v1.SinkService",
                        "UpdateAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}