AWS SDK

AWS SDK

rev. 03e6e47f15dfd569240d570d98975ebba692c405

Files changed:

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/disable_kinesis_streaming_destination.rs

@@ -175,175 +255,255 @@
  195    195   
                _input: &crate::operation::disable_kinesis_streaming_destination::DisableKinesisStreamingDestinationInput,
  196    196   
                output: &mut ::std::string::String,
  197    197   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  198    198   
                use ::std::fmt::Write as _;
  199    199   
                ::std::write!(output, "/").expect("formatting should succeed");
  200    200   
                ::std::result::Result::Ok(())
  201    201   
            }
  202    202   
            #[allow(clippy::unnecessary_wraps)]
  203    203   
            fn update_http_builder(
  204    204   
                input: &crate::operation::disable_kinesis_streaming_destination::DisableKinesisStreamingDestinationInput,
  205         -
                builder: ::http::request::Builder,
  206         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         205  +
                builder: ::http_1x::request::Builder,
         206  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  207    207   
                let mut uri = ::std::string::String::new();
  208    208   
                uri_base(input, &mut uri)?;
  209    209   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  210    210   
            }
  211         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  212         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.0");
         211  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         212  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
  213    213   
            builder = _header_serialization_settings.set_default_header(
  214    214   
                builder,
  215         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         215  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  216    216   
                "DynamoDB_20120810.DisableKinesisStreamingDestination",
  217    217   
            );
  218    218   
            builder
  219    219   
        };
  220    220   
        let body = ::aws_smithy_types::body::SdkBody::from(
  221    221   
            crate::protocol_serde::shape_disable_kinesis_streaming_destination::ser_disable_kinesis_streaming_destination_input(&input)?,
  222    222   
        );
  223    223   
        if let Some(content_length) = body.content_length() {
  224    224   
            let content_length = content_length.to_string();
  225         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         225  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  226    226   
        }
  227    227   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  228    228   
    }
  229    229   
}
  230    230   
#[derive(Debug)]
  231    231   
struct DisableKinesisStreamingDestinationEndpointParamsInterceptor;
  232    232   
  233    233   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DisableKinesisStreamingDestinationEndpointParamsInterceptor {
  234    234   
    fn name(&self) -> &'static str {
  235    235   
        "DisableKinesisStreamingDestinationEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/enable_kinesis_streaming_destination.rs

@@ -175,175 +255,255 @@
  195    195   
                _input: &crate::operation::enable_kinesis_streaming_destination::EnableKinesisStreamingDestinationInput,
  196    196   
                output: &mut ::std::string::String,
  197    197   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  198    198   
                use ::std::fmt::Write as _;
  199    199   
                ::std::write!(output, "/").expect("formatting should succeed");
  200    200   
                ::std::result::Result::Ok(())
  201    201   
            }
  202    202   
            #[allow(clippy::unnecessary_wraps)]
  203    203   
            fn update_http_builder(
  204    204   
                input: &crate::operation::enable_kinesis_streaming_destination::EnableKinesisStreamingDestinationInput,
  205         -
                builder: ::http::request::Builder,
  206         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         205  +
                builder: ::http_1x::request::Builder,
         206  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  207    207   
                let mut uri = ::std::string::String::new();
  208    208   
                uri_base(input, &mut uri)?;
  209    209   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  210    210   
            }
  211         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  212         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.0");
         211  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         212  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
  213    213   
            builder = _header_serialization_settings.set_default_header(
  214    214   
                builder,
  215         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         215  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  216    216   
                "DynamoDB_20120810.EnableKinesisStreamingDestination",
  217    217   
            );
  218    218   
            builder
  219    219   
        };
  220    220   
        let body = ::aws_smithy_types::body::SdkBody::from(
  221    221   
            crate::protocol_serde::shape_enable_kinesis_streaming_destination::ser_enable_kinesis_streaming_destination_input(&input)?,
  222    222   
        );
  223    223   
        if let Some(content_length) = body.content_length() {
  224    224   
            let content_length = content_length.to_string();
  225         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         225  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  226    226   
        }
  227    227   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  228    228   
    }
  229    229   
}
  230    230   
#[derive(Debug)]
  231    231   
