AWS SDK

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/error/_internal_server_exception.rs

@@ -1,1 +105,117 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Timestream was unable to fully process this request because of an internal server error.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct InternalServerException {
     #[allow(missing_docs)] // documentation missing in model
     pub message: ::std::string::String,
     pub(crate) meta: ::aws_smithy_types::error::ErrorMetadata,
-10
+}
 static INTERNALSERVEREXCEPTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.timestreamwrite#InternalServerException",

     "com.amazonaws.timestreamwrite",
     "InternalServerException",
 );
 static INTERNALSERVEREXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.timestreamwrite#InternalServerException$Message",
         "com.amazonaws.timestreamwrite",
         "InternalServerException",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "message",
     "Message",
 ,
 );
 static INTERNALSERVEREXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     INTERNALSERVEREXCEPTION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&INTERNALSERVEREXCEPTION_MEMBER_MESSAGE],
 );
 impl InternalServerException {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INTERNALSERVEREXCEPTION_SCHEMA;
-34
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for InternalServerException {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
-41
+        {
             let val = &self.message;
             ser.write_string(&INTERNALSERVEREXCEPTION_MEMBER_MESSAGE, val)?;
-44
+        }
         Ok(())
-46
+    }
-47
+}
 impl InternalServerException {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&INTERNALSERVEREXCEPTION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&INTERNALSERVEREXCEPTION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.message = Some(deser.read_string(member)?);
-66
+                }
                 _ => {}
-68
+            }
             Ok(())
         })?;
         builder.message = builder.message.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-75
+    }
-76
+}
 impl InternalServerException {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl InternalServerException {
     /// Returns the error message.
     pub fn message(&self) -> &str {
         &self.message
-92
+    }
-93
+}
 impl ::std::fmt::Display for InternalServerException {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "InternalServerException")?;
-97
+        {

↧ Expand context

             ::std::write!(f, ": {}", &self.message)?;
-99
+        }
         Ok(())
-101
+    }
-102
+}
 impl ::std::error::Error for InternalServerException {}
 impl ::aws_types::request_id::RequestId for crate::types::error::InternalServerException {
     fn request_id(&self) -> Option<&str> {
         use ::aws_smithy_types::error::metadata::ProvideErrorMetadata;
         self.meta().request_id()
-108
+    }
-109
+}
 impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for InternalServerException {
     fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
         &self.meta
-113
+    }
-114
+}
 impl InternalServerException {
     /// Creates a new builder-style object to manufacture [`InternalServerException`](crate::types::error::InternalServerException).
     pub fn builder() -> crate::types::error::builders::InternalServerExceptionBuilder {

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/error/_rejected_records_exception.rs

@@ -19,19 +165,173 @@

↥ Expand context

 /// <p>For more information, see <a href="https://docs.aws.amazon.com/timestream/latest/developerguide/ts-limits.html">Quotas</a> in the Amazon Timestream Developer Guide.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct RejectedRecordsException {
     #[allow(missing_docs)] // documentation missing in model
     pub message: ::std::option::Option<::std::string::String>,
     /// <p></p>
     pub rejected_records: ::std::option::Option<::std::vec::Vec<crate::types::RejectedRecord>>,
     pub(crate) meta: ::aws_smithy_types::error::ErrorMetadata,
-28
+}
 impl RejectedRecordsException {
     /// <p></p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.rejected_records.is_none()`.
     pub fn rejected_records(&self) -> &[crate::types::RejectedRecord] {
         self.rejected_records.as_deref().unwrap_or_default()
-35
+    }
-36
+}
 static REJECTEDRECORDSEXCEPTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.timestreamwrite#RejectedRecordsException",

     "com.amazonaws.timestreamwrite",
     "RejectedRecordsException",
 );
 static REJECTEDRECORDSEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.timestreamwrite#RejectedRecordsException$Message",
         "com.amazonaws.timestreamwrite",
         "RejectedRecordsException",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "message",
     "Message",
 ,
 );
 static REJECTEDRECORDSEXCEPTION_MEMBER_REJECTED_RECORDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.timestreamwrite#RejectedRecordsException$RejectedRecords",
         "com.amazonaws.timestreamwrite",
         "RejectedRecordsException",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "rejected_records",
     "RejectedRecords",
 ,
 );
 static REJECTEDRECORDSEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     REJECTEDRECORDSEXCEPTION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &REJECTEDRECORDSEXCEPTION_MEMBER_MESSAGE,
         &REJECTEDRECORDSEXCEPTION_MEMBER_REJECTED_RECORDS,
     ],
 );
 impl RejectedRecordsException {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &REJECTEDRECORDSEXCEPTION_SCHEMA;
-73
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RejectedRecordsException {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.message {
             ser.write_string(&REJECTEDRECORDSEXCEPTION_MEMBER_MESSAGE, val)?;
-82
+        }
         if let Some(ref val) = self.rejected_records {
             ser.write_list(
                 &REJECTEDRECORDSEXCEPTION_MEMBER_REJECTED_RECORDS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::RejectedRecord::SCHEMA, item)?;
-89
+                    }
                     Ok(())
                 },
             )?;
-93
+        }
         Ok(())
-95
+    }
-96
+}
 impl RejectedRecordsException {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&REJECTEDRECORDSEXCEPTION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&REJECTEDRECORDSEXCEPTION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.message = Some(deser.read_string(member)?);
-115
+                }
                 Some(1) => {
                     builder.rejected_records = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::RejectedRecord::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::RejectedRecord::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-125
+                }
                 _ => {}
-127
+            }
             Ok(())
         })?;
         Ok(builder.build())
-131
+    }
-132
+}
 impl RejectedRecordsException {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl RejectedRecordsException {
     /// Returns the error message.
     pub fn message(&self) -> ::std::option::Option<&str> {
         self.message.as_deref()
-148
+    }
-149
+}
 impl ::std::fmt::Display for RejectedRecordsException {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "RejectedRecordsException")?;
         if let ::std::option::Option::Some(inner_1) = &self.message {

↧ Expand context

-154
+            {
                 ::std::write!(f, ": {inner_1}")?;
-156
+            }
-157
+        }
         Ok(())
-159
+    }
-160
+}
 impl ::std::error::Error for RejectedRecordsException {}
 impl ::aws_types::request_id::RequestId for crate::types::error::RejectedRecordsException {
     fn request_id(&self) -> Option<&str> {
         use ::aws_smithy_types::error::metadata::ProvideErrorMetadata;
         self.meta().request_id()
-166
+    }
-167
+}
 impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for RejectedRecordsException {
     fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
         &self.meta
-171
+    }
-172
+}
 impl RejectedRecordsException {

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/error/_resource_not_found_exception.rs

@@ -1,1 +102,113 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>The operation tried to access a nonexistent resource. The resource might not be specified correctly, or its status might not be ACTIVE.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct ResourceNotFoundException {
     #[allow(missing_docs)] // documentation missing in model
     pub message: ::std::option::Option<::std::string::String>,
     pub(crate) meta: ::aws_smithy_types::error::ErrorMetadata,
-10
+}
 static RESOURCENOTFOUNDEXCEPTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.timestreamwrite#ResourceNotFoundException",

     "com.amazonaws.timestreamwrite",
     "ResourceNotFoundException",
 );
 static RESOURCENOTFOUNDEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.timestreamwrite#ResourceNotFoundException$Message",
         "com.amazonaws.timestreamwrite",
         "ResourceNotFoundException",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "message",
     "Message",
 ,
 );
 static RESOURCENOTFOUNDEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     RESOURCENOTFOUNDEXCEPTION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&RESOURCENOTFOUNDEXCEPTION_MEMBER_MESSAGE],
 );
 impl ResourceNotFoundException {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RESOURCENOTFOUNDEXCEPTION_SCHEMA;
-34
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ResourceNotFoundException {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.message {
             ser.write_string(&RESOURCENOTFOUNDEXCEPTION_MEMBER_MESSAGE, val)?;
-43
+        }
         Ok(())
-45
+    }
-46
+}
 impl ResourceNotFoundException {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&RESOURCENOTFOUNDEXCEPTION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&RESOURCENOTFOUNDEXCEPTION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.message = Some(deser.read_string(member)?);
-65
+                }
                 _ => {}
-67
+            }
             Ok(())
         })?;
         Ok(builder.build())
