AWS SDK

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

@@ -184,184 +269,270 @@

-184
+}
 #[derive(Debug)]
 struct StartMedicalStreamTranscriptionRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for StartMedicalStreamTranscriptionRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/medical-stream-transcription").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-210
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 let builder =
                     crate::protocol_serde::shape_start_medical_stream_transcription::ser_start_medical_stream_transcription_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-221
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/vnd.amazon.eventstream");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/vnd.amazon.eventstream");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from({
             let error_marshaller = crate::event_stream_serde::AudioStreamErrorMarshaller::new();
             let marshaller = crate::event_stream_serde::AudioStreamMarshaller::new();
             let (signer, signer_sender) = ::aws_smithy_eventstream::frame::DeferredSigner::new();
             _cfg.interceptor_state().store_put(signer_sender);
             ::aws_smithy_types::body::SdkBody::from_body_0_4(::hyper::Body::wrap_stream(input.audio_stream.into_body_stream(
                 marshaller,
                 error_marshaller,
                 signer,
             )))
         });
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-241
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-243
+    }
-244
+}
 #[derive(Debug)]
 struct StartMedicalStreamTranscriptionEndpointParamsInterceptor;
-247
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StartMedicalStreamTranscriptionEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "StartMedicalStreamTranscriptionEndpointParamsInterceptor"

↧ Expand context

-251
+    }
-252
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<StartMedicalStreamTranscriptionInput>()
             .ok_or("failed to downcast to StartMedicalStreamTranscriptionInput")?;
-267
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))

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

@@ -184,184 +268,269 @@

↥ Expand context

-184
+}
 #[derive(Debug)]
 struct StartStreamTranscriptionRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for StartStreamTranscriptionRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::start_stream_transcription::StartStreamTranscriptionInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::start_stream_transcription::StartStreamTranscriptionInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/stream-transcription").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-210
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::start_stream_transcription::StartStreamTranscriptionInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_start_stream_transcription::ser_start_stream_transcription_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-220
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/vnd.amazon.eventstream");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder =
                 _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/vnd.amazon.eventstream");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from({
             let error_marshaller = crate::event_stream_serde::AudioStreamErrorMarshaller::new();
             let marshaller = crate::event_stream_serde::AudioStreamMarshaller::new();
             let (signer, signer_sender) = ::aws_smithy_eventstream::frame::DeferredSigner::new();
             _cfg.interceptor_state().store_put(signer_sender);
             ::aws_smithy_types::body::SdkBody::from_body_0_4(::hyper::Body::wrap_stream(input.audio_stream.into_body_stream(
                 marshaller,
                 error_marshaller,
                 signer,
             )))
         });
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-240
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-242
+    }
-243
+}
 #[derive(Debug)]
 struct StartStreamTranscriptionEndpointParamsInterceptor;
-246
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StartStreamTranscriptionEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "StartStreamTranscriptionEndpointParamsInterceptor"

↧ Expand context

-250
+    }
-251
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<StartStreamTranscriptionInput>()
             .ok_or("failed to downcast to StartStreamTranscriptionInput")?;
-266
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))

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

@@ -285,285 +519,519 @@

↥ Expand context

-285
+                }
                 tmp
             })
-288
+        }
         "ServiceUnavailableException" => {
             crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::ServiceUnavailableException({
                 #[allow(unused_mut)]
                 let mut tmp = {
                     #[allow(unused_mut)]
                     let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
                     output =
                         crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_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;

-305
+                }
                 tmp
             })
-308
+        }
         _ => crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::generic(generic),
     })
-311
+}
-312
 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> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::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| {
         let header_value: ::http_1x::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),
-324
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-language-code", header_value);
-327
+    }
     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| {
         let header_value: ::http_1x::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),
-336
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-sample-rate", header_value);
-339
+    }
     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| {
         let header_value: ::http_1x::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),
-347
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-media-encoding", header_value);
-350
+    }
     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| {
         let header_value: ::http_1x::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),
