AWS SDK

/// <important>

/// <p>End of support notice: Beginning October 1, 2025, Amazon S3 will discontinue support for creating new Email Grantee Access Control Lists (ACL). Email Grantee ACLs created prior to this date will continue to work and remain accessible through the Amazon Web Services Management Console, Command Line Interface (CLI), SDKs, and REST API. However, you will no longer be able to create new Email Grantee ACLs.</p>

/// <p>This change affects the following Amazon Web Services Regions: US East (N. Virginia) Region, US West (N. California) Region, US West (Oregon) Region, Asia Pacific (Singapore) Region, Asia Pacific (Sydney) Region, Asia Pacific (Tokyo) Region, Europe (Ireland) Region, and South America (São Paulo) Region.</p>

/// </important>

    /// <li>

    /// <p><b>S3 access points for Amazon FSx </b> - When accessing data stored in Amazon FSx file systems using S3 access points, the only valid server side encryption option is <code>aws:fsx</code>. All Amazon FSx file systems have encryption configured by default and are encrypted at rest. Data is automatically encrypted before being written to the file system, and automatically decrypted as it is read. These processes are handled transparently by Amazon FSx.</p></li>

    /// <li>

    /// <p><b>S3 access points for Amazon FSx </b> - When accessing data stored in Amazon FSx file systems using S3 access points, the only valid server side encryption option is <code>aws:fsx</code>. All Amazon FSx file systems have encryption configured by default and are encrypted at rest. Data is automatically encrypted before being written to the file system, and automatically decrypted as it is read. These processes are handled transparently by Amazon FSx.</p></li>

    /// <li>

    /// <p><b>S3 access points for Amazon FSx </b> - When accessing data stored in Amazon FSx file systems using S3 access points, the only valid server side encryption option is <code>aws:fsx</code>. All Amazon FSx file systems have encryption configured by default and are encrypted at rest. Data is automatically encrypted before being written to the file system, and automatically decrypted as it is read. These processes are handled transparently by Amazon FSx.</p></li>

    /// <p>The Amazon Resource Name (ARN) of the S3 bucket. ARNs uniquely identify Amazon Web Services resources across all of Amazon Web Services.</p><note>

    /// <p>This parameter is only supported for S3 directory buckets. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-tagging.html">Using tags with directory buckets</a>.</p>

    /// </note>

    pub bucket_arn: ::std::option::Option<::std::string::String>,

    /// <p>The Amazon Resource Name (ARN) of the S3 bucket. ARNs uniquely identify Amazon Web Services resources across all of Amazon Web Services.</p><note>

    /// <p>This parameter is only supported for S3 directory buckets. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-tagging.html">Using tags with directory buckets</a>.</p>

    /// </note>

    pub fn bucket_arn(&self) -> ::std::option::Option<&str> {

        self.bucket_arn.as_deref()

    }

    pub(crate) bucket_arn: ::std::option::Option<::std::string::String>,

    /// <p>The Amazon Resource Name (ARN) of the S3 bucket. ARNs uniquely identify Amazon Web Services resources across all of Amazon Web Services.</p><note>

    /// <p>This parameter is only supported for S3 directory buckets. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-tagging.html">Using tags with directory buckets</a>.</p>

    /// </note>

    pub fn bucket_arn(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {

        self.bucket_arn = ::std::option::Option::Some(input.into());

        self

    }

    /// <p>The Amazon Resource Name (ARN) of the S3 bucket. ARNs uniquely identify Amazon Web Services resources across all of Amazon Web Services.</p><note>

    /// <p>This parameter is only supported for S3 directory buckets. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-tagging.html">Using tags with directory buckets</a>.</p>

    /// </note>

    pub fn set_bucket_arn(mut self, input: ::std::option::Option<::std::string::String>) -> Self {

        self.bucket_arn = input;

        self

    }

    /// <p>The Amazon Resource Name (ARN) of the S3 bucket. ARNs uniquely identify Amazon Web Services resources across all of Amazon Web Services.</p><note>

    /// <p>This parameter is only supported for S3 directory buckets. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-tagging.html">Using tags with directory buckets</a>.</p>

    /// </note>

    pub fn get_bucket_arn(&self) -> &::std::option::Option<::std::string::String> {

        &self.bucket_arn

    }

            bucket_arn: self.bucket_arn,

/// <important>

/// <p>End of support notice: Beginning October 1, 2025, Amazon S3 will discontinue support for creating new Email Grantee Access Control Lists (ACL). Email Grantee ACLs created prior to this date will continue to work and remain accessible through the Amazon Web Services Management Console, Command Line Interface (CLI), SDKs, and REST API. However, you will no longer be able to create new Email Grantee ACLs.</p>

/// <p>This change affects the following Amazon Web Services Regions: US East (N. Virginia) Region, US West (N. California) Region, US West (Oregon) Region, Asia Pacific (Singapore) Region, Asia Pacific (Sydney) Region, Asia Pacific (Tokyo) Region, Europe (Ireland) Region, and South America (São Paulo) Region.</p>

/// </important> <important>

/// <p>End of support notice: Beginning October 1, 2025, Amazon S3 will stop returning <code>DisplayName</code>. Update your applications to use canonical IDs (unique identifier for Amazon Web Services accounts), Amazon Web Services account ID (12 digit identifier) or IAM ARNs (full resource naming) as a direct replacement of <code>DisplayName</code>.</p>

/// <p>This change affects the following Amazon Web Services Regions: US East (N. Virginia) Region, US West (N. California) Region, US West (Oregon) Region, Asia Pacific (Singapore) Region, Asia Pacific (Sydney) Region, Asia Pacific (Tokyo) Region, Europe (Ireland) Region, and South America (São Paulo) Region.</p>

/// </important> <note>

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

/// Orchestration and serialization glue logic for `CreateBucketMetadataConfiguration`.

#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]

#[non_exhaustive]

pub struct CreateBucketMetadataConfiguration;

impl CreateBucketMetadataConfiguration {

    /// Creates a new `CreateBucketMetadataConfiguration`

    pub fn new() -> Self {

        Self

    }

    pub(crate) async fn orchestrate(

        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,

        input: crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationInput,

    ) -> ::std::result::Result<

        crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationOutput,

        ::aws_smithy_runtime_api::client::result::SdkError<

            crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationError,

            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,

        >,

    > {

        let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<

            ::aws_smithy_runtime_api::client::interceptors::context::Error,

            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,

        >| {

            err.map_service_error(|err| {

                err.downcast::<crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationError>()

                    .expect("correct error type")

            })

        };

        let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)

            .await

            .map_err(map_err)?;

        let output = context.finalize().map_err(map_err)?;

        ::std::result::Result::Ok(

            output

                .downcast::<crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationOutput>()

                .expect("correct output type"),

        )

    }

    pub(crate) async fn orchestrate_with_stop_point(

        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,

        input: crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationInput,

        stop_point: ::aws_smithy_runtime::client::orchestrator::StopPoint,

    ) -> ::std::result::Result<

        ::aws_smithy_runtime_api::client::interceptors::context::InterceptorContext,

        ::aws_smithy_runtime_api::client::result::SdkError<

            ::aws_smithy_runtime_api::client::interceptors::context::Error,

            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,

        >,

    > {

        let input = ::aws_smithy_runtime_api::client::interceptors::context::Input::erase(input);

        use ::tracing::Instrument;

        ::aws_smithy_runtime::client::orchestrator::invoke_with_stop_point(

            "S3",

            "CreateBucketMetadataConfiguration",

            input,

            runtime_plugins,

            stop_point,

        )

        // Create a parent span for the entire operation. Includes a random, internal-only,

        // seven-digit ID for the operation orchestration so that it can be correlated in the logs.

        .instrument(::tracing::debug_span!(

            "S3.CreateBucketMetadataConfiguration",

            "rpc.service" = "S3",

            "rpc.method" = "CreateBucketMetadataConfiguration",

            "sdk_invocation_id" = ::fastrand::u32(1_000_000..10_000_000),

            "rpc.system" = "aws-api",

        ))

        .await

    }

    pub(crate) fn operation_runtime_plugins(

        client_runtime_plugins: ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,

        client_config: &crate::config::Config,

        config_override: ::std::option::Option<crate::config::Builder>,

    ) -> ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins {

        let mut runtime_plugins = client_runtime_plugins.with_operation_plugin(Self::new());

        if let ::std::option::Option::Some(config_override) = config_override {

            for plugin in config_override.runtime_plugins.iter().cloned() {

                runtime_plugins = runtime_plugins.with_operation_plugin(plugin);

            }

            runtime_plugins = runtime_plugins.with_operation_plugin(crate::config::ConfigOverrideRuntimePlugin::new(

                config_override,

                client_config.config.clone(),

                &client_config.runtime_components,

            ));

        }

        runtime_plugins

    }

}

impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for CreateBucketMetadataConfiguration {

    fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {

        let mut cfg = ::aws_smithy_types::config_bag::Layer::new("CreateBucketMetadataConfiguration");

        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedRequestSerializer::new(

            CreateBucketMetadataConfigurationRequestSerializer,

        ));

        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(

            CreateBucketMetadataConfigurationResponseDeserializer,

        ));

        cfg.store_put(::aws_smithy_runtime_api::client::auth::AuthSchemeOptionResolverParams::new(

            crate::config::auth::Params::builder()

                .operation_name("CreateBucketMetadataConfiguration")

                .build()

                .expect("required fields set"),

        ));

        cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(

            "CreateBucketMetadataConfiguration",

            "S3",

        ));

        cfg.store_put(crate::s3_express::checksum::provide_default_checksum_algorithm());

        let mut signing_options = ::aws_runtime::auth::SigningOptions::default();

        signing_options.double_uri_encode = false;

        signing_options.content_sha256_header = true;

        signing_options.normalize_uri_path = false;

        signing_options.payload_override = None;

        cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {

            signing_options,

            ..::std::default::Default::default()

        });

        ::std::option::Option::Some(cfg.freeze())

    }

    fn runtime_components(

        &self,

        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,

    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {

        #[allow(unused_mut)]

        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("CreateBucketMetadataConfiguration")

            .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())

            .with_interceptor(CreateBucketMetadataConfigurationEndpointParamsInterceptor)

            .with_interceptor(crate::http_request_checksum::RequestChecksumInterceptor::new(

                |input: &::aws_smithy_runtime_api::client::interceptors::context::Input| {

                    let input: &crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationInput =

                        input.downcast_ref().expect("correct type");

                    let checksum_algorithm = input.checksum_algorithm();

                    let checksum_algorithm = checksum_algorithm.map(|algorithm| algorithm.as_str());

                    (checksum_algorithm.map(|s| s.to_string()), true)

                },

                |request: &mut ::aws_smithy_runtime_api::http::Request, cfg: &::aws_smithy_types::config_bag::ConfigBag| {

                    // We check if the user has set any of the checksum values manually

                    let mut user_set_checksum_value = false;

                    let headers_to_check =

                        request

                            .headers()

                            .iter()

                            .filter_map(|(name, _val)| if name.starts_with("x-amz-checksum-") { Some(name) } else { None });

                    for algo_header in headers_to_check {

                        if request.headers().get(algo_header).is_some() {

                            user_set_checksum_value = true;

                        }

                    }

                    // We check if the user set the checksum algo manually

                    let user_set_checksum_algo = request.headers().get("x-amz-sdk-checksum-algorithm").is_some();

                    // This value is set by the user on the SdkConfig to indicate their preference

                    let request_checksum_calculation = cfg

                        .load::<::aws_smithy_types::checksum_config::RequestChecksumCalculation>()

                        .unwrap_or(&::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported);

                    // From the httpChecksum trait

                    let http_checksum_required = true;

                    let is_presigned_req = cfg.load::<crate::presigning::PresigningMarker>().is_some();

                    // If the request is presigned we do not set a default.

                    // If the RequestChecksumCalculation is WhenSupported and the user has not set a checksum value or algo

                    // we set the default. If it is WhenRequired and a checksum is required by the trait and the user has not

                    // set a checksum value or algo we also set the default. In all other cases we do nothing.

                    match (

                        request_checksum_calculation,

                        http_checksum_required,

                        user_set_checksum_value,

                        user_set_checksum_algo,

                        is_presigned_req,

                    ) {

                        (_, _, _, _, true) => {}

                        (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported, _, false, false, _)

                        | (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenRequired, true, false, false, _) => {

                            request.headers_mut().insert("x-amz-sdk-checksum-algorithm", "CRC32");

                        }

                        _ => {}

                    }

                    // We return a bool indicating if the user did set the checksum value, if they did

                    // we can short circuit and exit the interceptor early.

                    Ok(user_set_checksum_value)

                },

            ))

            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<

                crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationError,

            >::new())

            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationError,

            >::new())

            .with_retry_classifier(

                ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                    crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationError,

                >::builder()

                .transient_errors({

                    let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();

                    transient_errors.push("InternalError");

                    ::std::borrow::Cow::Owned(transient_errors)

                })

                .build(),

            );

        ::std::borrow::Cow::Owned(rcb)

    }

}

