AWS SDK

rev. a7fb2e3446d314cfbe48069306e4e0a389b39aeb

Files changed:

tmp-codegen-diff/aws-sdk/sdk/s3control/src/protocol_serde/shape_update_storage_lens_group.rs

@@ -12,12 +67,69 @@

     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::update_storage_lens_group::UpdateStorageLensGroupError::unhandled)?;
     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     Err(crate::operation::update_storage_lens_group::UpdateStorageLensGroupError::generic(generic))
-17
+}
-18
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_update_storage_lens_group_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::update_storage_lens_group::UpdateStorageLensGroupOutput,
     crate::operation::update_storage_lens_group::UpdateStorageLensGroupError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::update_storage_lens_group::builders::UpdateStorageLensGroupOutputBuilder::default();
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));

         output.build()
     })
-34
+}
-35
 pub fn ser_update_storage_lens_group_headers(
     input: &crate::operation::update_storage_lens_group::UpdateStorageLensGroupInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.account_id {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "account_id",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-account-id", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "account_id",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-account-id", header_value);
-+
+        }
-52
+    }
     Ok(builder)
-54
+}
-55
 pub fn ser_update_storage_lens_group_op_input(
     input: &crate::operation::update_storage_lens_group::UpdateStorageLensGroupInput,
 ) -> Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
     let mut out = String::new();
-60
+    {
         let mut writer = ::aws_smithy_xml::encode::XmlWriter::new(&mut out);

↧ Expand context

         #[allow(unused_mut)]
         let mut root = writer
             .start_el("UpdateStorageLensGroupRequest")
             .write_ns("http://awss3control.amazonaws.com/doc/2018-08-20/", None);
         crate::protocol_serde::shape_update_storage_lens_group_input::ser_update_storage_lens_group_input_input_input(input, root)?
-67
+    }
     Ok(::aws_smithy_types::body::SdkBody::from(out))
-69
+}

tmp-codegen-diff/aws-sdk/sdk/sso/src/protocol_serde/shape_get_role_credentials.rs

@@ -82,82 +149,151 @@

↥ Expand context

         }),
         _ => crate::operation::get_role_credentials::GetRoleCredentialsError::generic(generic),
     })
-85
+}
-86
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_get_role_credentials_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::get_role_credentials::GetRoleCredentialsOutput,
     crate::operation::get_role_credentials::GetRoleCredentialsError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::get_role_credentials::builders::GetRoleCredentialsOutputBuilder::default();
         output = crate::protocol_serde::shape_get_role_credentials::de_get_role_credentials(_response_body, output)
             .map_err(crate::operation::get_role_credentials::GetRoleCredentialsError::unhandled)?;
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));

         output.build()
     })
-104
+}
-105
 pub fn ser_get_role_credentials_headers(
     input: &crate::operation::get_role_credentials::GetRoleCredentialsInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.access_token {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "access_token",
                 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
--
+            )
         })?;
         builder = builder.header("x-amz-sso_bearer_token", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "access_token",
                     format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
-+
+                )
             })?;
             builder = builder.header("x-amz-sso_bearer_token", header_value);
-+
+        }
-122
+    }
     Ok(builder)
-124
+}
-125
 pub(crate) fn de_get_role_credentials(
     value: &[u8],
     mut builder: crate::operation::get_role_credentials::builders::GetRoleCredentialsOutputBuilder,
 ) -> Result<crate::operation::get_role_credentials::builders::GetRoleCredentialsOutputBuilder, ::aws_smithy_json::deserialize::error::DeserializeError>
-130
+{
     let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(value)).peekable();

↧ Expand context

     let tokens = &mut tokens_owned;
     ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
     loop {
         match tokens.next().transpose()? {
             Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
             Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
                 "roleCredentials" => {
                     builder = builder.set_role_credentials(crate::protocol_serde::shape_role_credentials::de_role_credentials(tokens)?);
-140
+                }
                 _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
             },
             other => {
                 return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                     "expected object key or end object, found: {:?}",
                     other
                 )))
-148
+            }
-149
+        }
-150
+    }
     if tokens.next().is_some() {

tmp-codegen-diff/aws-sdk/sdk/sso/src/protocol_serde/shape_list_account_roles.rs

@@ -76,76 +143,145 @@

↥ Expand context

                 tmp.message = _error_message;
-77
+            }
             tmp
         }),
         _ => crate::operation::list_account_roles::ListAccountRolesError::generic(generic),
     })