-358
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-vocabulary-name", header_value);
-361
+    }
     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| {
         let header_value: ::http_1x::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),
-369
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-session-id", header_value);
-372
+    }
     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| {
         let header_value: ::http_1x::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),
-380
+            )
         })?;
         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| {
         let header_value: ::http_1x::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),
-391
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-vocabulary-filter-method", header_value);
-394
+    }
     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| {
         let header_value: ::http_1x::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),
-402
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-language-model-name", header_value);
-405
+    }
     if let ::std::option::Option::Some(inner_17) = &input.identify_language {
         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| {
         let header_value: ::http_1x::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),
-414
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-identify-language", header_value);
-417
+    }
     if let ::std::option::Option::Some(inner_19) = &input.language_options {
         let formatted_20 = inner_19.as_str();
         let header_value = formatted_20;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::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),
-425
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-language-options", header_value);
-428
+    }
     if let ::std::option::Option::Some(inner_21) = &input.preferred_language {
         let formatted_22 = inner_21.as_str();
         let header_value = formatted_22;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::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),
-436
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-preferred-language", header_value);
-439
+    }
     if let ::std::option::Option::Some(inner_23) = &input.vocabulary_names {
         let formatted_24 = inner_23.as_str();
         let header_value = formatted_24;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::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),
-447
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-vocabulary-names", header_value);
-450
+    }
     if let ::std::option::Option::Some(inner_25) = &input.vocabulary_filter_names {
         let formatted_26 = inner_25.as_str();
         let header_value = formatted_26;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::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),
-458
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-vocabulary-filter-names", header_value);
-461
+    }
     if let ::std::option::Option::Some(inner_27) = &input.enable_partial_results_stabilization {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_27);
         let formatted_28 = encoder.encode();
         let header_value = formatted_28;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::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),
-470
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-enable-partial-results-stabilization", header_value);
-473
+    }
     if let ::std::option::Option::Some(inner_29) = &input.partial_results_stability {
         let formatted_30 = inner_29.as_str();
         let header_value = formatted_30;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::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),
-481
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-partial-results-stability", header_value);
-484
+    }
     if let ::std::option::Option::Some(inner_31) = &input.content_identification_type {
         let formatted_32 = inner_31.as_str();
         let header_value = formatted_32;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::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),
-492
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-content-identification-type", header_value);
-495
+    }
     if let ::std::option::Option::Some(inner_33) = &input.content_redaction_type {
         let formatted_34 = inner_33.as_str();
         let header_value = formatted_34;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::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),
-503
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-content-redaction-type", header_value);
-506
+    }
     if let ::std::option::Option::Some(inner_35) = &input.pii_entity_types {
         let formatted_36 = inner_35.as_str();
         let header_value = formatted_36;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::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),
-514
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-pii-entity-types", header_value);
-517
+    }
     Ok(builder)
-519
+}

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

@@ -140,140 +218,218 @@

↥ Expand context

                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
-145
+            }
             tmp
         }),
         "ServiceUnavailableException" => crate::operation::start_medical_scribe_stream::StartMedicalScribeStreamError::ServiceUnavailableException({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
                 output =
                     crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
                         .map_err(crate::operation::start_medical_scribe_stream::StartMedicalScribeStreamError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {

                 tmp.message = _error_message;
-161
+            }
             tmp
         }),
         _ => crate::operation::start_medical_scribe_stream::StartMedicalScribeStreamError::generic(generic),
     })
-166
+}
-167
 pub fn ser_start_medical_scribe_stream_headers(
     input: &crate::operation::start_medical_scribe_stream::StartMedicalScribeStreamInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.session_id {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::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),
-179
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-session-id", header_value);
-182
+    }
     if let ::std::option::Option::Some(inner_3) = &input.language_code {
         let formatted_4 = inner_3.as_str();
         let header_value = formatted_4;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::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),