#[derive(Debug)]

struct CreateBucketMetadataConfigurationResponseDeserializer;

impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateBucketMetadataConfigurationResponseDeserializer {

    fn deserialize_nonstreaming(

        &self,

        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,

    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {

        let (success, status) = (response.status().is_success(), response.status().as_u16());

        let headers = response.headers();

        let body = response.body().bytes().expect("body loaded");

        #[allow(unused_mut)]

        let mut force_error = false;

        ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));

        if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {

            force_error = true;

        }

        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));

        let parse_result = if !success && status != 200 || force_error {

            crate::protocol_serde::shape_create_bucket_metadata_configuration::de_create_bucket_metadata_configuration_http_error(

                status, headers, body,

            )

        } else {

            crate::protocol_serde::shape_create_bucket_metadata_configuration::de_create_bucket_metadata_configuration_http_response(

                status, headers, body,

            )

        };

        crate::protocol_serde::type_erase_result(parse_result)

    }

}

#[derive(Debug)]

struct CreateBucketMetadataConfigurationRequestSerializer;

impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CreateBucketMetadataConfigurationRequestSerializer {

    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]

    fn serialize_input(

        &self,

        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,

        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,

    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {

        let input = input

            .downcast::<crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationInput>()

            .expect("correct type");

        let _header_serialization_settings = _cfg

            .load::<crate::serialization_settings::HeaderSerializationSettings>()

            .cloned()

            .unwrap_or_default();

        let mut request_builder = {

            #[allow(clippy::uninlined_format_args)]

            fn uri_base(

                _input: &crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationInput,

                output: &mut ::std::string::String,

            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {

                use ::std::fmt::Write as _;

                ::std::write!(output, "/").expect("formatting should succeed");

                ::std::result::Result::Ok(())

            }

            fn uri_query(

                _input: &crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationInput,

                mut output: &mut ::std::string::String,

            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {

                let mut query = ::aws_smithy_http::query::Writer::new(output);

                query.push_v("metadataConfiguration");

                ::std::result::Result::Ok(())

            }

            #[allow(clippy::unnecessary_wraps)]

            fn update_http_builder(

                input: &crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationInput,

                builder: ::http::request::Builder,

            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {

                let mut uri = ::std::string::String::new();

                uri_base(input, &mut uri)?;

                uri_query(input, &mut uri)?;

                let builder = crate::protocol_serde::shape_create_bucket_metadata_configuration::ser_create_bucket_metadata_configuration_headers(

                    input, builder,

                )?;

                ::std::result::Result::Ok(builder.method("POST").uri(uri))

            }

            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;

            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");

            builder

        };

        let body = ::aws_smithy_types::body::SdkBody::from(

            crate::protocol_serde::shape_create_bucket_metadata_configuration_input::ser_metadata_configuration_http_payload(

                &input.metadata_configuration,

            )?,

        );

        if let Some(content_length) = body.content_length() {

            let content_length = content_length.to_string();

            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);

        }

        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())

    }

}

#[derive(Debug)]

struct CreateBucketMetadataConfigurationEndpointParamsInterceptor;

impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateBucketMetadataConfigurationEndpointParamsInterceptor {

    fn name(&self) -> &'static str {

        "CreateBucketMetadataConfigurationEndpointParamsInterceptor"

    }

    fn read_before_execution(

        &self,

        context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<

            '_,

            ::aws_smithy_runtime_api::client::interceptors::context::Input,

            ::aws_smithy_runtime_api::client::interceptors::context::Output,

            ::aws_smithy_runtime_api::client::interceptors::context::Error,

        >,

        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,

    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {

        let _input = context

            .input()

            .downcast_ref::<CreateBucketMetadataConfigurationInput>()

            .ok_or("failed to downcast to CreateBucketMetadataConfigurationInput")?;

        let params = crate::config::endpoint::Params::builder()

            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))

            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))

            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))

            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))

            .set_force_path_style(cfg.load::<crate::config::ForcePathStyle>().map(|ty| ty.0))

            .set_use_arn_region(cfg.load::<crate::config::UseArnRegion>().map(|ty| ty.0))

            .set_disable_multi_region_access_points(cfg.load::<crate::config::DisableMultiRegionAccessPoints>().map(|ty| ty.0))

            .set_accelerate(cfg.load::<crate::config::Accelerate>().map(|ty| ty.0))

            .set_disable_s3_express_session_auth(cfg.load::<crate::config::DisableS3ExpressSessionAuth>().map(|ty| ty.0))

            .set_use_s3_express_control_endpoint(Some(true))

            .set_bucket(Some(

                _input

                    .bucket

                    .clone()

                    .filter(|f| !AsRef::<str>::as_ref(f).trim().is_empty())

                    .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("bucket", "A required field was not set"))?,

            ))

            .build()

            .map_err(|err| {

                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)

            })?;

        cfg.interceptor_state()

            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

        ::std::result::Result::Ok(())

    }

}

