AWS SDK

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/src/types/_transcript_result_stream.rs

@@ -9,9 +0,95 @@

     /// The `Unknown` variant represents cases where new union variant was received. Consider upgrading the SDK to the latest available version.
     /// An unknown enum variant
     ///
     /// _Note: If you encounter this error, consider upgrading your SDK to the latest version._
     /// The `Unknown` variant represents cases where the server sent a value that wasn't recognized
     /// by the client. This can happen when the server adds new functionality, but the client has not been updated.
     /// To investigate this, consider turning on debug logging to print the raw HTTP response.
     #[non_exhaustive]
     Unknown,
-18
+}
 impl TranscriptResultStream {
     #[allow(irrefutable_let_patterns)]
     /// Tries to convert the enum instance into [`TranscriptEvent`](crate::types::TranscriptResultStream::TranscriptEvent), extracting the inner [`TranscriptEvent`](crate::types::TranscriptEvent).
     /// Returns `Err(&Self)` if it can't be converted.
     pub fn as_transcript_event(&self) -> ::std::result::Result<&crate::types::TranscriptEvent, &Self> {
         if let TranscriptResultStream::TranscriptEvent(val) = &self {
             ::std::result::Result::Ok(val)
         } else {
             ::std::result::Result::Err(self)
-28
+        }

-29
+    }
     /// Returns true if this is a [`TranscriptEvent`](crate::types::TranscriptResultStream::TranscriptEvent).
     pub fn is_transcript_event(&self) -> bool {
         self.as_transcript_event().is_ok()
-33
+    }
     /// Returns true if the enum instance is the `Unknown` variant.
     pub fn is_unknown(&self) -> bool {
         matches!(self, Self::Unknown)
-37
+    }
-38
+}
 static TRANSCRIPTRESULTSTREAM_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming#TranscriptResultStream",
     "com.amazonaws.transcribestreaming",
     "TranscriptResultStream",
 );
 static TRANSCRIPTRESULTSTREAM_MEMBER_TRANSCRIPTEVENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#TranscriptResultStream$TranscriptEvent",
         "com.amazonaws.transcribestreaming",
         "TranscriptResultStream",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "TranscriptEvent",
 ,
 );
 static TRANSCRIPTRESULTSTREAM_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     TRANSCRIPTRESULTSTREAM_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Union,
     &[&TRANSCRIPTRESULTSTREAM_MEMBER_TRANSCRIPTEVENT],
-+
+)
 .with_streaming();
 impl TranscriptResultStream {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TRANSCRIPTRESULTSTREAM_SCHEMA;
-+
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for TranscriptResultStream {
     #[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> {
         match self {
             Self::TranscriptEvent(val) => {
                 ser.write_struct(&TRANSCRIPTRESULTSTREAM_MEMBER_TRANSCRIPTEVENT, val)?;
-+
+            }
             Self::Unknown => return Err(::aws_smithy_schema::serde::SerdeError::custom("cannot serialize unknown union variant")),
-+
+        }
         Ok(())
-+
+    }
-+
+}
 impl TranscriptResultStream {
     /// Deserializes this union from a [`ShapeDeserializer`].
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         let mut result: ::std::option::Option<Self> = ::std::option::Option::None;
         #[allow(unused_variables, unreachable_code, clippy::single_match, clippy::match_single_binding)]
         deserializer.read_struct(&TRANSCRIPTRESULTSTREAM_SCHEMA, &mut |member, deser| {
             result = ::std::option::Option::Some(match member.member_index() {
                 Some(0) => Self::TranscriptEvent(crate::types::TranscriptEvent::deserialize(deser)?),
                 _ => Self::Unknown,
             });
             Ok(())
         })?;
         result.ok_or_else(|| ::aws_smithy_schema::serde::SerdeError::custom("expected a union variant"))
-+
+    }
-+
+}

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/src/types/_utterance_event.rs

@@ -72,72 +242,242 @@

↥ Expand context