-71
+    }
-72
+}
 impl ResourceNotFoundException {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl ResourceNotFoundException {
     /// Returns the error message.
     pub fn message(&self) -> ::std::option::Option<&str> {
         self.message.as_deref()
-88
+    }
-89
+}
 impl ::std::fmt::Display for ResourceNotFoundException {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "ResourceNotFoundException")?;
         if let ::std::option::Option::Some(inner_1) = &self.message {

↧ Expand context

-94
+            {
                 ::std::write!(f, ": {inner_1}")?;
-96
+            }
-97
+        }
         Ok(())
-99
+    }
-100
+}
 impl ::std::error::Error for ResourceNotFoundException {}
 impl ::aws_types::request_id::RequestId for crate::types::error::ResourceNotFoundException {
     fn request_id(&self) -> Option<&str> {
         use ::aws_smithy_types::error::metadata::ProvideErrorMetadata;
         self.meta().request_id()
-106
+    }
-107
+}
 impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for ResourceNotFoundException {
     fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
         &self.meta
-111
+    }
-112
+}
 impl ResourceNotFoundException {

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/error/_service_quota_exceeded_exception.rs

@@ -1,1 +102,113 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>The instance quota of resource exceeded for this account.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct ServiceQuotaExceededException {
     #[allow(missing_docs)] // documentation missing in model
     pub message: ::std::option::Option<::std::string::String>,
     pub(crate) meta: ::aws_smithy_types::error::ErrorMetadata,
-10
+}
 static SERVICEQUOTAEXCEEDEDEXCEPTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.timestreamwrite#ServiceQuotaExceededException",

     "com.amazonaws.timestreamwrite",
     "ServiceQuotaExceededException",
 );
 static SERVICEQUOTAEXCEEDEDEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.timestreamwrite#ServiceQuotaExceededException$Message",
         "com.amazonaws.timestreamwrite",
         "ServiceQuotaExceededException",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "message",
     "Message",
 ,
 );
 static SERVICEQUOTAEXCEEDEDEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SERVICEQUOTAEXCEEDEDEXCEPTION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&SERVICEQUOTAEXCEEDEDEXCEPTION_MEMBER_MESSAGE],
 );
 impl ServiceQuotaExceededException {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SERVICEQUOTAEXCEEDEDEXCEPTION_SCHEMA;
-34
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ServiceQuotaExceededException {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.message {
             ser.write_string(&SERVICEQUOTAEXCEEDEDEXCEPTION_MEMBER_MESSAGE, val)?;
-43
+        }
         Ok(())
-45
+    }
-46
+}
 impl ServiceQuotaExceededException {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&SERVICEQUOTAEXCEEDEDEXCEPTION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SERVICEQUOTAEXCEEDEDEXCEPTION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.message = Some(deser.read_string(member)?);
-65
+                }
                 _ => {}
-67
+            }
             Ok(())
         })?;
         Ok(builder.build())
-71
+    }
-72
+}
 impl ServiceQuotaExceededException {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl ServiceQuotaExceededException {
     /// Returns the error message.
     pub fn message(&self) -> ::std::option::Option<&str> {
         self.message.as_deref()
-88
+    }
-89
+}
 impl ::std::fmt::Display for ServiceQuotaExceededException {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "ServiceQuotaExceededException")?;
         if let ::std::option::Option::Some(inner_1) = &self.message {

↧ Expand context

-94
+            {
                 ::std::write!(f, ": {inner_1}")?;
-96
+            }
-97
+        }
         Ok(())
-99
+    }
-100
+}
 impl ::std::error::Error for ServiceQuotaExceededException {}
 impl ::aws_types::request_id::RequestId for crate::types::error::ServiceQuotaExceededException {
     fn request_id(&self) -> Option<&str> {
         use ::aws_smithy_types::error::metadata::ProvideErrorMetadata;
         self.meta().request_id()
-106
+    }
-107
+}
 impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for ServiceQuotaExceededException {
     fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
         &self.meta
-111
+    }
-112
+}
 impl ServiceQuotaExceededException {

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/error/_throttling_exception.rs

@@ -1,1 +105,117 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Too many requests were made by a user and they exceeded the service quotas. The request was throttled.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct ThrottlingException {
     #[allow(missing_docs)] // documentation missing in model
     pub message: ::std::string::String,
     pub(crate) meta: ::aws_smithy_types::error::ErrorMetadata,
-10
+}
 static THROTTLINGEXCEPTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.timestreamwrite#ThrottlingException",

     "com.amazonaws.timestreamwrite",
     "ThrottlingException",
 );
 static THROTTLINGEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.timestreamwrite#ThrottlingException$Message",
         "com.amazonaws.timestreamwrite",
         "ThrottlingException",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "message",
     "Message",
 ,
 );
 static THROTTLINGEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     THROTTLINGEXCEPTION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&THROTTLINGEXCEPTION_MEMBER_MESSAGE],
 );
 impl ThrottlingException {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &THROTTLINGEXCEPTION_SCHEMA;
-34
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ThrottlingException {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
-41
+        {
             let val = &self.message;
             ser.write_string(&THROTTLINGEXCEPTION_MEMBER_MESSAGE, val)?;
-44
+        }
         Ok(())
-46
+    }
-47
+}
 impl ThrottlingException {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&THROTTLINGEXCEPTION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&THROTTLINGEXCEPTION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.message = Some(deser.read_string(member)?);
-66
+                }
                 _ => {}
-68
+            }
             Ok(())
         })?;
         builder.message = builder.message.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-75
+    }
-76
+}
 impl ThrottlingException {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl ThrottlingException {
     /// Returns the error message.
     pub fn message(&self) -> &str {
         &self.message
-92
+    }
-93
+}
 impl ::std::fmt::Display for ThrottlingException {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "ThrottlingException")?;
-97
+        {

↧ Expand context

             ::std::write!(f, ": {}", &self.message)?;
-99
+        }
         Ok(())
-101
+    }
-102
+}
 impl ::std::error::Error for ThrottlingException {}
 impl ::aws_types::request_id::RequestId for crate::types::error::ThrottlingException {
     fn request_id(&self) -> Option<&str> {
         use ::aws_smithy_types::error::metadata::ProvideErrorMetadata;
         self.meta().request_id()
-108
+    }
-109
+}
 impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for ThrottlingException {
     fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
         &self.meta
-113
+    }
-114
+}
 impl ThrottlingException {
     /// Creates a new builder-style object to manufacture [`ThrottlingException`](crate::types::error::ThrottlingException).
     pub fn builder() -> crate::types::error::builders::ThrottlingExceptionBuilder {

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/error/_validation_exception.rs

@@ -1,1 +105,117 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>An invalid or malformed request.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct ValidationException {
     #[allow(missing_docs)] // documentation missing in model
     pub message: ::std::string::String,
     pub(crate) meta: ::aws_smithy_types::error::ErrorMetadata,
-10
+}
 static VALIDATIONEXCEPTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.timestreamwrite#ValidationException",

     "com.amazonaws.timestreamwrite",
     "ValidationException",
 );
 static VALIDATIONEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.timestreamwrite#ValidationException$Message",
         "com.amazonaws.timestreamwrite",
         "ValidationException",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "message",
     "Message",
 ,
 );
 static VALIDATIONEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     VALIDATIONEXCEPTION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&VALIDATIONEXCEPTION_MEMBER_MESSAGE],
 );
 impl ValidationException {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &VALIDATIONEXCEPTION_SCHEMA;
-34
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ValidationException {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
-41
+        {
             let val = &self.message;
             ser.write_string(&VALIDATIONEXCEPTION_MEMBER_MESSAGE, val)?;
-44
+        }
         Ok(())
-46
+    }
-47
+}
 impl ValidationException {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&VALIDATIONEXCEPTION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&VALIDATIONEXCEPTION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.message = Some(deser.read_string(member)?);
-66
+                }
                 _ => {}
-68
+            }
             Ok(())
         })?;
         builder.message = builder.message.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-75