// The get_* functions below are generated from JMESPath expressions in the

// operationContextParams trait. They target the operation's input shape.

/// Error type for the `CreateBucketMetadataConfigurationError` operation.

#[non_exhaustive]

#[derive(::std::fmt::Debug)]

pub enum CreateBucketMetadataConfigurationError {

    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).

    #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \

    variable wildcard pattern and check `.code()`:

     \

       `err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`

     \

    See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-CreateBucketMetadataConfigurationError) for what information is available for the error.")]

    Unhandled(crate::error::sealed_unhandled::Unhandled),

}

impl CreateBucketMetadataConfigurationError {

    /// Creates the `CreateBucketMetadataConfigurationError::Unhandled` variant from any error type.

    pub fn unhandled(

        err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,

    ) -> Self {

        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {

            source: err.into(),

            meta: ::std::default::Default::default(),

        })

    }

    /// Creates the `CreateBucketMetadataConfigurationError::Unhandled` variant from an [`ErrorMetadata`](::aws_smithy_types::error::ErrorMetadata).

    pub fn generic(err: ::aws_smithy_types::error::ErrorMetadata) -> Self {

        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {

            source: err.clone().into(),

            meta: err,

        })

    }

    ///

    /// Returns error metadata, which includes the error code, message,

    /// request ID, and potentially additional information.

    ///

    pub fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {

        match self {

            Self::Unhandled(e) => &e.meta,

        }

    }

}

impl ::std::error::Error for CreateBucketMetadataConfigurationError {

    fn source(&self) -> ::std::option::Option<&(dyn ::std::error::Error + 'static)> {

        match self {

            Self::Unhandled(_inner) => ::std::option::Option::Some(&*_inner.source),

        }

    }

}

impl ::std::fmt::Display for CreateBucketMetadataConfigurationError {

    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {

        match self {

            Self::Unhandled(_inner) => {

                if let ::std::option::Option::Some(code) = ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self) {

                    write!(f, "unhandled error ({code})")

                } else {

                    f.write_str("unhandled error")

                }

            }

        }

    }

}

