Client Test

Client Test

rev. d06a46cae0f385cdae37a9f8264db3469a090ab5 (ignoring whitespace)

Files changed:

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/delete_table.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/describe_backup.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/describe_continuous_backups.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/describe_contributor_insights.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/describe_endpoints.rs

@@ -151,151 +221,221 @@
  171    171   
                _input: &crate::operation::describe_endpoints::DescribeEndpointsInput,
  172    172   
                output: &mut ::std::string::String,
  173    173   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  174    174   
                use ::std::fmt::Write as _;
  175    175   
                ::std::write!(output, "/").expect("formatting should succeed");
  176    176   
                ::std::result::Result::Ok(())
  177    177   
            }
  178    178   
            #[allow(clippy::unnecessary_wraps)]
  179    179   
            fn update_http_builder(
  180    180   
                input: &crate::operation::describe_endpoints::DescribeEndpointsInput,
  181         -
                builder: ::http::request::Builder,
  182         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         181  +
                builder: ::http_1x::request::Builder,
         182  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  183    183   
                let mut uri = ::std::string::String::new();
  184    184   
                uri_base(input, &mut uri)?;
  185    185   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  186    186   
            }
  187         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  188         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.0");
         187  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         188  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
  189    189   
            builder = _header_serialization_settings.set_default_header(
  190    190   
                builder,
  191         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         191  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  192    192   
                "DynamoDB_20120810.DescribeEndpoints",
  193    193   
            );
  194    194   
            builder
  195    195   
        };
  196    196   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_describe_endpoints::ser_describe_endpoints_input(&input)?);
  197    197   
  198    198   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  199    199   
    }
  200    200   
}
  201    201   
#[derive(Debug)]

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/describe_export.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/describe_global_table.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/describe_global_table_settings.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/describe_kinesis_streaming_destination.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/describe_limits.rs

@@ -151,151 +221,221 @@
  171    171   
                _input: &crate::operation::describe_limits::DescribeLimitsInput,
  172    172   
                output: &mut ::std::string::String,
  173    173   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  174    174   
                use ::std::fmt::Write as _;
  175    175   
                ::std::write!(output, "/").expect("formatting should succeed");
  176    176   
                ::std::result::Result::Ok(())
  177    177   
            }
  178    178   
            #[allow(clippy::unnecessary_wraps)]
  179    179   
            fn update_http_builder(
  180    180   
                input: &crate::operation::describe_limits::DescribeLimitsInput,
  181         -
                builder: ::http::request::Builder,
  182         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         181  +
                builder: ::http_1x::request::Builder,
         182  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  183    183   
                let mut uri = ::std::string::String::new();
  184    184   
                uri_base(input, &mut uri)?;
  185    185   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  186    186   
            }
  187         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  188         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.0");
         187  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         188  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
  189    189   
            builder = _header_serialization_settings.set_default_header(
  190    190   
                builder,
  191         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         191  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  192    192   
                "DynamoDB_20120810.DescribeLimits",
  193    193   
            );
  194    194   
            builder
  195    195   
        };
  196    196   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_describe_limits::ser_describe_limits_input(&input)?);
  197    197   
  198    198   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  199    199   
    }
  200    200   
}
  201    201   
#[derive(Debug)]

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/describe_table.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/describe_table_replica_auto_scaling.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/describe_time_to_live.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/disable_kinesis_streaming_destination.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/enable_kinesis_streaming_destination.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/operation/execute_statement.rs

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