+    }
-76
+}
 impl ValidationException {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl ValidationException {
     /// Returns the error message.
     pub fn message(&self) -> &str {
         &self.message
-92
+    }
-93
+}
 impl ::std::fmt::Display for ValidationException {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "ValidationException")?;
-97
+        {

↧ Expand context

             ::std::write!(f, ": {}", &self.message)?;
-99
+        }
         Ok(())
-101
+    }
-102
+}
 impl ::std::error::Error for ValidationException {}
 impl ::aws_types::request_id::RequestId for crate::types::error::ValidationException {
     fn request_id(&self) -> Option<&str> {
         use ::aws_smithy_types::error::metadata::ProvideErrorMetadata;
         self.meta().request_id()
-108
+    }
-109
+}
 impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for ValidationException {
     fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
         &self.meta
-113
+    }
-114
+}
 impl ValidationException {
     /// Creates a new builder-style object to manufacture [`ValidationException`](crate::types::error::ValidationException).
     pub fn builder() -> crate::types::error::builders::ValidationExceptionBuilder {

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

@@ -1,1 +170,170 @@

↥ 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.91.1"
 readme = "README.md"
 [package.metadata.smithy]
 codegen-version = "ci"
 protocol = "aws.protocols#restJson1"

 [package.metadata.docs.rs]
 all-features = true
 targets = ["x86_64-unknown-linux-gnu"]
 [dependencies.aws-credential-types]
 path = "../aws-credential-types"
 version = "1.2.14"
-21
 [dependencies.aws-runtime]
 path = "../aws-runtime"
 features = ["event-stream"]
 version = "1.7.3"
 version = "1.7.4"
-26
 [dependencies.aws-sigv4]
 path = "../aws-sigv4"
 version = "1.4.2"
-30
 [dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 version = "1.2.14"
-34
 [dependencies.aws-smithy-eventstream]
 path = "../aws-smithy-eventstream"
 version = "0.60.20"
-38
 [dependencies.aws-smithy-http]
 path = "../aws-smithy-http"
 features = ["event-stream"]
 version = "0.63.6"
-43
 [dependencies.aws-smithy-json]
 path = "../aws-smithy-json"
 version = "0.62.6"
-47
 [dependencies.aws-smithy-observability]
 path = "../aws-smithy-observability"
 version = "0.2.6"
-51
 [dependencies.aws-smithy-runtime]
 path = "../aws-smithy-runtime"
 features = ["client"]
 version = "1.10.3"
 version = "1.10.4"
-56
 [dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["client", "http-1x"]
 version = "1.11.6"
 version = "1.11.7"
-61
 [dependencies.aws-smithy-schema]
 path = "../aws-smithy-schema"
 version = "1.0.0"
-65
 [dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 features = ["http-body-1-x"]
 version = "1.4.7"
-70
 [dependencies.aws-types]
 path = "../aws-types"
 version = "1.4.0"
-74
 [dependencies.bytes]
 version = "1.4.0"
-77
 [dependencies.fastrand]
 version = "2.0.0"
-80
 [dependencies.http]
 version = "0.2.9"
-83
 [dependencies.http-1x]
 version = "1"
 package = "http"
-87
 [dependencies.http-body-util]
 version = "0.1.3"
-90
 [dependencies.regex-lite]
 version = "0.1.5"
-93
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.async-stream]
 version = "0.3.0"
-98
 [dev-dependencies.aws-config]
 path = "../aws-config"
 version = "1.9.0"
-102
 [dev-dependencies.aws-credential-types]
 path = "../aws-credential-types"
 features = ["test-util"]
 version = "1.2.14"
-107
 [dev-dependencies.aws-runtime]
 path = "../aws-runtime"
 features = ["test-util"]
 version = "1.7.3"
 version = "1.7.4"
-112
 [dev-dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 features = ["test-util"]
 version = "1.2.14"
-117
 [dev-dependencies.aws-smithy-eventstream]
 path = "../aws-smithy-eventstream"
 features = ["test-util"]
 version = "0.60.20"
-122
 [dev-dependencies.aws-smithy-http-client]
 path = "../aws-smithy-http-client"
 features = ["test-util", "wire-mock"]
 version = "1.1.12"
-127
 [dev-dependencies.aws-smithy-protocol-test]
 path = "../aws-smithy-protocol-test"
 version = "0.63.14"
-131
 [dev-dependencies.aws-smithy-runtime]
 path = "../aws-smithy-runtime"
 features = ["test-util"]
 version = "1.10.3"
 version = "1.10.4"
-136
 [dev-dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["test-util"]
 version = "1.11.6"
 version = "1.11.7"
-141
 [dev-dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 features = ["http-body-1-x", "test-util"]
 version = "1.4.7"
-146
 [dev-dependencies.futures-core]
 version = "0.3.25"
-149
 [dev-dependencies.futures-util]

↧ Expand context

 version = "0.3.25"
 features = ["alloc"]
 default-features = false
-154
 [dev-dependencies.hound]
 version = "3.4.0"
-157
 [dev-dependencies.proptest]
 version = "1"
-160
 [dev-dependencies.serde_json]
 version = "1.0.0"
-163
 [dev-dependencies.tokio]
 version = "1.23.1"
 features = ["macros", "test-util", "rt-multi-thread"]
-167
 [dev-dependencies.tracing-subscriber]
 version = "0.3.16"
 features = ["env-filter", "json"]

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

@@ -23,23 +82,86 @@

↥ Expand context

     pub(crate) config: crate::config::FrozenLayer,
     cloneable: ::aws_smithy_types::config_bag::CloneableLayer,
     pub(crate) runtime_components: crate::config::RuntimeComponentsBuilder,
     pub(crate) runtime_plugins: ::std::vec::Vec<crate::config::SharedRuntimePlugin>,
     pub(crate) behavior_version: ::std::option::Option<crate::config::BehaviorVersion>,
-28
+}
 impl Config {
     ///
     /// Constructs a config builder.
     /// <div class="warning">
     /// Note that a config created from this builder will not have the same safe defaults as one created by
     /// the <a href="https://crates.io/crates/aws-config" target="_blank">aws-config</a> crate.
     /// </div>
     ///
     pub fn builder() -> Builder {
         Builder::default()
-39
+    }
     /// Converts this config back into a builder so that it can be tweaked.
     pub fn to_builder(&self) -> Builder {
         Builder {

             config: self.cloneable.clone(),
             runtime_components: self.runtime_components.clone(),
             runtime_plugins: self.runtime_plugins.clone(),
             behavior_version: self.behavior_version,
-47
+        }
-48
+    }
     /// Return a reference to the stalled stream protection configuration contained in this config, if any.
     pub fn stalled_stream_protection(&self) -> ::std::option::Option<&crate::config::StalledStreamProtectionConfig> {
         self.config.load::<crate::config::StalledStreamProtectionConfig>()
-52
+    }
     /// Returns the client protocol used for serialization and deserialization.
     pub fn protocol(&self) -> ::std::option::Option<&::aws_smithy_schema::protocol::SharedClientProtocol> {
         self.config.load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
-+
+    }
     /// Return the [`SharedHttpClient`](crate::config::SharedHttpClient) to use when making requests, if any.
     pub fn http_client(&self) -> Option<crate::config::SharedHttpClient> {
         self.runtime_components.http_client()
-60
+    }
     /// Return the auth schemes configured on this service config
     pub fn auth_schemes(&self) -> impl Iterator<Item = ::aws_smithy_runtime_api::client::auth::SharedAuthScheme> + '_ {
         self.runtime_components.auth_schemes()
-64
+    }
-65
     /// Return the auth scheme resolver configured on this service config

↧ Expand context

     pub fn auth_scheme_resolver(&self) -> ::std::option::Option<::aws_smithy_runtime_api::client::auth::SharedAuthSchemeOptionResolver> {
         self.runtime_components.auth_scheme_option_resolver()
-69
+    }
     /// Returns the configured auth scheme preference
     pub fn auth_scheme_preference(&self) -> ::std::option::Option<&::aws_smithy_runtime_api::client::auth::AuthSchemePreference> {
         self.config.load::<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>()
-73
+    }
     /// Returns the endpoint resolver.
     pub fn endpoint_resolver(&self) -> ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver {
         self.runtime_components.endpoint_resolver().expect("resolver defaulted if not set")
-77
+    }
     /// Return a reference to the retry configuration contained in this config, if any.
     pub fn retry_config(&self) -> ::std::option::Option<&::aws_smithy_types::retry::RetryConfig> {
         self.config.load::<::aws_smithy_types::retry::RetryConfig>()
-81
+    }
-82
     /// Return a cloned shared async sleep implementation from this config, if any.
     pub fn sleep_impl(&self) -> ::std::option::Option<crate::config::SharedAsyncSleep> {
         self.runtime_components.sleep_impl()
-86
+    }

@@ -153,157 +238,261 @@

↥ Expand context

     pub(crate) runtime_plugins: ::std::vec::Vec<crate::config::SharedRuntimePlugin>,
     pub(crate) behavior_version: ::std::option::Option<crate::config::BehaviorVersion>,
-159
+}
 impl ::std::default::Default for Builder {
     fn default() -> Self {
         Self {
             config: ::std::default::Default::default(),
             runtime_components: crate::config::RuntimeComponentsBuilder::new("service config"),
             runtime_plugins: ::std::default::Default::default(),
             behavior_version: ::std::default::Default::default(),
-167
+        }
-168
+    }
-169
+}
 impl Builder {
     ///
     /// Constructs a config builder.
     /// <div class="warning">
     /// Note that a config created from this builder will not have the same safe defaults as one created by
     /// the <a href="https://crates.io/crates/aws-config" target="_blank">aws-config</a> crate.
     /// </div>

     ///
     pub fn new() -> Self {
         Self::default()
-180
+    }
     /// Constructs a config builder from the given `config_bag`, setting only fields stored in the config bag,
     /// but not those in runtime components.
     #[allow(unused)]
     pub(crate) fn from_config_bag(config_bag: &::aws_smithy_types::config_bag::ConfigBag) -> Self {
         let mut builder = Self::new();
         builder.set_stalled_stream_protection(config_bag.load::<crate::config::StalledStreamProtectionConfig>().cloned());
         if let ::std::option::Option::Some(protocol) = config_bag.load::<::aws_smithy_schema::protocol::SharedClientProtocol>().cloned() {
             builder.set_protocol(::std::option::Option::Some(protocol));
-+
+        }
         builder.set_auth_scheme_preference(config_bag.load::<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>().cloned());
         builder.set_retry_config(config_bag.load::<::aws_smithy_types::retry::RetryConfig>().cloned());
         builder.set_timeout_config(config_bag.load::<::aws_smithy_types::timeout::TimeoutConfig>().cloned());
         builder.set_retry_partition(config_bag.load::<::aws_smithy_runtime::client::retries::RetryPartition>().cloned());
         builder.set_app_name(config_bag.load::<::aws_types::app_name::AppName>().cloned());
         builder.set_endpoint_url(config_bag.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()));
         builder.set_use_dual_stack(config_bag.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0));
         builder.set_use_fips(config_bag.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0));
         builder.set_region(config_bag.load::<crate::config::Region>().cloned());
         builder
-200
+    }
     /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
     /// to configure protection for stalled streams.
     pub fn stalled_stream_protection(mut self, stalled_stream_protection_config: crate::config::StalledStreamProtectionConfig) -> Self {
         self.set_stalled_stream_protection(::std::option::Option::Some(stalled_stream_protection_config));
         self
-206
+    }
     /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
     /// to configure protection for stalled streams.
     pub fn set_stalled_stream_protection(
         &mut self,
         stalled_stream_protection_config: ::std::option::Option<crate::config::StalledStreamProtectionConfig>,
     ) -> &mut Self {
         self.config.store_or_unset(stalled_stream_protection_config);
         self
-215
+    }
     /// Sets the client protocol to use for serialization and deserialization.
     ///
     /// This overrides the default protocol determined by the service model,
     /// enabling runtime protocol selection.
     pub fn protocol(mut self, protocol: impl ::aws_smithy_schema::protocol::ClientProtocol + 'static) -> Self {
         self.set_protocol(::std::option::Option::Some(::aws_smithy_schema::protocol::SharedClientProtocol::new(
             protocol,
         )));
         self
-+
+    }
-+
     /// Sets the client protocol to use for serialization and deserialization.
     pub fn set_protocol(&mut self, protocol: ::std::option::Option<::aws_smithy_schema::protocol::SharedClientProtocol>) -> &mut Self {
         self.config.store_or_unset(protocol);
         self
-+
+    }
     /// Sets the HTTP client to use when making requests.
     ///
     /// # Examples
     /// ```no_run
     /// # #[cfg(test)]
     /// # mod tests {
     /// # #[test]
     /// # fn example() {
     /// use std::time::Duration;
     /// use aws_sdk_transcribestreaming::config::Config;

↧ Expand context

     /// use aws_smithy_runtime::client::http::hyper_014::HyperClientBuilder;
     ///
     /// let https_connector = hyper_rustls::HttpsConnectorBuilder::new()
     ///     .with_webpki_roots()
     ///     .https_only()
     ///     .enable_http1()
     ///     .enable_http2()
     ///     .build();
     /// let hyper_client = HyperClientBuilder::new().build(https_connector);
     ///
     /// // This connector can then be given to a generated service Config
     /// let config = my_service_client::Config::builder()
     ///     .endpoint_url("https://example.com")
     ///     .http_client(hyper_client)
     ///     .build();
     /// let client = my_service_client::Client::from_conf(config);
     /// # }
     /// # }
     /// ```
     pub fn http_client(mut self, http_client: impl crate::config::HttpClient + 'static) -> Self {

@@ -1272,1295 +1331,1359 @@

↥ Expand context

             self.runtime_components
                 .set_time_source(::std::option::Option::Some(::std::default::Default::default()));
-1297
+        }
         layer.store_put(crate::meta::API_METADATA.clone());
         layer.store_put(::aws_types::SigningName::from_static("transcribe"));
         layer
             .load::<::aws_types::region::Region>()
             .cloned()
             .map(|r| layer.store_put(::aws_types::region::SigningRegion::from(r)));
         Config {
             config: crate::config::Layer::from(layer.clone())
                 .with_name("aws_sdk_transcribestreaming::config::Config")
                 .freeze(),
             cloneable: layer,
             runtime_components: self.runtime_components,
             runtime_plugins: self.runtime_plugins,
             behavior_version: self.behavior_version,
-1312
+        }
-1313
+    }
-1314
+}

 #[derive(::std::fmt::Debug)]
 pub(crate) struct ServiceRuntimePlugin {
     config: ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer>,
     runtime_components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
-1319
+}
-1320
 impl ServiceRuntimePlugin {
     pub fn new(_service_config: crate::config::Config) -> Self {
         let config = {
             let mut cfg = ::aws_smithy_types::config_bag::Layer::new("Transcribe");
             if _service_config.protocol().is_none() {
                 cfg.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
-+
+            }
             cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
             ::std::option::Option::Some(cfg.freeze())
         };
         let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
         runtime_components.set_auth_scheme_option_resolver(::std::option::Option::Some({
             use crate::config::auth::ResolveAuthScheme;
             crate::config::auth::DefaultAuthSchemeResolver::default().into_shared_resolver()
         }));
         runtime_components.set_endpoint_resolver(::std::option::Option::Some({
             use crate::config::endpoint::ResolveEndpoint;

↧ Expand context

             crate::config::endpoint::DefaultResolver::new().into_shared_resolver()
         }));
         runtime_components.push_interceptor(::aws_smithy_runtime::client::http::connection_poisoning::ConnectionPoisoningInterceptor::new());
         runtime_components.push_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::HttpStatusCodeClassifier::default());
         runtime_components.push_interceptor(crate::sdk_feature_tracker::retry_mode::RetryModeFeatureTrackerInterceptor::new());
         runtime_components.push_interceptor(::aws_runtime::service_clock_skew::ServiceClockSkewInterceptor::new());
         runtime_components.push_interceptor(::aws_runtime::request_info::RequestInfoInterceptor::new());
         runtime_components.push_interceptor(::aws_runtime::user_agent::UserAgentInterceptor::new());
         runtime_components.push_interceptor(::aws_runtime::invocation_id::InvocationIdInterceptor::new());
         runtime_components.push_interceptor(::aws_runtime::recursion_detection::RecursionDetectionInterceptor::new());
         runtime_components.push_auth_scheme(::aws_smithy_runtime_api::client::auth::SharedAuthScheme::new(
             ::aws_runtime::auth::sigv4::SigV4AuthScheme::new(),
         ));
         runtime_components.push_interceptor(crate::config::endpoint::EndpointOverrideFeatureTrackerInterceptor);
         runtime_components.push_interceptor(crate::observability_feature::ObservabilityFeatureTrackerInterceptor);
         Self { config, runtime_components }
-1356
+    }
-1357
+}
-1358
 impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ServiceRuntimePlugin {

@@ -1407,1435 +1466,1497 @@

↥ Expand context

-1435
 impl From<&::aws_types::sdk_config::SdkConfig> for Builder {
     fn from(input: &::aws_types::sdk_config::SdkConfig) -> Self {
         let mut builder = Builder::default();
         builder.set_credentials_provider(input.credentials_provider());
         builder = builder.region(input.region().cloned());
         builder.set_use_fips(input.use_fips());
         builder.set_use_dual_stack(input.use_dual_stack());
         if input.get_origin("endpoint_url").is_client_config() {
             builder.set_endpoint_url(input.endpoint_url().map(|s| s.to_string()));
         } else {
             builder.set_endpoint_url(
                 input
                     .service_config()
                     .and_then(|conf| {
                         conf.load_config(service_config_key("Transcribe Streaming", "AWS_ENDPOINT_URL", "endpoint_url"))
                             .map(|it| it.parse().unwrap())
                     })
                     .or_else(|| input.endpoint_url().map(|s| s.to_string())),
             );

-1455
+        }
         // resiliency
         builder.set_retry_config(input.retry_config().cloned());
         builder.set_timeout_config(input.timeout_config().cloned());
         builder.set_sleep_impl(input.sleep_impl());
-1460
         builder.set_http_client(input.http_client());
         builder.set_time_source(input.time_source());
         builder.set_behavior_version(input.behavior_version());
         builder.set_auth_scheme_preference(input.auth_scheme_preference().cloned());
         if let Some(protocol) = input.protocol() {
             builder.set_protocol(Some(protocol.clone()));
-+
+        }
         // setting `None` here removes the default
         if let Some(config) = input.stalled_stream_protection() {
             builder.set_stalled_stream_protection(Some(config));
-1471
+        }
-1472
         if let Some(cache) = input.identity_cache() {
             builder.set_identity_cache(cache);
-1475
+        }
         builder.set_app_name(input.app_name().cloned());
-1477

↧ Expand context

         builder
-1479
+    }
-1480
+}
-1481
 impl From<&::aws_types::sdk_config::SdkConfig> for Config {
     fn from(sdk_config: &::aws_types::sdk_config::SdkConfig) -> Self {
         Builder::from(sdk_config).build()
-1485
+    }
-1486
+}
-1487
 pub use ::aws_types::app_name::AppName;
-1489
 #[allow(dead_code)]
 fn service_config_key<'a>(service_id: &'a str, env: &'a str, profile: &'a str) -> aws_types::service_config::ServiceConfigKey<'a> {
     ::aws_types::service_config::ServiceConfigKey::builder()
         .service_id(service_id)
         .env(env)
         .profile(profile)
         .build()
         .expect("all field sets explicitly, can't fail")

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