struct EnableKinesisStreamingDestinationEndpointParamsInterceptor;
  232    232   
  233    233   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for EnableKinesisStreamingDestinationEndpointParamsInterceptor {
  234    234   
    fn name(&self) -> &'static str {
  235    235   
        "EnableKinesisStreamingDestinationEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/execute_statement.rs

@@ -165,165 +243,243 @@
  185    185   
                _input: &crate::operation::execute_statement::ExecuteStatementInput,
  186    186   
                output: &mut ::std::string::String,
  187    187   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  188    188   
                use ::std::fmt::Write as _;
  189    189   
                ::std::write!(output, "/").expect("formatting should succeed");
  190    190   
                ::std::result::Result::Ok(())
  191    191   
            }
  192    192   
            #[allow(clippy::unnecessary_wraps)]
  193    193   
            fn update_http_builder(
  194    194   
                input: &crate::operation::execute_statement::ExecuteStatementInput,
  195         -
                builder: ::http::request::Builder,
  196         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         195  +
                builder: ::http_1x::request::Builder,
         196  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  197    197   
                let mut uri = ::std::string::String::new();
  198    198   
                uri_base(input, &mut uri)?;
  199    199   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  200    200   
            }
  201         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  202         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.0");
         201  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         202  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
  203    203   
            builder = _header_serialization_settings.set_default_header(
  204    204   
                builder,
  205         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         205  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  206    206   
                "DynamoDB_20120810.ExecuteStatement",
  207    207   
            );
  208    208   
            builder
  209    209   
        };
  210    210   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_execute_statement::ser_execute_statement_input(&input)?);
  211    211   
        if let Some(content_length) = body.content_length() {
  212    212   
            let content_length = content_length.to_string();
  213         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         213  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  214    214   
        }
  215    215   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  216    216   
    }
  217    217   
}
  218    218   
#[derive(Debug)]
  219    219   
struct ExecuteStatementEndpointParamsInterceptor;
  220    220   
  221    221   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ExecuteStatementEndpointParamsInterceptor {
  222    222   
    fn name(&self) -> &'static str {
  223    223   
        "ExecuteStatementEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/execute_transaction.rs

@@ -172,172 +250,250 @@
  192    192   
                _input: &crate::operation::execute_transaction::ExecuteTransactionInput,
  193    193   
                output: &mut ::std::string::String,
  194    194   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  195    195   
                use ::std::fmt::Write as _;
  196    196   
                ::std::write!(output, "/").expect("formatting should succeed");
  197    197   
                ::std::result::Result::Ok(())
  198    198   
            }
  199    199   
            #[allow(clippy::unnecessary_wraps)]
  200    200   
            fn update_http_builder(
  201    201   
                input: &crate::operation::execute_transaction::ExecuteTransactionInput,
  202         -
                builder: ::http::request::Builder,
  203         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         202  +
                builder: ::http_1x::request::Builder,
         203  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  204    204   
                let mut uri = ::std::string::String::new();
  205    205   
                uri_base(input, &mut uri)?;
  206    206   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  207    207   
            }
  208         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  209         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.0");
         208  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         209  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
  210    210   
            builder = _header_serialization_settings.set_default_header(
  211    211   
                builder,
  212         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         212  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  213    213   
                "DynamoDB_20120810.ExecuteTransaction",
  214    214   
            );
  215    215   
            builder
  216    216   
        };
  217    217   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_execute_transaction::ser_execute_transaction_input(&input)?);
  218    218   
        if let Some(content_length) = body.content_length() {
  219    219   
            let content_length = content_length.to_string();
  220         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         220  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  221    221   
        }
  222    222   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  223    223   
    }
  224    224   
}
  225    225   
#[derive(Debug)]
  226    226   