impl ::aws_smithy_types::retry::ProvideErrorKind for CreateBucketMetadataConfigurationError {

    fn code(&self) -> ::std::option::Option<&str> {

        ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self)

    }

    fn retryable_error_kind(&self) -> ::std::option::Option<::aws_smithy_types::retry::ErrorKind> {

        ::std::option::Option::None

    }

}

impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for CreateBucketMetadataConfigurationError {

    fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {

        match self {

            Self::Unhandled(_inner) => &_inner.meta,

        }

    }

}

impl ::aws_smithy_runtime_api::client::result::CreateUnhandledError for CreateBucketMetadataConfigurationError {

    fn create_unhandled_error(

        source: ::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>,

        meta: ::std::option::Option<::aws_smithy_types::error::ErrorMetadata>,

    ) -> Self {

        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {

            source,

            meta: meta.unwrap_or_default(),

        })

    }

}

impl crate::s3_request_id::RequestIdExt for crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationError {

    fn extended_request_id(&self) -> Option<&str> {

        self.meta().extended_request_id()

    }

}

impl ::aws_types::request_id::RequestId for crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationError {

    fn request_id(&self) -> Option<&str> {

        self.meta().request_id()

    }

}

pub use crate::operation::create_bucket_metadata_configuration::_create_bucket_metadata_configuration_output::CreateBucketMetadataConfigurationOutput;

pub use crate::operation::create_bucket_metadata_configuration::_create_bucket_metadata_configuration_input::CreateBucketMetadataConfigurationInput;

mod _create_bucket_metadata_configuration_input;

mod _create_bucket_metadata_configuration_output;

/// Builders

pub mod builders;

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

#[allow(missing_docs)] // documentation missing in model

#[non_exhaustive]

#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]

pub struct CreateBucketMetadataConfigurationInput {

    /// <p>The general purpose bucket that you want to create the metadata configuration for.</p>

    pub bucket: ::std::option::Option<::std::string::String>,

    /// <p>The <code>Content-MD5</code> header for the metadata configuration.</p>

    pub content_md5: ::std::option::Option<::std::string::String>,

    /// <p>The checksum algorithm to use with your metadata configuration.</p>

    pub checksum_algorithm: ::std::option::Option<crate::types::ChecksumAlgorithm>,

    /// <p>The contents of your metadata configuration.</p>

    pub metadata_configuration: ::std::option::Option<crate::types::MetadataConfiguration>,

    /// <p>The expected owner of the general purpose bucket that corresponds to your metadata configuration.</p>

    pub expected_bucket_owner: ::std::option::Option<::std::string::String>,

}

impl CreateBucketMetadataConfigurationInput {

    /// <p>The general purpose bucket that you want to create the metadata configuration for.</p>

    pub fn bucket(&self) -> ::std::option::Option<&str> {

        self.bucket.as_deref()

    }

    /// <p>The <code>Content-MD5</code> header for the metadata configuration.</p>

    pub fn content_md5(&self) -> ::std::option::Option<&str> {

        self.content_md5.as_deref()

    }

    /// <p>The checksum algorithm to use with your metadata configuration.</p>

    pub fn checksum_algorithm(&self) -> ::std::option::Option<&crate::types::ChecksumAlgorithm> {

        self.checksum_algorithm.as_ref()

    }

    /// <p>The contents of your metadata configuration.</p>

    pub fn metadata_configuration(&self) -> ::std::option::Option<&crate::types::MetadataConfiguration> {

        self.metadata_configuration.as_ref()

    }

    /// <p>The expected owner of the general purpose bucket that corresponds to your metadata configuration.</p>

    pub fn expected_bucket_owner(&self) -> ::std::option::Option<&str> {

        self.expected_bucket_owner.as_deref()

    }

}

impl CreateBucketMetadataConfigurationInput {

    /// Creates a new builder-style object to manufacture [`CreateBucketMetadataConfigurationInput`](crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationInput).

    pub fn builder() -> crate::operation::create_bucket_metadata_configuration::builders::CreateBucketMetadataConfigurationInputBuilder {

        crate::operation::create_bucket_metadata_configuration::builders::CreateBucketMetadataConfigurationInputBuilder::default()

    }

}

/// A builder for [`CreateBucketMetadataConfigurationInput`](crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationInput).

#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]

#[non_exhaustive]

pub struct CreateBucketMetadataConfigurationInputBuilder {

    pub(crate) bucket: ::std::option::Option<::std::string::String>,

    pub(crate) content_md5: ::std::option::Option<::std::string::String>,

    pub(crate) checksum_algorithm: ::std::option::Option<crate::types::ChecksumAlgorithm>,

    pub(crate) metadata_configuration: ::std::option::Option<crate::types::MetadataConfiguration>,

    pub(crate) expected_bucket_owner: ::std::option::Option<::std::string::String>,

}

impl CreateBucketMetadataConfigurationInputBuilder {