-72
+    }
     /// <p>Provides the issue that was detected in the specified segment.</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 `.issues_detected.is_none()`.
     pub fn issues_detected(&self) -> &[crate::types::IssueDetected] {
         self.issues_detected.as_deref().unwrap_or_default()
-78
+    }
     /// <p>The language code that represents the language spoken in your audio stream.</p>
     pub fn language_code(&self) -> ::std::option::Option<&crate::types::CallAnalyticsLanguageCode> {
         self.language_code.as_ref()
-82
+    }
     /// <p>The language code of the dominant language identified in your stream.</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 `.language_identification.is_none()`.
     pub fn language_identification(&self) -> &[crate::types::CallAnalyticsLanguageWithScore] {
         self.language_identification.as_deref().unwrap_or_default()
-88
+    }
-89
+}
 static UTTERANCEEVENT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming#UtteranceEvent",

     "com.amazonaws.transcribestreaming",
     "UtteranceEvent",
 );
 static UTTERANCEEVENT_MEMBER_UTTERANCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#UtteranceEvent$UtteranceId",
         "com.amazonaws.transcribestreaming",
         "UtteranceEvent",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "utterance_id",
     "UtteranceId",
 ,
 );
 static UTTERANCEEVENT_MEMBER_IS_PARTIAL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#UtteranceEvent$IsPartial",
         "com.amazonaws.transcribestreaming",
         "UtteranceEvent",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "is_partial",
     "IsPartial",
 ,
 );
 static UTTERANCEEVENT_MEMBER_PARTICIPANT_ROLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#UtteranceEvent$ParticipantRole",
         "com.amazonaws.transcribestreaming",
         "UtteranceEvent",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "participant_role",
     "ParticipantRole",
 ,
 );
 static UTTERANCEEVENT_MEMBER_BEGIN_OFFSET_MILLIS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#UtteranceEvent$BeginOffsetMillis",
         "com.amazonaws.transcribestreaming",
         "UtteranceEvent",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "begin_offset_millis",
     "BeginOffsetMillis",
 ,
 );
 static UTTERANCEEVENT_MEMBER_END_OFFSET_MILLIS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#UtteranceEvent$EndOffsetMillis",
         "com.amazonaws.transcribestreaming",
         "UtteranceEvent",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "end_offset_millis",
     "EndOffsetMillis",
 ,
 );
 static UTTERANCEEVENT_MEMBER_TRANSCRIPT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#UtteranceEvent$Transcript",
         "com.amazonaws.transcribestreaming",
         "UtteranceEvent",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "transcript",
     "Transcript",
 ,
 );
 static UTTERANCEEVENT_MEMBER_ITEMS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#UtteranceEvent$Items",
         "com.amazonaws.transcribestreaming",
         "UtteranceEvent",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "items",
     "Items",
 ,
 );
 static UTTERANCEEVENT_MEMBER_ENTITIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#UtteranceEvent$Entities",
         "com.amazonaws.transcribestreaming",
         "UtteranceEvent",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "entities",
     "Entities",
 ,
 );
 static UTTERANCEEVENT_MEMBER_SENTIMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#UtteranceEvent$Sentiment",
         "com.amazonaws.transcribestreaming",
         "UtteranceEvent",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "sentiment",
     "Sentiment",
 ,
 );
 static UTTERANCEEVENT_MEMBER_ISSUES_DETECTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#UtteranceEvent$IssuesDetected",
         "com.amazonaws.transcribestreaming",
         "UtteranceEvent",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "issues_detected",
     "IssuesDetected",
 ,
 );
 static UTTERANCEEVENT_MEMBER_LANGUAGE_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#UtteranceEvent$LanguageCode",
         "com.amazonaws.transcribestreaming",
         "UtteranceEvent",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "language_code",
     "LanguageCode",
 ,
 );
 static UTTERANCEEVENT_MEMBER_LANGUAGE_IDENTIFICATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#UtteranceEvent$LanguageIdentification",
         "com.amazonaws.transcribestreaming",
         "UtteranceEvent",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "language_identification",
     "LanguageIdentification",
 ,
 );
 static UTTERANCEEVENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     UTTERANCEEVENT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &UTTERANCEEVENT_MEMBER_UTTERANCE_ID,
         &UTTERANCEEVENT_MEMBER_IS_PARTIAL,
         &UTTERANCEEVENT_MEMBER_PARTICIPANT_ROLE,
         &UTTERANCEEVENT_MEMBER_BEGIN_OFFSET_MILLIS,