-190
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-language-code", header_value);
-193
+    }
     if let ::std::option::Option::Some(inner_5) = &input.media_sample_rate_hertz {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_5);
         let formatted_6 = encoder.encode();
         let header_value = formatted_6;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::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),
-202
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-sample-rate", header_value);
-205
+    }
     if let ::std::option::Option::Some(inner_7) = &input.media_encoding {
         let formatted_8 = inner_7.as_str();
         let header_value = formatted_8;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::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),
-213
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-media-encoding", header_value);
-216
+    }
     Ok(builder)
-218
+}

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

@@ -199,199 +357,357 @@

↥ Expand context

                 if tmp.message.is_none() {
                     tmp.message = _error_message;
-201
+                }
                 tmp
             })
-204
+        }
         "ServiceUnavailableException" => {
             crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionError::ServiceUnavailableException({
                 #[allow(unused_mut)]
                 let mut tmp = {
                     #[allow(unused_mut)]
                     let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
                     output =
                         crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_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> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::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| {
         let header_value: ::http_1x::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),
-238
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-language-code", header_value);
-241
+    }
     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| {
         let header_value: ::http_1x::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),
-250
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-sample-rate", header_value);
-253
+    }
     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| {
         let header_value: ::http_1x::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),
-261
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-media-encoding", header_value);
-264
+    }
     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| {
         let header_value: ::http_1x::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),
-272
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-vocabulary-name", header_value);
-275
+    }
     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| {
         let header_value: ::http_1x::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),
-283
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-specialty", header_value);
-286
+    }
     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| {
         let header_value: ::http_1x::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),
-294
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-type", header_value);
-297
+    }
     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| {
         let header_value: ::http_1x::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),
-306
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-show-speaker-label", header_value);
-309
+    }
     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| {
         let header_value: ::http_1x::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),
-317
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-session-id", header_value);
-320
+    }
     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| {
         let header_value: ::http_1x::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),
-329
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-enable-channel-identification", header_value);
-332
+    }
     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| {
         let header_value: ::http_1x::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),
-341
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-number-of-channels", header_value);
-344
+    }
     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| {
         let header_value: ::http_1x::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),
-352
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-content-identification-type", header_value);
-355
+    }
     Ok(builder)
-357
+}

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

@@ -273,273 +555,555 @@

↥ Expand context

                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
-278
+            }
             tmp
         }),
         "ServiceUnavailableException" => crate::operation::start_stream_transcription::StartStreamTranscriptionError::ServiceUnavailableException({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
                 output =
                     crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_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> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::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| {
         let header_value: ::http_1x::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),
-312
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-language-code", header_value);
-315
+    }
     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| {
         let header_value: ::http_1x::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),
-324
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-sample-rate", header_value);
-327
+    }
     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| {
         let header_value: ::http_1x::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),
-335
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-media-encoding", header_value);
-338
+    }
     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| {
         let header_value: ::http_1x::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),
-346
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-vocabulary-name", header_value);
-349
+    }
     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| {
         let header_value: ::http_1x::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),
-357
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-session-id", header_value);
-360
+    }
     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| {
         let header_value: ::http_1x::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),
-368
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-vocabulary-filter-name", header_value);
-371
+    }
     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| {
         let header_value: ::http_1x::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),
-379
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-vocabulary-filter-method", header_value);
-382
+    }
     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| {
         let header_value: ::http_1x::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),
-391
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-show-speaker-label", header_value);
-394
+    }
     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| {
         let header_value: ::http_1x::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),
-403
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-enable-channel-identification", header_value);
-406
+    }
     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| {
         let header_value: ::http_1x::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),
-415
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-number-of-channels", header_value);
-418
+    }
     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| {
         let header_value: ::http_1x::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),
-427
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-enable-partial-results-stabilization", header_value);
-430
+    }
     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| {
         let header_value: ::http_1x::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),
-438
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-partial-results-stability", header_value);
-441
+    }
     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| {
         let header_value: ::http_1x::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),