@@ -176,176 +215,211 @@

↥ Expand context

 /// Configuration for Amazon Transcribe Streaming Service.
 pub mod config;
-178
 /// Common errors and error handling utilities.
 pub mod error;
-181
 mod error_meta;
-183
 /// Information about this crate.
 pub mod meta;
-186
 /// All operations that this crate can perform.
 pub mod operation;
-189
 /// Primitives such as `Blob` or `DateTime` used by other types.
 pub mod primitives;
-192
 /// Data structures used by operation inputs/outputs.
 pub mod types;
-195

 mod event_receiver;
-197
 mod event_stream_serde;
-199
 mod observability_feature;
-201
 pub(crate) mod protocol_serde;
-203
 mod sdk_feature_tracker;
-205
 mod serialization_settings;
--
 mod endpoint_lib;
-207
 mod json_errors;
-209
 mod serde_util;
--
 #[doc(inline)]
 pub use client::Client;

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

@@ -1,1 +40,44 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `GetMedicalScribeStream`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct GetMedicalScribeStream;
 impl GetMedicalScribeStream {
     /// Creates a new `GetMedicalScribeStream`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamInput,
     ) -> ::std::result::Result<
         crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -124,128 +253,364 @@

↥ Expand context

         });
-129
         ::std::option::Option::Some(cfg.freeze())
