yandex-cloud 2025.4.14

/// A bucket resource.
/// For details about the concept, see \[documentation\](/docs/storage/concepts/bucket).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Bucket {
    /// ID of the bucket. Always equal to \[name\], which has priority.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Name of the bucket.
    ///
    /// The name is unique within the platform. For naming limitations and rules, see
    /// \[documentation\](/docs/storage/concepts/bucket#naming).
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// ID of the folder that the bucket belongs to.
    #[prost(string, tag = "3")]
    pub folder_id: ::prost::alloc::string::String,
    /// Flags for configuring public (anonymous) access to the bucket's content and settings.
    /// For details, see \[documentation\](/docs/storage/concepts/bucket#bucket-access).
    #[prost(message, optional, tag = "4")]
    pub anonymous_access_flags: ::core::option::Option<AnonymousAccessFlags>,
    /// Default storage class for objects in the bucket. Supported classes are standard storage (`STANDARD`), cold storage
    /// (`COLD`, `STANDARD_IA`, `NEARLINE` all synonyms), and ice storage (`ICE` and `GLACIER` are synonyms).
    /// For details, see \[documentation\](/docs/storage/concepts/storage-class).
    #[prost(string, tag = "5")]
    pub default_storage_class: ::prost::alloc::string::String,
    /// Bucket versioning status.
    /// For details, see \[documentation\](/docs/storage/concepts/versioning).
    #[prost(enumeration = "Versioning", tag = "6")]
    pub versioning: i32,
    /// Maximum size of the bucket, in bytes.
    /// For details, see \[documentation\](/docs/storage/operations/buckets/limit-max-volume).
    #[prost(int64, tag = "7")]
    pub max_size: i64,
    /// Bucket policies that set permissions for actions with the bucket, its objects, and groups of objects.
    /// For details, see \[documentation\](/docs/storage/concepts/policy).
    #[prost(message, optional, tag = "8")]
    pub policy: ::core::option::Option<::prost_types::Struct>,
    /// Access control list (ACL) of the bucket.
    /// For details, see \[documentation\](/docs/storage/concepts/acl).
    #[prost(message, optional, tag = "9")]
    pub acl: ::core::option::Option<Acl>,
    /// Creation timestamp.
    #[prost(message, optional, tag = "10")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// List of rules for cross-domain requests to objects in the bucket (cross-origin resource sharing, CORS).
    /// For details, see \[documentation\](/docs/storage/concepts/cors).
    #[prost(message, repeated, tag = "11")]
    pub cors: ::prost::alloc::vec::Vec<CorsRule>,
    /// Configuration for hosting a static website in the bucket.
    /// For details, see \[documentation\](/docs/storage/concepts/hosting).
    #[prost(message, optional, tag = "12")]
    pub website_settings: ::core::option::Option<WebsiteSettings>,
    /// List of object lifecycle rules for the bucket.
    /// For details, see \[documentation\](/docs/storage/concepts/lifecycles).
    #[prost(message, repeated, tag = "13")]
    pub lifecycle_rules: ::prost::alloc::vec::Vec<LifecycleRule>,
    /// List of tags for the bucket.
    /// For details, see \[documentation\](/docs/resource-manager/concepts/labels).
    #[prost(message, repeated, tag = "14")]
    pub tags: ::prost::alloc::vec::Vec<Tag>,
    /// Configuration for object lock on the bucket.
    /// For details about the concept, see \[documentation\](/docs/storage/concepts/object-lock).
    #[prost(message, optional, tag = "15")]
    pub object_lock: ::core::option::Option<ObjectLock>,
    /// Configuration for bucket's encryption
    /// For details, see \[documentation\](/docs/storage/concepts/encryption)
    #[prost(message, optional, tag = "16")]
    pub encryption: ::core::option::Option<Encryption>,
    /// Bucket allowed private endpoints.
    #[prost(message, optional, tag = "17")]
    pub allowed_private_endpoints: ::core::option::Option<BucketAllowedPrivateEndpoints>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Tag {
    /// Key of the bucket tag.
    #[prost(string, tag = "1")]
    pub key: ::prost::alloc::string::String,
    /// Value of the bucket tag.
    #[prost(string, tag = "2")]
    pub value: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Acl {
    /// List of permissions granted and the grantees.
    #[prost(message, repeated, tag = "1")]
    pub grants: ::prost::alloc::vec::Vec<acl::Grant>,
}
/// Nested message and enum types in `ACL`.
pub mod acl {
    /// A grant resource, used to specify the permission granted and the grantee.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Grant {
        /// Permission granted by the grant.
        #[prost(enumeration = "grant::Permission", tag = "1")]
        pub permission: i32,
        /// The grantee type for the grant.
        #[prost(enumeration = "grant::GrantType", tag = "2")]
        pub grant_type: i32,
        /// ID of the account who is a grantee. Required when the \[grant_type\] is `GRANT_TYPE_ACCOUNT`.
        #[prost(string, tag = "3")]
        pub grantee_id: ::prost::alloc::string::String,
    }
    /// Nested message and enum types in `Grant`.
    pub mod grant {
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum Permission {
            Unspecified = 0,
            /// Allows grantee the `PERMISSION_WRITE`, `PERMISSION_WRITE_ACP`, `PERMISSION_READ`, and `PERMISSION_READ_ACP`
            /// on the bucket.
            ///
            /// Maps to `x-amz-grant-full-control` header for \[bucketPutAcl\](/docs/storage/s3/api-ref/acl/bucketput) method of
            /// Amazon S3-compatible HTTP API.
            FullControl = 1,
            /// Allows grantee to create new objects in the bucket. For the bucket and object owners of existing objects, also
            /// allows deletions and overwrites of those objects.
            ///
            /// Maps to `x-amz-grant-write` header for \[bucketPutAcl\](/docs/storage/s3/api-ref/acl/bucketput) method of Amazon
            /// S3-compatible HTTP API.
            Write = 2,
            /// Allows grantee to write the ACL for the bucket.
            ///
            /// Maps to `x-amz-grant-write-acp` header for \[bucketPutAcl\](/docs/storage/s3/api-ref/acl/bucketput) method of
            /// Amazon S3-compatible HTTP API.
            WriteAcp = 3,
            /// Allows grantee to list the objects in the bucket.
            ///
            /// Maps to `x-amz-grant-read` header for \[bucketPutAcl\](/docs/storage/s3/api-ref/acl/bucketput) method of Amazon
            /// S3-compatible HTTP API.
            Read = 4,
            /// Allows grantee to read the bucket ACL
            ///
            /// Maps to `x-amz-grant-read-acp` header for \[bucketPutAcl\](/docs/storage/s3/api-ref/acl/bucketput) method of
            /// Amazon S3-compatible HTTP API.
            ReadAcp = 5,
        }
        impl Permission {
            /// 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 {
                    Permission::Unspecified => "PERMISSION_UNSPECIFIED",
                    Permission::FullControl => "PERMISSION_FULL_CONTROL",
                    Permission::Write => "PERMISSION_WRITE",
                    Permission::WriteAcp => "PERMISSION_WRITE_ACP",
                    Permission::Read => "PERMISSION_READ",
                    Permission::ReadAcp => "PERMISSION_READ_ACP",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "PERMISSION_UNSPECIFIED" => Some(Self::Unspecified),
                    "PERMISSION_FULL_CONTROL" => Some(Self::FullControl),
                    "PERMISSION_WRITE" => Some(Self::Write),
                    "PERMISSION_WRITE_ACP" => Some(Self::WriteAcp),
                    "PERMISSION_READ" => Some(Self::Read),
                    "PERMISSION_READ_ACP" => Some(Self::ReadAcp),
                    _ => None,
                }
            }
        }
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum GrantType {
            Unspecified = 0,
            /// A grantee is an [account on the platform](/docs/iam/concepts/#accounts).
            ///
            /// For this grantee type, you need to specify the user ID in \[Bucket.acl.grants.grantee_id\] field. To get user ID, see
            /// \[instruction\](/docs/iam/operations/users/get).
            ///
            /// Maps to using `id="*"` value for `x-amz-grant-*` header (\[bucketPutAcl\](/docs/storage/s3/api-ref/acl/bucketput)
            /// method of Amazon S3-compatible HTTP API).
            Account = 1,
            /// Grantees are all authenticated users, both from your clouds and other users' clouds. Access
            /// permission to this group allows any account on the platform to access the resource via a signed (authenticated)
            /// request.
            ///
            /// Maps to using `uri="<http://acs.amazonaws.com/groups/global/AuthenticatedUsers"`> value for `x-amz-grant-*`
            /// header (\[bucketPutAcl\](/docs/storage/s3/api-ref/acl/bucketput) method of Amazon S3-compatible HTTP API).
            AllAuthenticatedUsers = 2,
            /// Grantees are all internet users. Access permission to this group allows anyone in the world access to the
            /// resource via signed (authenticated) or unsigned (anonymous) requests.
            ///
            /// Maps to using `uri="<http://acs.amazonaws.com/groups/global/AllUsers"`> value for `x-amz-grant-*` header
            /// (\[bucketPutAcl\](/docs/storage/s3/api-ref/acl/bucketput) method of Amazon S3-compatible HTTP API).
            AllUsers = 3,
        }
        impl GrantType {
            /// 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 {
                    GrantType::Unspecified => "GRANT_TYPE_UNSPECIFIED",
                    GrantType::Account => "GRANT_TYPE_ACCOUNT",
                    GrantType::AllAuthenticatedUsers => {
                        "GRANT_TYPE_ALL_AUTHENTICATED_USERS"
                    }
                    GrantType::AllUsers => "GRANT_TYPE_ALL_USERS",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "GRANT_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                    "GRANT_TYPE_ACCOUNT" => Some(Self::Account),
                    "GRANT_TYPE_ALL_AUTHENTICATED_USERS" => {
                        Some(Self::AllAuthenticatedUsers)
                    }
                    "GRANT_TYPE_ALL_USERS" => Some(Self::AllUsers),
                    _ => None,
                }
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AnonymousAccessFlags {
    /// Specifies whether public (anonymous) access to read objects in the bucket is enabled.
    #[prost(message, optional, tag = "1")]
    pub read: ::core::option::Option<bool>,
    /// Specifies whether public (anonymous) access to the list of objects in the bucket is enabled.
    #[prost(message, optional, tag = "2")]
    pub list: ::core::option::Option<bool>,
    /// Specifies whether public (anonymous) access to read \[CORS\](/docs/storage/concepts/cors),
    /// [static website hosting](/docs/storage/concepts/hosting), and
    /// [object lifecycles](/docs/storage/concepts/lifecycles) settings of the bucket is enabled.
    #[prost(message, optional, tag = "3")]
    pub config_read: ::core::option::Option<bool>,
}
/// A CORS rule resource.
/// For details about the concept, see \[documentation\](/docs/storage/concepts/cors).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CorsRule {
    /// ID of the CORS rule.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// List of HTTP methods allowed by the CORS rule.
    ///
    /// When a client sends a CORS-preflight `options` request with the `Access-Control-Request-Method` header (see
    /// [S3-compatible API reference](/docs/storage/s3/api-ref/object/options)), the specified method is checked against
    /// the list of the allowed methods. If there is a match, all the allowed methods are listed in the
    /// `Access-Control-Allow-Methods` header of the response.
    #[prost(enumeration = "cors_rule::Method", repeated, packed = "false", tag = "2")]
    pub allowed_methods: ::prost::alloc::vec::Vec<i32>,
    /// List of HTTP headers allowed by the CORS rule.
    ///
    /// When a client sends a CORS-preflight `options` request with the `Access-Control-Request-Headers` header (see
    /// [S3-compatible API reference](/docs/storage/s3/api-ref/object/options)), the specified headers are checked against
    /// the list of the allowed headers. If there is a match, the specified headers that are allowed are listed in the
    /// `Access-Control-Allow-Headers` header of the response.
    ///
    /// Each string in the list can contain at most one `*` wildcard character that matches 0 or more characters.
    /// For example, `x-amz-*` value will allow all Amazon S3-compatible headers.
    #[prost(string, repeated, tag = "3")]
    pub allowed_headers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// List of request origins allowed by the CORS rule.
    ///
    /// Each string in the list can contain at most one `*` wildcard character that matches 0 or more characters.
    /// For example, `<http://*.example.com`> value will allow requests originating from all subdomains of `example.com`.
    #[prost(string, repeated, tag = "4")]
    pub allowed_origins: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// List of headers contained in responses to CORS requests that can be accessed by applications.
    #[prost(string, repeated, tag = "5")]
    pub expose_headers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Time in seconds that a client can cache the response to a CORS-preflight request as identified by the
    /// object requested, the HTTP method, and the origin.
    #[prost(message, optional, tag = "6")]
    pub max_age_seconds: ::core::option::Option<i64>,
}
/// Nested message and enum types in `CorsRule`.
pub mod cors_rule {
    /// List of HTTP methods that are allowed by the CORS rule.
    ///
    /// When a client sends a CORS-preflight `options` request with the `Access-Control-Request-Method` header (see
    /// S3-compatible API reference](/docs/storage/s3/api-ref/object/options)), the specified method is checked against the
    /// list of the allowed methods. If there is a match, all the allowed methods are listed in the
    /// `Access-Control-Allow-Methods` header of the response.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Method {
        Unspecified = 0,
        /// HTTP `GET` method.
        Get = 1,
        /// HTTP `HEAD` method.
        Head = 2,
        /// HTTP `POST` method.
        Post = 3,
        /// HTTP `PUT` method.
        Put = 4,
        /// HTTP `DELETE` method.
        Delete = 5,
    }
    impl Method {
        /// 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 {
                Method::Unspecified => "METHOD_UNSPECIFIED",
                Method::Get => "METHOD_GET",
                Method::Head => "METHOD_HEAD",
                Method::Post => "METHOD_POST",
                Method::Put => "METHOD_PUT",
                Method::Delete => "METHOD_DELETE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "METHOD_UNSPECIFIED" => Some(Self::Unspecified),
                "METHOD_GET" => Some(Self::Get),
                "METHOD_HEAD" => Some(Self::Head),
                "METHOD_POST" => Some(Self::Post),
                "METHOD_PUT" => Some(Self::Put),
                "METHOD_DELETE" => Some(Self::Delete),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WebsiteSettings {
    /// Key of the index page object that is returned when a response is made to the root of the website.
    ///
    /// Either \[index\] or \[redirect_all_requests\] must be specified in order for the bucket to host a static website.
    ///
    /// If specified, the index page object must be located in the root of the bucket.
    #[prost(string, tag = "1")]
    pub index: ::prost::alloc::string::String,
    /// Key of the error page object that is returned when an error occurs.
    #[prost(string, tag = "2")]
    pub error: ::prost::alloc::string::String,
    /// Configuration for redirecting all requests sent to the website.
    ///
    /// Either \[redirect_all_requests\] or \[index\] must be specified in order for the bucket to host a static website.
    /// If \[redirect_all_requests\] is specified, it must be the only field in \[Bucket.website_settings\].
    #[prost(message, optional, tag = "3")]
    pub redirect_all_requests: ::core::option::Option<website_settings::Scheme>,
    /// List of redirect rules.
    #[prost(message, repeated, tag = "4")]
    pub routing_rules: ::prost::alloc::vec::Vec<website_settings::RoutingRule>,
}
/// Nested message and enum types in `WebsiteSettings`.
pub mod website_settings {
    /// A configuration resource for redirecting all requests sent to the website.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Scheme {
        /// Scheme of the redirect URI.
        #[prost(enumeration = "Protocol", tag = "1")]
        pub protocol: i32,
        /// Hostname of the redirect URI.
        #[prost(string, tag = "2")]
        pub hostname: ::prost::alloc::string::String,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Condition {
        /// HTTP status code (number only) that must match for the redirect to apply.
        #[prost(string, tag = "1")]
        pub http_error_code_returned_equals: ::prost::alloc::string::String,
        /// Prefix of the object key from which requests are redirected.
        #[prost(string, tag = "2")]
        pub key_prefix_equals: ::prost::alloc::string::String,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Redirect {
        /// Hostname of the redirect URI.
        #[prost(string, tag = "1")]
        pub hostname: ::prost::alloc::string::String,
        /// HTTP status code of the redirect response.
        ///
        /// Default value: `"301"`.
        #[prost(string, tag = "2")]
        pub http_redirect_code: ::prost::alloc::string::String,
        /// Scheme of the redirect URI.
        #[prost(enumeration = "Protocol", tag = "3")]
        pub protocol: i32,
        /// Substitution for the prefix of the object key specified in \[Condition.key_prefix_equals\].
        ///
        /// At most one of \[replace_key_prefix_with\] and \[replace_key_with\] can be specified.
        #[prost(string, tag = "4")]
        pub replace_key_prefix_with: ::prost::alloc::string::String,
        /// New object key.
        ///
        /// At most one of \[replace_key_with\] and \[replace_key_prefix_with\] can be specified.
        #[prost(string, tag = "5")]
        pub replace_key_with: ::prost::alloc::string::String,
    }
    /// List of redirect rules.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RoutingRule {
        /// Redirect condition.
        #[prost(message, optional, tag = "1")]
        pub condition: ::core::option::Option<Condition>,
        /// Redirect instructions.
        #[prost(message, optional, tag = "2")]
        pub redirect: ::core::option::Option<Redirect>,
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Protocol {
        Unspecified = 0,
        /// `http` scheme.
        Http = 1,
        /// `https` scheme.
        Https = 2,
    }
    impl Protocol {
        /// 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 {
                Protocol::Unspecified => "PROTOCOL_UNSPECIFIED",
                Protocol::Http => "PROTOCOL_HTTP",
                Protocol::Https => "PROTOCOL_HTTPS",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "PROTOCOL_UNSPECIFIED" => Some(Self::Unspecified),
                "PROTOCOL_HTTP" => Some(Self::Http),
                "PROTOCOL_HTTPS" => Some(Self::Https),
                _ => None,
            }
        }
    }
}
/// An object lifecycle rule resource for the bucket.
/// For details about the concept, see \[documentation\](/docs/storage/concepts/lifecycles).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LifecycleRule {
    /// ID of the rule. Provided by the client or generated at creation time.
    #[prost(message, optional, tag = "1")]
    pub id: ::core::option::Option<::prost::alloc::string::String>,
    /// Indicates whether the rule is in effect.
    #[prost(bool, tag = "2")]
    pub enabled: bool,
    /// Filter that identifies the objects to which the rule applies.
    ///
    /// If not specified, the rule applies to all objects in the bucket.
    #[prost(message, optional, tag = "3")]
    pub filter: ::core::option::Option<lifecycle_rule::RuleFilter>,
    /// Expiration rule.
    ///
    /// The expiration of an object is described as follows.
    ///
    /// For the unversioned bucket (\[Bucket.versioning\] is `VERSIONING_DISABLED`), the object is deleted and cannot be
    /// recovered.
    ///
    /// For the bucket with versioning enabled (\[Bucket.versioning\] is `VERSIONING_ENABLED`), the current version of the
    /// object (if it exists and is not a delete marker) is retained as a non-current version, and a delete marker becomes
    /// the current version of the object.
    ///
    /// For the bucket with versioning suspended (\[Bucket.versioning\] is `VERSIONING_SUSPENDED`), the current version of
    /// the object is retained as a non-current version if it is not a delete marker, or is removed otherwise, and a
    /// delete marker becomes the current version of the object.
    #[prost(message, optional, tag = "4")]
    pub expiration: ::core::option::Option<lifecycle_rule::Expiration>,
    /// List of transition rules.
    ///
    /// The transition of an object is described as follows.
    ///
    /// For the unversioned bucket (\[Bucket.versioning\] is `VERSIONING_DISABLED`), the object is transitioned to the
    /// specified storage class.
    ///
    /// For the bucket with versioning enabled (\[Bucket.versioning\] is `VERSIONING_ENABLED`) or suspended
    /// (`VERSIONING_SUSPENDED`), the current version of the object is transitioned to the specified storage class.
    #[prost(message, repeated, tag = "5")]
    pub transitions: ::prost::alloc::vec::Vec<lifecycle_rule::Transition>,
    /// Configuration for aborting incomplete [multipart uploads](/docs/storage/concepts/multipart).
    #[prost(message, optional, tag = "6")]
    pub abort_incomplete_multipart_upload: ::core::option::Option<
        lifecycle_rule::AfterDays,
    >,
    /// Expiration rule for non-current versions of objects in a bucket with versioning enabled (\[Bucket.versioning\] is
    /// `VERSIONING_ENABLED`) or suspended (`VERSIONING_SUSPENDED`).
    ///
    /// At expiration, the non-current version of the object is deleted and cannot be recovered.
    #[prost(message, optional, tag = "7")]
    pub noncurrent_expiration: ::core::option::Option<
        lifecycle_rule::NoncurrentExpiration,
    >,
    /// List of transition rules for non-current versions of objects in a bucket with versioning enabled
    /// (\[Bucket.versioning\] is `VERSIONING_ENABLED`) or suspended (`VERSIONING_SUSPENDED`).
    ///
    /// At transition, the non-current version of the object is transitioned to the specified storage class.
    #[prost(message, repeated, tag = "8")]
    pub noncurrent_transitions: ::prost::alloc::vec::Vec<
        lifecycle_rule::NoncurrentTransition,
    >,
    /// Expiration rule for non-current delete markers of an objects in a bucket with versioning
    /// enabled (\[Bucket.versioning\] is `VERSIONING_ENABLED`) or suspended (`VERSIONING_SUSPENDED`).
    /// Works in the same way as noncurrent_expiration rule, but only for delete markers.
    ///
    /// At expiration, the non-current delete marker of the object is deleted and cannot be recovered.
    #[prost(message, optional, tag = "9")]
    pub noncurrent_delete_markers: ::core::option::Option<
        lifecycle_rule::NoncurrentDeleteMarkers,
    >,
}
/// Nested message and enum types in `LifecycleRule`.
pub mod lifecycle_rule {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct AfterDays {
        /// Time period, in number of days from the start of the multipart upload, after which the incomplete upload is
        /// aborted.
        #[prost(message, optional, tag = "1")]
        pub days_after_expiration: ::core::option::Option<i64>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct NoncurrentDeleteMarkers {
        /// Time period, in number of days since the version of a delete marker was classified as non-current, after which
        /// the delete marker expires.
        #[prost(message, optional, tag = "1")]
        pub noncurrent_days: ::core::option::Option<i64>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct NoncurrentExpiration {
        /// Time period, in number of days since the version of an object was classified as non-current, after which the
        /// version expires.
        #[prost(message, optional, tag = "1")]
        pub noncurrent_days: ::core::option::Option<i64>,
    }
    /// List of transition rules for non-current versions of objects in a bucket with versioning enabled
    /// (\[Bucket.versioning\] is `VERSIONING_ENABLED`) or suspended (`VERSIONING_SUSPENDED`).
    ///
    /// At transition, the non-current version of the object is transitioned to the specified storage class.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct NoncurrentTransition {
        /// Time period, in number of days since the version of an object was classified as non-current, after which the
        /// version is transitioned.
        #[prost(message, optional, tag = "1")]
        pub noncurrent_days: ::core::option::Option<i64>,
        /// Storage class to which a non-current version of an object is transitioned from standard storage.
        ///
        /// The only supported class is cold storage (`COLD`, `STANDARD_IA`, `NEARLINE` all synonyms). Transitions from cold
        /// to standard storage and transitions to or from ice storage are not allowed.
        #[prost(string, tag = "2")]
        pub storage_class: ::prost::alloc::string::String,
    }
    /// List of transition rules.
    ///
    /// The transition of an object is described as follows.
    ///
    /// For the unversioned bucket (\[Bucket.versioning\] is `VERSIONING_DISABLED`), the object is transitioned to the
    /// specified storage class.
    ///
    /// For the bucket with versioning enabled (\[Bucket.versioning\] is `VERSIONING_ENABLED`) or suspended
    /// (`VERSIONING_SUSPENDED`), the current version of the object is transitioned to the specified storage class.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Transition {
        /// Specific date of object transition.
        ///
        /// The rule continues to apply even after the date has passed, i.e. any new objects created in the bucket are
        /// transitioned immediately.
        ///
        /// At most one of \[date\] and \[days\] fields can be specified.
        #[prost(message, optional, tag = "1")]
        pub date: ::core::option::Option<::prost_types::Timestamp>,
        /// Time period, in number of days from the creation or modification of the object, after which an object is
        /// transitioned.
        ///
        /// At most one of \[days\] and \[date\] fields can be specified.
        #[prost(message, optional, tag = "2")]
        pub days: ::core::option::Option<i64>,
        /// Storage class to which an object is transitioned from standard storage.
        ///
        /// The only supported class is cold storage (`COLD`, `STANDARD_IA`, `NEARLINE` all synonyms). Transitions from cold
        /// to standard storage and transitions to or from ice storage are not allowed.
        #[prost(string, tag = "4")]
        pub storage_class: ::prost::alloc::string::String,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Expiration {
        /// Specific date of object expiration.
        ///
        /// The rule continues to apply even after the date has passed, i.e. any new objects created in the bucket expire
        /// immediately.
        ///
        /// Exactly one of \[date\], \[days\], and \[expired_object_delete_marker\] fields can be specified.
        #[prost(message, optional, tag = "1")]
        pub date: ::core::option::Option<::prost_types::Timestamp>,
        /// Time period, in number of days from the creation or modification of the object, after which an object expires.
        ///
        /// Exactly one of \[days\], \[date\], and \[expired_object_delete_marker\] fields can be specified.
        #[prost(message, optional, tag = "2")]
        pub days: ::core::option::Option<i64>,
        /// Indicates whether a delete marker of an object with no non-current versions (referred to as an expired object
        /// delete marker) is removed at the object's expiration.
        ///
        /// Exactly one of \[expired_object_delete_marker\], \[date\], and \[days\] fields can be specified.
        #[prost(message, optional, tag = "3")]
        pub expired_object_delete_marker: ::core::option::Option<bool>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RuleFilter {
        /// Key prefix that the object must have in order for the rule to apply.
        #[prost(string, tag = "1")]
        pub prefix: ::prost::alloc::string::String,
        /// Size that the object must be greater.
        #[prost(message, optional, tag = "2")]
        pub object_size_greater_than: ::core::option::Option<i64>,
        /// Size that the object must be less t.
        #[prost(message, optional, tag = "3")]
        pub object_size_less_than: ::core::option::Option<i64>,
        /// Tags that the object's tag set must have for the rule to apply.
        #[prost(message, optional, tag = "4")]
        pub tag: ::core::option::Option<super::Tag>,
        /// Apply a logical AND to all of the predicates configured inside the And operator.
        #[prost(message, optional, tag = "5")]
        pub and_operator: ::core::option::Option<rule_filter::And>,
    }
    /// Nested message and enum types in `RuleFilter`.
    pub mod rule_filter {
        #[allow(clippy::derive_partial_eq_without_eq)]
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct And {
            #[prost(string, tag = "1")]
            pub prefix: ::prost::alloc::string::String,
            #[prost(message, optional, tag = "2")]
            pub object_size_greater_than: ::core::option::Option<i64>,
            #[prost(message, optional, tag = "3")]
            pub object_size_less_than: ::core::option::Option<i64>,
            #[prost(message, repeated, tag = "4")]
            pub tag: ::prost::alloc::vec::Vec<super::super::Tag>,
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Counters {
    /// Total size of objects uploaded in single operation, in bytes.
    #[prost(int64, tag = "1")]
    pub simple_object_size: i64,
    /// Number of objects uploaded in single operation.
    #[prost(int64, tag = "2")]
    pub simple_object_count: i64,
    /// Total size of uploaded parts in incomplete multipart uploads, in bytes.
    #[prost(int64, tag = "3")]
    pub objects_parts_size: i64,
    /// Number of uploaded parts in incomplete multipart uploads.
    #[prost(int64, tag = "4")]
    pub objects_parts_count: i64,
    /// Total size of objects uploaded in multiple parts, in bytes.
    #[prost(int64, tag = "5")]
    pub multipart_objects_size: i64,
    /// Number of objects uploaded in multiple parts.
    #[prost(int64, tag = "6")]
    pub multipart_objects_count: i64,
    /// Number of incomplete multipart uploads.
    #[prost(int64, tag = "7")]
    pub active_multipart_count: i64,
}
/// A resource for size of available space in a bucket for a storage class.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OptionalSizeByClass {
    /// Storage class. Supported classes are standard storage (`STANDARD`), cold storage (`COLD`, `STANDARD_IA`, `NEARLINE`
    /// all synonyms), and ice storage (`ICE` and `GLACIER` are synonyms).
    /// For details, see \[documentation\](/docs/storage/concepts/storage-class).
    #[prost(string, tag = "1")]
    pub storage_class: ::prost::alloc::string::String,
    /// Size of available space in the bucket for the storage class.
    #[prost(message, optional, tag = "2")]
    pub class_size: ::core::option::Option<i64>,
}
/// A resource for size of used space in a bucket for a storage class.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SizeByClass {
    /// Storage class. Supported classes are standard storage (`STANDARD`), cold storage (`COLD`, `STANDARD_IA`, `NEARLINE`
    /// all synonyms), and ice storage (`ICE` and `GLACIER` are synonyms).
    /// For details, see \[documentation\](/docs/storage/concepts/storage-class).
    #[prost(string, tag = "1")]
    pub storage_class: ::prost::alloc::string::String,
    /// Size of used space in the bucket for the storage class.
    #[prost(int64, tag = "2")]
    pub class_size: i64,
}
/// A resource for object-related statistics for a storage class by type of upload (simple vs. multipart).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CountersByClass {
    /// Storage class. Supported classes are standard storage (`STANDARD`), cold storage (`COLD`, `STANDARD_IA`, `NEARLINE`
    /// all synonyms), and ice storage (`ice` and `GLACIER` are synonyms).
    /// For details, see \[documentation\](/docs/storage/concepts/storage-class).
    #[prost(string, tag = "1")]
    pub storage_class: ::prost::alloc::string::String,
    /// Object-related statistics for the storage class by type of upload.
    #[prost(message, optional, tag = "2")]
    pub counters: ::core::option::Option<Counters>,
}
/// A bucket statistics resource.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BucketStats {
    /// Name of the bucket.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Maximum size of the bucket, in bytes.
    #[prost(message, optional, tag = "2")]
    pub max_size: ::core::option::Option<i64>,
    /// Size of used space in the bucket, in bytes.
    #[prost(int64, tag = "3")]
    pub used_size: i64,
    /// Size of available space in the bucket by storage class, in bytes.
    #[prost(message, repeated, tag = "4")]
    pub storage_class_max_sizes: ::prost::alloc::vec::Vec<OptionalSizeByClass>,
    /// Size of used space in the bucket by storage class, in bytes.
    #[prost(message, repeated, tag = "5")]
    pub storage_class_used_sizes: ::prost::alloc::vec::Vec<SizeByClass>,
    /// Object-related statistics by storage class and type of upload (simple vs. multipart), in bytes.
    #[prost(message, repeated, tag = "6")]
    pub storage_class_counters: ::prost::alloc::vec::Vec<CountersByClass>,
    /// Default storage class for objects in the bucket. Supported classes are standard storage (`STANDARD`), cold storage
    /// (`COLD`, `STANDARD_IA`, `NEARLINE` all synonyms), and ice storage (`ICE` and `GLACIER` are synonyms).
    /// For details, see \[documentation\](/docs/storage/concepts/storage-class).
    #[prost(message, optional, tag = "7")]
    pub default_storage_class: ::core::option::Option<::prost::alloc::string::String>,
    /// Flags for configuring public (anonymous) access to the bucket's content and settings.
    /// For details, see \[documentation\](/docs/storage/concepts/bucket#bucket-access).
    #[prost(message, optional, tag = "8")]
    pub anonymous_access_flags: ::core::option::Option<AnonymousAccessFlags>,
    /// Bucket creation timestamp.
    #[prost(message, optional, tag = "9")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Bucket latest update timestamp.
    #[prost(message, optional, tag = "10")]
    pub updated_at: ::core::option::Option<::prost_types::Timestamp>,
}
/// A resource for HTTPS configuration of a bucket.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HttpsConfig {
    /// Name of the bucket.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Type of TLS certificate source.
    #[prost(enumeration = "https_config::SourceType", tag = "2")]
    pub source_type: i32,
    /// Issuer of the TLS certificate.
    #[prost(message, optional, tag = "3")]
    pub issuer: ::core::option::Option<::prost::alloc::string::String>,
    /// Subject of the TLS certificate.
    #[prost(message, optional, tag = "4")]
    pub subject: ::core::option::Option<::prost::alloc::string::String>,
    /// List of DNS names of the TLS certificate (Subject Alternative Name field).
    #[prost(string, repeated, tag = "5")]
    pub dns_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Start of the TLS certificate validity period (Not Before field).
    #[prost(message, optional, tag = "6")]
    pub not_before: ::core::option::Option<::prost_types::Timestamp>,
    /// End of the TLS certificate validity period (Not After field)
    #[prost(message, optional, tag = "7")]
    pub not_after: ::core::option::Option<::prost_types::Timestamp>,
    /// ID of the TLS certificate in Certificate Manager.
    ///
    /// To get information about the certificate from Certificate Manager, make a
    /// \[yandex.cloud.certificatemanager.v1.CertificateService.Get\] request.
    #[prost(string, tag = "8")]
    pub certificate_id: ::prost::alloc::string::String,
}
/// Nested message and enum types in `HTTPSConfig`.
pub mod https_config {
    /// A resource for type of TLS certificate source.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum SourceType {
        Unspecified = 0,
        /// Your certificate, uploaded directly.
        SelfManaged = 1,
        /// Certificate managed by Certificate Manager.
        ManagedByCertificateManager = 2,
    }
    impl SourceType {
        /// 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 {
                SourceType::Unspecified => "SOURCE_TYPE_UNSPECIFIED",
                SourceType::SelfManaged => "SOURCE_TYPE_SELF_MANAGED",
                SourceType::ManagedByCertificateManager => {
                    "SOURCE_TYPE_MANAGED_BY_CERTIFICATE_MANAGER"
                }
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "SOURCE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "SOURCE_TYPE_SELF_MANAGED" => Some(Self::SelfManaged),
                "SOURCE_TYPE_MANAGED_BY_CERTIFICATE_MANAGER" => {
                    Some(Self::ManagedByCertificateManager)
                }
                _ => None,
            }
        }
    }
}
/// A resource for Object Lock configuration of a bucket.
/// For details about the concept, see \[documentation\](/docs/storage/concepts/object-lock).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ObjectLock {
    #[prost(enumeration = "object_lock::ObjectLockStatus", tag = "2")]
    pub status: i32,
    #[prost(message, optional, tag = "3")]
    pub default_retention: ::core::option::Option<object_lock::DefaultRetention>,
}
/// Nested message and enum types in `ObjectLock`.
pub mod object_lock {
    /// Default lock configuration for added objects
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct DefaultRetention {
        #[prost(enumeration = "default_retention::Mode", tag = "1")]
        pub mode: i32,
        #[prost(oneof = "default_retention::Period", tags = "2, 3")]
        pub period: ::core::option::Option<default_retention::Period>,
    }
    /// Nested message and enum types in `DefaultRetention`.
    pub mod default_retention {
        /// Lock type
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum Mode {
            Unspecified = 0,
            Governance = 1,
            Compliance = 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::Governance => "MODE_GOVERNANCE",
                    Mode::Compliance => "MODE_COMPLIANCE",
                }
            }
            /// 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),
                    "MODE_GOVERNANCE" => Some(Self::Governance),
                    "MODE_COMPLIANCE" => Some(Self::Compliance),
                    _ => None,
                }
            }
        }
        #[allow(clippy::derive_partial_eq_without_eq)]
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Period {
            /// Number of days for locking
            #[prost(int64, tag = "2")]
            Days(i64),
            /// Number of years for locking
            #[prost(int64, tag = "3")]
            Years(i64),
        }
    }
    /// Activity status of the object lock settings on the bucket
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ObjectLockStatus {
        Unspecified = 0,
        Disabled = 1,
        Enabled = 2,
    }
    impl ObjectLockStatus {
        /// 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 {
                ObjectLockStatus::Unspecified => "OBJECT_LOCK_STATUS_UNSPECIFIED",
                ObjectLockStatus::Disabled => "OBJECT_LOCK_STATUS_DISABLED",
                ObjectLockStatus::Enabled => "OBJECT_LOCK_STATUS_ENABLED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "OBJECT_LOCK_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
                "OBJECT_LOCK_STATUS_DISABLED" => Some(Self::Disabled),
                "OBJECT_LOCK_STATUS_ENABLED" => Some(Self::Enabled),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Encryption {
    #[prost(message, repeated, tag = "1")]
    pub rules: ::prost::alloc::vec::Vec<encryption::EncryptionRule>,
}
/// Nested message and enum types in `Encryption`.
pub mod encryption {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct EncryptionRule {
        #[prost(string, tag = "1")]
        pub kms_master_key_id: ::prost::alloc::string::String,
        #[prost(string, tag = "2")]
        pub sse_algorithm: ::prost::alloc::string::String,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BucketAllowedPrivateEndpoints {
    /// if true, private endpoints white list check is enabled
    /// even if private_endpoints list is empty
    #[prost(bool, tag = "1")]
    pub enabled: bool,
    /// white list of private endpoints bucket accessible from
    #[prost(string, repeated, tag = "2")]
    pub private_endpoints: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Versioning {
    Unspecified = 0,
    /// The bucket is unversioned, i.e. versioning has never been enabled for the bucket, including at its creation.
    /// Objects that are stored in the bucket have a version ID of `null`.
    ///
    /// To enable versioning, change status to `VERSIONING_ENABLED` via a \[BucketService.Update\] request. Note that this
    /// action is irreversible, and a bucket with versioning enabled can never return to `VERSIONING_DISABLED` state.
    Disabled = 1,
    /// Bucket versioning is enabled, i.e. all new objects are versioned and given a unique version ID, and objects that
    /// already existed at the time versioning was enabled will be versioned and given a unique version ID when modified
    /// by future requests.
    ///
    /// To suspend versioning, change status to `VERSIONING_SUSPENDED` via a \[BucketService.Update\] request. You cannot
    /// disable versioning altogether for a bucket that already had it enabled; objects that had version IDs will keep
    /// them.
    Enabled = 2,
    /// Bucket versioning is suspended, i.e. new objects are not versioned, but objects that already existed at the time
    /// versioning was suspended are still versioned and keep their version IDs.
    ///
    /// To resume versioning, change status to `VERSIONING_ENABLED` via a \[BucketService.Update\] request.
    Suspended = 3,
}
impl Versioning {
    /// 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 {
            Versioning::Unspecified => "VERSIONING_UNSPECIFIED",
            Versioning::Disabled => "VERSIONING_DISABLED",
            Versioning::Enabled => "VERSIONING_ENABLED",
            Versioning::Suspended => "VERSIONING_SUSPENDED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "VERSIONING_UNSPECIFIED" => Some(Self::Unspecified),
            "VERSIONING_DISABLED" => Some(Self::Disabled),
            "VERSIONING_ENABLED" => Some(Self::Enabled),
            "VERSIONING_SUSPENDED" => Some(Self::Suspended),
            _ => None,
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetBucketRequest {
    /// Name of the bucket to return.
    ///
    /// To get the bucket name, make a \[BucketService.List\] request.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Scope of information about the bucket to return.
    ///
    /// Access to scopes is managed via [Identity and Access Management roles](/docs/storage/security),
    /// bucket \[ACL\](/docs/storage/concepts/acl) and \[policies\](/docs/storage/concepts/policy).
    #[prost(enumeration = "get_bucket_request::View", tag = "2")]
    pub view: i32,
}
/// Nested message and enum types in `GetBucketRequest`.
pub mod get_bucket_request {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum View {
        Unspecified = 0,
        /// Returns basic information about a bucket.
        ///
        /// The following fields will _not_ be returned: \[Bucket.acl\], \[Bucket.cors\], \[Bucket.website_settings\],
        /// \[Bucket.lifecycle_rules\], \[Bucket.tags\].
        Basic = 1,
        /// Returns basic information and access control list (ACL) for the bucket.
        ///
        /// The following fields will _not_ be returned: \[Bucket.cors\], \[Bucket.website_settings\], \[Bucket.lifecycle_rules\],
        /// \[Bucket.tags\].
        Acl = 2,
        /// Returns full information about a bucket.
        Full = 3,
    }
    impl View {
        /// 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 {
                View::Unspecified => "VIEW_UNSPECIFIED",
                View::Basic => "VIEW_BASIC",
                View::Acl => "VIEW_ACL",
                View::Full => "VIEW_FULL",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "VIEW_UNSPECIFIED" => Some(Self::Unspecified),
                "VIEW_BASIC" => Some(Self::Basic),
                "VIEW_ACL" => Some(Self::Acl),
                "VIEW_FULL" => Some(Self::Full),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListBucketsRequest {
    /// ID of the folder to list buckets in.
    ///
    /// To get the folder ID, make a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListBucketsResponse {
    /// List of buckets in the specified folder.
    #[prost(message, repeated, tag = "1")]
    pub buckets: ::prost::alloc::vec::Vec<Bucket>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateBucketRequest {
    /// Name of the bucket.
    ///
    /// The name must be unique within the platform. For naming limitations and rules, see
    /// \[documentation\](/docs/storage/concepts/bucket#naming).
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// ID of the folder to create a bucket in.
    ///
    /// To get the folder ID, make a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
    #[prost(string, tag = "2")]
    pub folder_id: ::prost::alloc::string::String,
    /// Default storage class for objects in the bucket. Supported classes are standard storage (`STANDARD`), cold storage
    /// (`COLD`, `STANDARD_IA`, `NEARLINE` all synonyms), and ice storage (`ICE` and `GLACIER` are synonyms).
    /// For details, see \[documentation\](/docs/storage/concepts/storage-class).
    #[prost(string, tag = "4")]
    pub default_storage_class: ::prost::alloc::string::String,
    /// Maximum size of the bucket.
    /// For details, see \[documentation\](/docs/storage/operations/buckets/limit-max-volume).
    #[prost(int64, tag = "5")]
    pub max_size: i64,
    /// Flags for configuring public (anonymous) access to the bucket's content and settings.
    /// For details, see \[documentation\](/docs/storage/concepts/bucket#bucket-access).
    #[prost(message, optional, tag = "6")]
    pub anonymous_access_flags: ::core::option::Option<AnonymousAccessFlags>,
    /// Access control list (ACL) of the bucket.
    /// For details, see \[documentation\](/docs/storage/concepts/acl).
    #[prost(message, optional, tag = "7")]
    pub acl: ::core::option::Option<Acl>,
    /// List of tags for the bucket.
    /// For details, see \[documentation\](/docs/resource-manager/concepts/labels).
    #[prost(message, repeated, tag = "8")]
    pub tags: ::prost::alloc::vec::Vec<Tag>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateBucketMetadata {
    /// Name of the bucket that is being created.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateBucketRequest {
    /// Name of the bucket to update.
    ///
    /// The name cannot be updated.
    ///
    /// To get the bucket name, make a \[BucketService.List\] request.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Update mask that specifies which attributes of the bucket should be updated.
    /// Use * for full update.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Flags for configuring public (anonymous) access to the bucket's content and settings.
    /// For details, see \[documentation\](/docs/storage/concepts/bucket#bucket-access).
    #[prost(message, optional, tag = "3")]
    pub anonymous_access_flags: ::core::option::Option<AnonymousAccessFlags>,
    /// Default storage class for objects in the bucket. Supported classes are standard storage (`STANDARD`), cold storage
    /// (`COLD`, `STANDARD_IA`, `NEARLINE` all synonyms), and ice storage (`ICE` and `GLACIER` are synonyms).
    /// For details, see \[documentation\](/docs/storage/concepts/storage-class).
    #[prost(string, tag = "4")]
    pub default_storage_class: ::prost::alloc::string::String,
    /// Maximum size of the bucket, in bytes.
    /// For details, see \[documentation\](/docs/storage/operations/buckets/limit-max-volume).
    #[prost(int64, tag = "5")]
    pub max_size: i64,
    /// List of rules for cross-domain requests to objects in the bucket (cross-origin resource sharing, CORS).
    /// For details, see \[documentation\](/docs/storage/concepts/cors).
    #[prost(message, repeated, tag = "6")]
    pub cors: ::prost::alloc::vec::Vec<CorsRule>,
    /// Configuration for hosting a static website in the bucket.
    /// For details, see \[documentation\](/docs/storage/concepts/hosting).
    #[prost(message, optional, tag = "7")]
    pub website_settings: ::core::option::Option<WebsiteSettings>,
    /// Bucket versioning status.
    /// For details, see \[documentation\](/docs/storage/concepts/versioning).
    #[prost(enumeration = "Versioning", tag = "8")]
    pub versioning: i32,
    /// List of object lifecycle rules for the bucket.
    /// For details, see \[documentation\](/docs/storage/concepts/lifecycles).
    #[prost(message, repeated, tag = "9")]
    pub lifecycle_rules: ::prost::alloc::vec::Vec<LifecycleRule>,
    /// Bucket policies that set permissions for actions with the bucket, its objects, and groups of objects.
    /// For details, see \[documentation\](/docs/storage/concepts/policy).
    #[prost(message, optional, tag = "10")]
    pub policy: ::core::option::Option<::prost_types::Struct>,
    /// Access control list (ACL) of the bucket.
    /// For details, see \[documentation\](/docs/storage/concepts/acl).
    #[prost(message, optional, tag = "11")]
    pub acl: ::core::option::Option<Acl>,
    /// List of tags for the bucket.
    /// For details, see \[documentation\](/docs/resource-manager/concepts/labels).
    #[prost(message, repeated, tag = "12")]
    pub tags: ::prost::alloc::vec::Vec<Tag>,
    /// Configuration for object lock on the bucket.
    /// For details about the concept, see \[documentation\](/docs/storage/concepts/object-lock).
    #[prost(message, optional, tag = "13")]
    pub object_lock: ::core::option::Option<ObjectLock>,
    /// Configuration for bucket's encryption
    /// For detauls, see \[documentation\](/docs/storage/concepts/encryption)
    #[prost(message, optional, tag = "14")]
    pub encryption: ::core::option::Option<Encryption>,
    /// requires permission s3:PutBucketAllowedPrivateEndpoints
    #[prost(message, optional, tag = "15")]
    pub allowed_private_endpoints: ::core::option::Option<BucketAllowedPrivateEndpoints>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateBucketMetadata {
    /// Name of the bucket that is being updated.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// DeleteBucketRequest deletes requested bucket from the Cloud.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteBucketRequest {
    /// Name of the bucket to update.
    ///
    /// To get the bucket name, make a \[BucketService.List\] request.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteBucketMetadata {
    /// Name of the bucket that is being deleted.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetBucketStatsRequest {
    /// Name of the bucket to return the statistics for.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetBucketHttpsConfigRequest {
    /// Name of the bucket to return the HTTPS configuration for.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SelfManagedHttpsConfigParams {
    /// \[PEM\](<https://en.wikipedia.org/wiki/Privacy-Enhanced_Mail>)-encoded certificate.
    #[prost(string, tag = "1")]
    pub certificate_pem: ::prost::alloc::string::String,
    /// \[PEM\](<https://en.wikipedia.org/wiki/Privacy-Enhanced_Mail>)-encoded private key for the certificate.
    #[prost(string, tag = "2")]
    pub private_key_pem: ::prost::alloc::string::String,
}
/// A resource for a TLS certificate from Certificate Manager.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CertificateManagerHttpsConfigParams {
    /// ID of the certificate.
    ///
    /// To get the list of all available certificates, make a \[yandex.cloud.certificatemanager.v1.CertificateService.List\]
    /// request.
    #[prost(string, tag = "1")]
    pub certificate_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SetBucketHttpsConfigRequest {
    /// Name of the bucket to update the HTTPS configuration for.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// HTTPS configuration parameters.
    #[prost(oneof = "set_bucket_https_config_request::Params", tags = "2, 3")]
    pub params: ::core::option::Option<set_bucket_https_config_request::Params>,
}
/// Nested message and enum types in `SetBucketHTTPSConfigRequest`.
pub mod set_bucket_https_config_request {
    /// HTTPS configuration parameters.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Params {
        /// Your TLS certificate, uploaded directly.
        ///
        /// Object Storage only supports \[PEM\](<https://en.wikipedia.org/wiki/Privacy-Enhanced_Mail>)-encoded certificates.
        #[prost(message, tag = "2")]
        SelfManaged(super::SelfManagedHttpsConfigParams),
        /// TLS certificate from Certificate Manager.
        ///
        /// To create a certificate in Certificate Manager, make a
        /// \[yandex.cloud.certificatemanager.v1.CertificateService.Create\] request.
        #[prost(message, tag = "3")]
        CertificateManager(super::CertificateManagerHttpsConfigParams),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SetBucketHttpsConfigMetadata {
    /// Name of the bucket the HTTPS configuration is being updated for.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteBucketHttpsConfigRequest {
    /// Name of the bucket to delete the HTTPS configuration for.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteBucketHttpsConfigMetadata {
    /// Name of the bucket the HTTPS configuration is being deleted for.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod bucket_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 buckets.
    #[derive(Debug, Clone)]
    pub struct BucketServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl BucketServiceClient<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> BucketServiceClient<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,
        ) -> BucketServiceClient<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,
        {
            BucketServiceClient::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
        }
        /// Retrieves the list of buckets in the specified folder.
        ///
        /// The following fields will not be returned for buckets in the list: [Bucket.policy], [Bucket.acl], [Bucket.cors],
        /// [Bucket.website_settings], [Bucket.lifecycle_rules], [Bucket.tags].
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListBucketsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListBucketsResponse>,
            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.storage.v1.BucketService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.storage.v1.BucketService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns the specified bucket.
        ///
        /// To get the list of all available buckets, make a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetBucketRequest>,
        ) -> std::result::Result<tonic::Response<super::Bucket>, 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.storage.v1.BucketService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.storage.v1.BucketService", "Get"));
            self.inner.unary(req, path, codec).await
        }
        /// Creates a bucket in the specified folder.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateBucketRequest>,
        ) -> 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.storage.v1.BucketService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.storage.v1.BucketService", "Create"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified bucket.
        ///
        /// In most cases, `storage.editor` role (see [documentation](/docs/storage/security/#storage-editor)) should be enough
        /// to update a bucket, subject to its [policy](/docs/storage/concepts/policy).
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateBucketRequest>,
        ) -> 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.storage.v1.BucketService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.storage.v1.BucketService", "Update"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified bucket.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteBucketRequest>,
        ) -> 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.storage.v1.BucketService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.storage.v1.BucketService", "Delete"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns the statistics for the specified bucket.
        pub async fn get_stats(
            &mut self,
            request: impl tonic::IntoRequest<super::GetBucketStatsRequest>,
        ) -> std::result::Result<tonic::Response<super::BucketStats>, 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.storage.v1.BucketService/GetStats",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.storage.v1.BucketService", "GetStats"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns the HTTPS configuration for the specified bucket.
        pub async fn get_https_config(
            &mut self,
            request: impl tonic::IntoRequest<super::GetBucketHttpsConfigRequest>,
        ) -> std::result::Result<tonic::Response<super::HttpsConfig>, 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.storage.v1.BucketService/GetHTTPSConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.storage.v1.BucketService",
                        "GetHTTPSConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the HTTPS configuration for the specified bucket.
        ///
        /// The updated configuration could take up to 30 minutes to apply to the bucket.
        pub async fn set_https_config(
            &mut self,
            request: impl tonic::IntoRequest<super::SetBucketHttpsConfigRequest>,
        ) -> 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.storage.v1.BucketService/SetHTTPSConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.storage.v1.BucketService",
                        "SetHTTPSConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the HTTPS configuration for the specified bucket.
        pub async fn delete_https_config(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteBucketHttpsConfigRequest>,
        ) -> 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.storage.v1.BucketService/DeleteHTTPSConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.storage.v1.BucketService",
                        "DeleteHTTPSConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Represents a response of the get object request to S3.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct S3apiGetObjectResponse {
    /// MD5 hash of the object.
    #[prost(string, tag = "1")]
    pub etag: ::prost::alloc::string::String,
    /// Unique request ID.
    #[prost(string, tag = "2")]
    pub request_id: ::prost::alloc::string::String,
    /// Indicates that a range of bytes was specified in the request.
    #[prost(string, tag = "3")]
    pub accept_ranges: ::prost::alloc::string::String,
    /// Specifies caching behavior along the request/reply chain.
    #[prost(string, tag = "4")]
    pub cache_control: ::prost::alloc::string::String,
    /// Specifies presentational information for the object.
    #[prost(string, tag = "5")]
    pub content_disposition: ::prost::alloc::string::String,
    /// Indicates what content encodings have been applied to the object.
    #[prost(string, tag = "6")]
    pub content_encoding: ::prost::alloc::string::String,
    /// The language the content is in.
    #[prost(string, tag = "7")]
    pub content_language: ::prost::alloc::string::String,
    /// Size of the body in bytes.
    #[prost(int64, tag = "8")]
    pub content_length: i64,
    /// The portion of the object returned in the response.
    #[prost(string, tag = "9")]
    pub content_range: ::prost::alloc::string::String,
    /// A standard MIME type describing the format of the object data.
    #[prost(string, tag = "10")]
    pub content_type: ::prost::alloc::string::String,
    /// Version ID of the object.
    #[prost(string, tag = "11")]
    pub version_id: ::prost::alloc::string::String,
    /// The date and time at which the object is no longer cacheable.
    #[prost(message, optional, tag = "12")]
    pub expires_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Date and time when the object was last modified.
    #[prost(message, optional, tag = "13")]
    pub last_modified_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Object user-defined metadata.
    #[prost(map = "string, string", tag = "14")]
    pub metadata: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Provides storage class information of the object.
    #[prost(string, tag = "15")]
    pub storage_class: ::prost::alloc::string::String,
    /// Encryption algorithm used to encrypt the object.
    #[prost(string, tag = "16")]
    pub server_side_encryption: ::prost::alloc::string::String,
    /// ID of the key KMS.
    #[prost(string, tag = "17")]
    pub sse_kms_key_id: ::prost::alloc::string::String,
    /// Type of retention put on the object.
    #[prost(string, tag = "18")]
    pub object_lock_mode: ::prost::alloc::string::String,
    /// Date and time until which the object is retained
    #[prost(message, optional, tag = "19")]
    pub object_lock_retain_until_date: ::core::option::Option<::prost_types::Timestamp>,
    /// Type of legal hold put on the object
    #[prost(string, tag = "20")]
    pub object_lock_legal_hold_status: ::prost::alloc::string::String,
}
/// Represents a response of the put object request to S3.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct S3apiPutObjectResponse {
    /// MD5 hash of the object.
    #[prost(string, tag = "1")]
    pub etag: ::prost::alloc::string::String,
    /// Unique request ID.
    #[prost(string, tag = "2")]
    pub request_id: ::prost::alloc::string::String,
    /// Version ID of the object.
    #[prost(string, tag = "3")]
    pub version_id: ::prost::alloc::string::String,
}
/// Represents a response of the delete object request to S3.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct S3apiDeleteObjectResponse {
    /// Unique request ID.
    #[prost(string, tag = "1")]
    pub request_id: ::prost::alloc::string::String,
    /// Version ID of the object.
    #[prost(string, tag = "2")]
    pub version_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CopyObjectResult {
    /// Returns the ETag of the new object.
    #[prost(string, tag = "1")]
    pub etag: ::prost::alloc::string::String,
    /// Creation date of the object.
    #[prost(message, optional, tag = "2")]
    pub last_modified_at: ::core::option::Option<::prost_types::Timestamp>,
}
/// Represents a response of the copy object request to S3.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct S3apiCopyObjectResponse {
    /// Container for all response elements.
    #[prost(message, optional, tag = "1")]
    pub copy_object_result: ::core::option::Option<CopyObjectResult>,
    /// Unique request ID.
    #[prost(string, tag = "2")]
    pub request_id: ::prost::alloc::string::String,
    /// Version ID of the source object that was copied.
    #[prost(string, tag = "3")]
    pub copy_source_version_id: ::prost::alloc::string::String,
    /// Version ID of the newly created copy.
    #[prost(string, tag = "4")]
    pub version_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SuccessfullyDeletedObject {
    /// The name of the deleted object.
    #[prost(string, tag = "1")]
    pub key: ::prost::alloc::string::String,
    /// The version ID of the deleted object.
    #[prost(string, tag = "2")]
    pub version_id: ::prost::alloc::string::String,
    /// Specifies whether the versioned object that was permanently deleted was (true) or was not (false) a delete marker.
    #[prost(bool, tag = "3")]
    pub delete_marker: bool,
    /// The version ID of the delete marker created as a result of the DELETE operation.
    #[prost(string, tag = "4")]
    pub delete_marker_version_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteObjectError {
    /// The error key.
    #[prost(string, tag = "1")]
    pub key: ::prost::alloc::string::String,
    /// The version ID of the error.
    #[prost(string, tag = "2")]
    pub version_id: ::prost::alloc::string::String,
    /// The error code is a string that uniquely identifies an error condition.
    #[prost(string, tag = "3")]
    pub code: ::prost::alloc::string::String,
    /// The error message contains a generic description of the error condition in English.
    #[prost(string, tag = "4")]
    pub msg: ::prost::alloc::string::String,
}
/// Represents a response of the delete objects request to S3.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct S3apiDeleteObjectsResponse {
    /// List of successfully deleted objects
    #[prost(message, repeated, tag = "1")]
    pub deleted: ::prost::alloc::vec::Vec<SuccessfullyDeletedObject>,
    /// List of objects that attempted to be deleted but encountered an error
    #[prost(message, repeated, tag = "2")]
    pub errors: ::prost::alloc::vec::Vec<DeleteObjectError>,
    /// Unique request ID.
    #[prost(string, tag = "3")]
    pub request_id: ::prost::alloc::string::String,
}
/// Represents a response of the put object retention request to S3.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct S3apiPutObjectRetentionResponse {
    /// Unique request ID.
    #[prost(string, tag = "1")]
    pub request_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ObjectLockRetention {
    /// Indicates the Retention mode for the specified object.
    #[prost(string, tag = "1")]
    pub mode: ::prost::alloc::string::String,
    /// The date on which this object lock retention will expire.
    #[prost(message, optional, tag = "2")]
    pub retain_until_date: ::core::option::Option<::prost_types::Timestamp>,
}
/// Represents a response of the get object retention request to S3.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct S3apiGetObjectRetentionResponse {
    /// Unique request ID.
    #[prost(string, tag = "1")]
    pub request_id: ::prost::alloc::string::String,
    /// An object retention settings.
    #[prost(message, optional, tag = "2")]
    pub retention: ::core::option::Option<ObjectLockRetention>,
}
/// Represents a response of the put object retention request to S3.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct S3apiPutObjectLegalHoldResponse {
    /// Unique request ID.
    #[prost(string, tag = "1")]
    pub request_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ObjectLockLegalHold {
    /// Indicates whether the specified object has a legal hold in place.
    #[prost(string, tag = "1")]
    pub status: ::prost::alloc::string::String,
}
/// Represents a response of the get object legal hold request to S3.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct S3apiGetObjectLegalHoldResponse {
    /// Unique request ID.
    #[prost(string, tag = "1")]
    pub request_id: ::prost::alloc::string::String,
    /// The current legal hold status for the specified object.
    #[prost(message, optional, tag = "2")]
    pub legal_hold: ::core::option::Option<ObjectLockLegalHold>,
}
/// Represents a response of put object tagging request to S3.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct S3apiPutObjectTaggingResponse {
    /// Unique request ID.
    #[prost(string, tag = "1")]
    pub request_id: ::prost::alloc::string::String,
    /// The versionId of the object the tag-set was added to.
    #[prost(string, tag = "2")]
    pub version_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ObjectTag {
    /// Key of the object tag.
    #[prost(string, tag = "1")]
    pub key: ::prost::alloc::string::String,
    /// Value of the object tag.
    #[prost(string, tag = "2")]
    pub value: ::prost::alloc::string::String,
}
/// Represents a response of get object tagging request to S3.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct S3apiGetObjectTaggingResponse {
    /// Unique request ID.
    #[prost(string, tag = "1")]
    pub request_id: ::prost::alloc::string::String,
    /// The versionId of the object for which you got the tagging information.
    #[prost(string, tag = "2")]
    pub version_id: ::prost::alloc::string::String,
    /// Contains the tag set.
    #[prost(message, repeated, tag = "3")]
    pub tag_set: ::prost::alloc::vec::Vec<ObjectTag>,
}
/// Represents a response of delete object tagging request to S3.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct S3apiDeleteObjectTaggingResponse {
    /// Unique request ID.
    #[prost(string, tag = "1")]
    pub request_id: ::prost::alloc::string::String,
    /// The versionId of the object the tag-set was removed from.
    #[prost(string, tag = "2")]
    pub version_id: ::prost::alloc::string::String,
}
/// Represents a response of start multipart upload request to S3.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct S3apiStartMultipartUploadResponse {
    /// Unique request ID.
    #[prost(string, tag = "1")]
    pub request_id: ::prost::alloc::string::String,
    /// The name of the bucket in which the initiated multipart upload was initiated.
    #[prost(string, tag = "2")]
    pub bucket: ::prost::alloc::string::String,
    /// Object key for which the multipart upload was initiated.
    #[prost(string, tag = "3")]
    pub key: ::prost::alloc::string::String,
    /// The ID of the initiated multipart upload.
    #[prost(string, tag = "4")]
    pub upload_id: ::prost::alloc::string::String,
}
/// Represents a response of upload part request to S3.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct S3apiUploadPartResponse {
    /// Unique request ID.
    #[prost(string, tag = "1")]
    pub request_id: ::prost::alloc::string::String,
    /// MD5 hash of the object.
    #[prost(string, tag = "2")]
    pub etag: ::prost::alloc::string::String,
}
/// Represents a response of list parts request to S3.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct S3apiListPartsResponse {
    /// The name of the bucket to which the multipart upload was initiated.
    #[prost(string, tag = "1")]
    pub bucket: ::prost::alloc::string::String,
    /// Object key for which the multipart upload was initiated.
    #[prost(string, tag = "2")]
    pub key: ::prost::alloc::string::String,
    /// Upload ID identifying the multipart upload whose parts are being listed.
    #[prost(string, tag = "3")]
    pub upload_id: ::prost::alloc::string::String,
    /// When a list is truncated, this element specifies the last part in the list, as
    /// well as the value to use for the part-number-marker request parameter in a
    /// subsequent request.
    #[prost(string, tag = "4")]
    pub part_number_marker: ::prost::alloc::string::String,
    /// When a list is truncated, this element specifies the last part in the list, as
    /// well as the value to use for the part-number-marker request parameter in a
    /// subsequent request.
    #[prost(string, tag = "5")]
    pub next_part_number_marker: ::prost::alloc::string::String,
    /// Maximum number of parts that were allowed in the response.
    #[prost(int64, tag = "6")]
    pub max_parts: i64,
    /// Indicates whether the returned list of parts is truncated.
    #[prost(bool, tag = "7")]
    pub is_truncated: bool,
    /// Container for elements related to a particular part.
    #[prost(message, repeated, tag = "8")]
    pub parts: ::prost::alloc::vec::Vec<S3apiPart>,
    /// Container element that identifies who initiated the multipart upload.
    #[prost(message, optional, tag = "9")]
    pub initiator: ::core::option::Option<S3apiOwner>,
    /// Container element that identifies who initiated the multipart upload.
    #[prost(message, optional, tag = "10")]
    pub owner: ::core::option::Option<S3apiOwner>,
    /// Class of storage used to store the uploaded object.
    #[prost(string, tag = "11")]
    pub storage_class: ::prost::alloc::string::String,
    /// Unique request ID.
    #[prost(string, tag = "12")]
    pub request_id: ::prost::alloc::string::String,
}
/// Container for elements related to a part.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct S3apiPart {
    /// Part number identifying the part. This is a positive integer between 1 and
    /// 10,000.
    #[prost(int64, tag = "1")]
    pub part_number: i64,
    /// Date and time at which the part was uploaded.
    #[prost(message, optional, tag = "2")]
    pub last_modified_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Size in bytes of the uploaded part data.
    #[prost(int64, tag = "3")]
    pub size: i64,
    /// Entity tag returned when the part was uploaded.
    #[prost(string, tag = "4")]
    pub etag: ::prost::alloc::string::String,
}
/// Represents a response of abort multipart upload request to S3.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct S3apiAbortMultipartUploadResponse {
    /// Unique request ID.
    #[prost(string, tag = "1")]
    pub request_id: ::prost::alloc::string::String,
}
/// Represents a response of complete multipart upload request to S3.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct S3apiCompleteMultipartUploadResponse {
    /// Unique request ID.
    #[prost(string, tag = "1")]
    pub request_id: ::prost::alloc::string::String,
    /// The name of the bucket that contains the newly created object.
    #[prost(string, tag = "2")]
    pub bucket: ::prost::alloc::string::String,
    /// The object key of the newly created object.
    #[prost(string, tag = "3")]
    pub key: ::prost::alloc::string::String,
    /// Entity tag that identifies the newly created object's data.
    #[prost(string, tag = "4")]
    pub etag: ::prost::alloc::string::String,
    /// The URI that identifies the newly created object.
    #[prost(string, tag = "5")]
    pub location: ::prost::alloc::string::String,
    /// Version ID of the newly created object, in case the bucket has versioning
    /// turned on.
    #[prost(string, tag = "6")]
    pub version_id: ::prost::alloc::string::String,
}
/// Represents a response of list multipart uploads request to S3.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct S3apiListMultipartUploadsResponse {
    /// The name of the bucket to which the multipart upload was initiated.
    #[prost(string, tag = "1")]
    pub bucket: ::prost::alloc::string::String,
    /// The key at or after which the listing began.
    #[prost(string, tag = "2")]
    pub key_marker: ::prost::alloc::string::String,
    /// Upload ID after which listing began.
    #[prost(string, tag = "3")]
    pub upload_id_marker: ::prost::alloc::string::String,
    /// When a list is truncated, this element specifies the value that should be used
    /// for the key-marker request parameter in a subsequent request.
    #[prost(string, tag = "4")]
    pub next_key_marker: ::prost::alloc::string::String,
    /// When a list is truncated, this element specifies the value that should be used
    /// for the upload-id-marker request parameter in a subsequent request.
    #[prost(string, tag = "5")]
    pub next_upload_id_marker: ::prost::alloc::string::String,
    /// Contains the delimiter you specified in the request.
    #[prost(string, tag = "6")]
    pub delimiter: ::prost::alloc::string::String,
    /// When a prefix is provided in the request, this field contains the specified
    /// prefix.
    #[prost(string, tag = "7")]
    pub prefix: ::prost::alloc::string::String,
    /// Maximum number of multipart uploads that could have been included in the
    /// response.
    #[prost(int64, tag = "8")]
    pub max_uploads: i64,
    /// Indicates whether the returned list of multipart uploads is truncated.
    #[prost(bool, tag = "9")]
    pub is_truncated: bool,
    /// Container for elements related to a particular multipart upload.
    #[prost(message, repeated, tag = "10")]
    pub uploads: ::prost::alloc::vec::Vec<S3apiMultipartUpload>,
    /// If you specify a delimiter in the request, then the result returns each
    /// distinct key prefix containing the delimiter in a CommonPrefixes element.
    #[prost(string, repeated, tag = "11")]
    pub common_prefixes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Unique request ID.
    #[prost(string, tag = "12")]
    pub request_id: ::prost::alloc::string::String,
}
/// Container for the MultipartUpload for the S3 object.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct S3apiMultipartUpload {
    /// Key of the object for which the multipart upload was initiated.
    #[prost(string, tag = "1")]
    pub key: ::prost::alloc::string::String,
    /// Upload ID that identifies the multipart upload.
    #[prost(string, tag = "2")]
    pub upload_id: ::prost::alloc::string::String,
    /// Identifies who initiated the multipart upload.
    #[prost(message, optional, tag = "3")]
    pub initiator: ::core::option::Option<S3apiOwner>,
    /// Specifies the owner of the object that is part of the multipart upload.
    #[prost(message, optional, tag = "4")]
    pub owner: ::core::option::Option<S3apiOwner>,
    /// The class of storage used to store the object.
    #[prost(string, tag = "5")]
    pub storage_class: ::prost::alloc::string::String,
    /// Date and time at which the multipart upload was initiated.
    #[prost(message, optional, tag = "6")]
    pub initiated_at: ::core::option::Option<::prost_types::Timestamp>,
}
/// Container for the owner/initiator display name and ID.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct S3apiOwner {
    /// Container for the ID of the owner/initiator.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Container for the display name of the owner/initiator.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
}
/// Response message for UploadPartCopy operation
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct S3apiUploadPartCopyResponse {
    /// Entity tag of the object.
    #[prost(string, tag = "1")]
    pub etag: ::prost::alloc::string::String,
    /// Date and time at which the object was uploaded.
    #[prost(message, optional, tag = "2")]
    pub last_modified_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Unique request ID.
    #[prost(string, tag = "3")]
    pub request_id: ::prost::alloc::string::String,
}
/// Represents a response of list objects v2 request to S3.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct S3apiListObjectsV2Response {
    /// A flag that indicates whether S3 returned all of the results that satisfied the search criteria.
    #[prost(bool, tag = "1")]
    pub is_truncated: bool,
    /// Metadata about each object returned.
    #[prost(message, repeated, tag = "2")]
    pub contents: ::prost::alloc::vec::Vec<S3apiObject>,
    /// The bucket name.
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    /// Keys that begin with the indicated prefix.
    #[prost(string, tag = "4")]
    pub prefix: ::prost::alloc::string::String,
    /// Causes keys that contain the same string between the prefix and the first occurrence of the delimiter to be rolled up into a single result element in the CommonPrefixes collection.
    #[prost(string, tag = "5")]
    pub delimiter: ::prost::alloc::string::String,
    /// The maximum number of keys returned in the response body.
    #[prost(int64, tag = "6")]
    pub max_keys: i64,
    /// All of the keys rolled up into a common prefix count as a single return when calculating the number of returns.
    #[prost(message, repeated, tag = "7")]
    pub common_prefixes: ::prost::alloc::vec::Vec<S3apiCommonPrefix>,
    /// The number of keys returned with this request.
    #[prost(int64, tag = "8")]
    pub key_count: i64,
    /// Indicates where in the bucket listing begins. This is only returned if a continuation token was used in the request.
    #[prost(string, tag = "9")]
    pub continuation_token: ::prost::alloc::string::String,
    /// If the response is truncated, S3 returns this continuation token, which you can use in the next request to fetch the next set of keys.
    #[prost(string, tag = "10")]
    pub next_continuation_token: ::prost::alloc::string::String,
    /// StartAfter is where you want S3 to start listing from. This is only returned if a start-after was used in the request.
    #[prost(string, tag = "11")]
    pub start_after: ::prost::alloc::string::String,
    /// Unique request ID.
    #[prost(string, tag = "12")]
    pub request_id: ::prost::alloc::string::String,
}
/// Container for object metadata.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct S3apiObject {
    /// The object key.
    #[prost(string, tag = "1")]
    pub key: ::prost::alloc::string::String,
    /// Date and time the object was last modified.
    #[prost(message, optional, tag = "2")]
    pub last_modified: ::core::option::Option<::prost_types::Timestamp>,
    /// The entity tag is a hash of the object.
    #[prost(string, tag = "3")]
    pub etag: ::prost::alloc::string::String,
    /// Size in bytes of the object.
    #[prost(int64, tag = "4")]
    pub size: i64,
    /// The owner of the object.
    #[prost(message, optional, tag = "5")]
    pub owner: ::core::option::Option<S3apiOwner>,
    /// The class of storage used to store the object.
    #[prost(string, tag = "6")]
    pub storage_class: ::prost::alloc::string::String,
}
/// Container for common prefix information.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct S3apiCommonPrefix {
    /// Container for the specified common prefix.
    #[prost(string, tag = "1")]
    pub prefix: ::prost::alloc::string::String,
}