↧ Expand context

         &UTTERANCEEVENT_MEMBER_END_OFFSET_MILLIS,
         &UTTERANCEEVENT_MEMBER_TRANSCRIPT,
         &UTTERANCEEVENT_MEMBER_ITEMS,
         &UTTERANCEEVENT_MEMBER_ENTITIES,
         &UTTERANCEEVENT_MEMBER_SENTIMENT,
         &UTTERANCEEVENT_MEMBER_ISSUES_DETECTED,
         &UTTERANCEEVENT_MEMBER_LANGUAGE_CODE,
         &UTTERANCEEVENT_MEMBER_LANGUAGE_IDENTIFICATION,
     ],
 );
 impl UtteranceEvent {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UTTERANCEEVENT_SCHEMA;
-236
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UtteranceEvent {
     #[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> {

@@ -287,287 +443,442 @@

↥ Expand context

         if let Some(ref val) = self.issues_detected {
             ser.write_list(
                 &UTTERANCEEVENT_MEMBER_ISSUES_DETECTED,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::IssueDetected::SCHEMA, item)?;
-293
+                    }
                     Ok(())
                 },
             )?;
-297
+        }
         if let Some(ref val) = self.language_code {
             ser.write_string(&UTTERANCEEVENT_MEMBER_LANGUAGE_CODE, val.as_str())?;
-300
+        }
         if let Some(ref val) = self.language_identification {
             ser.write_list(
                 &UTTERANCEEVENT_MEMBER_LANGUAGE_IDENTIFICATION,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::CallAnalyticsLanguageWithScore::SCHEMA, item)?;

-307
+                    }
                     Ok(())
                 },
             )?;
-311
+        }
         Ok(())
-313
+    }
-314
+}
 impl UtteranceEvent {
     /// 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(&UTTERANCEEVENT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UTTERANCEEVENT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.utterance_id = Some(deser.read_string(member)?);
-333
+                }
                 Some(1) => {
                     builder.is_partial = Some(deser.read_boolean(member)?);
-336
+                }
                 Some(2) => {
                     builder.participant_role = Some(crate::types::ParticipantRole::from(deser.read_string(member)?.as_str()));
-339
+                }
                 Some(3) => {
                     builder.begin_offset_millis = Some(deser.read_long(member)?);
-342
+                }
                 Some(4) => {
                     builder.end_offset_millis = Some(deser.read_long(member)?);
-345
+                }
                 Some(5) => {
                     builder.transcript = Some(deser.read_string(member)?);
-348
+                }
                 Some(6) => {
                     builder.items = 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::CallAnalyticsItem::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::CallAnalyticsItem::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-358
+                }
                 Some(7) => {
                     builder.entities = 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::CallAnalyticsEntity::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::CallAnalyticsEntity::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-368
+                }
                 Some(8) => {
                     builder.sentiment = Some(crate::types::Sentiment::from(deser.read_string(member)?.as_str()));
-371
+                }
                 Some(9) => {
                     builder.issues_detected = 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::IssueDetected::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::IssueDetected::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-381
+                }
                 Some(10) => {
                     builder.language_code = Some(crate::types::CallAnalyticsLanguageCode::from(deser.read_string(member)?.as_str()));
-384
+                }
                 Some(11) => {
                     builder.language_identification = 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::CallAnalyticsLanguageWithScore::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::CallAnalyticsLanguageWithScore::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-394
+                }
                 _ => {}
-396
+            }
             Ok(())
         })?;
         Ok(builder.build())
-400
+    }
-401
+}
 impl UtteranceEvent {
     /// 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 UtteranceEvent {
     /// Creates a new builder-style object to manufacture [`UtteranceEvent`](crate::types::UtteranceEvent).
     pub fn builder() -> crate::types::builders::UtteranceEventBuilder {
         crate::types::builders::UtteranceEventBuilder::default()
-417
+    }
-418
+}
-419
 /// A builder for [`UtteranceEvent`](crate::types::UtteranceEvent).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct UtteranceEventBuilder {
     pub(crate) utterance_id: ::std::option::Option<::std::string::String>,
     pub(crate) is_partial: ::std::option::Option<bool>,
     pub(crate) participant_role: ::std::option::Option<crate::types::ParticipantRole>,
     pub(crate) begin_offset_millis: ::std::option::Option<i64>,
     pub(crate) end_offset_millis: ::std::option::Option<i64>,
     pub(crate) transcript: ::std::option::Option<::std::string::String>,
     pub(crate) items: ::std::option::Option<::std::vec::Vec<crate::types::CallAnalyticsItem>>,
     pub(crate) entities: ::std::option::Option<::std::vec::Vec<crate::types::CallAnalyticsEntity>>,
     pub(crate) sentiment: ::std::option::Option<crate::types::Sentiment>,
     pub(crate) issues_detected: ::std::option::Option<::std::vec::Vec<crate::types::IssueDetected>>,
     pub(crate) language_code: ::std::option::Option<crate::types::CallAnalyticsLanguageCode>,
     pub(crate) language_identification: ::std::option::Option<::std::vec::Vec<crate::types::CallAnalyticsLanguageWithScore>>,