-131
+    }
-132
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("GetMedicalScribeStream")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(GetMedicalScribeStreamEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamError,
             >::new());
-150
         ::std::borrow::Cow::Owned(rcb)
-152
+    }
-153
+}
-154
 #[derive(Debug)]
 struct GetMedicalScribeStreamResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetMedicalScribeStreamResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_get_medical_scribe_stream::de_get_medical_scribe_stream_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(
                             crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamError::unhandled(generic),
                         ),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "BadRequestException" => crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamError::BadRequestException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::BadRequestException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::BadRequestException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "InternalFailureException" => crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamError::InternalFailureException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InternalFailureException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InternalFailureException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "LimitExceededException" => crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamError::LimitExceededException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::LimitExceededException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::LimitExceededException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ResourceNotFoundException" => crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamError::ResourceNotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceNotFoundException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_get_medical_scribe_stream::de_get_medical_scribe_stream_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, GetMedicalScribeStream::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-313
+    }
-314
+}
 #[derive(Debug)]
 struct GetMedicalScribeStreamRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetMedicalScribeStreamRequestSerializer {
     #[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::get_medical_scribe_stream::GetMedicalScribeStreamInput>()
             .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::get_medical_scribe_stream::GetMedicalScribeStreamInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.session_id;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("session_id", "cannot be empty or unset"))?;
                 let session_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if session_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "session_id",
                         "cannot be empty or unset",
                     ));
--
+                }
                 ::std::write!(output, "/medical-scribe-stream/{SessionId}", SessionId = session_id).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamInput,
                 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)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, GetMedicalScribeStream::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-333
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         return ::std::result::Result::Ok(request);
-335
+    }
-336
+}
 #[derive(Debug)]
 struct GetMedicalScribeStreamEndpointParamsInterceptor;
-339
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetMedicalScribeStreamEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetMedicalScribeStreamEndpointParamsInterceptor"
-343
+    }
-344

↧ Expand context

     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::<GetMedicalScribeStreamInput>()
             .ok_or("failed to downcast to GetMedicalScribeStreamInput")?;
-359
         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))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))

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

@@ -1,1 +109,126 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct GetMedicalScribeStreamInput {
     /// <p>The identifier of the HealthScribe streaming session you want information about.</p>
     pub session_id: ::std::option::Option<::std::string::String>,
-8
+}
 impl GetMedicalScribeStreamInput {
     /// <p>The identifier of the HealthScribe streaming session you want information about.</p>
     pub fn session_id(&self) -> ::std::option::Option<&str> {
         self.session_id.as_deref()
-13
+    }
-14
+}
 static GETMEDICALSCRIBESTREAMINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming.synthetic#GetMedicalScribeStreamInput",

     "com.amazonaws.transcribestreaming.synthetic",
     "GetMedicalScribeStreamInput",
 );
 static GETMEDICALSCRIBESTREAMINPUT_MEMBER_SESSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#GetMedicalScribeStreamInput$SessionId",
         "com.amazonaws.transcribestreaming.synthetic",
         "GetMedicalScribeStreamInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "session_id",
     "SessionId",
 ,
-29
+)
 .with_http_label();
 static GETMEDICALSCRIBESTREAMINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GETMEDICALSCRIBESTREAMINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&GETMEDICALSCRIBESTREAMINPUT_MEMBER_SESSION_ID],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "GET",
     "/medical-scribe-stream/{SessionId}",
     None,
 ));
 impl GetMedicalScribeStreamInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETMEDICALSCRIBESTREAMINPUT_SCHEMA;
-44
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GetMedicalScribeStreamInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.session_id {
             ser.write_string(&GETMEDICALSCRIBESTREAMINPUT_MEMBER_SESSION_ID, val)?;
-53
+        }
         Ok(())
-55
+    }
-56
+}
 impl GetMedicalScribeStreamInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&GETMEDICALSCRIBESTREAMINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GETMEDICALSCRIBESTREAMINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.session_id = Some(deser.read_string(member)?);
-75
+                }
                 _ => {}
-77
+            }
             Ok(())
         })?;
         builder.session_id = builder.session_id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-84
+    }
-85
+}
 impl GetMedicalScribeStreamInput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl GetMedicalScribeStreamInput {
     /// Creates a new builder-style object to manufacture [`GetMedicalScribeStreamInput`](crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamInput).
     pub fn builder() -> crate::operation::get_medical_scribe_stream::builders::GetMedicalScribeStreamInputBuilder {
         crate::operation::get_medical_scribe_stream::builders::GetMedicalScribeStreamInputBuilder::default()
-101
+    }
-102
+}
-103
 /// A builder for [`GetMedicalScribeStreamInput`](crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct GetMedicalScribeStreamInputBuilder {
     pub(crate) session_id: ::std::option::Option<::std::string::String>,
-109
+}
 impl GetMedicalScribeStreamInputBuilder {
     /// <p>The identifier of the HealthScribe streaming session you want information about.</p>
     /// This field is required.
     pub fn session_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.session_id = ::std::option::Option::Some(input.into());
         self
-116
+    }
     /// <p>The identifier of the HealthScribe streaming session you want information about.</p>
     pub fn set_session_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.session_id = input;
         self
-121
+    }
     /// <p>The identifier of the HealthScribe streaming session you want information about.</p>
     pub fn get_session_id(&self) -> &::std::option::Option<::std::string::String> {
         &self.session_id
-125
+    }
     /// Consumes the builder and constructs a [`GetMedicalScribeStreamInput`](crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamInput).

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

@@ -1,1 +96,143 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct GetMedicalScribeStreamOutput {
     /// <p>Provides details about a HealthScribe streaming session.</p>
     pub medical_scribe_stream_details: ::std::option::Option<crate::types::MedicalScribeStreamDetails>,
     _request_id: Option<String>,
-9
+}
 impl GetMedicalScribeStreamOutput {
     /// <p>Provides details about a HealthScribe streaming session.</p>
     pub fn medical_scribe_stream_details(&self) -> ::std::option::Option<&crate::types::MedicalScribeStreamDetails> {
         self.medical_scribe_stream_details.as_ref()
-14
+    }
-15
+}
 static GETMEDICALSCRIBESTREAMOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming.synthetic#GetMedicalScribeStreamOutput",

     "com.amazonaws.transcribestreaming.synthetic",
     "GetMedicalScribeStreamOutput",
 );
 static GETMEDICALSCRIBESTREAMOUTPUT_MEMBER_MEDICAL_SCRIBE_STREAM_DETAILS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#GetMedicalScribeStreamOutput$MedicalScribeStreamDetails",
         "com.amazonaws.transcribestreaming.synthetic",
         "GetMedicalScribeStreamOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "medical_scribe_stream_details",
     "MedicalScribeStreamDetails",
 ,
 );
 static GETMEDICALSCRIBESTREAMOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
     ::aws_smithy_schema::ShapeType::String,
     "request_id",
 ,