struct ExecuteTransactionEndpointParamsInterceptor;
  227    227   
  228    228   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ExecuteTransactionEndpointParamsInterceptor {
  229    229   
    fn name(&self) -> &'static str {
  230    230   
        "ExecuteTransactionEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/export_table_to_point_in_time.rs

@@ -173,173 +253,253 @@
  193    193   
                _input: &crate::operation::export_table_to_point_in_time::ExportTableToPointInTimeInput,
  194    194   
                output: &mut ::std::string::String,
  195    195   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  196    196   
                use ::std::fmt::Write as _;
  197    197   
                ::std::write!(output, "/").expect("formatting should succeed");
  198    198   
                ::std::result::Result::Ok(())
  199    199   
            }
  200    200   
            #[allow(clippy::unnecessary_wraps)]
  201    201   
            fn update_http_builder(
  202    202   
                input: &crate::operation::export_table_to_point_in_time::ExportTableToPointInTimeInput,
  203         -
                builder: ::http::request::Builder,
  204         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         203  +
                builder: ::http_1x::request::Builder,
         204  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  205    205   
                let mut uri = ::std::string::String::new();
  206    206   
                uri_base(input, &mut uri)?;
  207    207   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  208    208   
            }
  209         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  210         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.0");
         209  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         210  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
  211    211   
            builder = _header_serialization_settings.set_default_header(
  212    212   
                builder,
  213         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         213  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  214    214   
                "DynamoDB_20120810.ExportTableToPointInTime",
  215    215   
            );
  216    216   
            builder
  217    217   
        };
  218    218   
        let body = ::aws_smithy_types::body::SdkBody::from(
  219    219   
            crate::protocol_serde::shape_export_table_to_point_in_time::ser_export_table_to_point_in_time_input(&input)?,
  220    220   
        );
  221    221   
        if let Some(content_length) = body.content_length() {
  222    222   
            let content_length = content_length.to_string();
  223         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         223  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  224    224   
        }
  225    225   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  226    226   
    }
  227    227   
}
  228    228   
#[derive(Debug)]
  229    229   
struct ExportTableToPointInTimeEndpointParamsInterceptor;
  230    230   
  231    231   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ExportTableToPointInTimeEndpointParamsInterceptor {
  232    232   
    fn name(&self) -> &'static str {
  233    233   
        "ExportTableToPointInTimeEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/get_item.rs

@@ -156,156 +234,234 @@
  176    176   
                _input: &crate::operation::get_item::GetItemInput,
  177    177   
                output: &mut ::std::string::String,
  178    178   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  179    179   
                use ::std::fmt::Write as _;
  180    180   
                ::std::write!(output, "/").expect("formatting should succeed");
  181    181   
                ::std::result::Result::Ok(())
  182    182   
            }
  183    183   
            #[allow(clippy::unnecessary_wraps)]
  184    184   
            fn update_http_builder(
  185    185   
                input: &crate::operation::get_item::GetItemInput,
  186         -
                builder: ::http::request::Builder,
  187         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         186  +
                builder: ::http_1x::request::Builder,
         187  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  188    188   
                let mut uri = ::std::string::String::new();
  189    189   
                uri_base(input, &mut uri)?;
  190    190   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  191    191   
            }
  192         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  193         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.0");
         192  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         193  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
  194    194   
            builder = _header_serialization_settings.set_default_header(
  195    195   
                builder,
  196         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         196  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  197    197   
                "DynamoDB_20120810.GetItem",
  198    198   
            );
  199    199   
            builder
  200    200   
        };
  201    201   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_get_item::ser_get_item_input(&input)?);
  202    202   
        if let Some(content_length) = body.content_length() {
  203    203   
            let content_length = content_length.to_string();
  204         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         204  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  205    205   
        }
  206    206   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  207    207   
    }
  208    208   
}
  209    209   
#[derive(Debug)]
  210    210   
struct GetItemEndpointParamsInterceptor;
  211    211   
  212    212   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetItemEndpointParamsInterceptor {
  213    213   
    fn name(&self) -> &'static str {
  214    214   
        "GetItemEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/get_resource_policy.rs

@@ -165,165 +243,243 @@
  185    185   
                _input: &crate::operation::get_resource_policy::GetResourcePolicyInput,
  186    186   
                output: &mut ::std::string::String,
  187    187   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  188    188   
                use ::std::fmt::Write as _;
  189    189   
                ::std::write!(output, "/").expect("formatting should succeed");
  190    190   
                ::std::result::Result::Ok(())
  191    191   
            }
  192    192   
            #[allow(clippy::unnecessary_wraps)]
  193    193   
            fn update_http_builder(
  194    194   
                input: &crate::operation::get_resource_policy::GetResourcePolicyInput,
  195         -
                builder: ::http::request::Builder,
  196         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         195  +
                builder: ::http_1x::request::Builder,
         196  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  197    197   
                let mut uri = ::std::string::String::new();
  198    198   
                uri_base(input, &mut uri)?;
  199    199   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  200    200   
            }
  201         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  202         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.0");
         201  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         202  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
  203    203   
            builder = _header_serialization_settings.set_default_header(
  204    204   
                builder,
  205         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         205  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  206    206   
                "DynamoDB_20120810.GetResourcePolicy",
  207    207   
            );
  208    208   
            builder
  209    209   
        };
  210    210   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_get_resource_policy::ser_get_resource_policy_input(&input)?);
  211    211   
        if let Some(content_length) = body.content_length() {
  212    212   
            let content_length = content_length.to_string();
  213         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         213  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  214    214   
        }
  215    215   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  216    216   
    }
  217    217   
}
  218    218   