-436
+}
 impl UtteranceEventBuilder {
     /// <p>The unique identifier that is associated with the specified <code>UtteranceEvent</code>.</p>
     pub fn utterance_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.utterance_id = ::std::option::Option::Some(input.into());
         self
-442
+    }

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/src/types/error/_bad_request_exception.rs

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

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>One or more arguments to the <code>StartStreamTranscription</code>, <code>StartMedicalStreamTranscription</code>, or <code>StartCallAnalyticsStreamTranscription</code> operation was not valid. For example, <code>MediaEncoding</code> or <code>LanguageCode</code> used unsupported values. Check the specified parameters and try your request again.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct BadRequestException {
     #[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 BADREQUESTEXCEPTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming#BadRequestException",

     "com.amazonaws.transcribestreaming",
     "BadRequestException",
 );
 static BADREQUESTEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#BadRequestException$Message",
         "com.amazonaws.transcribestreaming",
         "BadRequestException",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "message",
     "Message",
 ,
 );
 static BADREQUESTEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     BADREQUESTEXCEPTION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&BADREQUESTEXCEPTION_MEMBER_MESSAGE],
 );
 impl BadRequestException {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &BADREQUESTEXCEPTION_SCHEMA;
-34
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for BadRequestException {
     #[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(&BADREQUESTEXCEPTION_MEMBER_MESSAGE, val)?;
-43
+        }
         Ok(())
-45
+    }
-46
+}
 impl BadRequestException {
     /// 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(&BADREQUESTEXCEPTION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&BADREQUESTEXCEPTION_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 BadRequestException {
     /// 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 BadRequestException {
     /// Returns the error message.
     pub fn message(&self) -> ::std::option::Option<&str> {
         self.message.as_deref()
-88
+    }
-89
+}
 impl ::std::fmt::Display for BadRequestException {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "BadRequestException")?;
         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 BadRequestException {}
 impl ::aws_types::request_id::RequestId for crate::types::error::BadRequestException {
     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 BadRequestException {
     fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
         &self.meta
-111
+    }
-112
+}
 impl BadRequestException {

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

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

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>A new stream started with the same session ID. The current stream has been terminated.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct ConflictException {
     #[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 CONFLICTEXCEPTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming#ConflictException",

     "com.amazonaws.transcribestreaming",
     "ConflictException",
 );
 static CONFLICTEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#ConflictException$Message",
         "com.amazonaws.transcribestreaming",
         "ConflictException",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "message",
     "Message",
 ,
 );
 static CONFLICTEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CONFLICTEXCEPTION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&CONFLICTEXCEPTION_MEMBER_MESSAGE],
 );
 impl ConflictException {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CONFLICTEXCEPTION_SCHEMA;
-34
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ConflictException {
     #[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(&CONFLICTEXCEPTION_MEMBER_MESSAGE, val)?;
-43
+        }
         Ok(())
-45
+    }
-46
+}
 impl ConflictException {
     /// 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(&CONFLICTEXCEPTION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CONFLICTEXCEPTION_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 ConflictException {
     /// 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 ConflictException {
     /// Returns the error message.
     pub fn message(&self) -> ::std::option::Option<&str> {
         self.message.as_deref()
-88
+    }
-89
+}
 impl ::std::fmt::Display for ConflictException {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "ConflictException")?;
         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 ConflictException {}
 impl ::aws_types::request_id::RequestId for crate::types::error::ConflictException {
     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 ConflictException {
     fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
         &self.meta
-111
+    }
-112
+}
 impl ConflictException {

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/src/types/error/_internal_failure_exception.rs

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

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>A problem occurred while processing the audio. Amazon Transcribe terminated processing.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct InternalFailureException {
     #[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 INTERNALFAILUREEXCEPTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming#InternalFailureException",

     "com.amazonaws.transcribestreaming",
     "InternalFailureException",
 );
 static INTERNALFAILUREEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#InternalFailureException$Message",
         "com.amazonaws.transcribestreaming",
         "InternalFailureException",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "message",
     "Message",
 ,
 );
 static INTERNALFAILUREEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     INTERNALFAILUREEXCEPTION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&INTERNALFAILUREEXCEPTION_MEMBER_MESSAGE],
 );
 impl InternalFailureException {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INTERNALFAILUREEXCEPTION_SCHEMA;
-34
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for InternalFailureException {
     #[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(&INTERNALFAILUREEXCEPTION_MEMBER_MESSAGE, val)?;
-43
+        }
         Ok(())
-45
+    }
-46
+}
 impl InternalFailureException {
     /// 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(&INTERNALFAILUREEXCEPTION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&INTERNALFAILUREEXCEPTION_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 InternalFailureException {
     /// 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 InternalFailureException {
     /// Returns the error message.
     pub fn message(&self) -> ::std::option::Option<&str> {
         self.message.as_deref()
-88
+    }
-89
+}
 impl ::std::fmt::Display for InternalFailureException {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "InternalFailureException")?;
         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 InternalFailureException {}
 impl ::aws_types::request_id::RequestId for crate::types::error::InternalFailureException {
     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 InternalFailureException {
     fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
         &self.meta
-111
+    }
-112
+}
 impl InternalFailureException {

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/src/types/error/_limit_exceeded_exception.rs

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

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Your client has exceeded one of the Amazon Transcribe limits. This is typically the audio length limit. Break your audio stream into smaller chunks and try your request again.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct LimitExceededException {
     #[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 LIMITEXCEEDEDEXCEPTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming#LimitExceededException",

     "com.amazonaws.transcribestreaming",
     "LimitExceededException",
 );
 static LIMITEXCEEDEDEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#LimitExceededException$Message",
         "com.amazonaws.transcribestreaming",
         "LimitExceededException",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "message",
     "Message",
 ,
 );
 static LIMITEXCEEDEDEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LIMITEXCEEDEDEXCEPTION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&LIMITEXCEEDEDEXCEPTION_MEMBER_MESSAGE],
 );
 impl LimitExceededException {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LIMITEXCEEDEDEXCEPTION_SCHEMA;
-34
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for LimitExceededException {
     #[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(&LIMITEXCEEDEDEXCEPTION_MEMBER_MESSAGE, val)?;
-43
+        }
         Ok(())
-45
+    }
-46
+}
 impl LimitExceededException {
     /// 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(&LIMITEXCEEDEDEXCEPTION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LIMITEXCEEDEDEXCEPTION_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 LimitExceededException {
     /// 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 LimitExceededException {
     /// Returns the error message.
     pub fn message(&self) -> ::std::option::Option<&str> {
         self.message.as_deref()
-88
+    }
-89
+}
 impl ::std::fmt::Display for LimitExceededException {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "LimitExceededException")?;
         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 LimitExceededException {}
 impl ::aws_types::request_id::RequestId for crate::types::error::LimitExceededException {
     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 LimitExceededException {
     fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
         &self.meta
-111
+    }
-112
+}
 impl LimitExceededException {

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/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 request references a resource which doesn't exist.</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.transcribestreaming#ResourceNotFoundException",

     "com.amazonaws.transcribestreaming",
     "ResourceNotFoundException",
 );
 static RESOURCENOTFOUNDEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#ResourceNotFoundException$Message",
         "com.amazonaws.transcribestreaming",
         "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/transcribestreaming/src/types/error/_service_unavailable_exception.rs

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

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>The service is currently unavailable. Try your request later.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct ServiceUnavailableException {
     #[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 SERVICEUNAVAILABLEEXCEPTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming#ServiceUnavailableException",

     "com.amazonaws.transcribestreaming",
     "ServiceUnavailableException",
 );
 static SERVICEUNAVAILABLEEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#ServiceUnavailableException$Message",
         "com.amazonaws.transcribestreaming",
         "ServiceUnavailableException",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "message",
     "Message",
 ,
 );
 static SERVICEUNAVAILABLEEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SERVICEUNAVAILABLEEXCEPTION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&SERVICEUNAVAILABLEEXCEPTION_MEMBER_MESSAGE],
 );
 impl ServiceUnavailableException {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SERVICEUNAVAILABLEEXCEPTION_SCHEMA;
-34
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ServiceUnavailableException {
     #[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(&SERVICEUNAVAILABLEEXCEPTION_MEMBER_MESSAGE, val)?;
-43
+        }
         Ok(())
-45
+    }
-46
+}
 impl ServiceUnavailableException {
     /// 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(&SERVICEUNAVAILABLEEXCEPTION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SERVICEUNAVAILABLEEXCEPTION_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 ServiceUnavailableException {
     /// 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 ServiceUnavailableException {
     /// Returns the error message.
     pub fn message(&self) -> ::std::option::Option<&str> {
         self.message.as_deref()
-88
+    }
-89
+}
 impl ::std::fmt::Display for ServiceUnavailableException {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "ServiceUnavailableException")?;
         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 ServiceUnavailableException {}
 impl ::aws_types::request_id::RequestId for crate::types::error::ServiceUnavailableException {
     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 ServiceUnavailableException {
     fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
         &self.meta
-111
+    }
-112
+}
 impl ServiceUnavailableException {

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/tests/canary_repro.rs

@@ -0,1 +0,126 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-+
 //! Verifies that the schema-based serialization path (via SdkConfig →
 //! SharedClientProtocol) produces correct requests for streaming operations.
-+
 use async_stream::stream;
 use aws_credential_types::Credentials;
 use aws_sdk_transcribestreaming::config::Region;
 use aws_sdk_transcribestreaming::primitives::Blob;
 use aws_sdk_transcribestreaming::types::{
     AudioEvent, AudioStream, LanguageCode, MediaEncoding, TranscriptResultStream,
 };
 use aws_sdk_transcribestreaming::Client;
 use aws_smithy_http_client::test_util::dvr::{Event, ReplayingClient};
 use bytes::BufMut;
-+
 const CHUNK_SIZE: usize = 8192;
-+
 fn client_from_sdk_config(replayer: ReplayingClient) -> Client {
     let sdk_config =
         aws_types::SdkConfig::builder()
             .region(Region::from_static("us-west-2"))
             .credentials_provider(
                 aws_credential_types::provider::SharedCredentialsProvider::new(
                     Credentials::for_tests(),
                 ),
-+
+            )
             .http_client(replayer)
             .build();
     Client::new(&sdk_config)
-+
+}
-+
 async fn run_transcribe(client: &Client) -> Result<String, Box<dyn std::error::Error>> {
     let input_stream = stream! {
         let pcm = pcm_data();
         for chunk in pcm.chunks(CHUNK_SIZE) {
             yield Ok(AudioStream::AudioEvent(
                 AudioEvent::builder().audio_chunk(Blob::new(chunk)).build(),
             ));
-+
+        }
     };
-+
     let mut output = client
         .start_stream_transcription()
         .language_code(LanguageCode::EnGb)
         .media_sample_rate_hertz(8000)
         .media_encoding(MediaEncoding::Pcm)
         .audio_stream(input_stream.into())
         .send()
         .await?;
-+
     let mut full_message = String::new();
     while let Some(event) = output.transcript_result_stream.recv().await? {
         match event {
             TranscriptResultStream::TranscriptEvent(transcript_event) => {
                 let transcript = transcript_event.transcript.unwrap();
                 for result in transcript.results.unwrap_or_default() {
                     if !result.is_partial {
                         let first_alternative = &result.alternatives.as_ref().unwrap()[0];
                         full_message += first_alternative.transcript.as_ref().unwrap();
                         full_message.push(' ');
-+
+                    }
-+
+                }
-+
+            }
             otherwise => panic!("received unexpected event type: {otherwise:?}"),
-+
+        }
-+
+    }
     Ok(full_message)
-+
+}
-+
 /// Test that the schema-based path (SdkConfig → SharedClientProtocol) produces
 /// correct requests, matching the canary's code path.
 #[tokio::test]
 async fn test_schema_path_with_replaying_client() {
     let events: Vec<Event> = serde_json::from_str(include_str!("success.json")).unwrap();
     let replayer = ReplayingClient::new(events);
     let client = client_from_sdk_config(replayer.clone());
     let result = run_transcribe(&client)
         .await
         .expect("transcription should succeed");
     assert!(
         !result.trim().is_empty(),
         "transcription result should not be empty"
     );
     replayer
         .validate(&["content-type", "content-length"], |expected, actual| {
             aws_smithy_eventstream::test_util::validate_body(expected, actual, true)
         })
         .await
         .unwrap();
-+
+}
-+
 /// Verify that event stream requests do NOT have a Content-Length header.
 /// The protocol's serialize_request may set Content-Length from the initial
 /// empty body, but it must be removed when the body is replaced with the
 /// streaming event stream. A stale Content-Length: 0 causes the service to
 /// cancel the HTTP/2 stream immediately.
 #[tokio::test]
 async fn test_event_stream_no_content_length() {
     let events: Vec<Event> = serde_json::from_str(include_str!("success.json")).unwrap();
     let replayer = ReplayingClient::new(events);
     let client = client_from_sdk_config(replayer.clone());
     let _ = run_transcribe(&client).await;
     let requests = replayer.take_requests().await;
     let first = requests.first().expect("should have at least one request");
     assert!(
         first.headers().get("content-length").is_none(),
         "event stream request must not have Content-Length header, \
          but found: {:?}",
         first.headers().get("content-length"),
     );
-+
+}
-+
 fn pcm_data() -> Vec<u8> {
     let reader = hound::WavReader::new(&include_bytes!("hello-transcribe-8000.wav")[..])
         .expect("valid wav data");
     let samples_result: hound::Result<Vec<i16>> = reader.into_samples::<i16>().collect();
     let mut pcm: Vec<u8> = Vec::new();
     for sample in samples_result.unwrap() {
         pcm.put_i16_le(sample);
-+
+    }
     pcm
-+
+}

 [package]
 name = "no-default-features"
 version = "0.1.0"
 authors = ["Zelda Hessler <zhessler@amazon.com>"]
 description = "These tests ensure that things will fail (or not fail) as expected\nwhen default features are disabled for all SDK and runtime crates.\n"
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/smithy-lang/smithy-rs"
 publish = false
-11
 [dev-dependencies]
 futures = "0.3.25"
-14
 [dev-dependencies.aws-config]
 path = "../../sdk/aws-config"
 default-features = false
 version = "1.9.0"
-19
 [dev-dependencies.aws-sdk-s3]
 path = "../../sdk/s3"

 default-features = false
 version = "0.0.0-local"
-24
 [dev-dependencies.aws-smithy-async]
 path = "../../sdk/aws-smithy-async"
 version = "1.2.14"
-28
 [dev-dependencies.aws-smithy-runtime]
 path = "../../sdk/aws-smithy-runtime"
 features = ["test-util"]
 version = "1.10.3"
 version = "1.10.4"
-33
 [dev-dependencies.aws-smithy-http-client]
 path = "../../sdk/aws-smithy-http-client"
 features = ["test-util"]
 version = "1.1.12"
-38
 [dev-dependencies.aws-credential-types]
 path = "../../sdk/aws-credential-types"
 features = ["test-util"]
 version = "1.2.14"

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

 path = "../../sdk/aws-config"
 features = ["test-util", "behavior-version-latest"]
 version = "1.9.0"
-22
 [dev-dependencies.aws-runtime]
 path = "../../sdk/aws-runtime"
 features = ["test-util"]
 version = "1.7.3"
-27
 [dev-dependencies.aws-sdk-dynamodb]
 path = "../../sdk/dynamodb"
 features = ["test-util", "behavior-version-latest"]
 version = "0.0.0-local"
-32
 [dev-dependencies.aws-sdk-s3]
 path = "../../sdk/s3"
 features = ["test-util", "behavior-version-latest"]
 version = "0.0.0-local"
-37
 [dev-dependencies.aws-smithy-observability]

 path = "../../sdk/aws-smithy-observability"
 version = "0.2.6"
-41
 [dev-dependencies.aws-smithy-observability-otel]
 path = "../../sdk/aws-smithy-observability-otel"
 version = "0.1.11"
-45
 [dev-dependencies.aws-smithy-runtime]
 path = "../../sdk/aws-smithy-runtime"
 features = ["client", "test-util"]
 version = "1.10.3"
 version = "1.10.4"
-50
 [dev-dependencies.aws-smithy-types]
 path = "../../sdk/aws-smithy-types"
 version = "1.4.7"
-54
 [dev-dependencies.opentelemetry]
 version = "0.26.0"
 features = ["metrics"]
-58
 [dev-dependencies.opentelemetry_sdk]

AWS SDK

Files changed:

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/src/types/_transcript_result_stream.rs

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/src/types/_utterance_event.rs

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/src/types/error/_bad_request_exception.rs

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

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/src/types/error/_internal_failure_exception.rs

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/src/types/error/_limit_exceeded_exception.rs

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

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/src/types/error/_service_unavailable_exception.rs

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/tests/canary_repro.rs

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

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