-+
+)
 .with_http_header("x-amzn-requestid");
 static GETMEDICALSCRIBESTREAMOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GETMEDICALSCRIBESTREAMOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&GETMEDICALSCRIBESTREAMOUTPUT_MEMBER_MEDICAL_SCRIBE_STREAM_DETAILS],
     &[
         &GETMEDICALSCRIBESTREAMOUTPUT_MEMBER_MEDICAL_SCRIBE_STREAM_DETAILS,
         &GETMEDICALSCRIBESTREAMOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl GetMedicalScribeStreamOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETMEDICALSCRIBESTREAMOUTPUT_SCHEMA;
-49
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GetMedicalScribeStreamOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.medical_scribe_stream_details {
             ser.write_struct(&GETMEDICALSCRIBESTREAMOUTPUT_MEMBER_MEDICAL_SCRIBE_STREAM_DETAILS, val)?;
-58
+        }
         Ok(())
-60
+    }
-61
+}
 impl GetMedicalScribeStreamOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&GETMEDICALSCRIBESTREAMOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GETMEDICALSCRIBESTREAMOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.medical_scribe_stream_details = Some(crate::types::MedicalScribeStreamDetails::deserialize(deser)?);
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl GetMedicalScribeStreamOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&GETMEDICALSCRIBESTREAMOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.medical_scribe_stream_details = Some(crate::types::MedicalScribeStreamDetails::deserialize(deser)?);
-117
+                }
                 _ => {}
-119
+            }
             Ok(())
         })?;
         Ok(builder.build())
-123
+    }

↧ Expand context

-124
+}
 impl ::aws_types::request_id::RequestId for GetMedicalScribeStreamOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-128
+    }
-129
+}
 impl GetMedicalScribeStreamOutput {
     /// Creates a new builder-style object to manufacture [`GetMedicalScribeStreamOutput`](crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamOutput).
     pub fn builder() -> crate::operation::get_medical_scribe_stream::builders::GetMedicalScribeStreamOutputBuilder {
         crate::operation::get_medical_scribe_stream::builders::GetMedicalScribeStreamOutputBuilder::default()
-134
+    }
-135
+}
-136
 /// A builder for [`GetMedicalScribeStreamOutput`](crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct GetMedicalScribeStreamOutputBuilder {
     pub(crate) medical_scribe_stream_details: ::std::option::Option<crate::types::MedicalScribeStreamDetails>,
     _request_id: Option<String>,
-143
+}

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

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `StartCallAnalyticsStreamTranscription`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StartCallAnalyticsStreamTranscription;
 impl StartCallAnalyticsStreamTranscription {
     /// Creates a new `StartCallAnalyticsStreamTranscription`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionInput,
     ) -> ::std::result::Result<
         crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -142,148 +276,411 @@

↥ Expand context

             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError,
             >::new());
-151
         ::std::borrow::Cow::Owned(rcb)
-153
+    }
-154
+}
-155
 #[derive(Debug)]
 struct StartCallAnalyticsStreamTranscriptionResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for StartCallAnalyticsStreamTranscriptionResponseDeserializer {
     fn deserialize_streaming(
         &self,
         response: &mut ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::std::option::Option<::aws_smithy_runtime_api::client::interceptors::context::OutputOrError> {
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
-166
         // If this is an error, defer to the non-streaming parser

         if (!response.status().is_success() && response.status().as_u16() != 200) || force_error {
             return ::std::option::Option::None;
-170
+        }
         ::std::option::Option::Some(crate::protocol_serde::type_erase_result(
             crate::protocol_serde::shape_start_call_analytics_stream_transcription::de_start_call_analytics_stream_transcription_http_response(
                 response,
             ),
         ))
-176
+    }
-177
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         // For streaming operations, we only hit this case if its an error
         let body = response.body().bytes().expect("body loaded");
         crate::protocol_serde::type_erase_result(
             crate::protocol_serde::shape_start_call_analytics_stream_transcription::de_start_call_analytics_stream_transcription_http_error(
                 response.status().as_u16(),
                 response.headers(),
                 body,
             ),
--
+        )
         let status = response.status().as_u16();
         let headers = response.headers();
         #[allow(unused_mut)]
         let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
             ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         })?;
         generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
         let generic = generic_builder.build();
         let error_code = match generic.code() {
             ::std::option::Option::Some(code) => code,
             ::std::option::Option::None => {
                 return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                     ::aws_smithy_runtime_api::box_error::BoxError::from(
                         crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::unhandled(generic),
                     ),
                 ))
-+
+            }
         };
         let _error_message = generic.message().map(|msg| msg.to_owned());
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let err = match error_code {
             "BadRequestException" => {
                 crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::BadRequestException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::BadRequestException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::BadRequestException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 })
-+
+            }
             "ConflictException" => {
                 crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::ConflictException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ConflictException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ConflictException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 })
-+
+            }
             "InternalFailureException" => {
                 crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::InternalFailureException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InternalFailureException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InternalFailureException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 })
-+
+            }
             "LimitExceededException" => {
                 crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::LimitExceededException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::LimitExceededException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::LimitExceededException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 })
-+
+            }
             "ServiceUnavailableException" => {
                 crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::ServiceUnavailableException(
-+
+                    {
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::ServiceUnavailableException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::ServiceUnavailableException::deserialize_with_response(
                                     &mut *deser,
                                     response.headers(),
                                     response.status().into(),
                                     body,
-+
+                                )
                             }) {
                             ::std::result::Result::Ok(val) => val,
                             ::std::result::Result::Err(e) => {
                                 return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                     ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                                 ))
-+
+                            }
                         };
                         tmp.meta = generic;
                         if tmp.message.is_none() {
                             tmp.message = _error_message;
-+
+                        }
                         tmp
                     },
-+
+                )
-+
+            }
             _ => crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::generic(generic),
         };
         ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
             ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         ))
-345
+    }
-346
+}
 #[derive(Debug)]
 struct StartCallAnalyticsStreamTranscriptionRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for StartCallAnalyticsStreamTranscriptionRequestSerializer {
     #[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_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionInput>()
             .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_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/call-analytics-stream-transcription").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionInput,
                 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_call_analytics_stream_transcription::ser_start_call_analytics_stream_transcription_headers(
                         input, builder,
                     )?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             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 protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, StartCallAnalyticsStreamTranscription::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         *request.body_mut() = ::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_1_x(::http_body_util::StreamBody::new(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_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         // The protocol may have set Content-Length based on the initial empty body.
         // Remove it since the event stream body has unknown length.
         request.headers_mut().remove("Content-Length");
         request.headers_mut().insert("Content-Type", "application/vnd.amazon.eventstream");
-+
         return ::std::result::Result::Ok(request);
-382
+    }
-383
+}
 #[derive(Debug)]
 struct StartCallAnalyticsStreamTranscriptionEndpointParamsInterceptor;
-386
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StartCallAnalyticsStreamTranscriptionEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "StartCallAnalyticsStreamTranscriptionEndpointParamsInterceptor"
-390
+    }
-391

↧ Expand context

     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::<StartCallAnalyticsStreamTranscriptionInput>()
             .ok_or("failed to downcast to StartCallAnalyticsStreamTranscriptionInput")?;
-406
         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))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))

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

@@ -203,203 +654,764 @@

↥ Expand context

     pub fn content_identification_type(&self) -> ::std::option::Option<&crate::types::ContentIdentificationType> {
         self.content_identification_type.as_ref()
-205
+    }
     /// <p>Redacts all personally identifiable information (PII) identified in your transcript.</p>
     /// <p>Content redaction is performed at the segment level; PII specified in <code>PiiEntityTypes</code> is redacted upon complete transcription of an audio segment. If you don't include <code>PiiEntityTypes</code> in your request, all PII is redacted.</p>
     /// <p>You can’t set <code>ContentRedactionType</code> and <code>ContentIdentificationType</code> in the same request. If you set both, your request returns a <code>BadRequestException</code>.</p>
     /// <p>For more information, see <a href="https://docs.aws.amazon.com/transcribe/latest/dg/pii-redaction.html">Redacting or identifying personally identifiable information</a>.</p>
     pub fn content_redaction_type(&self) -> ::std::option::Option<&crate::types::ContentRedactionType> {
         self.content_redaction_type.as_ref()
-212
+    }
     /// <p>Specify which types of personally identifiable information (PII) you want to redact in your transcript. You can include as many types as you'd like, or you can select <code>ALL</code>.</p>
     /// <p>Values must be comma-separated and can include: <code>ADDRESS</code>, <code>BANK_ACCOUNT_NUMBER</code>, <code>BANK_ROUTING</code>, <code>CREDIT_DEBIT_CVV</code>, <code>CREDIT_DEBIT_EXPIRY</code>, <code>CREDIT_DEBIT_NUMBER</code>, <code>EMAIL</code>, <code>NAME</code>, <code>PHONE</code>, <code>PIN</code>, <code>SSN</code>, or <code>ALL</code>.</p>
     /// <p>Note that if you include <code>PiiEntityTypes</code> in your request, you must also include <code>ContentIdentificationType</code> or <code>ContentRedactionType</code>.</p>
     /// <p>If you include <code>ContentRedactionType</code> or <code>ContentIdentificationType</code> in your request, but do not include <code>PiiEntityTypes</code>, all PII is redacted or identified.</p>
     pub fn pii_entity_types(&self) -> ::std::option::Option<&str> {
         self.pii_entity_types.as_deref()
-219
+    }
-220
+}
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput",

     "com.amazonaws.transcribestreaming.synthetic",
     "StartCallAnalyticsStreamTranscriptionInput",
 );
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_LANGUAGE_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$LanguageCode",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartCallAnalyticsStreamTranscriptionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "language_code",
     "LanguageCode",
 ,