#[derive(Debug)]
  219    219   
struct GetResourcePolicyEndpointParamsInterceptor;
  220    220   
  221    221   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetResourcePolicyEndpointParamsInterceptor {
  222    222   
    fn name(&self) -> &'static str {
  223    223   
        "GetResourcePolicyEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/import_table.rs

@@ -169,169 +247,247 @@
  189    189   
                _input: &crate::operation::import_table::ImportTableInput,
  190    190   
                output: &mut ::std::string::String,
  191    191   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  192    192   
                use ::std::fmt::Write as _;
  193    193   
                ::std::write!(output, "/").expect("formatting should succeed");
  194    194   
                ::std::result::Result::Ok(())
  195    195   
            }
  196    196   
            #[allow(clippy::unnecessary_wraps)]
  197    197   
            fn update_http_builder(
  198    198   
                input: &crate::operation::import_table::ImportTableInput,
  199         -
                builder: ::http::request::Builder,
  200         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         199  +
                builder: ::http_1x::request::Builder,
         200  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  201    201   
                let mut uri = ::std::string::String::new();
  202    202   
                uri_base(input, &mut uri)?;
  203    203   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  204    204   
            }
  205         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  206         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.0");
         205  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         206  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
  207    207   
            builder = _header_serialization_settings.set_default_header(
  208    208   
                builder,
  209         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         209  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  210    210   
                "DynamoDB_20120810.ImportTable",
  211    211   
            );
  212    212   
            builder
  213    213   
        };
  214    214   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_import_table::ser_import_table_input(&input)?);
  215    215   
        if let Some(content_length) = body.content_length() {
  216    216   
            let content_length = content_length.to_string();
  217         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         217  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  218    218   
        }
  219    219   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  220    220   
    }
  221    221   
}
  222    222   
#[derive(Debug)]
  223    223   
struct ImportTableEndpointParamsInterceptor;
  224    224   
  225    225   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ImportTableEndpointParamsInterceptor {
  226    226   
    fn name(&self) -> &'static str {
  227    227   
        "ImportTableEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/list_backups.rs

@@ -162,162 +240,240 @@
  182    182   
                _input: &crate::operation::list_backups::ListBackupsInput,
  183    183   
                output: &mut ::std::string::String,
  184    184   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  185    185   
                use ::std::fmt::Write as _;
  186    186   
                ::std::write!(output, "/").expect("formatting should succeed");
  187    187   
                ::std::result::Result::Ok(())
  188    188   
            }
  189    189   
            #[allow(clippy::unnecessary_wraps)]
  190    190   
            fn update_http_builder(
  191    191   
                input: &crate::operation::list_backups::ListBackupsInput,
  192         -
                builder: ::http::request::Builder,
  193         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         192  +
                builder: ::http_1x::request::Builder,
         193  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  194    194   
                let mut uri = ::std::string::String::new();
  195    195   
                uri_base(input, &mut uri)?;
  196    196   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  197    197   
            }
  198         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  199         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.0");
         198  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         199  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
  200    200   
            builder = _header_serialization_settings.set_default_header(
  201    201   
                builder,
  202         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         202  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  203    203   
                "DynamoDB_20120810.ListBackups",
  204    204   
            );
  205    205   
            builder
  206    206   
        };
  207    207   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_list_backups::ser_list_backups_input(&input)?);
  208    208   
        if let Some(content_length) = body.content_length() {
  209    209   
            let content_length = content_length.to_string();
  210         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         210  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  211    211   
        }
  212    212   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  213    213   
    }
  214    214   
}
  215    215   
#[derive(Debug)]
  216    216   