-449
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-content-identification-type", header_value);
-452
+    }
     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| {
         let header_value: ::http_1x::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),
-460
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-content-redaction-type", header_value);
-463
+    }
     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| {
         let header_value: ::http_1x::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),
-471
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-pii-entity-types", header_value);
-474
+    }
     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| {
         let header_value: ::http_1x::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),
-482
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-language-model-name", header_value);
-485
+    }
     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| {
         let header_value: ::http_1x::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),
-494
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-identify-language", header_value);
-497
+    }
     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| {
         let header_value: ::http_1x::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),
-505
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-language-options", header_value);
-508
+    }
     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| {
         let header_value: ::http_1x::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),
-516
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-preferred-language", header_value);
-519
+    }
     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| {
         let header_value: ::http_1x::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),
-528
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-identify-multiple-languages", header_value);
-531
+    }
     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| {
         let header_value: ::http_1x::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),
-539
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-vocabulary-names", header_value);
-542
+    }
     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| {
         let header_value: ::http_1x::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),
-550
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-vocabulary-filter-names", header_value);
-553
+    }
     Ok(builder)
-555
+}

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

@@ -1,1 +78,83 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-6
 #![allow(dead_code)]
-8
 use aws_smithy_http::header::set_request_header_if_absent;
 use aws_smithy_types::config_bag::{Storable, StoreReplace};
 use http::header::{HeaderName, CONTENT_LENGTH, CONTENT_TYPE};
 use http_1x::header::{HeaderName, CONTENT_LENGTH, CONTENT_TYPE};