-235
+)
 .with_http_header("x-amzn-transcribe-language-code");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_MEDIA_SAMPLE_RATE_HERTZ: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$MediaSampleRateHertz",
             "com.amazonaws.transcribestreaming.synthetic",
             "StartCallAnalyticsStreamTranscriptionInput",
         ),
         ::aws_smithy_schema::ShapeType::Integer,
         "media_sample_rate_hertz",
         "MediaSampleRateHertz",
 ,
-247
+    )
     .with_http_header("x-amzn-transcribe-sample-rate");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_MEDIA_ENCODING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$MediaEncoding",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartCallAnalyticsStreamTranscriptionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "media_encoding",
     "MediaEncoding",
 ,
-258
+)
 .with_http_header("x-amzn-transcribe-media-encoding");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$VocabularyName",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartCallAnalyticsStreamTranscriptionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vocabulary_name",
     "VocabularyName",
 ,
-269
+)
 .with_http_header("x-amzn-transcribe-vocabulary-name");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_SESSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$SessionId",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartCallAnalyticsStreamTranscriptionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "session_id",
     "SessionId",
 ,
-280
+)
 .with_http_header("x-amzn-transcribe-session-id");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_AUDIO_STREAM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$AudioStream",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartCallAnalyticsStreamTranscriptionInput",
     ),
     ::aws_smithy_schema::ShapeType::Union,
     "audio_stream",
     "AudioStream",
 ,
-291
+)
 .with_http_payload();
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_FILTER_NAME: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$VocabularyFilterName",
             "com.amazonaws.transcribestreaming.synthetic",
             "StartCallAnalyticsStreamTranscriptionInput",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "vocabulary_filter_name",
         "VocabularyFilterName",
 ,
-303
+    )
     .with_http_header("x-amzn-transcribe-vocabulary-filter-name");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_FILTER_METHOD: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$VocabularyFilterMethod",
             "com.amazonaws.transcribestreaming.synthetic",
             "StartCallAnalyticsStreamTranscriptionInput",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "vocabulary_filter_method",
         "VocabularyFilterMethod",
 ,
-315
+    )
     .with_http_header("x-amzn-transcribe-vocabulary-filter-method");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_LANGUAGE_MODEL_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$LanguageModelName",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartCallAnalyticsStreamTranscriptionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "language_model_name",
     "LanguageModelName",
 ,
-326
+)
 .with_http_header("x-amzn-transcribe-language-model-name");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_IDENTIFY_LANGUAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$IdentifyLanguage",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartCallAnalyticsStreamTranscriptionInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "identify_language",
     "IdentifyLanguage",
 ,
-337
+)
 .with_http_header("x-amzn-transcribe-identify-language");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_LANGUAGE_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$LanguageOptions",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartCallAnalyticsStreamTranscriptionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "language_options",
     "LanguageOptions",
 ,
-348
+)
 .with_http_header("x-amzn-transcribe-language-options");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_PREFERRED_LANGUAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$PreferredLanguage",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartCallAnalyticsStreamTranscriptionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "preferred_language",
     "PreferredLanguage",
 ,
-359
+)
 .with_http_header("x-amzn-transcribe-preferred-language");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_NAMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$VocabularyNames",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartCallAnalyticsStreamTranscriptionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vocabulary_names",
     "VocabularyNames",
 ,
-370
+)
 .with_http_header("x-amzn-transcribe-vocabulary-names");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_FILTER_NAMES: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$VocabularyFilterNames",
             "com.amazonaws.transcribestreaming.synthetic",
             "StartCallAnalyticsStreamTranscriptionInput",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "vocabulary_filter_names",
         "VocabularyFilterNames",
 ,
-382
+    )
     .with_http_header("x-amzn-transcribe-vocabulary-filter-names");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_ENABLE_PARTIAL_RESULTS_STABILIZATION: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$EnablePartialResultsStabilization",
             "com.amazonaws.transcribestreaming.synthetic",
             "StartCallAnalyticsStreamTranscriptionInput",
         ),
         ::aws_smithy_schema::ShapeType::Boolean,
         "enable_partial_results_stabilization",
         "EnablePartialResultsStabilization",
 ,
-394
+    )
     .with_http_header("x-amzn-transcribe-enable-partial-results-stabilization");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_PARTIAL_RESULTS_STABILITY: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$PartialResultsStability",
             "com.amazonaws.transcribestreaming.synthetic",
             "StartCallAnalyticsStreamTranscriptionInput",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "partial_results_stability",
         "PartialResultsStability",
 ,
-406
+    )
     .with_http_header("x-amzn-transcribe-partial-results-stability");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_CONTENT_IDENTIFICATION_TYPE: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$ContentIdentificationType",
             "com.amazonaws.transcribestreaming.synthetic",
             "StartCallAnalyticsStreamTranscriptionInput",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "content_identification_type",
         "ContentIdentificationType",
 ,
-418
+    )
     .with_http_header("x-amzn-transcribe-content-identification-type");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_CONTENT_REDACTION_TYPE: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$ContentRedactionType",
             "com.amazonaws.transcribestreaming.synthetic",
             "StartCallAnalyticsStreamTranscriptionInput",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "content_redaction_type",
         "ContentRedactionType",
 ,
-430
+    )
     .with_http_header("x-amzn-transcribe-content-redaction-type");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_PII_ENTITY_TYPES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$PiiEntityTypes",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartCallAnalyticsStreamTranscriptionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "pii_entity_types",
     "PiiEntityTypes",
 ,
-441
+)
 .with_http_header("x-amzn-transcribe-pii-entity-types");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_LANGUAGE_CODE,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_MEDIA_SAMPLE_RATE_HERTZ,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_MEDIA_ENCODING,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_NAME,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_SESSION_ID,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_AUDIO_STREAM,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_FILTER_NAME,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_FILTER_METHOD,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_LANGUAGE_MODEL_NAME,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_IDENTIFY_LANGUAGE,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_LANGUAGE_OPTIONS,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_PREFERRED_LANGUAGE,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_NAMES,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_FILTER_NAMES,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_ENABLE_PARTIAL_RESULTS_STABILIZATION,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_PARTIAL_RESULTS_STABILITY,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_CONTENT_IDENTIFICATION_TYPE,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_CONTENT_REDACTION_TYPE,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_PII_ENTITY_TYPES,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "POST",
     "/call-analytics-stream-transcription",
     None,
 ));
 impl StartCallAnalyticsStreamTranscriptionInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_SCHEMA;
-476
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StartCallAnalyticsStreamTranscriptionInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.language_code {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_LANGUAGE_CODE, val.as_str())?;
-485
+        }
         if let Some(ref val) = self.media_sample_rate_hertz {
             ser.write_integer(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_MEDIA_SAMPLE_RATE_HERTZ, *val)?;
-488
+        }
         if let Some(ref val) = self.media_encoding {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_MEDIA_ENCODING, val.as_str())?;
-491
+        }
         if let Some(ref val) = self.vocabulary_name {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_NAME, val)?;
-494
+        }
         if let Some(ref val) = self.session_id {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_SESSION_ID, val)?;
-497
+        }
--
+        {
             let val = &self.audio_stream;
             ser.write_null(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_AUDIO_STREAM)?;
--
+        }
         if let Some(ref val) = self.vocabulary_filter_name {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_FILTER_NAME, val)?;
-500
+        }
         if let Some(ref val) = self.vocabulary_filter_method {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_FILTER_METHOD, val.as_str())?;
-503
+        }
         if let Some(ref val) = self.language_model_name {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_LANGUAGE_MODEL_NAME, val)?;
-506
+        }
         if let Some(ref val) = self.identify_language {
             ser.write_boolean(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_IDENTIFY_LANGUAGE, *val)?;
-509
+        }
         if let Some(ref val) = self.language_options {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_LANGUAGE_OPTIONS, val)?;