struct ListBackupsEndpointParamsInterceptor;
  217    217   
  218    218   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListBackupsEndpointParamsInterceptor {
  219    219   
    fn name(&self) -> &'static str {
  220    220   
        "ListBackupsEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/list_contributor_insights.rs

@@ -165,165 +245,245 @@
  185    185   
                _input: &crate::operation::list_contributor_insights::ListContributorInsightsInput,
  186    186   
                output: &mut ::std::string::String,
  187    187   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  188    188   
                use ::std::fmt::Write as _;
  189    189   
                ::std::write!(output, "/").expect("formatting should succeed");
  190    190   
                ::std::result::Result::Ok(())
  191    191   
            }
  192    192   
            #[allow(clippy::unnecessary_wraps)]
  193    193   
            fn update_http_builder(
  194    194   
                input: &crate::operation::list_contributor_insights::ListContributorInsightsInput,
  195         -
                builder: ::http::request::Builder,
  196         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         195  +
                builder: ::http_1x::request::Builder,
         196  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  197    197   
                let mut uri = ::std::string::String::new();
  198    198   
                uri_base(input, &mut uri)?;
  199    199   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  200    200   
            }
  201         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  202         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.0");
         201  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         202  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
  203    203   
            builder = _header_serialization_settings.set_default_header(
  204    204   
                builder,
  205         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         205  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  206    206   
                "DynamoDB_20120810.ListContributorInsights",
  207    207   
            );
  208    208   
            builder
  209    209   
        };
  210    210   
        let body = ::aws_smithy_types::body::SdkBody::from(
  211    211   
            crate::protocol_serde::shape_list_contributor_insights::ser_list_contributor_insights_input(&input)?,
  212    212   
        );
  213    213   
        if let Some(content_length) = body.content_length() {
  214    214   
            let content_length = content_length.to_string();
  215         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         215  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  216    216   
        }
  217    217   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  218    218   
    }
  219    219   
}
  220    220   
#[derive(Debug)]
  221    221   
struct ListContributorInsightsEndpointParamsInterceptor;
  222    222   
  223    223   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListContributorInsightsEndpointParamsInterceptor {
  224    224   
    fn name(&self) -> &'static str {
  225    225   
        "ListContributorInsightsEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/list_exports.rs

@@ -162,162 +240,240 @@
  182    182   
                _input: &crate::operation::list_exports::ListExportsInput,
  183    183   
                output: &mut ::std::string::String,
  184    184   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  185    185   
                use ::std::fmt::Write as _;
  186    186   
                ::std::write!(output, "/").expect("formatting should succeed");
  187    187   
                ::std::result::Result::Ok(())
  188    188   
            }
  189    189   
            #[allow(clippy::unnecessary_wraps)]
  190    190   
            fn update_http_builder(
  191    191   
                input: &crate::operation::list_exports::ListExportsInput,
  192         -
                builder: ::http::request::Builder,
  193         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         192  +
                builder: ::http_1x::request::Builder,
         193  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  194    194   
                let mut uri = ::std::string::String::new();
  195    195   
                uri_base(input, &mut uri)?;
  196    196   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  197    197   
            }
  198         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  199         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.0");
         198  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         199  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
  200    200   
            builder = _header_serialization_settings.set_default_header(
  201    201   
                builder,
  202         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         202  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  203    203   
                "DynamoDB_20120810.ListExports",
  204    204   
            );
  205    205   
            builder
  206    206   
        };
  207    207   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_list_exports::ser_list_exports_input(&input)?);
  208    208   
        if let Some(content_length) = body.content_length() {
  209    209   
            let content_length = content_length.to_string();
  210         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         210  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  211    211   
        }
  212    212   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  213    213   
    }
  214    214   
}
  215    215   
#[derive(Debug)]
  216    216   