-12
 /// Configuration for how default protocol headers are serialized
 #[derive(Clone, Debug, Default)]
 pub(crate) struct HeaderSerializationSettings {
     omit_default_content_length: bool,
     omit_default_content_type: bool,
-18
+}
-19
 impl HeaderSerializationSettings {
     /// Creates new [`HeaderSerializationSettings`]
     pub(crate) fn new() -> Self {
         Default::default()
-24
+    }
-25
     /// Omit the default `Content-Length` header during serialization
     pub(crate) fn omit_default_content_length(self) -> Self {
         Self {
             omit_default_content_length: true,
             ..self
-31
+        }
-32
+    }
-33
     /// Omit the default `Content-Type` header during serialization
     pub(crate) fn omit_default_content_type(self) -> Self {
         Self {
             omit_default_content_type: true,
             ..self
-39
+        }
-40
+    }
-41
     /// Returns true if the given default header name should be serialized
     fn include_header(&self, header: &HeaderName) -> bool {
         (!self.omit_default_content_length || header != CONTENT_LENGTH) && (!self.omit_default_content_type || header != CONTENT_TYPE)
-45
+    }
-46
     /// Sets a default header on the given request builder if it should be serialized
     pub(crate) fn set_default_header(&self, mut request: http::request::Builder, header_name: HeaderName, value: &str) -> http::request::Builder {
     pub(crate) fn set_default_header(
         &self,
         mut request: http_1x::request::Builder,
         header_name: HeaderName,
         value: &str,
     ) -> http_1x::request::Builder {
         if self.include_header(&header_name) {
             request = set_request_header_if_absent(request, header_name, value);
-56
+        }
         request
-58
+    }
-59
+}
-60
 impl Storable for HeaderSerializationSettings {
     type Storer = StoreReplace<Self>;
-63
+}

↧ Expand context

-64
 #[cfg(test)]
 mod tests {
     use super::*;
-68
     #[test]
     fn test_include_header() {
         let settings = HeaderSerializationSettings::default();
         assert!(settings.include_header(&CONTENT_LENGTH));
         assert!(settings.include_header(&CONTENT_TYPE));
-74
         let settings = HeaderSerializationSettings::default().omit_default_content_length();
         assert!(!settings.include_header(&CONTENT_LENGTH));
         assert!(settings.include_header(&CONTENT_TYPE));
-78
         let settings = HeaderSerializationSettings::default().omit_default_content_type();
         assert!(settings.include_header(&CONTENT_LENGTH));
         assert!(!settings.include_header(&CONTENT_TYPE));
-82
         let settings = HeaderSerializationSettings::default()

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

@@ -1,1 +54,54 @@

↥ 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"
-14
 [dev-dependencies.aws-config]
 path = "../../sdk/aws-config"

 default-features = false
 version = "1.8.12"
-19
 [dev-dependencies.aws-sdk-s3]
 path = "../../sdk/s3"
 default-features = false
 version = "0.0.0-local"
-24
 [dev-dependencies.aws-smithy-async]
 path = "../../sdk/aws-smithy-async"
 version = "1.2.7"
 version = "1.2.8"
-28
 [dev-dependencies.aws-smithy-runtime]
 path = "../../sdk/aws-smithy-runtime"
 features = ["test-util"]
 version = "1.9.8"
 version = "1.10.0"
-33
 [dev-dependencies.aws-smithy-http-client]
 path = "../../sdk/aws-smithy-http-client"
 features = ["test-util"]
 version = "1.1.6"
-38
 [dev-dependencies.aws-credential-types]
 path = "../../sdk/aws-credential-types"
 features = ["test-util"]
 version = "1.2.11"

↧ Expand context

-43
 [dev-dependencies.tokio]
 version = "1.23.1"
 features = ["full", "test-util"]
-47
 [dev-dependencies.tracing-subscriber]
 version = "0.3.15"
 features = ["env-filter"]
-51
 [dev-dependencies.http-1x]
 package = "http"
 version = "1"

tmp-codegen-diff/aws-sdk/tests/telemetry/Cargo.toml

@@ -1,1 +65,65 @@

↥ Expand context

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "telemetry-tests"
 version = "0.1.0"
 authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>"]
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/smithy-lang/smithy-rs"
 publish = false
-10
 [dev-dependencies]
 http = "0.2.0"
 serial_test = "3.1.1"
 tracing = "0.1.40"
 tracing-subscriber = "0.3.18"

 tracing-fluent-assertions = "0.3.0"
-17
 [dev-dependencies.aws-config]
 path = "../../sdk/aws-config"
 features = ["test-util", "behavior-version-latest"]
 version = "1.8.12"
-22
 [dev-dependencies.aws-runtime]
 path = "../../sdk/aws-runtime"
 features = ["test-util"]
 version = "1.5.18"
 version = "1.6.0"
-27
 [dev-dependencies.aws-sdk-dynamodb]
 path = "../../sdk/dynamodb"
 features = ["test-util", "behavior-version-latest"]
 version = "0.0.0-local"
-32
 [dev-dependencies.aws-sdk-s3]
 path = "../../sdk/s3"
 features = ["test-util", "behavior-version-latest"]
 version = "0.0.0-local"
-37
 [dev-dependencies.aws-smithy-observability]
 path = "../../sdk/aws-smithy-observability"
 version = "0.2.0"
 version = "0.2.1"
-41
 [dev-dependencies.aws-smithy-observability-otel]
 path = "../../sdk/aws-smithy-observability-otel"
 version = "0.1.4"
 version = "0.1.5"
-45
 [dev-dependencies.aws-smithy-runtime]
 path = "../../sdk/aws-smithy-runtime"
 features = ["client", "test-util"]
 version = "1.9.8"
 version = "1.10.0"
-50
 [dev-dependencies.aws-smithy-types]
 path = "../../sdk/aws-smithy-types"
 version = "1.3.6"
 version = "1.4.0"
-54
 [dev-dependencies.opentelemetry]
 version = "0.26.0"
 features = ["metrics"]
-58
 [dev-dependencies.opentelemetry_sdk]
 version = "0.26.0"
 features = ["metrics", "testing"]
-62
 [dev-dependencies.tokio]

↧ Expand context

64 64	`version = "1.23.1"`
65 65	`features = ["full", "test-util"]`

AWS SDK

Files changed: