AWS SDK

AWS SDK

rev. d06a46cae0f385cdae37a9f8264db3469a090ab5 (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/operation/list_batch_load_tasks.rs

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

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/operation/list_databases.rs

@@ -165,165 +243,243 @@
  185    185   
                _input: &crate::operation::list_databases::ListDatabasesInput,
  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_databases::ListDatabasesInput,
  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   
                "Timestream_20181101.ListDatabases",
  207    207   
            );
  208    208   
            builder
  209    209   
        };
  210    210   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_list_databases::ser_list_databases_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 ListDatabasesEndpointParamsInterceptor;
  220    220   
  221    221   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListDatabasesEndpointParamsInterceptor {
  222    222   
    fn name(&self) -> &'static str {
  223    223   
        "ListDatabasesEndpointParamsInterceptor"

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

@@ -163,163 +241,241 @@
  183    183   
                _input: &crate::operation::list_tables::ListTablesInput,
  184    184   
                output: &mut ::std::string::String,
  185    185   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  186    186   
                use ::std::fmt::Write as _;
  187    187   
                ::std::write!(output, "/").expect("formatting should succeed");
  188    188   
                ::std::result::Result::Ok(())
  189    189   
            }
  190    190   
            #[allow(clippy::unnecessary_wraps)]
  191    191   
            fn update_http_builder(
  192    192   
                input: &crate::operation::list_tables::ListTablesInput,
  193         -
                builder: ::http::request::Builder,
  194         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         193  +
                builder: ::http_1x::request::Builder,
         194  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  195    195   
                let mut uri = ::std::string::String::new();
  196    196   
                uri_base(input, &mut uri)?;
  197    197   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  198    198   
            }
  199         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  200         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.0");
         199  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         200  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
  201    201   
            builder = _header_serialization_settings.set_default_header(
  202    202   
                builder,
  203         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         203  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  204    204   
                "Timestream_20181101.ListTables",
  205    205   
            );
  206    206   
            builder
  207    207   
        };
  208    208   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_list_tables::ser_list_tables_input(&input)?);
  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 ListTablesEndpointParamsInterceptor;
  218    218   
  219    219   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListTablesEndpointParamsInterceptor {
  220    220   
    fn name(&self) -> &'static str {
  221    221   
        "ListTablesEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/operation/list_tags_for_resource.rs

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

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/operation/resume_batch_load_task.rs

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

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/operation/tag_resource.rs

@@ -165,165 +243,243 @@
  185    185   
                _input: &crate::operation::tag_resource::TagResourceInput,
  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::tag_resource::TagResourceInput,
  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   
                "Timestream_20181101.TagResource",
  207    207   
            );
  208    208   
            builder
  209    209   
        };
  210    210   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_tag_resource::ser_tag_resource_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 TagResourceEndpointParamsInterceptor;
  220    220   
  221    221   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for TagResourceEndpointParamsInterceptor {
  222    222   
    fn name(&self) -> &'static str {
  223    223   
        "TagResourceEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/operation/untag_resource.rs

@@ -165,165 +243,243 @@
  185    185   
                _input: &crate::operation::untag_resource::UntagResourceInput,
  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::untag_resource::UntagResourceInput,
  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   
                "Timestream_20181101.UntagResource",
  207    207   
            );
  208    208   
            builder
  209    209   
        };
  210    210   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_untag_resource::ser_untag_resource_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 UntagResourceEndpointParamsInterceptor;
  220    220   
  221    221   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UntagResourceEndpointParamsInterceptor {
  222    222   
    fn name(&self) -> &'static str {
  223    223   
        "UntagResourceEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/operation/update_database.rs

@@ -165,165 +243,243 @@
  185    185   
                _input: &crate::operation::update_database::UpdateDatabaseInput,
  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::update_database::UpdateDatabaseInput,
  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   
                "Timestream_20181101.UpdateDatabase",
  207    207   
            );
  208    208   
            builder
  209    209   
        };
  210    210   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_update_database::ser_update_database_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 UpdateDatabaseEndpointParamsInterceptor;
  220    220   
  221    221   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateDatabaseEndpointParamsInterceptor {
  222    222   
    fn name(&self) -> &'static str {
  223    223   
        "UpdateDatabaseEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/operation/update_table.rs

@@ -165,165 +243,243 @@
  185    185   
                _input: &crate::operation::update_table::UpdateTableInput,
  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::update_table::UpdateTableInput,
  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   
                "Timestream_20181101.UpdateTable",
  207    207   
            );
  208    208   
            builder
  209    209   
        };
  210    210   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_update_table::ser_update_table_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 UpdateTableEndpointParamsInterceptor;
  220    220   
  221    221   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateTableEndpointParamsInterceptor {
  222    222   
    fn name(&self) -> &'static str {
  223    223   
        "UpdateTableEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/operation/write_records.rs

@@ -165,165 +243,243 @@
  185    185   
                _input: &crate::operation::write_records::WriteRecordsInput,
  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::write_records::WriteRecordsInput,
  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   
                "Timestream_20181101.WriteRecords",
  207    207   
            );
  208    208   
            builder
  209    209   
        };
  210    210   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_write_records::ser_write_records_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 WriteRecordsEndpointParamsInterceptor;
  220    220   
  221    221   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for WriteRecordsEndpointParamsInterceptor {
  222    222   
    fn name(&self) -> &'static str {
  223    223   
        "WriteRecordsEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/serialization_settings.rs

@@ -1,1 +78,83 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/*
    3      3   
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
    4      4   
 * SPDX-License-Identifier: Apache-2.0
    5      5   
 */
    6      6   
    7      7   
#![allow(dead_code)]
    8      8   
    9      9   
use aws_smithy_http::header::set_request_header_if_absent;
   10     10   
use aws_smithy_types::config_bag::{Storable, StoreReplace};
   11         -
use http::header::{HeaderName, CONTENT_LENGTH, CONTENT_TYPE};
          11  +
use http_1x::header::{HeaderName, CONTENT_LENGTH, CONTENT_TYPE};
   12     12   
   13     13   
/// Configuration for how default protocol headers are serialized
   14     14   
#[derive(Clone, Debug, Default)]
   15     15   
pub(crate) struct HeaderSerializationSettings {
   16     16   
    omit_default_content_length: bool,
   17     17   
    omit_default_content_type: bool,
   18     18   
}
   19     19   
   20     20   
impl HeaderSerializationSettings {
   21     21   
    /// Creates new [`HeaderSerializationSettings`]
   22     22   
    pub(crate) fn new() -> Self {
   23     23   
        Default::default()
   24     24   
    }
   25     25   
   26     26   
    /// Omit the default `Content-Length` header during serialization
   27     27   
    pub(crate) fn omit_default_content_length(self) -> Self {
   28     28   
        Self {
   29     29   
            omit_default_content_length: true,
   30     30   
            ..self
   31     31   
        }
   32     32   
    }
   33     33   
   34     34   
    /// Omit the default `Content-Type` header during serialization
   35     35   
    pub(crate) fn omit_default_content_type(self) -> Self {
   36     36   
        Self {
   37     37   
            omit_default_content_type: true,
   38     38   
            ..self
   39     39   
        }
   40     40   
    }
   41     41   
   42     42   
    /// Returns true if the given default header name should be serialized
   43     43   
    fn include_header(&self, header: &HeaderName) -> bool {
   44     44   
        (!self.omit_default_content_length || header != CONTENT_LENGTH) && (!self.omit_default_content_type || header != CONTENT_TYPE)
   45     45   
    }
   46     46   
   47     47   
    /// Sets a default header on the given request builder if it should be serialized
   48         -
    pub(crate) fn set_default_header(&self, mut request: http::request::Builder, header_name: HeaderName, value: &str) -> http::request::Builder {
          48  +
    pub(crate) fn set_default_header(
          49  +
        &self,
          50  +
        mut request: http_1x::request::Builder,
          51  +
        header_name: HeaderName,
          52  +
        value: &str,
          53  +
    ) -> http_1x::request::Builder {
   49     54   
        if self.include_header(&header_name) {
   50     55   
            request = set_request_header_if_absent(request, header_name, value);
   51     56   
        }
   52     57   
        request
   53     58   
    }
   54     59   
}
   55     60   
   56     61   
impl Storable for HeaderSerializationSettings {
   57     62   
    type Storer = StoreReplace<Self>;
   58     63   
}

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/Cargo.toml

@@ -1,1 +176,176 @@
   15     15   
[package.metadata.docs.rs]
   16     16   
all-features = true
   17     17   
targets = ["x86_64-unknown-linux-gnu"]
   18     18   
[dependencies.aws-credential-types]
   19     19   
path = "../aws-credential-types"
   20     20   
version = "1.2.11"
   21     21   
   22     22   
[dependencies.aws-runtime]
   23     23   
path = "../aws-runtime"
   24     24   
features = ["event-stream"]
   25         -
version = "1.5.18"
          25  +
version = "1.6.0"
   26     26   
   27     27   
[dependencies.aws-sigv4]
   28     28   
path = "../aws-sigv4"
   29         -
version = "1.3.7"
          29  +
version = "1.3.8"
   30     30   
   31     31   
[dependencies.aws-smithy-async]
   32     32   
path = "../aws-smithy-async"
   33         -
version = "1.2.7"
          33  +
version = "1.2.8"
   34     34   
   35     35   
[dependencies.aws-smithy-eventstream]
   36     36   
path = "../aws-smithy-eventstream"
   37         -
version = "0.60.14"
          37  +
version = "0.60.15"
   38     38   
   39     39   
[dependencies.aws-smithy-http]
   40     40   
path = "../aws-smithy-http"
   41     41   
features = ["event-stream"]
   42         -
version = "0.62.6"
          42  +
version = "0.63.0"
   43     43   
   44     44   
[dependencies.aws-smithy-json]
   45     45   
path = "../aws-smithy-json"
   46         -
version = "0.61.9"
          46  +
version = "0.62.0"
   47     47   
   48     48   
[dependencies.aws-smithy-observability]
   49     49   
path = "../aws-smithy-observability"
   50         -
version = "0.2.0"
          50  +
version = "0.2.1"
   51     51   
   52     52   
[dependencies.aws-smithy-runtime]
   53     53   
path = "../aws-smithy-runtime"
   54     54   
features = ["client"]
   55         -
version = "1.9.8"
          55  +
version = "1.10.0"
   56     56   
   57     57   
[dependencies.aws-smithy-runtime-api]
   58     58   
path = "../aws-smithy-runtime-api"
   59         -
features = ["client", "http-02x"]
   60         -
version = "1.10.0"
          59  +
features = ["client", "http-1x"]
          60  +
version = "1.11.0"
   61     61   
   62     62   
[dependencies.aws-smithy-types]
   63     63   
path = "../aws-smithy-types"
   64         -
features = ["http-body-0-4-x"]
   65         -
version = "1.3.6"
          64  +
features = ["http-body-1-x", "http-body-0-4-x"]
          65  +
version = "1.4.0"
   66     66   
   67     67   
[dependencies.aws-types]
   68     68   
path = "../aws-types"
   69     69   
version = "1.3.11"
   70     70   
   71     71   
[dependencies.bytes]
   72     72   
version = "1.4.0"
   73     73   
   74     74   
[dependencies.fastrand]
   75     75   
version = "2.0.0"
   76     76   
   77     77   
[dependencies.http]
   78     78   
version = "0.2.9"
   79     79   
          80  +
[dependencies.http-1x]
          81  +
version = "1"
          82  +
package = "http"
          83  +
   80     84   
[dependencies.hyper]
   81     85   
version = "0.14.26"
   82     86   
features = ["stream"]
   83     87   
   84     88   
[dependencies.regex-lite]
   85     89   
version = "0.1.5"
   86     90   
   87     91   
[dependencies.tracing]
   88     92   
version = "0.1"
   89     93   
[dev-dependencies.async-stream]
   90     94   
version = "0.3.0"
   91     95   
   92     96   
[dev-dependencies.aws-config]
   93     97   
path = "../aws-config"
   94     98   
version = "1.8.12"
   95     99   
   96    100   
[dev-dependencies.aws-credential-types]
   97    101   
path = "../aws-credential-types"
   98    102   
features = ["test-util"]
   99    103   
version = "1.2.11"
  100    104   
  101    105   
[dev-dependencies.aws-runtime]
  102    106   
path = "../aws-runtime"
  103    107   
features = ["test-util"]
  104         -
version = "1.5.18"
         108  +
version = "1.6.0"
  105    109   
  106    110   
[dev-dependencies.aws-smithy-async]
  107    111   
path = "../aws-smithy-async"
  108    112   
features = ["test-util"]
  109         -
version = "1.2.7"
         113  +
version = "1.2.8"
  110    114   
  111    115   
[dev-dependencies.aws-smithy-eventstream]
  112    116   
path = "../aws-smithy-eventstream"
  113    117   
features = ["test-util"]
  114         -
version = "0.60.14"
         118  +
version = "0.60.15"
  115    119   
  116    120   
[dev-dependencies.aws-smithy-http-client]
  117    121   
path = "../aws-smithy-http-client"
  118    122   
features = ["test-util", "wire-mock"]
  119         -
version = "1.1.5"
         123  +
version = "1.1.6"
  120    124   
  121    125   
[dev-dependencies.aws-smithy-protocol-test]
  122    126   
path = "../aws-smithy-protocol-test"
  123         -
version = "0.63.7"
         127  +
version = "0.63.8"
  124    128   
  125    129   
[dev-dependencies.aws-smithy-runtime]
  126    130   
path = "../aws-smithy-runtime"
  127    131   
features = ["test-util"]
  128         -
version = "1.9.8"
         132  +
version = "1.10.0"
  129    133   
  130    134   
[dev-dependencies.aws-smithy-runtime-api]
  131    135   
path = "../aws-smithy-runtime-api"
  132    136   
features = ["test-util"]
  133         -
version = "1.10.0"
         137  +
version = "1.11.0"
  134    138   
  135    139   
[dev-dependencies.aws-smithy-types]
  136    140   
path = "../aws-smithy-types"
  137         -
features = ["test-util"]
  138         -
version = "1.3.6"
         141  +
features = ["http-body-1-x", "test-util"]
         142  +
version = "1.4.0"
  139    143   
  140    144   
[dev-dependencies.futures-core]
  141    145   
version = "0.3.25"
  142    146   
  143    147   
[dev-dependencies.futures-util]
  144    148   
version = "0.3.25"
  145    149   
features = ["alloc"]
  146    150   
default-features = false
  147    151   
  148    152   
[dev-dependencies.hound]
  149    153   
version = "3.4.0"
  150    154   
  151         -
[dev-dependencies.http-1x]
  152         -
version = "1"
  153         -
package = "http"
  154         -
  155    155   
[dev-dependencies.proptest]
  156    156   
version = "1"
  157    157   
  158    158   
[dev-dependencies.serde_json]
  159    159   
version = "1.0.0"
  160    160   
  161    161   
[dev-dependencies.tokio]
  162    162   
version = "1.23.1"
  163    163   
features = ["macros", "test-util", "rt-multi-thread"]
  164    164

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/src/json_errors.rs

@@ -1,1 +45,45 @@
    5      5   
 */
    6      6   
    7      7   
use aws_smithy_json::deserialize::token::skip_value;
    8      8   
use aws_smithy_json::deserialize::{error::DeserializeError, json_token_iter, Token};
    9      9   
use aws_smithy_runtime_api::http::Headers;
   10     10   
use aws_smithy_types::error::metadata::{Builder as ErrorMetadataBuilder, ErrorMetadata};
   11     11   
use std::borrow::Cow;
   12     12   
   13     13   
// currently only used by AwsJson
   14     14   
#[allow(unused)]
   15         -
pub fn is_error<B>(response: &http::Response<B>) -> bool {
          15  +
pub fn is_error<B>(response: &http_1x::Response<B>) -> bool {
   16     16   
    !response.status().is_success()
   17     17   
}
   18     18   
   19     19   
fn sanitize_error_code(error_code: &str) -> &str {
   20     20   
    // Trim a trailing URL from the error code, which is done by removing the longest suffix
   21     21   
    // beginning with a `:`
   22     22   
    let error_code = match error_code.find(':') {
   23     23   
        Some(idx) => &error_code[..idx],
   24     24   
        None => error_code,
   25     25   
    };
@@ -60,60 +120,120 @@
   80     80   
#[cfg(test)]
   81     81   
mod test {
   82     82   
    use crate::json_errors::{parse_error_body, parse_error_metadata, sanitize_error_code};
   83     83   
    use aws_smithy_runtime_api::client::orchestrator::HttpResponse;
   84     84   
    use aws_smithy_types::{body::SdkBody, error::ErrorMetadata};
   85     85   
    use std::borrow::Cow;
   86     86   
   87     87   
    #[test]
   88     88   
    fn error_metadata() {
   89     89   
        let response = HttpResponse::try_from(
   90         -
            http::Response::builder()
          90  +
            http_1x::Response::builder()
   91     91   
                .body(SdkBody::from(r#"{ "__type": "FooError", "message": "Go to foo" }"#))
   92     92   
                .unwrap(),
   93     93   
        )
   94     94   
        .unwrap();
   95     95   
        assert_eq!(
   96     96   
            parse_error_metadata(response.body().bytes().unwrap(), response.headers())
   97     97   
                .unwrap()
   98     98   
                .build(),
   99     99   
            ErrorMetadata::builder().code("FooError").message("Go to foo").build()
  100    100   
        )
@@ -129,129 +180,180 @@
  149    149   
  150    150   
    #[test]
  151    151   
    fn sanitize_namespace() {
  152    152   
        assert_eq!(sanitize_error_code("aws.protocoltests.restjson#FooError"), "FooError");
  153    153   
    }
  154    154   
  155    155   
    // services like lambda use an alternate `Message` instead of `message`
  156    156   
    #[test]
  157    157   
    fn alternative_error_message_names() {
  158    158   
        let response = HttpResponse::try_from(
  159         -
            http::Response::builder()
         159  +
            http_1x::Response::builder()
  160    160   
                .header("x-amzn-errortype", "ResourceNotFoundException")
  161    161   
                .body(SdkBody::from(
  162    162   
                    r#"{
  163    163   
                    "Type": "User",
  164    164   
                    "Message": "Functions from 'us-west-2' are not reachable from us-east-1"
  165    165   
                }"#,
  166    166   
                ))
  167    167   
                .unwrap(),
  168    168   
        )
  169    169   
        .unwrap();

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/src/operation/get_medical_scribe_stream.rs

@@ -182,182 +248,248 @@
  202    202   
                        "session_id",
  203    203   
                        "cannot be empty or unset",
  204    204   
                    ));
  205    205   
                }
  206    206   
                ::std::write!(output, "/medical-scribe-stream/{SessionId}", SessionId = session_id).expect("formatting should succeed");
  207    207   
                ::std::result::Result::Ok(())
  208    208   
            }
  209    209   
            #[allow(clippy::unnecessary_wraps)]
  210    210   
            fn update_http_builder(
  211    211   
                input: &crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamInput,
  212         -
                builder: ::http::request::Builder,
  213         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         212  +
                builder: ::http_1x::request::Builder,
         213  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  214    214   
                let mut uri = ::std::string::String::new();
  215    215   
                uri_base(input, &mut uri)?;
  216    216   
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  217    217   
            }
  218         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         218  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  219    219   
            builder
  220    220   
        };
  221    221   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  222    222   
  223    223   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  224    224   
    }
  225    225   
}
  226    226   
#[derive(Debug)]
  227    227   
struct GetMedicalScribeStreamEndpointParamsInterceptor;
  228    228

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/src/operation/start_call_analytics_stream_transcription.rs

@@ -186,186 +273,274 @@
  206    206   
                _input: &crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionInput,
  207    207   
                output: &mut ::std::string::String,
  208    208   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  209    209   
                use ::std::fmt::Write as _;
  210    210   
                ::std::write!(output, "/call-analytics-stream-transcription").expect("formatting should succeed");
  211    211   
                ::std::result::Result::Ok(())
  212    212   
            }
  213    213   
            #[allow(clippy::unnecessary_wraps)]
  214    214   
            fn update_http_builder(
  215    215   
                input: &crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionInput,
  216         -
                builder: ::http::request::Builder,
  217         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         216  +
                builder: ::http_1x::request::Builder,
         217  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  218    218   
                let mut uri = ::std::string::String::new();
  219    219   
                uri_base(input, &mut uri)?;
  220    220   
                let builder =
  221    221   
                    crate::protocol_serde::shape_start_call_analytics_stream_transcription::ser_start_call_analytics_stream_transcription_headers(
  222    222   
                        input, builder,
  223    223   
                    )?;
  224    224   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  225    225   
            }
  226         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  227         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/vnd.amazon.eventstream");
         226  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         227  +
            builder =
         228  +
                _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/vnd.amazon.eventstream");
  228    229   
            builder
  229    230   
        };
  230    231   
        let body = ::aws_smithy_types::body::SdkBody::from({
  231    232   
            let error_marshaller = crate::event_stream_serde::AudioStreamErrorMarshaller::new();
  232    233   
            let marshaller = crate::event_stream_serde::AudioStreamMarshaller::new();
  233    234   
            let (signer, signer_sender) = ::aws_smithy_eventstream::frame::DeferredSigner::new();
  234    235   
            _cfg.interceptor_state().store_put(signer_sender);
  235    236   
            ::aws_smithy_types::body::SdkBody::from_body_0_4(::hyper::Body::wrap_stream(input.audio_stream.into_body_stream(
  236    237   
                marshaller,
  237    238   
                error_marshaller,
  238    239   
                signer,
  239    240   
            )))
  240    241   
        });
  241    242   
        if let Some(content_length) = body.content_length() {
  242    243   
            let content_length = content_length.to_string();
  243         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         244  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  244    245   
        }
  245    246   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  246    247   
    }
  247    248   
}
  248    249   