-82
+}
-83
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_list_account_roles_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::list_account_roles::ListAccountRolesOutput, crate::operation::list_account_roles::ListAccountRolesError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::list_account_roles::builders::ListAccountRolesOutputBuilder::default();
         output = crate::protocol_serde::shape_list_account_roles::de_list_account_roles(_response_body, output)
             .map_err(crate::operation::list_account_roles::ListAccountRolesError::unhandled)?;
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));

         output.build()
     })
-98
+}
-99
 pub fn ser_list_account_roles_headers(
     input: &crate::operation::list_account_roles::ListAccountRolesInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.access_token {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "access_token",
                 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
--
+            )
         })?;
         builder = builder.header("x-amz-sso_bearer_token", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "access_token",
                     format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
-+
+                )
             })?;
             builder = builder.header("x-amz-sso_bearer_token", header_value);
-+
+        }
-116
+    }
     Ok(builder)
-118
+}
-119
 pub(crate) fn de_list_account_roles(
     value: &[u8],
     mut builder: crate::operation::list_account_roles::builders::ListAccountRolesOutputBuilder,
 ) -> Result<crate::operation::list_account_roles::builders::ListAccountRolesOutputBuilder, ::aws_smithy_json::deserialize::error::DeserializeError> {
     let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(value)).peekable();
     let tokens = &mut tokens_owned;

↧ Expand context

     ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
     loop {
         match tokens.next().transpose()? {
             Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
             Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
                 "nextToken" => {
                     builder = builder.set_next_token(
                         ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                             .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                             .transpose()?,
                     );
-137
+                }
                 "roleList" => {
                     builder = builder.set_role_list(crate::protocol_serde::shape_role_list_type::de_role_list_type(tokens)?);
-140
+                }
                 _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
             },
             other => {
                 return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                     "expected object key or end object, found: {:?}",

tmp-codegen-diff/aws-sdk/sdk/sso/src/protocol_serde/shape_list_accounts.rs

@@ -76,76 +143,145 @@

↥ Expand context

                 tmp.message = _error_message;
-77
+            }
             tmp
         }),
         _ => crate::operation::list_accounts::ListAccountsError::generic(generic),
     })
-82
+}
-83
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_list_accounts_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::list_accounts::ListAccountsOutput, crate::operation::list_accounts::ListAccountsError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::list_accounts::builders::ListAccountsOutputBuilder::default();
         output = crate::protocol_serde::shape_list_accounts::de_list_accounts(_response_body, output)
             .map_err(crate::operation::list_accounts::ListAccountsError::unhandled)?;
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));

         output.build()
     })
-98
+}
-99
 pub fn ser_list_accounts_headers(
     input: &crate::operation::list_accounts::ListAccountsInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.access_token {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "access_token",
                 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
--
+            )
         })?;
         builder = builder.header("x-amz-sso_bearer_token", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "access_token",
                     format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
-+
+                )
             })?;
             builder = builder.header("x-amz-sso_bearer_token", header_value);
-+
+        }
-116
+    }
     Ok(builder)
-118
+}
-119
 pub(crate) fn de_list_accounts(
     value: &[u8],
     mut builder: crate::operation::list_accounts::builders::ListAccountsOutputBuilder,
 ) -> Result<crate::operation::list_accounts::builders::ListAccountsOutputBuilder, ::aws_smithy_json::deserialize::error::DeserializeError> {
     let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(value)).peekable();
     let tokens = &mut tokens_owned;

↧ Expand context

     ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
     loop {
         match tokens.next().transpose()? {
             Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
             Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
                 "accountList" => {
                     builder = builder.set_account_list(crate::protocol_serde::shape_account_list_type::de_account_list_type(tokens)?);
-133
+                }
                 "nextToken" => {
                     builder = builder.set_next_token(
                         ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                             .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                             .transpose()?,
                     );
-140
+                }
                 _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
             },
             other => {
                 return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                     "expected object key or end object, found: {:?}",

tmp-codegen-diff/aws-sdk/sdk/sso/src/protocol_serde/shape_logout.rs

@@ -59,59 +99,101 @@

↥ Expand context

             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
-62
+            }
             tmp
         }),
         _ => crate::operation::logout::LogoutError::generic(generic),
     })
-67
+}
-68
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_logout_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::logout::LogoutOutput, crate::operation::logout::LogoutError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::logout::builders::LogoutOutputBuilder::default();
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));

         output.build()
     })
-81
+}
-82
 pub fn ser_logout_headers(
     input: &crate::operation::logout::LogoutInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.access_token {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "access_token",
                 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
--
+            )
         })?;
         builder = builder.header("x-amz-sso_bearer_token", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "access_token",
                     format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
-+
+                )
             })?;
             builder = builder.header("x-amz-sso_bearer_token", header_value);
-+
+        }
-99
+    }
     Ok(builder)
-101
+}

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

@@ -48,48 +108,108 @@

↥ Expand context

 path = "../aws-smithy-types"
 version = "1.2.8"
-50
 [dependencies.aws-types]
 path = "../aws-types"
 version = "1.3.3"
-54
 [dependencies.bytes]
 version = "1.4.0"
-57
 [dependencies.fastrand]
 version = "2.0.0"
-60
 [dependencies.http]
 version = "0.2.9"
-63
 [dependencies.once_cell]
 version = "1.16"
-66
 [dependencies.regex-lite]

 version = "0.1.5"
-69
 [dependencies.tokio]
 version = "1.23.1"
 features = ["sync"]
-73
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.aws-config]
 path = "../aws-config"
 version = "1.5.9"
 version = "1.5.8"
-79
 [dev-dependencies.aws-credential-types]
 path = "../aws-credential-types"
 features = ["test-util"]
 version = "1.2.1"
-84
 [dev-dependencies.aws-runtime]
 path = "../aws-runtime"
 features = ["test-util"]
 version = "1.4.3"

↧ Expand context

-89
 [dev-dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 features = ["test-util"]
 version = "1.2.1"
-94
 [dev-dependencies.aws-smithy-protocol-test]
 path = "../aws-smithy-protocol-test"
 version = "0.63.0"
-98
 [dev-dependencies.aws-smithy-runtime]
 path = "../aws-smithy-runtime"
 features = ["test-util", "wire-mock"]
 version = "1.7.3"
-103
 [dev-dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["test-util"]
 version = "1.7.2"
-108

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

@@ -48,48 +99,99 @@

↥ Expand context

 path = "../aws-smithy-types"
 version = "1.2.8"
-50
 [dependencies.aws-types]
 path = "../aws-types"
 version = "1.3.3"
-54
 [dependencies.bytes]
 version = "1.4.0"
-57
 [dependencies.fastrand]
 version = "2.0.0"
-60
 [dependencies.http]
 version = "0.2.9"
-63
 [dependencies.once_cell]
 version = "1.16"
-66
 [dependencies.regex-lite]

 version = "0.1.5"
-69
 [dependencies.tokio]
 version = "1.23.1"
 features = ["sync"]
-73
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.aws-config]
 path = "../aws-config"
 version = "1.5.9"
 version = "1.5.8"
-79
 [dev-dependencies.aws-credential-types]
 path = "../aws-credential-types"
 features = ["test-util"]
 version = "1.2.1"
-84
 [dev-dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 features = ["test-util"]
 version = "1.2.1"

↧ Expand context

-89
 [dev-dependencies.tokio]
 version = "1.23.1"
 features = ["macros", "test-util", "rt-multi-thread"]
-93
 [features]
 behavior-version-latest = []
 rustls = ["aws-smithy-runtime/tls-rustls"]
 rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/rt-tokio"]
 test-util = ["aws-credential-types/test-util", "aws-smithy-runtime/test-util"]
 default = ["rustls", "rt-tokio"]

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

@@ -1,1 +119,119 @@

↥ Expand context

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "aws-sdk-transcribestreaming"
 version = "0.0.0-local"
 authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>", "Russell Cohen <rcoh@amazon.com>"]
 description = "AWS SDK for Amazon Transcribe Streaming Service"
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/awslabs/aws-sdk-rust"
 rust-version = "1.78.0"
 readme = "README.md"
 [package.metadata.smithy]
 codegen-version = "ci"
 [package.metadata.docs.rs]
 all-features = true
 targets = ["x86_64-unknown-linux-gnu"]
 [dependencies.aws-credential-types]

 path = "../aws-credential-types"
 version = "1.2.1"
-20
 [dependencies.aws-runtime]
 path = "../aws-runtime"
 features = ["event-stream"]
 version = "1.4.3"
-25
 [dependencies.aws-sigv4]
 path = "../aws-sigv4"
 version = "1.2.5"
 version = "1.2.4"
-29
 [dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 version = "1.2.1"
-33
 [dependencies.aws-smithy-eventstream]
 path = "../aws-smithy-eventstream"
 version = "0.60.5"
-37
 [dependencies.aws-smithy-http]
 path = "../aws-smithy-http"
 features = ["event-stream"]
 version = "0.60.11"
-42
 [dependencies.aws-smithy-json]
 path = "../aws-smithy-json"
 version = "0.60.7"
-46
 [dependencies.aws-smithy-runtime]
 path = "../aws-smithy-runtime"
 features = ["client"]
 version = "1.7.3"
-51
 [dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["client", "http-02x"]
 version = "1.7.2"
-56
 [dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 features = ["http-body-0-4-x"]
 version = "1.2.8"
-61
 [dependencies.aws-types]
 path = "../aws-types"
 version = "1.3.3"
-65
 [dependencies.bytes]
 version = "1.4.0"
-68
 [dependencies.http]
 version = "0.2.9"
-71
 [dependencies.hyper]
 version = "0.14.26"
 features = ["stream"]
-75
 [dependencies.once_cell]
 version = "1.16"
-78
 [dependencies.regex-lite]
 version = "0.1.5"
-81
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.async-stream]
 version = "0.3.0"
-86
 [dev-dependencies.aws-config]
 path = "../aws-config"
 version = "1.5.9"
 version = "1.5.8"
-90
 [dev-dependencies.aws-credential-types]
 path = "../aws-credential-types"
 features = ["test-util"]
 version = "1.2.1"
-95
 [dev-dependencies.aws-runtime]
 path = "../aws-runtime"
 features = ["test-util"]
 version = "1.4.3"

↧ Expand context

-100
 [dev-dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 features = ["test-util"]
 version = "1.2.1"
-105
 [dev-dependencies.aws-smithy-protocol-test]
 path = "../aws-smithy-protocol-test"
 version = "0.63.0"
-109
 [dev-dependencies.aws-smithy-runtime]
 path = "../aws-smithy-runtime"
 features = ["test-util", "wire-mock"]
 version = "1.7.3"
-114
 [dev-dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["test-util"]
 version = "1.7.2"
-119

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/src/protocol_serde/shape_start_call_analytics_stream_transcription.rs

@@ -245,245 +419,445 @@

↥ Expand context

-245
+        }
         "LimitExceededException" => {
             crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::LimitExceededException({
                 #[allow(unused_mut)]
                 let mut tmp = {
                     #[allow(unused_mut)]
                     let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
                     output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
                         .map_err(
                             crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::unhandled,
                         )?;
                     let output = output.meta(generic);
                     output.build()
                 };
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
-261
+                }
                 tmp
             })
-264
+        }

         _ => crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::generic(generic),
     })
-267
+}
-268
 pub fn ser_start_call_analytics_stream_transcription_headers(
     input: &crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.language_code {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "language_code",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-language-code", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "language_code",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-language-code", header_value);
-+
+        }
-285
+    }
     if let ::std::option::Option::Some(inner_3) = &input.media_sample_rate_hertz {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_3);
         let formatted_4 = encoder.encode();
         let header_value = formatted_4;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "media_sample_rate_hertz",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-sample-rate", header_value);
         if !formatted_4.is_empty() {
             let header_value = formatted_4;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "media_sample_rate_hertz",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-sample-rate", header_value);
-+
+        }
-299
+    }
     if let ::std::option::Option::Some(inner_5) = &input.media_encoding {
         let formatted_6 = inner_5.as_str();
         let header_value = formatted_6;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "media_encoding",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-media-encoding", header_value);
         if !formatted_6.is_empty() {
             let header_value = formatted_6;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "media_encoding",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-media-encoding", header_value);
-+
+        }
-312
+    }
     if let ::std::option::Option::Some(inner_7) = &input.vocabulary_name {
         let formatted_8 = inner_7.as_str();
         let header_value = formatted_8;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "vocabulary_name",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-vocabulary-name", header_value);
         if !formatted_8.is_empty() {
             let header_value = formatted_8;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "vocabulary_name",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-vocabulary-name", header_value);
-+
+        }
-325
+    }
     if let ::std::option::Option::Some(inner_9) = &input.session_id {
         let formatted_10 = inner_9.as_str();
         let header_value = formatted_10;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "session_id",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-session-id", header_value);
         if !formatted_10.is_empty() {
             let header_value = formatted_10;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "session_id",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-session-id", header_value);
-+
+        }
-338
+    }
     if let ::std::option::Option::Some(inner_11) = &input.vocabulary_filter_name {
         let formatted_12 = inner_11.as_str();
         let header_value = formatted_12;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "vocabulary_filter_name",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-vocabulary-filter-name", header_value);
         if !formatted_12.is_empty() {
             let header_value = formatted_12;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "vocabulary_filter_name",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-vocabulary-filter-name", header_value);
-+
+        }
-351
+    }
     if let ::std::option::Option::Some(inner_13) = &input.vocabulary_filter_method {
         let formatted_14 = inner_13.as_str();
         let header_value = formatted_14;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "vocabulary_filter_method",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-vocabulary-filter-method", header_value);
         if !formatted_14.is_empty() {
             let header_value = formatted_14;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "vocabulary_filter_method",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-vocabulary-filter-method", header_value);
-+
+        }
-364
+    }
     if let ::std::option::Option::Some(inner_15) = &input.language_model_name {
         let formatted_16 = inner_15.as_str();
         let header_value = formatted_16;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "language_model_name",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-language-model-name", header_value);
         if !formatted_16.is_empty() {
             let header_value = formatted_16;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "language_model_name",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-language-model-name", header_value);
-+
+        }
-377
+    }
     if let ::std::option::Option::Some(inner_17) = &input.enable_partial_results_stabilization {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_17);
         let formatted_18 = encoder.encode();
         let header_value = formatted_18;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "enable_partial_results_stabilization",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-enable-partial-results-stabilization", header_value);
         if !formatted_18.is_empty() {
             let header_value = formatted_18;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "enable_partial_results_stabilization",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-enable-partial-results-stabilization", header_value);
-+
+        }
-391
+    }
     if let ::std::option::Option::Some(inner_19) = &input.partial_results_stability {
         let formatted_20 = inner_19.as_str();
         let header_value = formatted_20;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "partial_results_stability",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-partial-results-stability", header_value);
         if !formatted_20.is_empty() {
             let header_value = formatted_20;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "partial_results_stability",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-partial-results-stability", header_value);
-+
+        }
-404
+    }
     if let ::std::option::Option::Some(inner_21) = &input.content_identification_type {
         let formatted_22 = inner_21.as_str();
         let header_value = formatted_22;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_identification_type",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-content-identification-type", header_value);
         if !formatted_22.is_empty() {
             let header_value = formatted_22;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "content_identification_type",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-content-identification-type", header_value);
-+
+        }
-417
+    }
     if let ::std::option::Option::Some(inner_23) = &input.content_redaction_type {
         let formatted_24 = inner_23.as_str();
         let header_value = formatted_24;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_redaction_type",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-content-redaction-type", header_value);
         if !formatted_24.is_empty() {
             let header_value = formatted_24;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "content_redaction_type",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-content-redaction-type", header_value);
-+
+        }
-430
+    }
     if let ::std::option::Option::Some(inner_25) = &input.pii_entity_types {
         let formatted_26 = inner_25.as_str();
         let header_value = formatted_26;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "pii_entity_types",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-pii-entity-types", header_value);
         if !formatted_26.is_empty() {
             let header_value = formatted_26;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "pii_entity_types",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-pii-entity-types", header_value);
-+
+        }
-443
+    }
     Ok(builder)