    /// <p>The general purpose bucket that you want to create the metadata configuration for.</p>

    /// This field is required.

    pub fn bucket(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {

        self.bucket = ::std::option::Option::Some(input.into());

        self

    }

    /// <p>The general purpose bucket that you want to create the metadata configuration for.</p>

    pub fn set_bucket(mut self, input: ::std::option::Option<::std::string::String>) -> Self {

        self.bucket = input;

        self

    }

    /// <p>The general purpose bucket that you want to create the metadata configuration for.</p>

    pub fn get_bucket(&self) -> &::std::option::Option<::std::string::String> {

        &self.bucket

    }

    /// <p>The <code>Content-MD5</code> header for the metadata configuration.</p>

    pub fn content_md5(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {

        self.content_md5 = ::std::option::Option::Some(input.into());

        self

    }

    /// <p>The <code>Content-MD5</code> header for the metadata configuration.</p>

    pub fn set_content_md5(mut self, input: ::std::option::Option<::std::string::String>) -> Self {

        self.content_md5 = input;

        self

    }

    /// <p>The <code>Content-MD5</code> header for the metadata configuration.</p>

    pub fn get_content_md5(&self) -> &::std::option::Option<::std::string::String> {

        &self.content_md5

    }

    /// <p>The checksum algorithm to use with your metadata configuration.</p>

    pub fn checksum_algorithm(mut self, input: crate::types::ChecksumAlgorithm) -> Self {

        self.checksum_algorithm = ::std::option::Option::Some(input);

        self

    }

    /// <p>The checksum algorithm to use with your metadata configuration.</p>

    pub fn set_checksum_algorithm(mut self, input: ::std::option::Option<crate::types::ChecksumAlgorithm>) -> Self {

        self.checksum_algorithm = input;

        self

    }

    /// <p>The checksum algorithm to use with your metadata configuration.</p>

    pub fn get_checksum_algorithm(&self) -> &::std::option::Option<crate::types::ChecksumAlgorithm> {

        &self.checksum_algorithm

    }

    /// <p>The contents of your metadata configuration.</p>

    /// This field is required.

    pub fn metadata_configuration(mut self, input: crate::types::MetadataConfiguration) -> Self {

        self.metadata_configuration = ::std::option::Option::Some(input);

        self

    }

    /// <p>The contents of your metadata configuration.</p>

    pub fn set_metadata_configuration(mut self, input: ::std::option::Option<crate::types::MetadataConfiguration>) -> Self {

        self.metadata_configuration = input;

        self

    }

    /// <p>The contents of your metadata configuration.</p>

    pub fn get_metadata_configuration(&self) -> &::std::option::Option<crate::types::MetadataConfiguration> {

        &self.metadata_configuration

    }

    /// <p>The expected owner of the general purpose bucket that corresponds to your metadata configuration.</p>

    pub fn expected_bucket_owner(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {

        self.expected_bucket_owner = ::std::option::Option::Some(input.into());

        self

    }

    /// <p>The expected owner of the general purpose bucket that corresponds to your metadata configuration.</p>

    pub fn set_expected_bucket_owner(mut self, input: ::std::option::Option<::std::string::String>) -> Self {

        self.expected_bucket_owner = input;

        self

    }

    /// <p>The expected owner of the general purpose bucket that corresponds to your metadata configuration.</p>

    pub fn get_expected_bucket_owner(&self) -> &::std::option::Option<::std::string::String> {

        &self.expected_bucket_owner

    }

    /// Consumes the builder and constructs a [`CreateBucketMetadataConfigurationInput`](crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationInput).

    pub fn build(

        self,

    ) -> ::std::result::Result<

        crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationInput,

        ::aws_smithy_types::error::operation::BuildError,

    > {

        ::std::result::Result::Ok(

            crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationInput {

                bucket: self.bucket,

                content_md5: self.content_md5,

                checksum_algorithm: self.checksum_algorithm,

                metadata_configuration: self.metadata_configuration,

                expected_bucket_owner: self.expected_bucket_owner,

            },

        )

    }

}

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

#[allow(missing_docs)] // documentation missing in model

#[non_exhaustive]

#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]

pub struct CreateBucketMetadataConfigurationOutput {

    _extended_request_id: Option<String>,

    _request_id: Option<String>,

}

impl crate::s3_request_id::RequestIdExt for CreateBucketMetadataConfigurationOutput {

    fn extended_request_id(&self) -> Option<&str> {

        self._extended_request_id.as_deref()

    }

}

impl ::aws_types::request_id::RequestId for CreateBucketMetadataConfigurationOutput {

    fn request_id(&self) -> Option<&str> {

        self._request_id.as_deref()

    }

}

impl CreateBucketMetadataConfigurationOutput {

    /// Creates a new builder-style object to manufacture [`CreateBucketMetadataConfigurationOutput`](crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationOutput).

    pub fn builder() -> crate::operation::create_bucket_metadata_configuration::builders::CreateBucketMetadataConfigurationOutputBuilder {

        crate::operation::create_bucket_metadata_configuration::builders::CreateBucketMetadataConfigurationOutputBuilder::default()

    }

}

/// A builder for [`CreateBucketMetadataConfigurationOutput`](crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationOutput).

#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]

#[non_exhaustive]

pub struct CreateBucketMetadataConfigurationOutputBuilder {

    _extended_request_id: Option<String>,

    _request_id: Option<String>,

}

impl CreateBucketMetadataConfigurationOutputBuilder {

    pub(crate) fn _extended_request_id(mut self, extended_request_id: impl Into<String>) -> Self {

        self._extended_request_id = Some(extended_request_id.into());

        self

    }

    pub(crate) fn _set_extended_request_id(&mut self, extended_request_id: Option<String>) -> &mut Self {

        self._extended_request_id = extended_request_id;

        self

    }

    pub(crate) fn _request_id(mut self, request_id: impl Into<String>) -> Self {

        self._request_id = Some(request_id.into());

        self

    }

    pub(crate) fn _set_request_id(&mut self, request_id: Option<String>) -> &mut Self {

        self._request_id = request_id;

        self

    }

    /// Consumes the builder and constructs a [`CreateBucketMetadataConfigurationOutput`](crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationOutput).

    pub fn build(self) -> crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationOutput {

        crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationOutput {

            _extended_request_id: self._extended_request_id,

            _request_id: self._request_id,

        }

    }

}

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

pub use crate::operation::create_bucket_metadata_configuration::_create_bucket_metadata_configuration_output::CreateBucketMetadataConfigurationOutputBuilder;

pub use crate::operation::create_bucket_metadata_configuration::_create_bucket_metadata_configuration_input::CreateBucketMetadataConfigurationInputBuilder;

impl crate::operation::create_bucket_metadata_configuration::builders::CreateBucketMetadataConfigurationInputBuilder {

    /// Sends a request with this input using the given client.

    pub async fn send_with(

        self,

        client: &crate::Client,

    ) -> ::std::result::Result<

        crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationOutput,

        ::aws_smithy_runtime_api::client::result::SdkError<

            crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationError,

            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,

        >,

    > {

        let mut fluent_builder = client.create_bucket_metadata_configuration();

        fluent_builder.inner = self;

        fluent_builder.send().await

    }

}

/// Fluent builder constructing a request to `CreateBucketMetadataConfiguration`.

///

/// <p>Creates an S3 Metadata V2 metadata configuration for a general purpose bucket. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/metadata-tables-overview.html">Accelerating data discovery with S3 Metadata</a> in the <i>Amazon S3 User Guide</i>.</p>

/// <dl>

/// <dt>

/// Permissions

/// </dt>

/// <dd>

/// <p>To use this operation, you must have the following permissions. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/metadata-tables-permissions.html">Setting up permissions for configuring metadata tables</a> in the <i>Amazon S3 User Guide</i>.</p>

/// <p>If you want to encrypt your metadata tables with server-side encryption with Key Management Service (KMS) keys (SSE-KMS), you need additional permissions in your KMS key policy. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/metadata-tables-permissions.html"> Setting up permissions for configuring metadata tables</a> in the <i>Amazon S3 User Guide</i>.</p>

/// <p>If you also want to integrate your table bucket with Amazon Web Services analytics services so that you can query your metadata table, you need additional permissions. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-integrating-aws.html"> Integrating Amazon S3 Tables with Amazon Web Services analytics services</a> in the <i>Amazon S3 User Guide</i>.</p>

/// <p>To query your metadata tables, you need additional permissions. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/metadata-tables-bucket-query-permissions.html"> Permissions for querying metadata tables</a> in the <i>Amazon S3 User Guide</i>.</p>

/// <ul>

/// <li>

/// <p><code>s3:CreateBucketMetadataTableConfiguration</code></p><note>

/// <p>The IAM policy action name is the same for the V1 and V2 API operations.</p>

/// </note></li>

/// <li>

/// <p><code>s3tables:CreateTableBucket</code></p></li>

/// <li>

/// <p><code>s3tables:CreateNamespace</code></p></li>

/// <li>

/// <p><code>s3tables:GetTable</code></p></li>

/// <li>

/// <p><code>s3tables:CreateTable</code></p></li>

/// <li>

/// <p><code>s3tables:PutTablePolicy</code></p></li>

/// <li>

/// <p><code>s3tables:PutTableEncryption</code></p></li>

/// <li>

/// <p><code>kms:DescribeKey</code></p></li>

/// </ul>

/// </dd>

/// </dl>

/// <p>The following operations are related to <code>CreateBucketMetadataConfiguration</code>:</p>

/// <ul>

/// <li>

/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteBucketMetadataConfiguration.html">DeleteBucketMetadataConfiguration</a></p></li>

/// <li>

/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketMetadataConfiguration.html">GetBucketMetadataConfiguration</a></p></li>

/// <li>

/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_UpdateBucketMetadataInventoryTableConfiguration.html">UpdateBucketMetadataInventoryTableConfiguration</a></p></li>

/// <li>

/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_UpdateBucketMetadataJournalTableConfiguration.html">UpdateBucketMetadataJournalTableConfiguration</a></p></li>

/// </ul>

#[derive(::std::clone::Clone, ::std::fmt::Debug)]

pub struct CreateBucketMetadataConfigurationFluentBuilder {

    handle: ::std::sync::Arc<crate::client::Handle>,

    inner: crate::operation::create_bucket_metadata_configuration::builders::CreateBucketMetadataConfigurationInputBuilder,

    config_override: ::std::option::Option<crate::config::Builder>,

}

impl

    crate::client::customize::internal::CustomizableSend<

        crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationOutput,

        crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationError,

    > for CreateBucketMetadataConfigurationFluentBuilder

{

    fn send(

        self,

        config_override: crate::config::Builder,

    ) -> crate::client::customize::internal::BoxFuture<

        crate::client::customize::internal::SendResult<

            crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationOutput,

            crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationError,

        >,

    > {

        ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })

    }

}

impl CreateBucketMetadataConfigurationFluentBuilder {