struct ListExportsEndpointParamsInterceptor;
  217    217   
  218    218   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListExportsEndpointParamsInterceptor {
  219    219   
    fn name(&self) -> &'static str {
  220    220   
        "ListExportsEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/list_global_tables.rs

@@ -165,165 +243,243 @@
  185    185   
                _input: &crate::operation::list_global_tables::ListGlobalTablesInput,
  186    186   
                output: &mut ::std::string::String,
  187    187   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  188    188   
                use ::std::fmt::Write as _;
  189    189   
                ::std::write!(output, "/").expect("formatting should succeed");
  190    190   
                ::std::result::Result::Ok(())
  191    191   
            }
  192    192   
            #[allow(clippy::unnecessary_wraps)]
  193    193   
            fn update_http_builder(
  194    194   
                input: &crate::operation::list_global_tables::ListGlobalTablesInput,
  195         -
                builder: ::http::request::Builder,
  196         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         195  +
                builder: ::http_1x::request::Builder,
         196  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  197    197   
                let mut uri = ::std::string::String::new();
  198    198   
                uri_base(input, &mut uri)?;
  199    199   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  200    200   
            }
  201         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  202         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.0");
         201  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         202  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
  203    203   
            builder = _header_serialization_settings.set_default_header(
  204    204   
                builder,
  205         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         205  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  206    206   
                "DynamoDB_20120810.ListGlobalTables",
  207    207   
            );
  208    208   
            builder
  209    209   
        };
  210    210   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_list_global_tables::ser_list_global_tables_input(&input)?);
  211    211   
        if let Some(content_length) = body.content_length() {
  212    212   
            let content_length = content_length.to_string();
  213         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         213  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  214    214   
        }
  215    215   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  216    216   
    }
  217    217   
}
  218    218   
#[derive(Debug)]
  219    219   
struct ListGlobalTablesEndpointParamsInterceptor;
  220    220   
  221    221   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListGlobalTablesEndpointParamsInterceptor {
  222    222   
    fn name(&self) -> &'static str {
  223    223   
        "ListGlobalTablesEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/list_imports.rs

@@ -162,162 +240,240 @@
  182    182   
                _input: &crate::operation::list_imports::ListImportsInput,
  183    183   
                output: &mut ::std::string::String,
  184    184   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  185    185   
                use ::std::fmt::Write as _;
  186    186   
                ::std::write!(output, "/").expect("formatting should succeed");
  187    187   
                ::std::result::Result::Ok(())
  188    188   
            }
  189    189   
            #[allow(clippy::unnecessary_wraps)]
  190    190   
            fn update_http_builder(
  191    191   
                input: &crate::operation::list_imports::ListImportsInput,
  192         -
                builder: ::http::request::Builder,
  193         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         192  +
                builder: ::http_1x::request::Builder,
         193  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  194    194   
                let mut uri = ::std::string::String::new();
  195    195   
                uri_base(input, &mut uri)?;
  196    196   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  197    197   
            }
  198         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  199         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.0");
         198  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         199  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
  200    200   
            builder = _header_serialization_settings.set_default_header(
  201    201   
                builder,
  202         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         202  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  203    203   
                "DynamoDB_20120810.ListImports",
  204    204   
            );
  205    205   
            builder
  206    206   
        };
  207    207   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_list_imports::ser_list_imports_input(&input)?);
  208    208   
        if let Some(content_length) = body.content_length() {
  209    209   
            let content_length = content_length.to_string();
  210         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         210  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  211    211   
        }
  212    212   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  213    213   
    }
  214    214   
}
  215    215   
#[derive(Debug)]
  216    216   
struct ListImportsEndpointParamsInterceptor;
  217    217   
  218    218   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListImportsEndpointParamsInterceptor {
  219    219   
    fn name(&self) -> &'static str {
  220    220   
        "ListImportsEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/list_tables.rs

@@ -160,160 +238,238 @@
  180    180   
                _input: &crate::operation::list_tables::ListTablesInput,
  181    181   
                output: &mut ::std::string::String,
  182    182   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  183    183   
                use ::std::fmt::Write as _;
  184    184   
                ::std::write!(output, "/").expect("formatting should succeed");
  185    185   
                ::std::result::Result::Ok(())
  186    186   
            }
  187    187   
            #[allow(clippy::unnecessary_wraps)]
  188    188   
            fn update_http_builder(
  189    189   
                input: &crate::operation::list_tables::ListTablesInput,
  190         -
                builder: ::http::request::Builder,
  191         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         190  +
                builder: ::http_1x::request::Builder,
         191  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  192    192   
                let mut uri = ::std::string::String::new();
  193    193   
                uri_base(input, &mut uri)?;
  194    194   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  195    195   
            }
  196         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  197         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.0");
         196  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         197  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
  198    198   
            builder = _header_serialization_settings.set_default_header(
  199    199   
                builder,
  200         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         200  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  201    201   
                "DynamoDB_20120810.ListTables",
  202    202   
            );
  203    203   
            builder
  204    204   
        };
  205    205   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_list_tables::ser_list_tables_input(&input)?);
  206    206   
        if let Some(content_length) = body.content_length() {
  207    207   
            let content_length = content_length.to_string();
  208         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         208  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  209    209   
        }
  210    210   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  211    211   
    }
  212    212   
}
  213    213   