-445
+}

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/src/protocol_serde/shape_start_medical_stream_transcription.rs

@@ -203,203 +357,379 @@

↥ Expand context

-203
+            }
             tmp
         }),
         "LimitExceededException" => {
             crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionError::LimitExceededException({
                 #[allow(unused_mut)]
                 let mut tmp = {
                     #[allow(unused_mut)]
                     let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
                     output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
                         .map_err(crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionError::unhandled)?;
                     let output = output.meta(generic);
                     output.build()
                 };
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
-219
+                }
                 tmp
             })
-222
+        }

         _ => crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionError::generic(generic),
     })
-225
+}
-226
 pub fn ser_start_medical_stream_transcription_headers(
     input: &crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.language_code {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "language_code",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-language-code", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "language_code",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-language-code", header_value);
-+
+        }
-243
+    }
     if let ::std::option::Option::Some(inner_3) = &input.media_sample_rate_hertz {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_3);
         let formatted_4 = encoder.encode();
         let header_value = formatted_4;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "media_sample_rate_hertz",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-sample-rate", header_value);
         if !formatted_4.is_empty() {
             let header_value = formatted_4;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "media_sample_rate_hertz",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-sample-rate", header_value);
-+
+        }
-257
+    }
     if let ::std::option::Option::Some(inner_5) = &input.media_encoding {
         let formatted_6 = inner_5.as_str();
         let header_value = formatted_6;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "media_encoding",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-media-encoding", header_value);
         if !formatted_6.is_empty() {
             let header_value = formatted_6;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "media_encoding",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-media-encoding", header_value);
-+
+        }
-270
+    }
     if let ::std::option::Option::Some(inner_7) = &input.vocabulary_name {
         let formatted_8 = inner_7.as_str();
         let header_value = formatted_8;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "vocabulary_name",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-vocabulary-name", header_value);
         if !formatted_8.is_empty() {
             let header_value = formatted_8;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "vocabulary_name",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-vocabulary-name", header_value);
-+
+        }
-283
+    }
     if let ::std::option::Option::Some(inner_9) = &input.specialty {
         let formatted_10 = inner_9.as_str();
         let header_value = formatted_10;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "specialty",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-specialty", header_value);
         if !formatted_10.is_empty() {
             let header_value = formatted_10;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "specialty",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-specialty", header_value);
-+
+        }
-296
+    }
     if let ::std::option::Option::Some(inner_11) = &input.r#type {
         let formatted_12 = inner_11.as_str();
         let header_value = formatted_12;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "r#type",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-type", header_value);
         if !formatted_12.is_empty() {
             let header_value = formatted_12;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "r#type",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-type", header_value);
-+
+        }
-309
+    }
     if let ::std::option::Option::Some(inner_13) = &input.show_speaker_label {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_13);
         let formatted_14 = encoder.encode();
         let header_value = formatted_14;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "show_speaker_label",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-show-speaker-label", header_value);
         if !formatted_14.is_empty() {
             let header_value = formatted_14;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "show_speaker_label",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-show-speaker-label", header_value);
-+
+        }
-323
+    }
     if let ::std::option::Option::Some(inner_15) = &input.session_id {
         let formatted_16 = inner_15.as_str();
         let header_value = formatted_16;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "session_id",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-session-id", header_value);
         if !formatted_16.is_empty() {
             let header_value = formatted_16;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "session_id",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-session-id", header_value);
-+
+        }
-336
+    }
     if let ::std::option::Option::Some(inner_17) = &input.enable_channel_identification {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_17);
         let formatted_18 = encoder.encode();
         let header_value = formatted_18;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "enable_channel_identification",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-enable-channel-identification", header_value);
         if !formatted_18.is_empty() {
             let header_value = formatted_18;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "enable_channel_identification",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-enable-channel-identification", header_value);
-+
+        }
-350
+    }
     if let ::std::option::Option::Some(inner_19) = &input.number_of_channels {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_19);
         let formatted_20 = encoder.encode();
         let header_value = formatted_20;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "number_of_channels",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-number-of-channels", header_value);
         if !formatted_20.is_empty() {
             let header_value = formatted_20;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "number_of_channels",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-number-of-channels", header_value);
-+
+        }
-364
+    }
     if let ::std::option::Option::Some(inner_21) = &input.content_identification_type {
         let formatted_22 = inner_21.as_str();
         let header_value = formatted_22;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_identification_type",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-content-identification-type", header_value);
         if !formatted_22.is_empty() {
             let header_value = formatted_22;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "content_identification_type",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-content-identification-type", header_value);
-+
+        }
-377
+    }
     Ok(builder)