    /// Creates a new `CreateBucketMetadataConfigurationFluentBuilder`.

    pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {

        Self {

            handle,

            inner: ::std::default::Default::default(),

            config_override: ::std::option::Option::None,

        }

    }

    /// Access the CreateBucketMetadataConfiguration as a reference.

    pub fn as_input(&self) -> &crate::operation::create_bucket_metadata_configuration::builders::CreateBucketMetadataConfigurationInputBuilder {

        &self.inner

    }

    /// Sends the request and returns the response.

    ///

    /// If an error occurs, an `SdkError` will be returned with additional details that

    /// can be matched against.

    ///

    /// By default, any retryable failures will be retried twice. Retry behavior

    /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be

    /// set when configuring the client.

    pub async fn send(

        self,

    ) -> ::std::result::Result<

        crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationOutput,

        ::aws_smithy_runtime_api::client::result::SdkError<

            crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationError,

            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,

        >,

    > {

        let input = self

            .inner

            .build()

            .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;

        let runtime_plugins = crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfiguration::operation_runtime_plugins(

            self.handle.runtime_plugins.clone(),

            &self.handle.conf,

            self.config_override,

        );

        crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfiguration::orchestrate(&runtime_plugins, input).await

    }

    /// Consumes this builder, creating a customizable operation that can be modified before being sent.