#[derive(Debug)]
  249    250   
struct StartCallAnalyticsStreamTranscriptionEndpointParamsInterceptor;
  250    251   
  251    252   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StartCallAnalyticsStreamTranscriptionEndpointParamsInterceptor {
  252    253   
    fn name(&self) -> &'static str {
  253    254   
        "StartCallAnalyticsStreamTranscriptionEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/src/operation/start_medical_scribe_stream.rs

@@ -184,184 +268,269 @@
  204    204   
                _input: &crate::operation::start_medical_scribe_stream::StartMedicalScribeStreamInput,
  205    205   
                output: &mut ::std::string::String,
  206    206   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  207    207   
                use ::std::fmt::Write as _;
  208    208   
                ::std::write!(output, "/medical-scribe-stream").expect("formatting should succeed");
  209    209   
                ::std::result::Result::Ok(())
  210    210   
            }
  211    211   
            #[allow(clippy::unnecessary_wraps)]
  212    212   
            fn update_http_builder(
  213    213   
                input: &crate::operation::start_medical_scribe_stream::StartMedicalScribeStreamInput,
  214         -
                builder: ::http::request::Builder,
  215         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         214  +
                builder: ::http_1x::request::Builder,
         215  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  216    216   
                let mut uri = ::std::string::String::new();
  217    217   
                uri_base(input, &mut uri)?;
  218    218   
                let builder = crate::protocol_serde::shape_start_medical_scribe_stream::ser_start_medical_scribe_stream_headers(input, builder)?;
  219    219   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  220    220   
            }
  221         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  222         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/vnd.amazon.eventstream");
         221  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         222  +
            builder =
         223  +
                _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/vnd.amazon.eventstream");
  223    224   
            builder
  224    225   
        };
  225    226   
        let body = ::aws_smithy_types::body::SdkBody::from({
  226    227   
            let error_marshaller = crate::event_stream_serde::MedicalScribeInputStreamErrorMarshaller::new();
  227    228   
            let marshaller = crate::event_stream_serde::MedicalScribeInputStreamMarshaller::new();
  228    229   
            let (signer, signer_sender) = ::aws_smithy_eventstream::frame::DeferredSigner::new();
  229    230   
            _cfg.interceptor_state().store_put(signer_sender);
  230    231   
            ::aws_smithy_types::body::SdkBody::from_body_0_4(::hyper::Body::wrap_stream(input.input_stream.into_body_stream(
  231    232   
                marshaller,
  232    233   
                error_marshaller,
  233    234   
                signer,
  234    235   
            )))
  235    236   
        });
  236    237   
        if let Some(content_length) = body.content_length() {
  237    238   
            let content_length = content_length.to_string();
  238         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         239  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  239    240   
        }
  240    241   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  241    242   
    }
  242    243   
}
  243    244   
#[derive(Debug)]
  244    245   
struct StartMedicalScribeStreamEndpointParamsInterceptor;
  245    246   
  246    247   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StartMedicalScribeStreamEndpointParamsInterceptor {
  247    248   
    fn name(&self) -> &'static str {
  248    249   
        "StartMedicalScribeStreamEndpointParamsInterceptor"