-379
+}

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/src/protocol_serde/shape_start_stream_transcription.rs

@@ -277,277 +555,599 @@

↥ Expand context

             if tmp.message.is_none() {
                 tmp.message = _error_message;
-279
+            }
             tmp
         }),
         "LimitExceededException" => crate::operation::start_stream_transcription::StartStreamTranscriptionError::LimitExceededException({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
                 output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
                     .map_err(crate::operation::start_stream_transcription::StartStreamTranscriptionError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
-294
+            }
             tmp
         }),

         _ => crate::operation::start_stream_transcription::StartStreamTranscriptionError::generic(generic),
     })
-299
+}
-300
 pub fn ser_start_stream_transcription_headers(
     input: &crate::operation::start_stream_transcription::StartStreamTranscriptionInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.language_code {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "language_code",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-language-code", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "language_code",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-language-code", header_value);
-+
+        }
-317
+    }
     if let ::std::option::Option::Some(inner_3) = &input.media_sample_rate_hertz {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_3);
         let formatted_4 = encoder.encode();
         let header_value = formatted_4;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "media_sample_rate_hertz",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-sample-rate", header_value);
         if !formatted_4.is_empty() {
             let header_value = formatted_4;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "media_sample_rate_hertz",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-sample-rate", header_value);
-+
+        }
-331
+    }
     if let ::std::option::Option::Some(inner_5) = &input.media_encoding {
         let formatted_6 = inner_5.as_str();
         let header_value = formatted_6;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "media_encoding",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-media-encoding", header_value);
         if !formatted_6.is_empty() {
             let header_value = formatted_6;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "media_encoding",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-media-encoding", header_value);
-+
+        }
-344
+    }
     if let ::std::option::Option::Some(inner_7) = &input.vocabulary_name {
         let formatted_8 = inner_7.as_str();
         let header_value = formatted_8;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "vocabulary_name",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-vocabulary-name", header_value);
         if !formatted_8.is_empty() {
             let header_value = formatted_8;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "vocabulary_name",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-vocabulary-name", header_value);
-+
+        }
-357
+    }
     if let ::std::option::Option::Some(inner_9) = &input.session_id {
         let formatted_10 = inner_9.as_str();
         let header_value = formatted_10;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "session_id",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-session-id", header_value);
         if !formatted_10.is_empty() {
             let header_value = formatted_10;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "session_id",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-session-id", header_value);
-+
+        }
-370
+    }
     if let ::std::option::Option::Some(inner_11) = &input.vocabulary_filter_name {
         let formatted_12 = inner_11.as_str();
         let header_value = formatted_12;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "vocabulary_filter_name",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-vocabulary-filter-name", header_value);
         if !formatted_12.is_empty() {
             let header_value = formatted_12;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "vocabulary_filter_name",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-vocabulary-filter-name", header_value);
-+
+        }
-383
+    }
     if let ::std::option::Option::Some(inner_13) = &input.vocabulary_filter_method {
         let formatted_14 = inner_13.as_str();
         let header_value = formatted_14;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "vocabulary_filter_method",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-vocabulary-filter-method", header_value);
         if !formatted_14.is_empty() {
             let header_value = formatted_14;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "vocabulary_filter_method",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-vocabulary-filter-method", header_value);
-+
+        }
-396
+    }
     if let ::std::option::Option::Some(inner_15) = &input.show_speaker_label {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_15);
         let formatted_16 = encoder.encode();
         let header_value = formatted_16;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "show_speaker_label",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-show-speaker-label", header_value);
         if !formatted_16.is_empty() {
             let header_value = formatted_16;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "show_speaker_label",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-show-speaker-label", header_value);
-+
+        }
-410
+    }
     if let ::std::option::Option::Some(inner_17) = &input.enable_channel_identification {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_17);
         let formatted_18 = encoder.encode();
         let header_value = formatted_18;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "enable_channel_identification",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-enable-channel-identification", header_value);
         if !formatted_18.is_empty() {
             let header_value = formatted_18;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "enable_channel_identification",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-enable-channel-identification", header_value);
-+
+        }
-424
+    }
     if let ::std::option::Option::Some(inner_19) = &input.number_of_channels {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_19);
         let formatted_20 = encoder.encode();
         let header_value = formatted_20;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "number_of_channels",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-number-of-channels", header_value);
         if !formatted_20.is_empty() {
             let header_value = formatted_20;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "number_of_channels",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-number-of-channels", header_value);
-+
+        }
-438
+    }
     if let ::std::option::Option::Some(inner_21) = &input.enable_partial_results_stabilization {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_21);
         let formatted_22 = encoder.encode();
         let header_value = formatted_22;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "enable_partial_results_stabilization",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-enable-partial-results-stabilization", header_value);
         if !formatted_22.is_empty() {
             let header_value = formatted_22;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "enable_partial_results_stabilization",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-enable-partial-results-stabilization", header_value);
-+
+        }
-452
+    }
     if let ::std::option::Option::Some(inner_23) = &input.partial_results_stability {
         let formatted_24 = inner_23.as_str();
         let header_value = formatted_24;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "partial_results_stability",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-partial-results-stability", header_value);
         if !formatted_24.is_empty() {
             let header_value = formatted_24;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "partial_results_stability",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-partial-results-stability", header_value);
-+
+        }
-465
+    }
     if let ::std::option::Option::Some(inner_25) = &input.content_identification_type {
         let formatted_26 = inner_25.as_str();
         let header_value = formatted_26;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_identification_type",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-content-identification-type", header_value);
         if !formatted_26.is_empty() {
             let header_value = formatted_26;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "content_identification_type",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-content-identification-type", header_value);
-+
+        }
-478
+    }
     if let ::std::option::Option::Some(inner_27) = &input.content_redaction_type {
         let formatted_28 = inner_27.as_str();
         let header_value = formatted_28;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_redaction_type",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-content-redaction-type", header_value);
         if !formatted_28.is_empty() {
             let header_value = formatted_28;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "content_redaction_type",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-content-redaction-type", header_value);
-+
+        }
-491
+    }
     if let ::std::option::Option::Some(inner_29) = &input.pii_entity_types {
         let formatted_30 = inner_29.as_str();
         let header_value = formatted_30;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "pii_entity_types",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-pii-entity-types", header_value);
         if !formatted_30.is_empty() {
             let header_value = formatted_30;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "pii_entity_types",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-pii-entity-types", header_value);
-+
+        }
-504
+    }
     if let ::std::option::Option::Some(inner_31) = &input.language_model_name {
         let formatted_32 = inner_31.as_str();
         let header_value = formatted_32;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "language_model_name",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-language-model-name", header_value);
         if !formatted_32.is_empty() {
             let header_value = formatted_32;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "language_model_name",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-language-model-name", header_value);
-+
+        }
-517
+    }
     if let ::std::option::Option::Some(inner_33) = &input.identify_language {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_33);
         let formatted_34 = encoder.encode();
         let header_value = formatted_34;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "identify_language",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-identify-language", header_value);
         if !formatted_34.is_empty() {
             let header_value = formatted_34;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "identify_language",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-identify-language", header_value);
-+
+        }
-531
+    }
     if let ::std::option::Option::Some(inner_35) = &input.language_options {
         let formatted_36 = inner_35.as_str();
         let header_value = formatted_36;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "language_options",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-language-options", header_value);
         if !formatted_36.is_empty() {
             let header_value = formatted_36;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "language_options",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-language-options", header_value);
-+
+        }
-544
+    }
     if let ::std::option::Option::Some(inner_37) = &input.preferred_language {
         let formatted_38 = inner_37.as_str();
         let header_value = formatted_38;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "preferred_language",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-preferred-language", header_value);
         if !formatted_38.is_empty() {
             let header_value = formatted_38;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "preferred_language",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-preferred-language", header_value);
-+
+        }
-557
+    }
     if let ::std::option::Option::Some(inner_39) = &input.identify_multiple_languages {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_39);
         let formatted_40 = encoder.encode();
         let header_value = formatted_40;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "identify_multiple_languages",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-identify-multiple-languages", header_value);
         if !formatted_40.is_empty() {
             let header_value = formatted_40;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "identify_multiple_languages",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-identify-multiple-languages", header_value);
-+
+        }
-571
+    }
     if let ::std::option::Option::Some(inner_41) = &input.vocabulary_names {
         let formatted_42 = inner_41.as_str();
         let header_value = formatted_42;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "vocabulary_names",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-vocabulary-names", header_value);
         if !formatted_42.is_empty() {
             let header_value = formatted_42;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "vocabulary_names",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-vocabulary-names", header_value);
-+
+        }
-584
+    }
     if let ::std::option::Option::Some(inner_43) = &input.vocabulary_filter_names {
         let formatted_44 = inner_43.as_str();
         let header_value = formatted_44;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "vocabulary_filter_names",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-vocabulary-filter-names", header_value);
         if !formatted_44.is_empty() {
             let header_value = formatted_44;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "vocabulary_filter_names",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amzn-transcribe-vocabulary-filter-names", header_value);
-+
+        }
-597
+    }
     Ok(builder)