-512
+        }
         if let Some(ref val) = self.preferred_language {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_PREFERRED_LANGUAGE, val.as_str())?;
-515
+        }
         if let Some(ref val) = self.vocabulary_names {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_NAMES, val)?;
-518
+        }
         if let Some(ref val) = self.vocabulary_filter_names {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_FILTER_NAMES, val)?;
-521
+        }
         if let Some(ref val) = self.enable_partial_results_stabilization {
             ser.write_boolean(
                 &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_ENABLE_PARTIAL_RESULTS_STABILIZATION,
                 *val,
             )?;
-527
+        }
         if let Some(ref val) = self.partial_results_stability {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_PARTIAL_RESULTS_STABILITY, val.as_str())?;
-530
+        }
         if let Some(ref val) = self.content_identification_type {
             ser.write_string(
                 &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_CONTENT_IDENTIFICATION_TYPE,
                 val.as_str(),
             )?;
-536
+        }
         if let Some(ref val) = self.content_redaction_type {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_CONTENT_REDACTION_TYPE, val.as_str())?;
-539
+        }
         if let Some(ref val) = self.pii_entity_types {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_PII_ENTITY_TYPES, val)?;
-542
+        }
         Ok(())
-544
+    }
-545
+}
 impl StartCallAnalyticsStreamTranscriptionInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.language_code = Some(crate::types::CallAnalyticsLanguageCode::from(deser.read_string(member)?.as_str()));
-564
+                }
                 Some(1) => {
                     builder.media_sample_rate_hertz = Some(deser.read_integer(member)?);
-567
+                }
                 Some(2) => {
                     builder.media_encoding = Some(crate::types::MediaEncoding::from(deser.read_string(member)?.as_str()));
-570
+                }
                 Some(3) => {
                     builder.vocabulary_name = Some(deser.read_string(member)?);
-573
+                }
                 Some(4) => {
                     builder.session_id = Some(deser.read_string(member)?);
-576
+                }
                 Some(5) => {
                     builder.audio_stream = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                         todo!("deserialize streaming union")
                     });
-582
+                }
                 Some(6) => {
                     builder.vocabulary_filter_name = Some(deser.read_string(member)?);
-585
+                }
                 Some(7) => {
                     builder.vocabulary_filter_method = Some(crate::types::VocabularyFilterMethod::from(deser.read_string(member)?.as_str()));
-588
+                }
                 Some(8) => {
                     builder.language_model_name = Some(deser.read_string(member)?);
-591
+                }
                 Some(9) => {
                     builder.identify_language = Some(deser.read_boolean(member)?);
-594
+                }
                 Some(10) => {
                     builder.language_options = Some(deser.read_string(member)?);
-597
+                }
                 Some(11) => {
                     builder.preferred_language = Some(crate::types::CallAnalyticsLanguageCode::from(deser.read_string(member)?.as_str()));
-600
+                }
                 Some(12) => {
                     builder.vocabulary_names = Some(deser.read_string(member)?);
-603
+                }
                 Some(13) => {
                     builder.vocabulary_filter_names = Some(deser.read_string(member)?);
-606
+                }
                 Some(14) => {
                     builder.enable_partial_results_stabilization = Some(deser.read_boolean(member)?);
-609
+                }
                 Some(15) => {
                     builder.partial_results_stability = Some(crate::types::PartialResultsStability::from(deser.read_string(member)?.as_str()));
-612
+                }
                 Some(16) => {
                     builder.content_identification_type = Some(crate::types::ContentIdentificationType::from(deser.read_string(member)?.as_str()));
-615
+                }
                 Some(17) => {
                     builder.content_redaction_type = Some(crate::types::ContentRedactionType::from(deser.read_string(member)?.as_str()));
-618
+                }
                 Some(18) => {
                     builder.pii_entity_types = Some(deser.read_string(member)?);
-621
+                }
                 _ => {}
-623
+            }
             Ok(())
         })?;
         builder.media_sample_rate_hertz = builder.media_sample_rate_hertz.or(Some(0i32));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl StartCallAnalyticsStreamTranscriptionInput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amzn-transcribe-language-code") {
             builder.language_code = Some(crate::types::CallAnalyticsLanguageCode::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-sample-rate") {
             builder.media_sample_rate_hertz = val.parse::<i32>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-media-encoding") {
             builder.media_encoding = Some(crate::types::MediaEncoding::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-vocabulary-name") {
             builder.vocabulary_name = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-session-id") {
             builder.session_id = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-vocabulary-filter-name") {
             builder.vocabulary_filter_name = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-vocabulary-filter-method") {
             builder.vocabulary_filter_method = Some(crate::types::VocabularyFilterMethod::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-language-model-name") {
             builder.language_model_name = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-identify-language") {
             builder.identify_language = val.parse::<bool>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-language-options") {
             builder.language_options = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-preferred-language") {
             builder.preferred_language = Some(crate::types::CallAnalyticsLanguageCode::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-vocabulary-names") {
             builder.vocabulary_names = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-vocabulary-filter-names") {
             builder.vocabulary_filter_names = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-enable-partial-results-stabilization") {
             builder.enable_partial_results_stabilization = val.parse::<bool>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-partial-results-stability") {
             builder.partial_results_stability = Some(crate::types::PartialResultsStability::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-content-identification-type") {
             builder.content_identification_type = Some(crate::types::ContentIdentificationType::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-content-redaction-type") {
             builder.content_redaction_type = Some(crate::types::ContentRedactionType::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-pii-entity-types") {
             builder.pii_entity_types = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => { /* read from headers above */ }
                 Some(1) => { /* read from headers above */ }
                 Some(2) => { /* read from headers above */ }
                 Some(3) => { /* read from headers above */ }
                 Some(4) => { /* read from headers above */ }
                 Some(5) => {
                     builder.audio_stream = Some({
                         let _ = member;
                         todo!("deserialize streaming union")
                     });
-+
+                }
                 Some(6) => { /* read from headers above */ }
                 Some(7) => { /* read from headers above */ }
                 Some(8) => { /* read from headers above */ }
                 Some(9) => { /* read from headers above */ }
                 Some(10) => { /* read from headers above */ }
                 Some(11) => { /* read from headers above */ }
                 Some(12) => { /* read from headers above */ }
                 Some(13) => { /* read from headers above */ }
                 Some(14) => { /* read from headers above */ }
                 Some(15) => { /* read from headers above */ }
                 Some(16) => { /* read from headers above */ }
                 Some(17) => { /* read from headers above */ }
                 Some(18) => { /* read from headers above */ }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-738
+    }
-739
+}
 impl StartCallAnalyticsStreamTranscriptionInput {
     /// Creates a new builder-style object to manufacture [`StartCallAnalyticsStreamTranscriptionInput`](crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionInput).
     pub fn builder() -> crate::operation::start_call_analytics_stream_transcription::builders::StartCallAnalyticsStreamTranscriptionInputBuilder {
         crate::operation::start_call_analytics_stream_transcription::builders::StartCallAnalyticsStreamTranscriptionInputBuilder::default()
-744
+    }

↧ Expand context

-745
+}
-746
 /// A builder for [`StartCallAnalyticsStreamTranscriptionInput`](crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionInput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StartCallAnalyticsStreamTranscriptionInputBuilder {
     pub(crate) language_code: ::std::option::Option<crate::types::CallAnalyticsLanguageCode>,
     pub(crate) media_sample_rate_hertz: ::std::option::Option<i32>,
     pub(crate) media_encoding: ::std::option::Option<crate::types::MediaEncoding>,
     pub(crate) vocabulary_name: ::std::option::Option<::std::string::String>,
     pub(crate) session_id: ::std::option::Option<::std::string::String>,
     pub(crate) audio_stream:
         ::std::option::Option<::aws_smithy_http::event_stream::EventStreamSender<crate::types::AudioStream, crate::types::error::AudioStreamError>>,
     pub(crate) vocabulary_filter_name: ::std::option::Option<::std::string::String>,
     pub(crate) vocabulary_filter_method: ::std::option::Option<crate::types::VocabularyFilterMethod>,
     pub(crate) language_model_name: ::std::option::Option<::std::string::String>,
     pub(crate) identify_language: ::std::option::Option<bool>,
     pub(crate) language_options: ::std::option::Option<::std::string::String>,
     pub(crate) preferred_language: ::std::option::Option<crate::types::CallAnalyticsLanguageCode>,
     pub(crate) vocabulary_names: ::std::option::Option<::std::string::String>,

AWS SDK

Files changed:

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/error/_conflict_exception.rs

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/error/_internal_server_exception.rs

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/error/_invalid_endpoint_exception.rs

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/error/_rejected_records_exception.rs

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/error/_resource_not_found_exception.rs

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/error/_service_quota_exceeded_exception.rs

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/error/_throttling_exception.rs

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/error/_validation_exception.rs

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

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

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

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

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

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

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

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