    pub fn customize(

        self,

    ) -> crate::client::customize::CustomizableOperation<

        crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationOutput,

        crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationError,

        Self,

    > {

        crate::client::customize::CustomizableOperation::new(self)

    }

    pub(crate) fn config_override(mut self, config_override: impl ::std::convert::Into<crate::config::Builder>) -> Self {

        self.set_config_override(::std::option::Option::Some(config_override.into()));

        self

    }

    pub(crate) fn set_config_override(&mut self, config_override: ::std::option::Option<crate::config::Builder>) -> &mut Self {

        self.config_override = config_override;

        self

    }

    /// <p>The general purpose bucket that you want to create the metadata configuration for.</p>

    pub fn bucket(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {

        self.inner = self.inner.bucket(input.into());

        self

    }

    /// <p>The general purpose bucket that you want to create the metadata configuration for.</p>

    pub fn set_bucket(mut self, input: ::std::option::Option<::std::string::String>) -> Self {

        self.inner = self.inner.set_bucket(input);

        self

    }

    /// <p>The general purpose bucket that you want to create the metadata configuration for.</p>

    pub fn get_bucket(&self) -> &::std::option::Option<::std::string::String> {

        self.inner.get_bucket()

    }

    /// <p>The <code>Content-MD5</code> header for the metadata configuration.</p>

    pub fn content_md5(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {

        self.inner = self.inner.content_md5(input.into());

        self

    }

    /// <p>The <code>Content-MD5</code> header for the metadata configuration.</p>

    pub fn set_content_md5(mut self, input: ::std::option::Option<::std::string::String>) -> Self {

        self.inner = self.inner.set_content_md5(input);

        self

    }

    /// <p>The <code>Content-MD5</code> header for the metadata configuration.</p>

    pub fn get_content_md5(&self) -> &::std::option::Option<::std::string::String> {

        self.inner.get_content_md5()

    }

    /// <p>The checksum algorithm to use with your metadata configuration.</p>

    pub fn checksum_algorithm(mut self, input: crate::types::ChecksumAlgorithm) -> Self {

        self.inner = self.inner.checksum_algorithm(input);

        self

    }

    /// <p>The checksum algorithm to use with your metadata configuration.</p>

    pub fn set_checksum_algorithm(mut self, input: ::std::option::Option<crate::types::ChecksumAlgorithm>) -> Self {

        self.inner = self.inner.set_checksum_algorithm(input);

        self

    }

    /// <p>The checksum algorithm to use with your metadata configuration.</p>

    pub fn get_checksum_algorithm(&self) -> &::std::option::Option<crate::types::ChecksumAlgorithm> {

        self.inner.get_checksum_algorithm()

    }

    /// <p>The contents of your metadata configuration.</p>