-599
+}

tmp-codegen-diff/aws-sdk/tests/no-default-features/Cargo.toml

@@ -1,1 +46,46 @@

↥ Expand context

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "no-default-features"
 version = "0.1.0"
 authors = ["Zelda Hessler <zhessler@amazon.com>"]
 description = "These tests ensure that things will fail (or not fail) as expected\nwhen default features are disabled for all SDK and runtime crates.\n"
 edition = "2021"
 license = "Apache-2.0"

 repository = "https://github.com/smithy-lang/smithy-rs"
 publish = false
-11
 [dev-dependencies]
 futures = "0.3.25"
 http = "0.2.9"
-15
 [dev-dependencies.aws-config]
 path = "../../sdk/aws-config"
 default-features = false
 version = "1.5.9"
 version = "1.5.8"
-20
 [dev-dependencies.aws-sdk-s3]
 path = "../../sdk/s3"
 default-features = false
 version = "0.0.0-local"
-25
 [dev-dependencies.aws-smithy-async]
 path = "../../sdk/aws-smithy-async"
 version = "1.2.1"
-29

↧ Expand context

 [dev-dependencies.aws-smithy-runtime]
 path = "../../sdk/aws-smithy-runtime"
 features = ["test-util"]
 version = "1.7.3"
-34
 [dev-dependencies.aws-credential-types]
 path = "../../sdk/aws-credential-types"
 features = ["test-util"]
 version = "1.2.1"
-39
 [dev-dependencies.tokio]
 version = "1.23.1"
 features = ["full", "test-util"]
-43
 [dev-dependencies.tracing-subscriber]
 version = "0.3.15"
 features = ["env-filter"]

Pages: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17