#[derive(Debug)]
  214    214   
struct ListTablesEndpointParamsInterceptor;
  215    215   
  216    216   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListTablesEndpointParamsInterceptor {
  217    217   
    fn name(&self) -> &'static str {
  218    218   
        "ListTablesEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/list_tags_of_resource.rs

@@ -165,165 +245,245 @@
  185    185   
                _input: &crate::operation::list_tags_of_resource::ListTagsOfResourceInput,
  186    186   
                output: &mut ::std::string::String,
  187    187   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  188    188   
                use ::std::fmt::Write as _;
  189    189   
                ::std::write!(output, "/").expect("formatting should succeed");
  190    190   
                ::std::result::Result::Ok(())
  191    191   
            }
  192    192   
            #[allow(clippy::unnecessary_wraps)]
  193    193   
            fn update_http_builder(
  194    194   
                input: &crate::operation::list_tags_of_resource::ListTagsOfResourceInput,
  195         -
                builder: ::http::request::Builder,
  196         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         195  +
                builder: ::http_1x::request::Builder,
         196  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  197    197   
                let mut uri = ::std::string::String::new();
  198    198   
                uri_base(input, &mut uri)?;
  199    199   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  200    200   
            }
  201         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  202         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.0");
         201  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         202  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
  203    203   
            builder = _header_serialization_settings.set_default_header(
  204    204   
                builder,
  205         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         205  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  206    206   
                "DynamoDB_20120810.ListTagsOfResource",
  207    207   
            );
  208    208   
            builder
  209    209   
        };
  210    210   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_list_tags_of_resource::ser_list_tags_of_resource_input(
  211    211   
            &input,
  212    212   
        )?);
  213    213   
        if let Some(content_length) = body.content_length() {
  214    214   
            let content_length = content_length.to_string();
  215         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         215  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  216    216   
        }
  217    217   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  218    218   
    }
  219    219   
}
  220    220   
#[derive(Debug)]
  221    221   
struct ListTagsOfResourceEndpointParamsInterceptor;
  222    222   
  223    223   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListTagsOfResourceEndpointParamsInterceptor {
  224    224   
    fn name(&self) -> &'static str {
  225    225   
        "ListTagsOfResourceEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/put_item.rs

@@ -156,156 +234,234 @@
  176    176   
                _input: &crate::operation::put_item::PutItemInput,
  177    177   
                output: &mut ::std::string::String,
  178    178   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  179    179   
                use ::std::fmt::Write as _;
  180    180   
                ::std::write!(output, "/").expect("formatting should succeed");
  181    181   
                ::std::result::Result::Ok(())
  182    182   
            }
  183    183   
            #[allow(clippy::unnecessary_wraps)]
  184    184   
            fn update_http_builder(
  185    185   
                input: &crate::operation::put_item::PutItemInput,
  186         -
                builder: ::http::request::Builder,
  187         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         186  +
                builder: ::http_1x::request::Builder,
         187  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  188    188   
                let mut uri = ::std::string::String::new();
  189    189   
                uri_base(input, &mut uri)?;
  190    190   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  191    191   
            }
  192         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  193         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.0");
         192  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         193  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
  194    194   
            builder = _header_serialization_settings.set_default_header(
  195    195   
                builder,
  196         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         196  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  197    197   
                "DynamoDB_20120810.PutItem",
  198    198   
            );
  199    199   
            builder
  200    200   
        };
  201    201   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_put_item::ser_put_item_input(&input)?);
  202    202   
        if let Some(content_length) = body.content_length() {
  203    203   
            let content_length = content_length.to_string();
  204         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         204  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  205    205   
        }
  206    206   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  207    207   
    }
  208    208   
}
  209    209   
#[derive(Debug)]
  210    210   
struct PutItemEndpointParamsInterceptor;
  211    211   
  212    212   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutItemEndpointParamsInterceptor {
  213    213   
    fn name(&self) -> &'static str {
  214    214   
        "PutItemEndpointParamsInterceptor"