yandex-cloud 2025.4.14

#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Container {
    /// ID of the container. Generated at creation time.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the folder that the container belongs to.
    #[prost(string, tag = "2")]
    pub folder_id: ::prost::alloc::string::String,
    /// Creation timestamp for the container.
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Name of the container. The name is unique within the folder.
    #[prost(string, tag = "4")]
    pub name: ::prost::alloc::string::String,
    /// Description of the container.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
    /// Container labels as `key:value` pairs.
    #[prost(map = "string, string", tag = "6")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// URL that needs to be requested to call the container.
    #[prost(string, tag = "8")]
    pub url: ::prost::alloc::string::String,
    /// Status of the container.
    #[prost(enumeration = "container::Status", tag = "9")]
    pub status: i32,
}
/// Nested message and enum types in `Container`.
pub mod container {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Status {
        Unspecified = 0,
        /// Container is being created.
        Creating = 1,
        /// Container is ready for use.
        Active = 2,
        /// Container is being deleted.
        Deleting = 3,
        /// Container failed. The only allowed action is delete.
        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 Revision {
    /// ID of the revision.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the container that the revision belongs to.
    #[prost(string, tag = "2")]
    pub container_id: ::prost::alloc::string::String,
    /// Description of the revision.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Creation timestamp for the revision.
    #[prost(message, optional, tag = "4")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Image configuration for the revision.
    #[prost(message, optional, tag = "5")]
    pub image: ::core::option::Option<Image>,
    /// Resources allocated to the revision.
    #[prost(message, optional, tag = "6")]
    pub resources: ::core::option::Option<Resources>,
    /// Timeout for the execution of the revision.
    ///
    /// If the timeout is exceeded, Serverless Containers responds with a 504 HTTP code.
    #[prost(message, optional, tag = "7")]
    pub execution_timeout: ::core::option::Option<::prost_types::Duration>,
    /// The number of concurrent requests allowed per container instance.
    #[prost(int64, tag = "8")]
    pub concurrency: i64,
    /// ID of the service account associated with the revision.
    #[prost(string, tag = "9")]
    pub service_account_id: ::prost::alloc::string::String,
    /// Status of the revision.
    #[prost(enumeration = "revision::Status", tag = "10")]
    pub status: i32,
    /// Yandex Lockbox secrets to be used by the revision.
    #[prost(message, repeated, tag = "11")]
    pub secrets: ::prost::alloc::vec::Vec<Secret>,
    /// Network access. If specified the revision will be attached to specified network/subnet(s).
    #[prost(message, optional, tag = "12")]
    pub connectivity: ::core::option::Option<Connectivity>,
    /// Policy for provisioning instances of the revision.
    ///
    /// The policy is only applied when the revision is ACTIVE.
    #[prost(message, optional, tag = "13")]
    pub provision_policy: ::core::option::Option<ProvisionPolicy>,
    /// Policy for scaling instances of the revision.
    #[prost(message, optional, tag = "14")]
    pub scaling_policy: ::core::option::Option<ScalingPolicy>,
    /// Options for logging from the container.
    #[prost(message, optional, tag = "15")]
    pub log_options: ::core::option::Option<LogOptions>,
    /// S3 mounts to be used by the revision.
    #[prost(message, repeated, tag = "16")]
    pub storage_mounts: ::prost::alloc::vec::Vec<StorageMount>,
    /// Mounts to be used by the revision.
    #[prost(message, repeated, tag = "17")]
    pub mounts: ::prost::alloc::vec::Vec<Mount>,
    /// The container's execution mode
    #[prost(message, optional, tag = "18")]
    pub runtime: ::core::option::Option<Runtime>,
    /// Metadata options for the revision.
    #[prost(message, optional, tag = "19")]
    pub metadata_options: ::core::option::Option<MetadataOptions>,
}
/// Nested message and enum types in `Revision`.
pub mod revision {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Status {
        Unspecified = 0,
        /// Revision is being created.
        Creating = 1,
        /// Revision is currently used by the container.
        Active = 2,
        /// Revision is not used by the container. May be deleted later.
        Obsolete = 3,
    }
    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::Obsolete => "OBSOLETE",
            }
        }
        /// 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),
                "OBSOLETE" => Some(Self::Obsolete),
                _ => None,
            }
        }
    }
}
/// Revision image specification.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Image {
    /// Image URL, that is used by the revision.
    #[prost(string, tag = "1")]
    pub image_url: ::prost::alloc::string::String,
    /// Digest of the image. Calculated at creation time.
    #[prost(string, tag = "2")]
    pub image_digest: ::prost::alloc::string::String,
    /// Override for the image's ENTRYPOINT.
    #[prost(message, optional, tag = "3")]
    pub command: ::core::option::Option<Command>,
    /// Override for the image's CMD.
    #[prost(message, optional, tag = "4")]
    pub args: ::core::option::Option<Args>,
    /// Additional environment for the container.
    #[prost(map = "string, string", tag = "5")]
    pub environment: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Override for the image's WORKDIR.
    #[prost(string, tag = "6")]
    pub working_dir: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Command {
    /// Command that will override ENTRYPOINT of an image.
    ///
    /// Commands will be executed as is. The runtime will not substitute environment
    /// variables or execute shell commands. If one wants to do that, they should
    /// invoke shell interpreter with an appropriate shell script.
    #[prost(string, repeated, tag = "1")]
    pub command: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Args {
    /// Arguments that will override CMD of an image.
    ///
    /// Arguments will be passed as is. The runtime will not substitute environment
    /// variables or execute shell commands. If one wants to do that, they should
    /// invoke shell interpreter with an appropriate shell script.
    #[prost(string, repeated, tag = "1")]
    pub args: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Resources allocated to a revision.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Resources {
    /// Amount of memory available to the revision, specified in bytes, multiple of 128MB.
    #[prost(int64, tag = "1")]
    pub memory: i64,
    /// Number of cores available to the revision.
    #[prost(int64, tag = "2")]
    pub cores: i64,
    /// Specifies baseline performance for a core in percent, multiple of 5%.
    /// Should be 100% for cores > 1.
    #[prost(int64, tag = "3")]
    pub core_fraction: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProvisionPolicy {
    /// Minimum number of guaranteed provisioned container instances for all zones
    /// in total.
    #[prost(int64, tag = "1")]
    pub min_instances: i64,
}
/// Secret that is available to the container at run time.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Secret {
    /// ID of Yandex Lockbox secret.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of Yandex Lockbox secret.
    #[prost(string, tag = "2")]
    pub version_id: ::prost::alloc::string::String,
    /// Key in secret's payload, which value to be delivered into container environment.
    #[prost(string, tag = "3")]
    pub key: ::prost::alloc::string::String,
    #[prost(oneof = "secret::Reference", tags = "4")]
    pub reference: ::core::option::Option<secret::Reference>,
}
/// Nested message and enum types in `Secret`.
pub mod secret {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Reference {
        /// Environment variable in which secret's value is delivered.
        #[prost(string, tag = "4")]
        EnvironmentVariable(::prost::alloc::string::String),
    }
}
/// Revision connectivity specification.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Connectivity {
    /// Network the revision will have access to.
    #[prost(string, tag = "1")]
    pub network_id: ::prost::alloc::string::String,
    /// The list of subnets (from the same network) the revision can be attached to.
    ///
    /// Deprecated, it is sufficient to specify only network_id, without the list of subnet_ids.
    #[prost(string, repeated, tag = "2")]
    pub subnet_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LogOptions {
    /// Is logging from container disabled.
    #[prost(bool, tag = "1")]
    pub disabled: bool,
    /// Minimum log entry level.
    ///
    /// See \[LogLevel.Level\] for details.
    #[prost(
        enumeration = "super::super::super::logging::v1::log_level::Level",
        tag = "4"
    )]
    pub min_level: i32,
    /// Log entries destination.
    #[prost(oneof = "log_options::Destination", tags = "2, 3")]
    pub destination: ::core::option::Option<log_options::Destination>,
}
/// Nested message and enum types in `LogOptions`.
pub mod log_options {
    /// Log entries 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 = "2")]
        LogGroupId(::prost::alloc::string::String),
        /// Entry should be written to default log group for specified folder.
        #[prost(string, tag = "3")]
        FolderId(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ScalingPolicy {
    /// Upper limit for instance count in each zone.
    /// 0 means no limit.
    #[prost(int64, tag = "1")]
    pub zone_instances_limit: i64,
    /// Upper limit of requests count in each zone.
    /// 0 means no limit.
    #[prost(int64, tag = "2")]
    pub zone_requests_limit: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StorageMount {
    /// S3 bucket name for mounting.
    #[prost(string, tag = "1")]
    pub bucket_id: ::prost::alloc::string::String,
    /// S3 bucket prefix for mounting.
    #[prost(string, tag = "2")]
    pub prefix: ::prost::alloc::string::String,
    /// Is mount read only.
    #[prost(bool, tag = "4")]
    pub read_only: bool,
    /// Mount point path inside the container for mounting.
    #[prost(string, tag = "5")]
    pub mount_point_path: ::prost::alloc::string::String,
}
/// Mount contains an information about version's external storage mount
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Mount {
    /// The absolute mount point path inside the container for mounting.
    #[prost(string, tag = "2")]
    pub mount_point_path: ::prost::alloc::string::String,
    /// Mount's mode
    #[prost(enumeration = "mount::Mode", tag = "3")]
    pub mode: i32,
    /// Target mount option
    #[prost(oneof = "mount::Target", tags = "10, 11")]
    pub target: ::core::option::Option<mount::Target>,
}
/// Nested message and enum types in `Mount`.
pub mod mount {
    /// ObjectStorage as a mount
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ObjectStorage {
        /// ObjectStorage bucket name for mounting.
        #[prost(string, tag = "1")]
        pub bucket_id: ::prost::alloc::string::String,
        /// ObjectStorage bucket prefix for mounting.
        #[prost(string, tag = "2")]
        pub prefix: ::prost::alloc::string::String,
    }
    /// Disk as a mount
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct DiskSpec {
        /// The size of disk for mount in bytes
        #[prost(int64, tag = "1")]
        pub size: i64,
        /// Optional block size of disk for mount in bytes
        #[prost(int64, tag = "2")]
        pub block_size: i64,
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Mode {
        Unspecified = 0,
        ReadOnly = 1,
        ReadWrite = 2,
    }
    impl Mode {
        /// 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 {
                Mode::Unspecified => "MODE_UNSPECIFIED",
                Mode::ReadOnly => "READ_ONLY",
                Mode::ReadWrite => "READ_WRITE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "MODE_UNSPECIFIED" => Some(Self::Unspecified),
                "READ_ONLY" => Some(Self::ReadOnly),
                "READ_WRITE" => Some(Self::ReadWrite),
                _ => None,
            }
        }
    }
    /// Target mount option
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Target {
        /// Object storage mounts
        #[prost(message, tag = "10")]
        ObjectStorage(ObjectStorage),
        /// Working disk (worker-local non-shared read-write NBS disk templates)
        #[prost(message, tag = "11")]
        EphemeralDiskSpec(DiskSpec),
    }
}
/// The container's execution mode
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Runtime {
    #[prost(oneof = "runtime::Type", tags = "1, 2")]
    pub r#type: ::core::option::Option<runtime::Type>,
}
/// Nested message and enum types in `Runtime`.
pub mod runtime {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Http {}
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Task {}
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Type {
        /// The classic one. You need to run an HTTP server inside the container.
        #[prost(message, tag = "1")]
        Http(Http),
        /// We run a process from ENTRYPOINT inside the container for each user request.
        #[prost(message, tag = "2")]
        Task(Task),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MetadataOptions {
    /// Enabled access to GCE flavored metadata
    #[prost(enumeration = "MetadataOption", tag = "1")]
    pub gce_http_endpoint: i32,
    /// Enabled access to AWS flavored metadata (IMDSv1)
    #[prost(enumeration = "MetadataOption", tag = "2")]
    pub aws_v1_http_endpoint: i32,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum MetadataOption {
    /// Option is default
    Unspecified = 0,
    /// Option is enabled
    Enabled = 1,
    /// Option is disabled
    Disabled = 2,
}
impl MetadataOption {
    /// 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 {
            MetadataOption::Unspecified => "METADATA_OPTION_UNSPECIFIED",
            MetadataOption::Enabled => "ENABLED",
            MetadataOption::Disabled => "DISABLED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "METADATA_OPTION_UNSPECIFIED" => Some(Self::Unspecified),
            "ENABLED" => Some(Self::Enabled),
            "DISABLED" => Some(Self::Disabled),
            _ => None,
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetContainerRequest {
    /// ID of the container to return.
    ///
    /// To get a container ID make a \[ContainerService.List\] request.
    #[prost(string, tag = "1")]
    pub container_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListContainersRequest {
    /// ID of the folder to list containers 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,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than `pageSize`, the service returns a \[ListContainersResponse.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 `pageToken` to the
    /// \[ListContainersResponse.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 containers listed in the response.
    ///
    /// The expression must specify:
    /// 1. The field name. Currently filtering can only be applied to the \[Container.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-container"`.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListContainersResponse {
    /// List of containers in the specified folder.
    #[prost(message, repeated, tag = "1")]
    pub containers: ::prost::alloc::vec::Vec<Container>,
    /// Token for getting the next page of the list. If the number of results is greater than
    /// the specified \[ListContainersRequest.page_size\], use `nextPageToken` as the value
    /// for the \[ListContainersRequest.page_token\] parameter in the next list request.
    ///
    /// Each subsequent page will have its own `nextPageToken` 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 CreateContainerRequest {
    /// ID of the folder to create a container 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 container.
    /// The name must be unique within the folder.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Description of the container.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Resource labels as `key:value` pairs.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateContainerMetadata {
    /// ID of the container that is being created.
    #[prost(string, tag = "1")]
    pub container_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateContainerRequest {
    /// ID of the container to update.
    ///
    /// To get a container ID make a \[ContainerService.List\] request.
    #[prost(string, tag = "1")]
    pub container_id: ::prost::alloc::string::String,
    /// Field mask that specifies which attributes of the container should be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// New name for the container.
    /// The name must be unique within the folder.
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    /// New description for the container.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// Container labels as `key:value` pairs.
    ///
    /// Existing set of labels is completely replaced by the provided set, so if you just want
    /// to add or remove a label, request the current set of labels with a \[ContainerService.Get\] request.
    #[prost(map = "string, string", tag = "5")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateContainerMetadata {
    /// ID of the container that is being updated.
    #[prost(string, tag = "1")]
    pub container_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteContainerRequest {
    /// ID of the container to delete.
    /// To get a container ID make a \[ContainerService.List\] request.
    #[prost(string, tag = "1")]
    pub container_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteContainerMetadata {
    /// ID of the container that is being deleted.
    #[prost(string, tag = "1")]
    pub container_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetContainerRevisionRequest {
    /// ID of the revision to return.
    ///
    /// To get a revision ID make a \[ContainerService.ListRevisions\] request.
    #[prost(string, tag = "1")]
    pub container_revision_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListContainersRevisionsRequest {
    /// The maximum number of results per page to return. If the number of available results
    /// is larger than `pageSize`, the service returns a \[ListContainersRevisionsResponse.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 `pageToken` to the
    /// \[ListContainersRevisionsResponse.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 resources listed in the response.
    ///
    /// The expression must specify:
    /// 1. The field name. Currently filtering can only be applied to the \[Revision.status\] and \[Revision.runtime\] 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\]`.
    /// Example of a filter: `status="ACTIVE"`.
    #[prost(string, tag = "5")]
    pub filter: ::prost::alloc::string::String,
    #[prost(oneof = "list_containers_revisions_request::Id", tags = "1, 2")]
    pub id: ::core::option::Option<list_containers_revisions_request::Id>,
}
/// Nested message and enum types in `ListContainersRevisionsRequest`.
pub mod list_containers_revisions_request {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Id {
        /// ID of the folder to list container revisions for.
        /// To get a folder ID make a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
        #[prost(string, tag = "1")]
        FolderId(::prost::alloc::string::String),
        /// ID of the container to list revisions for.
        /// To get a container ID use a \[ContainerService.List\] request.
        #[prost(string, tag = "2")]
        ContainerId(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListContainersRevisionsResponse {
    /// List of revisions for the specified folder or container.
    #[prost(message, repeated, tag = "1")]
    pub revisions: ::prost::alloc::vec::Vec<Revision>,
    /// Token for getting the next page of the list. If the number of results is greater than
    /// the specified \[ListContainersRevisionsRequest.page_size\], use `nextPageToken` as the value
    /// for the \[ListContainersRevisionsRequest.page_token\] parameter in the next list request.
    ///
    /// Each subsequent page will have its own `nextPageToken` 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 DeployContainerRevisionRequest {
    /// ID of the container to create a revision for.
    ///
    /// To get a container ID, make a \[ContainerService.List\] request.
    #[prost(string, tag = "1")]
    pub container_id: ::prost::alloc::string::String,
    /// Description of the revision.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Resources allocated to the revision.
    #[prost(message, optional, tag = "5")]
    pub resources: ::core::option::Option<Resources>,
    /// Timeout for the execution of the revision.
    ///
    /// If the timeout is exceeded, Serverless Containers responds with a 504 HTTP code.
    #[prost(message, optional, tag = "6")]
    pub execution_timeout: ::core::option::Option<::prost_types::Duration>,
    /// ID of the service account to associate with the revision.
    #[prost(string, tag = "7")]
    pub service_account_id: ::prost::alloc::string::String,
    /// Image configuration for the revision.
    #[prost(message, optional, tag = "8")]
    pub image_spec: ::core::option::Option<ImageSpec>,
    /// The number of concurrent requests allowed per container instance.
    ///
    /// The default value is 1.
    #[prost(int64, tag = "9")]
    pub concurrency: i64,
    /// Yandex Lockbox secrets to be used by the revision.
    #[prost(message, repeated, tag = "10")]
    pub secrets: ::prost::alloc::vec::Vec<Secret>,
    /// Network access. If specified the revision will be attached to specified network/subnet(s).
    #[prost(message, optional, tag = "11")]
    pub connectivity: ::core::option::Option<Connectivity>,
    /// Policy for provisioning instances of the revision.
    ///
    /// The policy is only applied when the revision is ACTIVE.
    #[prost(message, optional, tag = "12")]
    pub provision_policy: ::core::option::Option<ProvisionPolicy>,
    /// Policy for scaling instances of the revision.
    #[prost(message, optional, tag = "13")]
    pub scaling_policy: ::core::option::Option<ScalingPolicy>,
    /// Options for logging from the container.
    #[prost(message, optional, tag = "14")]
    pub log_options: ::core::option::Option<LogOptions>,
    /// S3 mounts to be used by the revision.
    #[prost(message, repeated, tag = "15")]
    pub storage_mounts: ::prost::alloc::vec::Vec<StorageMount>,
    /// Mounts to be used by the revision.
    #[prost(message, repeated, tag = "16")]
    pub mounts: ::prost::alloc::vec::Vec<Mount>,
    /// The container's execution mode
    #[prost(message, optional, tag = "17")]
    pub runtime: ::core::option::Option<Runtime>,
    /// Metadata options for the revision.
    #[prost(message, optional, tag = "18")]
    pub metadata_options: ::core::option::Option<MetadataOptions>,
}
/// Revision image specification.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ImageSpec {
    /// Image URL, that is used by the revision.
    #[prost(string, tag = "1")]
    pub image_url: ::prost::alloc::string::String,
    /// Override for the image's ENTRYPOINT.
    #[prost(message, optional, tag = "2")]
    pub command: ::core::option::Option<Command>,
    /// Override for the image's CMD.
    #[prost(message, optional, tag = "3")]
    pub args: ::core::option::Option<Args>,
    /// Additional environment for the container.
    #[prost(map = "string, string", tag = "4")]
    pub environment: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Override for the image's WORKDIR.
    #[prost(string, tag = "5")]
    pub working_dir: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeployContainerRevisionMetadata {
    /// ID of the revision that is being created.
    #[prost(string, tag = "1")]
    pub container_revision_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RollbackContainerRequest {
    /// ID of the container to rollback to an old revision.
    ///
    /// To get a container ID, make a \[ContainerService.List\] request.
    #[prost(string, tag = "1")]
    pub container_id: ::prost::alloc::string::String,
    /// ID of the revision to rollback to.
    ///
    /// To get a revision ID make a \[ContainerService.ListRevisions\] request.
    #[prost(string, tag = "2")]
    pub revision_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RollbackContainerMetadata {
    /// ID of the container that is being rolled back.
    #[prost(string, tag = "1")]
    pub container_id: ::prost::alloc::string::String,
    /// ID of the revision that the container is being rolled back to.
    #[prost(string, tag = "2")]
    pub revision_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListContainerOperationsRequest {
    /// ID of the container to list operations for.
    #[prost(string, tag = "1")]
    pub container_id: ::prost::alloc::string::String,
    /// The maximum number of results per page that should be returned. If the number of available
    /// results is larger than `pageSize`, the service returns a \[ListContainerOperationsResponse.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 `pageToken` to the
    /// \[ListContainerOperationsResponse.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.done\], \[operation.Operation.created_by\] 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\]`.
    /// 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 ListContainerOperationsResponse {
    /// List of operations for the specified container.
    #[prost(message, repeated, tag = "1")]
    pub operations: ::prost::alloc::vec::Vec<super::super::super::operation::Operation>,
    /// Token for getting the next page of the list. If the number of results is greater than
    /// the specified \[ListContainerOperationsRequest.page_size\], use `nextPageToken` as the value
    /// for the \[ListContainerOperationsRequest.page_token\] parameter in the next list request.
    ///
    /// Each subsequent page will have its own `nextPageToken` to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod container_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 serverless containers.
    #[derive(Debug, Clone)]
    pub struct ContainerServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ContainerServiceClient<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> ContainerServiceClient<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,
        ) -> ContainerServiceClient<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,
        {
            ContainerServiceClient::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 container.
        ///
        /// To get the list of all available containers, make a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetContainerRequest>,
        ) -> std::result::Result<tonic::Response<super::Container>, 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.serverless.containers.v1.ContainerService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.containers.v1.ContainerService",
                        "Get",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of containers in the specified folder.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListContainersRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListContainersResponse>,
            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.serverless.containers.v1.ContainerService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.containers.v1.ContainerService",
                        "List",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a container in the specified folder.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateContainerRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.serverless.containers.v1.ContainerService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.containers.v1.ContainerService",
                        "Create",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified container.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateContainerRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.serverless.containers.v1.ContainerService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.containers.v1.ContainerService",
                        "Update",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified container.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteContainerRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.serverless.containers.v1.ContainerService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.containers.v1.ContainerService",
                        "Delete",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deploys a revision for the specified container.
        pub async fn deploy_revision(
            &mut self,
            request: impl tonic::IntoRequest<super::DeployContainerRevisionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.serverless.containers.v1.ContainerService/DeployRevision",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.containers.v1.ContainerService",
                        "DeployRevision",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Rollback the specified container to an old revision.
        pub async fn rollback(
            &mut self,
            request: impl tonic::IntoRequest<super::RollbackContainerRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.serverless.containers.v1.ContainerService/Rollback",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.containers.v1.ContainerService",
                        "Rollback",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns the specified revision of a container.
        ///
        /// To get the list of available revisions, make a [ListRevisions] request.
        pub async fn get_revision(
            &mut self,
            request: impl tonic::IntoRequest<super::GetContainerRevisionRequest>,
        ) -> std::result::Result<tonic::Response<super::Revision>, 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.serverless.containers.v1.ContainerService/GetRevision",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.containers.v1.ContainerService",
                        "GetRevision",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of revisions for the specified container, or of all container revisions
        /// in the specified folder.
        pub async fn list_revisions(
            &mut self,
            request: impl tonic::IntoRequest<super::ListContainersRevisionsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListContainersRevisionsResponse>,
            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.serverless.containers.v1.ContainerService/ListRevisions",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.containers.v1.ContainerService",
                        "ListRevisions",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists operations for the specified container.
        pub async fn list_operations(
            &mut self,
            request: impl tonic::IntoRequest<super::ListContainerOperationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListContainerOperationsResponse>,
            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.serverless.containers.v1.ContainerService/ListOperations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.containers.v1.ContainerService",
                        "ListOperations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists existing access bindings for the specified container.
        pub async fn list_access_bindings(
            &mut self,
            request: impl tonic::IntoRequest<
                super::super::super::super::access::ListAccessBindingsRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<
                super::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.serverless.containers.v1.ContainerService/ListAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.containers.v1.ContainerService",
                        "ListAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Sets access bindings for the container.
        pub async fn set_access_bindings(
            &mut self,
            request: impl tonic::IntoRequest<
                super::super::super::super::access::SetAccessBindingsRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::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.serverless.containers.v1.ContainerService/SetAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.containers.v1.ContainerService",
                        "SetAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates access bindings for the specified container.
        pub async fn update_access_bindings(
            &mut self,
            request: impl tonic::IntoRequest<
                super::super::super::super::access::UpdateAccessBindingsRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::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.serverless.containers.v1.ContainerService/UpdateAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.serverless.containers.v1.ContainerService",
                        "UpdateAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}