AWS SDK

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

@@ -120,120 +591,713 @@

-120
+    }
     /// <p>Provides the stabilization level used for your transcription.</p>
     pub fn partial_results_stability(&self) -> ::std::option::Option<&crate::types::PartialResultsStability> {
         self.partial_results_stability.as_ref()
-124
+    }
     /// <p>Shows whether content identification was enabled for your Call Analytics transcription.</p>
     pub fn content_identification_type(&self) -> ::std::option::Option<&crate::types::ContentIdentificationType> {
         self.content_identification_type.as_ref()
-128
+    }
     /// <p>Shows whether content redaction was enabled for your Call Analytics transcription.</p>
     pub fn content_redaction_type(&self) -> ::std::option::Option<&crate::types::ContentRedactionType> {
         self.content_redaction_type.as_ref()
-132
+    }
     /// <p>Lists the PII entity types you specified in your Call Analytics request.</p>
     pub fn pii_entity_types(&self) -> ::std::option::Option<&str> {
         self.pii_entity_types.as_deref()
-136
+    }
-137
+}
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionOutput",

     "com.amazonaws.transcribestreaming.synthetic",
     "StartCallAnalyticsStreamTranscriptionOutput",
 );
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionOutput$RequestId",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartCallAnalyticsStreamTranscriptionOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "request_id",
     "RequestId",
 ,
-152
+)
 .with_http_header("x-amzn-request-id");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_LANGUAGE_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionOutput$LanguageCode",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartCallAnalyticsStreamTranscriptionOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "language_code",
     "LanguageCode",
 ,
-163
+)
 .with_http_header("x-amzn-transcribe-language-code");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_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#StartCallAnalyticsStreamTranscriptionOutput$MediaSampleRateHertz",
             "com.amazonaws.transcribestreaming.synthetic",
             "StartCallAnalyticsStreamTranscriptionOutput",
         ),
         ::aws_smithy_schema::ShapeType::Integer,
         "media_sample_rate_hertz",
         "MediaSampleRateHertz",
 ,
-175
+    )
     .with_http_header("x-amzn-transcribe-sample-rate");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_MEDIA_ENCODING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionOutput$MediaEncoding",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartCallAnalyticsStreamTranscriptionOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "media_encoding",
     "MediaEncoding",
 ,
-186
+)
 .with_http_header("x-amzn-transcribe-media-encoding");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_VOCABULARY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionOutput$VocabularyName",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartCallAnalyticsStreamTranscriptionOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vocabulary_name",
     "VocabularyName",
 ,
-197
+)
 .with_http_header("x-amzn-transcribe-vocabulary-name");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_SESSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionOutput$SessionId",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartCallAnalyticsStreamTranscriptionOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "session_id",
     "SessionId",
 ,
-208
+)
 .with_http_header("x-amzn-transcribe-session-id");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_CALL_ANALYTICS_TRANSCRIPT_RESULT_STREAM: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionOutput$CallAnalyticsTranscriptResultStream",
             "com.amazonaws.transcribestreaming.synthetic",
             "StartCallAnalyticsStreamTranscriptionOutput",
         ),
         ::aws_smithy_schema::ShapeType::Union,
         "call_analytics_transcript_result_stream",
         "CallAnalyticsTranscriptResultStream",
 ,
-220
+    )
     .with_http_payload();
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_VOCABULARY_FILTER_NAME: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionOutput$VocabularyFilterName",
             "com.amazonaws.transcribestreaming.synthetic",
             "StartCallAnalyticsStreamTranscriptionOutput",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "vocabulary_filter_name",
         "VocabularyFilterName",
 ,
-232
+    )
     .with_http_header("x-amzn-transcribe-vocabulary-filter-name");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_VOCABULARY_FILTER_METHOD: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionOutput$VocabularyFilterMethod",
             "com.amazonaws.transcribestreaming.synthetic",
             "StartCallAnalyticsStreamTranscriptionOutput",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "vocabulary_filter_method",
         "VocabularyFilterMethod",
 ,
-244
+    )
     .with_http_header("x-amzn-transcribe-vocabulary-filter-method");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_LANGUAGE_MODEL_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionOutput$LanguageModelName",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartCallAnalyticsStreamTranscriptionOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "language_model_name",
     "LanguageModelName",
 ,
-255
+)
 .with_http_header("x-amzn-transcribe-language-model-name");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_IDENTIFY_LANGUAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionOutput$IdentifyLanguage",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartCallAnalyticsStreamTranscriptionOutput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "identify_language",
     "IdentifyLanguage",
 ,
-266
+)
 .with_http_header("x-amzn-transcribe-identify-language");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_LANGUAGE_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionOutput$LanguageOptions",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartCallAnalyticsStreamTranscriptionOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "language_options",
     "LanguageOptions",
 ,
-277
+)
 .with_http_header("x-amzn-transcribe-language-options");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_PREFERRED_LANGUAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionOutput$PreferredLanguage",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartCallAnalyticsStreamTranscriptionOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "preferred_language",
     "PreferredLanguage",
 ,
-288
+)
 .with_http_header("x-amzn-transcribe-preferred-language");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_VOCABULARY_NAMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionOutput$VocabularyNames",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartCallAnalyticsStreamTranscriptionOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vocabulary_names",
     "VocabularyNames",
 ,
-299
+)
 .with_http_header("x-amzn-transcribe-vocabulary-names");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_VOCABULARY_FILTER_NAMES: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionOutput$VocabularyFilterNames",
             "com.amazonaws.transcribestreaming.synthetic",
             "StartCallAnalyticsStreamTranscriptionOutput",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "vocabulary_filter_names",
         "VocabularyFilterNames",
 ,
-311
+    )
     .with_http_header("x-amzn-transcribe-vocabulary-filter-names");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_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#StartCallAnalyticsStreamTranscriptionOutput$EnablePartialResultsStabilization",
             "com.amazonaws.transcribestreaming.synthetic",
             "StartCallAnalyticsStreamTranscriptionOutput",
         ),
         ::aws_smithy_schema::ShapeType::Boolean,
         "enable_partial_results_stabilization",
         "EnablePartialResultsStabilization",
 ,
-323
+    )
     .with_http_header("x-amzn-transcribe-enable-partial-results-stabilization");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_PARTIAL_RESULTS_STABILITY: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionOutput$PartialResultsStability",
             "com.amazonaws.transcribestreaming.synthetic",
             "StartCallAnalyticsStreamTranscriptionOutput",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "partial_results_stability",
         "PartialResultsStability",
 ,
-335
+    )
     .with_http_header("x-amzn-transcribe-partial-results-stability");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_CONTENT_IDENTIFICATION_TYPE: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionOutput$ContentIdentificationType",
             "com.amazonaws.transcribestreaming.synthetic",
             "StartCallAnalyticsStreamTranscriptionOutput",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "content_identification_type",
         "ContentIdentificationType",
 ,
-347
+    )
     .with_http_header("x-amzn-transcribe-content-identification-type");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_CONTENT_REDACTION_TYPE: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionOutput$ContentRedactionType",
             "com.amazonaws.transcribestreaming.synthetic",
             "StartCallAnalyticsStreamTranscriptionOutput",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "content_redaction_type",
         "ContentRedactionType",
 ,
-359
+    )
     .with_http_header("x-amzn-transcribe-content-redaction-type");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_PII_ENTITY_TYPES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionOutput$PiiEntityTypes",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartCallAnalyticsStreamTranscriptionOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "pii_entity_types",
     "PiiEntityTypes",
 ,
-370
+)
 .with_http_header("x-amzn-transcribe-pii-entity-types");
 static STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_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 STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_REQUEST_ID,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_LANGUAGE_CODE,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_MEDIA_SAMPLE_RATE_HERTZ,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_MEDIA_ENCODING,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_VOCABULARY_NAME,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_SESSION_ID,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_CALL_ANALYTICS_TRANSCRIPT_RESULT_STREAM,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_VOCABULARY_FILTER_NAME,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_VOCABULARY_FILTER_METHOD,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_LANGUAGE_MODEL_NAME,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_IDENTIFY_LANGUAGE,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_LANGUAGE_OPTIONS,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_PREFERRED_LANGUAGE,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_VOCABULARY_NAMES,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_VOCABULARY_FILTER_NAMES,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_ENABLE_PARTIAL_RESULTS_STABILIZATION,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_PARTIAL_RESULTS_STABILITY,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_CONTENT_IDENTIFICATION_TYPE,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_CONTENT_REDACTION_TYPE,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_PII_ENTITY_TYPES,
         &STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl StartCallAnalyticsStreamTranscriptionOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_SCHEMA;
-409
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StartCallAnalyticsStreamTranscriptionOutput {
     #[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.request_id {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_REQUEST_ID, val)?;
-418
+        }
         if let Some(ref val) = self.language_code {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_LANGUAGE_CODE, val.as_str())?;
-421
+        }
         if let Some(ref val) = self.media_sample_rate_hertz {
             ser.write_integer(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_MEDIA_SAMPLE_RATE_HERTZ, *val)?;
-424
+        }
         if let Some(ref val) = self.media_encoding {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_MEDIA_ENCODING, val.as_str())?;
-427
+        }
         if let Some(ref val) = self.vocabulary_name {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_VOCABULARY_NAME, val)?;
-430
+        }
         if let Some(ref val) = self.session_id {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_SESSION_ID, val)?;
-433
+        }
--
+        {
             let val = &self.call_analytics_transcript_result_stream;
             ser.write_null(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_CALL_ANALYTICS_TRANSCRIPT_RESULT_STREAM)?;
--
+        }
         if let Some(ref val) = self.vocabulary_filter_name {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_VOCABULARY_FILTER_NAME, val)?;
-436
+        }
         if let Some(ref val) = self.vocabulary_filter_method {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_VOCABULARY_FILTER_METHOD, val.as_str())?;
-439
+        }
         if let Some(ref val) = self.language_model_name {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_LANGUAGE_MODEL_NAME, val)?;
-442
+        }
-443
+        {
             let val = &self.identify_language;
             ser.write_boolean(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_IDENTIFY_LANGUAGE, *val)?;
-446
+        }
         if let Some(ref val) = self.language_options {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_LANGUAGE_OPTIONS, val)?;
-449
+        }
         if let Some(ref val) = self.preferred_language {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_PREFERRED_LANGUAGE, val.as_str())?;
-452
+        }
         if let Some(ref val) = self.vocabulary_names {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_VOCABULARY_NAMES, val)?;
-455
+        }
         if let Some(ref val) = self.vocabulary_filter_names {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_VOCABULARY_FILTER_NAMES, val)?;
-458
+        }
-459
+        {
             let val = &self.enable_partial_results_stabilization;
             ser.write_boolean(
                 &STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_ENABLE_PARTIAL_RESULTS_STABILIZATION,
                 *val,
             )?;
-465
+        }
         if let Some(ref val) = self.partial_results_stability {
             ser.write_string(
                 &STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_PARTIAL_RESULTS_STABILITY,
                 val.as_str(),
             )?;
-471
+        }
         if let Some(ref val) = self.content_identification_type {
             ser.write_string(
                 &STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_CONTENT_IDENTIFICATION_TYPE,
                 val.as_str(),
             )?;
-477
+        }
         if let Some(ref val) = self.content_redaction_type {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_CONTENT_REDACTION_TYPE, val.as_str())?;
-480
+        }
         if let Some(ref val) = self.pii_entity_types {
             ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_MEMBER_PII_ENTITY_TYPES, val)?;
-483
+        }
         Ok(())
-485
+    }
-486
+}
 impl StartCallAnalyticsStreamTranscriptionOutput {
     /// 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(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.request_id = Some(deser.read_string(member)?);
-505
+                }
                 Some(1) => {
                     builder.language_code = Some(crate::types::CallAnalyticsLanguageCode::from(deser.read_string(member)?.as_str()));
-508
+                }
                 Some(2) => {
                     builder.media_sample_rate_hertz = Some(deser.read_integer(member)?);
-511
+                }
                 Some(3) => {
                     builder.media_encoding = Some(crate::types::MediaEncoding::from(deser.read_string(member)?.as_str()));
-514
+                }
                 Some(4) => {
                     builder.vocabulary_name = Some(deser.read_string(member)?);
-517
+                }
                 Some(5) => {
                     builder.session_id = Some(deser.read_string(member)?);
-520
+                }
                 Some(6) => {
                     builder.call_analytics_transcript_result_stream = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                         todo!("deserialize streaming union")
                     });
-526
+                }
                 Some(7) => {
                     builder.vocabulary_filter_name = Some(deser.read_string(member)?);
-529
+                }
                 Some(8) => {
                     builder.vocabulary_filter_method = Some(crate::types::VocabularyFilterMethod::from(deser.read_string(member)?.as_str()));
-532
+                }
                 Some(9) => {
                     builder.language_model_name = Some(deser.read_string(member)?);
-535
+                }
                 Some(10) => {
                     builder.identify_language = Some(deser.read_boolean(member)?);
-538
+                }
                 Some(11) => {
                     builder.language_options = Some(deser.read_string(member)?);
-541
+                }
                 Some(12) => {
                     builder.preferred_language = Some(crate::types::CallAnalyticsLanguageCode::from(deser.read_string(member)?.as_str()));
-544
+                }
                 Some(13) => {
                     builder.vocabulary_names = Some(deser.read_string(member)?);
-547
+                }
                 Some(14) => {
                     builder.vocabulary_filter_names = Some(deser.read_string(member)?);
-550
+                }
                 Some(15) => {
                     builder.enable_partial_results_stabilization = Some(deser.read_boolean(member)?);
-553
+                }
                 Some(16) => {
                     builder.partial_results_stability = Some(crate::types::PartialResultsStability::from(deser.read_string(member)?.as_str()));
-556
+                }
                 Some(17) => {
                     builder.content_identification_type = Some(crate::types::ContentIdentificationType::from(deser.read_string(member)?.as_str()));
-559
+                }
                 Some(18) => {
                     builder.content_redaction_type = Some(crate::types::ContentRedactionType::from(deser.read_string(member)?.as_str()));
-562
+                }
                 Some(19) => {
                     builder.pii_entity_types = Some(deser.read_string(member)?);
-565
+                }
                 Some(20) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl StartCallAnalyticsStreamTranscriptionOutput {
     /// 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-request-id") {
             builder.request_id = Some(val.to_string());
-+
+        }
         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());
-+
+        }
         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(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONOUTPUT_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) => { /* read from headers above */ }
                 Some(6) => {
                     builder.call_analytics_transcript_result_stream = Some({
                         let _ = member;
                         todo!("deserialize streaming union")
                     });
-+
+                }
                 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 */ }
                 Some(19) => { /* read from headers above */ }
                 _ => {}
-685
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-691
+    }
-692
+}
 impl ::aws_types::request_id::RequestId for StartCallAnalyticsStreamTranscriptionOutput {

↧ Expand context

     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-696
+    }
-697
+}
 impl StartCallAnalyticsStreamTranscriptionOutput {
     /// Creates a new builder-style object to manufacture [`StartCallAnalyticsStreamTranscriptionOutput`](crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionOutput).
     pub fn builder() -> crate::operation::start_call_analytics_stream_transcription::builders::StartCallAnalyticsStreamTranscriptionOutputBuilder {
         crate::operation::start_call_analytics_stream_transcription::builders::StartCallAnalyticsStreamTranscriptionOutputBuilder::default()
-702
+    }
-703
+}
-704
 /// A builder for [`StartCallAnalyticsStreamTranscriptionOutput`](crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionOutput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StartCallAnalyticsStreamTranscriptionOutputBuilder {
     pub(crate) request_id: ::std::option::Option<::std::string::String>,
     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>,

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

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `StartMedicalScribeStream`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StartMedicalScribeStream;
 impl StartMedicalScribeStream {
     /// Creates a new `StartMedicalScribeStream`
     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_medical_scribe_stream::StartMedicalScribeStreamInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::start_medical_scribe_stream::StartMedicalScribeStreamOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::start_medical_scribe_stream::StartMedicalScribeStreamInput,
     ) -> ::std::result::Result<
         crate::operation::start_medical_scribe_stream::StartMedicalScribeStreamOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::start_medical_scribe_stream::StartMedicalScribeStreamError,
             ::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_medical_scribe_stream::StartMedicalScribeStreamError>()
                     .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_medical_scribe_stream::StartMedicalScribeStreamOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -143,149 +271,399 @@

↥ Expand context

                 crate::operation::start_medical_scribe_stream::StartMedicalScribeStreamError,
             >::new());
-151
         ::std::borrow::Cow::Owned(rcb)
-153
+    }
-154
+}
-155
 #[derive(Debug)]
 struct StartMedicalScribeStreamResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for StartMedicalScribeStreamResponseDeserializer {
     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_medical_scribe_stream::de_start_medical_scribe_stream_http_response(response),
         ))
-174
+    }
-175
     fn deserialize_nonstreaming(
         &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_medical_scribe_stream::de_start_medical_scribe_stream_http_error(
                 response.status().as_u16(),
         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_medical_scribe_stream::StartMedicalScribeStreamError::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_medical_scribe_stream::StartMedicalScribeStreamError::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_medical_scribe_stream::StartMedicalScribeStreamError::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_medical_scribe_stream::StartMedicalScribeStreamError::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_medical_scribe_stream::StartMedicalScribeStreamError::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,
             ),
-287
+                        )
                     }) {
                     ::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_medical_scribe_stream::StartMedicalScribeStreamError::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_medical_scribe_stream::StartMedicalScribeStreamError::generic(generic),
         };
         ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
             ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         ))
-333
+    }
-334
+}
 #[derive(Debug)]
 struct StartMedicalScribeStreamRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for StartMedicalScribeStreamRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::start_medical_scribe_stream::StartMedicalScribeStreamInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::start_medical_scribe_stream::StartMedicalScribeStreamInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/medical-scribe-stream").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::start_medical_scribe_stream::StartMedicalScribeStreamInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_start_medical_scribe_stream::ser_start_medical_scribe_stream_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, StartMedicalScribeStream::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::MedicalScribeInputStreamErrorMarshaller::new();
             let marshaller = crate::event_stream_serde::MedicalScribeInputStreamMarshaller::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.input_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);
-370
+    }
-371
+}
 #[derive(Debug)]
 struct StartMedicalScribeStreamEndpointParamsInterceptor;
-374
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StartMedicalScribeStreamEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "StartMedicalScribeStreamEndpointParamsInterceptor"
-378
+    }
-379

↧ 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::<StartMedicalScribeStreamInput>()
             .ok_or("failed to downcast to StartMedicalScribeStreamInput")?;
-394
         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_medical_scribe_stream/_start_medical_scribe_stream_input.rs

@@ -49,49 +228,278 @@

↥ Expand context

     /// <li>
     /// <p>OPUS-encoded audio in an Ogg container</p></li>
     /// <li>
     /// <p>PCM (only signed 16-bit little-endian audio formats, which does not include WAV)</p></li>
     /// </ul>
     /// <p>For more information, see <a href="https://docs.aws.amazon.com/transcribe/latest/dg/how-input.html#how-input-audio">Media formats</a>.</p>
     pub fn media_encoding(&self) -> ::std::option::Option<&crate::types::MedicalScribeMediaEncoding> {
         self.media_encoding.as_ref()
-57
+    }
     /// <p>Specify the input stream where you will send events in real time.</p>
     /// <p>The first element of the input stream must be a <code>MedicalScribeConfigurationEvent</code>.</p>
     pub fn input_stream(
         &self,
     ) -> &::aws_smithy_http::event_stream::EventStreamSender<crate::types::MedicalScribeInputStream, crate::types::error::MedicalScribeInputStreamError>
-63
+    {
         &self.input_stream
-65
+    }
-66
+}
 static STARTMEDICALSCRIBESTREAMINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming.synthetic#StartMedicalScribeStreamInput",

     "com.amazonaws.transcribestreaming.synthetic",
     "StartMedicalScribeStreamInput",
 );
 static STARTMEDICALSCRIBESTREAMINPUT_MEMBER_SESSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalScribeStreamInput$SessionId",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalScribeStreamInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "session_id",
     "SessionId",
 ,
-81
+)
 .with_http_header("x-amzn-transcribe-session-id");
 static STARTMEDICALSCRIBESTREAMINPUT_MEMBER_LANGUAGE_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalScribeStreamInput$LanguageCode",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalScribeStreamInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "language_code",
     "LanguageCode",
 ,
-92
+)
 .with_http_header("x-amzn-transcribe-language-code");
 static STARTMEDICALSCRIBESTREAMINPUT_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#StartMedicalScribeStreamInput$MediaSampleRateHertz",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalScribeStreamInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "media_sample_rate_hertz",
     "MediaSampleRateHertz",
 ,
-103
+)
 .with_http_header("x-amzn-transcribe-sample-rate");
 static STARTMEDICALSCRIBESTREAMINPUT_MEMBER_MEDIA_ENCODING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalScribeStreamInput$MediaEncoding",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalScribeStreamInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "media_encoding",
     "MediaEncoding",
 ,
-114
+)
 .with_http_header("x-amzn-transcribe-media-encoding");
 static STARTMEDICALSCRIBESTREAMINPUT_MEMBER_INPUT_STREAM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalScribeStreamInput$InputStream",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalScribeStreamInput",
     ),
     ::aws_smithy_schema::ShapeType::Union,
     "input_stream",
     "InputStream",
 ,
-125
+)
 .with_http_payload();
 static STARTMEDICALSCRIBESTREAMINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STARTMEDICALSCRIBESTREAMINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &STARTMEDICALSCRIBESTREAMINPUT_MEMBER_SESSION_ID,
         &STARTMEDICALSCRIBESTREAMINPUT_MEMBER_LANGUAGE_CODE,
         &STARTMEDICALSCRIBESTREAMINPUT_MEMBER_MEDIA_SAMPLE_RATE_HERTZ,
         &STARTMEDICALSCRIBESTREAMINPUT_MEMBER_MEDIA_ENCODING,
         &STARTMEDICALSCRIBESTREAMINPUT_MEMBER_INPUT_STREAM,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/medical-scribe-stream", None));
 impl StartMedicalScribeStreamInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STARTMEDICALSCRIBESTREAMINPUT_SCHEMA;
-142
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StartMedicalScribeStreamInput {
     #[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(&STARTMEDICALSCRIBESTREAMINPUT_MEMBER_SESSION_ID, val)?;
-151
+        }
         if let Some(ref val) = self.language_code {
             ser.write_string(&STARTMEDICALSCRIBESTREAMINPUT_MEMBER_LANGUAGE_CODE, val.as_str())?;
-154
+        }
         if let Some(ref val) = self.media_sample_rate_hertz {
             ser.write_integer(&STARTMEDICALSCRIBESTREAMINPUT_MEMBER_MEDIA_SAMPLE_RATE_HERTZ, *val)?;
-157
+        }
         if let Some(ref val) = self.media_encoding {
             ser.write_string(&STARTMEDICALSCRIBESTREAMINPUT_MEMBER_MEDIA_ENCODING, val.as_str())?;
-160
+        }
--
+        {
             let val = &self.input_stream;
             ser.write_null(&STARTMEDICALSCRIBESTREAMINPUT_MEMBER_INPUT_STREAM)?;
--
+        }
         Ok(())
-162
+    }
-163
+}
 impl StartMedicalScribeStreamInput {
     /// 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(&STARTMEDICALSCRIBESTREAMINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STARTMEDICALSCRIBESTREAMINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.session_id = Some(deser.read_string(member)?);
-182
+                }
                 Some(1) => {
                     builder.language_code = Some(crate::types::MedicalScribeLanguageCode::from(deser.read_string(member)?.as_str()));
-185
+                }
                 Some(2) => {
                     builder.media_sample_rate_hertz = Some(deser.read_integer(member)?);
-188
+                }
                 Some(3) => {
                     builder.media_encoding = Some(crate::types::MedicalScribeMediaEncoding::from(deser.read_string(member)?.as_str()));
-191
+                }
                 Some(4) => {
                     builder.input_stream = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                         todo!("deserialize streaming union")
                     });
-+
+                }
                 _ => {}
-+
+            }
             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 StartMedicalScribeStreamInput {
     /// 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-session-id") {
             builder.session_id = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-language-code") {
             builder.language_code = Some(crate::types::MedicalScribeLanguageCode::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::MedicalScribeMediaEncoding::from(val));
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&STARTMEDICALSCRIBESTREAMINPUT_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) => {
                     builder.input_stream = Some({
                         let _ = member;
                         todo!("deserialize streaming union")
                     });
-250
+                }
                 _ => {}
-252
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-258
+    }

↧ Expand context

-259
+}
 impl StartMedicalScribeStreamInput {
     /// Creates a new builder-style object to manufacture [`StartMedicalScribeStreamInput`](crate::operation::start_medical_scribe_stream::StartMedicalScribeStreamInput).
     pub fn builder() -> crate::operation::start_medical_scribe_stream::builders::StartMedicalScribeStreamInputBuilder {
         crate::operation::start_medical_scribe_stream::builders::StartMedicalScribeStreamInputBuilder::default()
-264
+    }
-265
+}
-266
 /// A builder for [`StartMedicalScribeStreamInput`](crate::operation::start_medical_scribe_stream::StartMedicalScribeStreamInput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StartMedicalScribeStreamInputBuilder {
     pub(crate) session_id: ::std::option::Option<::std::string::String>,
     pub(crate) language_code: ::std::option::Option<crate::types::MedicalScribeLanguageCode>,
     pub(crate) media_sample_rate_hertz: ::std::option::Option<i32>,
     pub(crate) media_encoding: ::std::option::Option<crate::types::MedicalScribeMediaEncoding>,
     pub(crate) input_stream: ::std::option::Option<
         ::aws_smithy_http::event_stream::EventStreamSender<
             crate::types::MedicalScribeInputStream,
             crate::types::error::MedicalScribeInputStreamError,

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

@@ -33,33 +230,296 @@

↥ Expand context

     pub fn language_code(&self) -> ::std::option::Option<&crate::types::MedicalScribeLanguageCode> {
         self.language_code.as_ref()
-35
+    }
     /// <p>The sample rate (in hertz) that you specified in your request. Same as provided in the <code>StartMedicalScribeStreamRequest</code></p>
     pub fn media_sample_rate_hertz(&self) -> ::std::option::Option<i32> {
         self.media_sample_rate_hertz
-39
+    }
     /// <p>The Media Encoding you specified in your request. Same as provided in the <code>StartMedicalScribeStreamRequest</code></p>
     pub fn media_encoding(&self) -> ::std::option::Option<&crate::types::MedicalScribeMediaEncoding> {
         self.media_encoding.as_ref()
-43
+    }
     /// <p>The result stream where you will receive the output events.</p>
     pub fn result_stream(
         &self,
     ) -> &crate::event_receiver::EventReceiver<crate::types::MedicalScribeResultStream, crate::types::error::MedicalScribeResultStreamError> {
         &self.result_stream
-49
+    }
-50
+}
 static STARTMEDICALSCRIBESTREAMOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming.synthetic#StartMedicalScribeStreamOutput",

     "com.amazonaws.transcribestreaming.synthetic",
     "StartMedicalScribeStreamOutput",
 );
 static STARTMEDICALSCRIBESTREAMOUTPUT_MEMBER_SESSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalScribeStreamOutput$SessionId",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalScribeStreamOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "session_id",
     "SessionId",
 ,
-65
+)
 .with_http_header("x-amzn-transcribe-session-id");
 static STARTMEDICALSCRIBESTREAMOUTPUT_MEMBER_REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalScribeStreamOutput$RequestId",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalScribeStreamOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "request_id",
     "RequestId",
 ,
-76
+)
 .with_http_header("x-amzn-request-id");
 static STARTMEDICALSCRIBESTREAMOUTPUT_MEMBER_LANGUAGE_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalScribeStreamOutput$LanguageCode",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalScribeStreamOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "language_code",
     "LanguageCode",
 ,
-87
+)
 .with_http_header("x-amzn-transcribe-language-code");
 static STARTMEDICALSCRIBESTREAMOUTPUT_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#StartMedicalScribeStreamOutput$MediaSampleRateHertz",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalScribeStreamOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "media_sample_rate_hertz",
     "MediaSampleRateHertz",
 ,
-98
+)
 .with_http_header("x-amzn-transcribe-sample-rate");
 static STARTMEDICALSCRIBESTREAMOUTPUT_MEMBER_MEDIA_ENCODING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalScribeStreamOutput$MediaEncoding",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalScribeStreamOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "media_encoding",
     "MediaEncoding",
 ,
-109
+)
 .with_http_header("x-amzn-transcribe-media-encoding");
 static STARTMEDICALSCRIBESTREAMOUTPUT_MEMBER_RESULT_STREAM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalScribeStreamOutput$ResultStream",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalScribeStreamOutput",
     ),
     ::aws_smithy_schema::ShapeType::Union,
     "result_stream",
     "ResultStream",
 ,
-120
+)
 .with_http_payload();
 static STARTMEDICALSCRIBESTREAMOUTPUT_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 STARTMEDICALSCRIBESTREAMOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STARTMEDICALSCRIBESTREAMOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &STARTMEDICALSCRIBESTREAMOUTPUT_MEMBER_SESSION_ID,
         &STARTMEDICALSCRIBESTREAMOUTPUT_MEMBER_REQUEST_ID,
         &STARTMEDICALSCRIBESTREAMOUTPUT_MEMBER_LANGUAGE_CODE,
         &STARTMEDICALSCRIBESTREAMOUTPUT_MEMBER_MEDIA_SAMPLE_RATE_HERTZ,
         &STARTMEDICALSCRIBESTREAMOUTPUT_MEMBER_MEDIA_ENCODING,
         &STARTMEDICALSCRIBESTREAMOUTPUT_MEMBER_RESULT_STREAM,
         &STARTMEDICALSCRIBESTREAMOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl StartMedicalScribeStreamOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STARTMEDICALSCRIBESTREAMOUTPUT_SCHEMA;
-145
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StartMedicalScribeStreamOutput {
     #[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(&STARTMEDICALSCRIBESTREAMOUTPUT_MEMBER_SESSION_ID, val)?;
-154
+        }
         if let Some(ref val) = self.request_id {
             ser.write_string(&STARTMEDICALSCRIBESTREAMOUTPUT_MEMBER_REQUEST_ID, val)?;
-157
+        }
         if let Some(ref val) = self.language_code {
             ser.write_string(&STARTMEDICALSCRIBESTREAMOUTPUT_MEMBER_LANGUAGE_CODE, val.as_str())?;
-160
+        }
         if let Some(ref val) = self.media_sample_rate_hertz {
             ser.write_integer(&STARTMEDICALSCRIBESTREAMOUTPUT_MEMBER_MEDIA_SAMPLE_RATE_HERTZ, *val)?;
-163
+        }
         if let Some(ref val) = self.media_encoding {
             ser.write_string(&STARTMEDICALSCRIBESTREAMOUTPUT_MEMBER_MEDIA_ENCODING, val.as_str())?;
-166
+        }
--
+        {
             let val = &self.result_stream;
             ser.write_null(&STARTMEDICALSCRIBESTREAMOUTPUT_MEMBER_RESULT_STREAM)?;
--
+        }
         Ok(())
-168
+    }
-169
+}
 impl StartMedicalScribeStreamOutput {
     /// 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(&STARTMEDICALSCRIBESTREAMOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STARTMEDICALSCRIBESTREAMOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.session_id = Some(deser.read_string(member)?);
-188
+                }
                 Some(1) => {
                     builder.request_id = Some(deser.read_string(member)?);
-191
+                }
                 Some(2) => {
                     builder.language_code = Some(crate::types::MedicalScribeLanguageCode::from(deser.read_string(member)?.as_str()));
-194
+                }
                 Some(3) => {
                     builder.media_sample_rate_hertz = Some(deser.read_integer(member)?);
-197
+                }
                 Some(4) => {
                     builder.media_encoding = Some(crate::types::MedicalScribeMediaEncoding::from(deser.read_string(member)?.as_str()));
-200
+                }
                 Some(5) => {
                     builder.result_stream = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                         todo!("deserialize streaming union")
                     });
-+
+                }
                 Some(6) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl StartMedicalScribeStreamOutput {
     /// 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-session-id") {
             builder.session_id = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amzn-request-id") {
             builder.request_id = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-language-code") {
             builder.language_code = Some(crate::types::MedicalScribeLanguageCode::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::MedicalScribeMediaEncoding::from(val));
-+
+        }
         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(&STARTMEDICALSCRIBESTREAMOUTPUT_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.result_stream = Some({
                         let _ = member;
                         todo!("deserialize streaming union")
                     });
-268
+                }
                 _ => {}
-270
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-276
+    }

↧ Expand context

-277
+}
 impl ::aws_types::request_id::RequestId for StartMedicalScribeStreamOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-281
+    }
-282
+}
 impl StartMedicalScribeStreamOutput {
     /// Creates a new builder-style object to manufacture [`StartMedicalScribeStreamOutput`](crate::operation::start_medical_scribe_stream::StartMedicalScribeStreamOutput).
     pub fn builder() -> crate::operation::start_medical_scribe_stream::builders::StartMedicalScribeStreamOutputBuilder {
         crate::operation::start_medical_scribe_stream::builders::StartMedicalScribeStreamOutputBuilder::default()
-287
+    }
-288
+}
-289
 /// A builder for [`StartMedicalScribeStreamOutput`](crate::operation::start_medical_scribe_stream::StartMedicalScribeStreamOutput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StartMedicalScribeStreamOutputBuilder {
     pub(crate) session_id: ::std::option::Option<::std::string::String>,
     pub(crate) request_id: ::std::option::Option<::std::string::String>,
     pub(crate) language_code: ::std::option::Option<crate::types::MedicalScribeLanguageCode>,

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/src/operation/start_medical_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 `StartMedicalStreamTranscription`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StartMedicalStreamTranscription;
 impl StartMedicalStreamTranscription {
     /// Creates a new `StartMedicalStreamTranscription`
     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_medical_stream_transcription::StartMedicalStreamTranscriptionInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionInput,
     ) -> ::std::result::Result<
         crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionError,
             ::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_medical_stream_transcription::StartMedicalStreamTranscriptionError>()
                     .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_medical_stream_transcription::StartMedicalStreamTranscriptionOutput>()
                 .expect("correct output type"),
-44
+        )
-45
+    }
-46

@@ -143,149 +272,405 @@

↥ Expand context

                 crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionError,
             >::new());
-151
         ::std::borrow::Cow::Owned(rcb)
-153
+    }
-154
+}
-155
 #[derive(Debug)]
 struct StartMedicalStreamTranscriptionResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for StartMedicalStreamTranscriptionResponseDeserializer {
     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_medical_stream_transcription::de_start_medical_stream_transcription_http_response(response),
         ))
-174
+    }
-175
     fn deserialize_nonstreaming(
         &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_medical_stream_transcription::de_start_medical_stream_transcription_http_error(
                 response.status().as_u16(),
         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_medical_stream_transcription::StartMedicalStreamTranscriptionError::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_medical_stream_transcription::StartMedicalStreamTranscriptionError::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,
             ),
-216
+                            )
                         }) {
                         ::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_medical_stream_transcription::StartMedicalStreamTranscriptionError::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_medical_stream_transcription::StartMedicalStreamTranscriptionError::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_medical_stream_transcription::StartMedicalStreamTranscriptionError::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_medical_stream_transcription::StartMedicalStreamTranscriptionError::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_medical_stream_transcription::StartMedicalStreamTranscriptionError::generic(generic),
         };
         ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
             ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         ))
-339
+    }
-340
+}
 #[derive(Debug)]
 struct StartMedicalStreamTranscriptionRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for StartMedicalStreamTranscriptionRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/medical-stream-transcription").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 let builder =
                     crate::protocol_serde::shape_start_medical_stream_transcription::ser_start_medical_stream_transcription_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             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, StartMedicalStreamTranscription::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);
-376
+    }
-377
+}
 #[derive(Debug)]
 struct StartMedicalStreamTranscriptionEndpointParamsInterceptor;
-380
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StartMedicalStreamTranscriptionEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "StartMedicalStreamTranscriptionEndpointParamsInterceptor"
-384
+    }
-385

↧ 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::<StartMedicalStreamTranscriptionInput>()
             .ok_or("failed to downcast to StartMedicalStreamTranscriptionInput")?;
-400
         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_medical_stream_transcription/_start_medical_stream_transcription_input.rs

@@ -105,105 +419,497 @@

↥ Expand context

     /// <p>If you have multi-channel audio and do not enable channel identification, your audio is transcribed in a continuous manner and your transcript is not separated by channel.</p>
     /// <p>If you include <code>EnableChannelIdentification</code> in your request, you must also include <code>NumberOfChannels</code>.</p>
     /// <p>For more information, see <a href="https://docs.aws.amazon.com/transcribe/latest/dg/channel-id.html">Transcribing multi-channel audio</a>.</p>
     pub fn enable_channel_identification(&self) -> ::std::option::Option<bool> {
         self.enable_channel_identification
-110
+    }
     /// <p>Specify the number of channels in your audio stream. This value must be <code>2</code>, as only two channels are supported. If your audio doesn't contain multiple channels, do not include this parameter in your request.</p>
     /// <p>If you include <code>NumberOfChannels</code> in your request, you must also include <code>EnableChannelIdentification</code>.</p>
     pub fn number_of_channels(&self) -> ::std::option::Option<i32> {
         self.number_of_channels
-115
+    }
     /// <p>Labels all personal health information (PHI) identified in your transcript.</p>
     /// <p>Content identification is performed at the segment level; PHI is flagged upon complete transcription of an audio segment.</p>
     /// <p>For more information, see <a href="https://docs.aws.amazon.com/transcribe/latest/dg/phi-id.html">Identifying personal health information (PHI) in a transcription</a>.</p>
     pub fn content_identification_type(&self) -> ::std::option::Option<&crate::types::MedicalContentIdentificationType> {
         self.content_identification_type.as_ref()
-121
+    }
-122
+}
 static STARTMEDICALSTREAMTRANSCRIPTIONINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming.synthetic#StartMedicalStreamTranscriptionInput",

     "com.amazonaws.transcribestreaming.synthetic",
     "StartMedicalStreamTranscriptionInput",
 );
 static STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_LANGUAGE_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalStreamTranscriptionInput$LanguageCode",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalStreamTranscriptionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "language_code",
     "LanguageCode",
 ,
-137
+)
 .with_http_header("x-amzn-transcribe-language-code");
 static STARTMEDICALSTREAMTRANSCRIPTIONINPUT_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#StartMedicalStreamTranscriptionInput$MediaSampleRateHertz",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalStreamTranscriptionInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "media_sample_rate_hertz",
     "MediaSampleRateHertz",
 ,
-148
+)
 .with_http_header("x-amzn-transcribe-sample-rate");
 static STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_MEDIA_ENCODING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalStreamTranscriptionInput$MediaEncoding",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalStreamTranscriptionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "media_encoding",
     "MediaEncoding",
 ,
-159
+)
 .with_http_header("x-amzn-transcribe-media-encoding");
 static STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalStreamTranscriptionInput$VocabularyName",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalStreamTranscriptionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vocabulary_name",
     "VocabularyName",
 ,
-170
+)
 .with_http_header("x-amzn-transcribe-vocabulary-name");
 static STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_SPECIALTY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalStreamTranscriptionInput$Specialty",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalStreamTranscriptionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "specialty",
     "Specialty",
 ,
-181
+)
 .with_http_header("x-amzn-transcribe-specialty");
 static STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalStreamTranscriptionInput$Type",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalStreamTranscriptionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "r##type",
     "Type",
 ,
-192
+)
 .with_http_header("x-amzn-transcribe-type");
 static STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_SHOW_SPEAKER_LABEL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalStreamTranscriptionInput$ShowSpeakerLabel",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalStreamTranscriptionInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "show_speaker_label",
     "ShowSpeakerLabel",
 ,
-203
+)
 .with_http_header("x-amzn-transcribe-show-speaker-label");
 static STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_SESSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalStreamTranscriptionInput$SessionId",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalStreamTranscriptionInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "session_id",
     "SessionId",
 ,
-214
+)
 .with_http_header("x-amzn-transcribe-session-id");
 static STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_AUDIO_STREAM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalStreamTranscriptionInput$AudioStream",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalStreamTranscriptionInput",
     ),
     ::aws_smithy_schema::ShapeType::Union,
     "audio_stream",
     "AudioStream",
 ,
-225
+)
 .with_http_payload();
 static STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_ENABLE_CHANNEL_IDENTIFICATION: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.transcribestreaming.synthetic#StartMedicalStreamTranscriptionInput$EnableChannelIdentification",
             "com.amazonaws.transcribestreaming.synthetic",
             "StartMedicalStreamTranscriptionInput",
         ),
         ::aws_smithy_schema::ShapeType::Boolean,
         "enable_channel_identification",
         "EnableChannelIdentification",
 ,
-237
+    )
     .with_http_header("x-amzn-transcribe-enable-channel-identification");
 static STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_NUMBER_OF_CHANNELS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalStreamTranscriptionInput$NumberOfChannels",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalStreamTranscriptionInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "number_of_channels",
     "NumberOfChannels",
 ,
-248
+)
 .with_http_header("x-amzn-transcribe-number-of-channels");
 static STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_CONTENT_IDENTIFICATION_TYPE: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.transcribestreaming.synthetic#StartMedicalStreamTranscriptionInput$ContentIdentificationType",
             "com.amazonaws.transcribestreaming.synthetic",
             "StartMedicalStreamTranscriptionInput",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "content_identification_type",
         "ContentIdentificationType",
 ,
-260
+    )
     .with_http_header("x-amzn-transcribe-content-identification-type");
 static STARTMEDICALSTREAMTRANSCRIPTIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STARTMEDICALSTREAMTRANSCRIPTIONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_LANGUAGE_CODE,
         &STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_MEDIA_SAMPLE_RATE_HERTZ,
         &STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_MEDIA_ENCODING,
         &STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_NAME,
         &STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_SPECIALTY,
         &STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_TYPE,
         &STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_SHOW_SPEAKER_LABEL,
         &STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_SESSION_ID,
         &STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_AUDIO_STREAM,
         &STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_ENABLE_CHANNEL_IDENTIFICATION,
         &STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_NUMBER_OF_CHANNELS,
         &STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_CONTENT_IDENTIFICATION_TYPE,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/medical-stream-transcription", None));
 impl StartMedicalStreamTranscriptionInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STARTMEDICALSTREAMTRANSCRIPTIONINPUT_SCHEMA;
-284
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StartMedicalStreamTranscriptionInput {
     #[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(&STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_LANGUAGE_CODE, val.as_str())?;
-293
+        }
         if let Some(ref val) = self.media_sample_rate_hertz {
             ser.write_integer(&STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_MEDIA_SAMPLE_RATE_HERTZ, *val)?;
-296
+        }
         if let Some(ref val) = self.media_encoding {
             ser.write_string(&STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_MEDIA_ENCODING, val.as_str())?;
-299
+        }
         if let Some(ref val) = self.vocabulary_name {
             ser.write_string(&STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_NAME, val)?;
-302
+        }
         if let Some(ref val) = self.specialty {
             ser.write_string(&STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_SPECIALTY, val.as_str())?;
-305
+        }
         if let Some(ref val) = self.r#type {
             ser.write_string(&STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_TYPE, val.as_str())?;
-308
+        }
         if let Some(ref val) = self.show_speaker_label {
             ser.write_boolean(&STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_SHOW_SPEAKER_LABEL, *val)?;
-311
+        }
         if let Some(ref val) = self.session_id {
             ser.write_string(&STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_SESSION_ID, val)?;
-314
+        }
--
+        {
             let val = &self.audio_stream;
             ser.write_null(&STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_AUDIO_STREAM)?;
--
+        }
         if let Some(ref val) = self.enable_channel_identification {
             ser.write_boolean(&STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_ENABLE_CHANNEL_IDENTIFICATION, *val)?;
-317
+        }
         if let Some(ref val) = self.number_of_channels {
             ser.write_integer(&STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_NUMBER_OF_CHANNELS, *val)?;
-320
+        }
         if let Some(ref val) = self.content_identification_type {
             ser.write_string(&STARTMEDICALSTREAMTRANSCRIPTIONINPUT_MEMBER_CONTENT_IDENTIFICATION_TYPE, val.as_str())?;
-323
+        }
         Ok(())
-325
+    }
-326
+}
 impl StartMedicalStreamTranscriptionInput {
     /// 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(&STARTMEDICALSTREAMTRANSCRIPTIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STARTMEDICALSTREAMTRANSCRIPTIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.language_code = Some(crate::types::LanguageCode::from(deser.read_string(member)?.as_str()));
-345
+                }
                 Some(1) => {
                     builder.media_sample_rate_hertz = Some(deser.read_integer(member)?);
-348
+                }
                 Some(2) => {
                     builder.media_encoding = Some(crate::types::MediaEncoding::from(deser.read_string(member)?.as_str()));
-351
+                }
                 Some(3) => {
                     builder.vocabulary_name = Some(deser.read_string(member)?);
-354
+                }
                 Some(4) => {
                     builder.specialty = Some(crate::types::Specialty::from(deser.read_string(member)?.as_str()));
-357
+                }
                 Some(5) => {
                     builder.r#type = Some(crate::types::Type::from(deser.read_string(member)?.as_str()));
-360
+                }
                 Some(6) => {
                     builder.show_speaker_label = Some(deser.read_boolean(member)?);
-363
+                }
                 Some(7) => {
                     builder.session_id = Some(deser.read_string(member)?);
-366
+                }
                 Some(8) => {
                     builder.audio_stream = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                         todo!("deserialize streaming union")
                     });
-372
+                }
                 Some(9) => {
                     builder.enable_channel_identification = Some(deser.read_boolean(member)?);
-375
+                }
                 Some(10) => {
                     builder.number_of_channels = Some(deser.read_integer(member)?);
-378
+                }
                 Some(11) => {
                     builder.content_identification_type =
                         Some(crate::types::MedicalContentIdentificationType::from(deser.read_string(member)?.as_str()));
-382
+                }
                 _ => {}
-384
+            }
             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 StartMedicalStreamTranscriptionInput {
     /// 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::LanguageCode::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-specialty") {
             builder.specialty = Some(crate::types::Specialty::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-type") {
             builder.r#type = Some(crate::types::Type::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-show-speaker-label") {
             builder.show_speaker_label = val.parse::<bool>().ok();
-+
+        }
         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-enable-channel-identification") {
             builder.enable_channel_identification = val.parse::<bool>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-number-of-channels") {
             builder.number_of_channels = val.parse::<i32>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-content-identification-type") {
             builder.content_identification_type = Some(crate::types::MedicalContentIdentificationType::from(val));
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&STARTMEDICALSTREAMTRANSCRIPTIONINPUT_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) => { /* read from headers above */ }
                 Some(6) => { /* read from headers above */ }
                 Some(7) => { /* read from headers above */ }
                 Some(8) => {
                     builder.audio_stream = Some({
                         let _ = member;
                         todo!("deserialize streaming union")
                     });
-+
+                }
                 Some(9) => { /* read from headers above */ }
                 Some(10) => { /* read from headers above */ }
                 Some(11) => { /* read from headers above */ }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-471
+    }
-472
+}
 impl StartMedicalStreamTranscriptionInput {
     /// Creates a new builder-style object to manufacture [`StartMedicalStreamTranscriptionInput`](crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionInput).
     pub fn builder() -> crate::operation::start_medical_stream_transcription::builders::StartMedicalStreamTranscriptionInputBuilder {
         crate::operation::start_medical_stream_transcription::builders::StartMedicalStreamTranscriptionInputBuilder::default()
-477
+    }

↧ Expand context

-478
+}
-479
 /// A builder for [`StartMedicalStreamTranscriptionInput`](crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionInput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StartMedicalStreamTranscriptionInputBuilder {
     pub(crate) language_code: ::std::option::Option<crate::types::LanguageCode>,
     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) specialty: ::std::option::Option<crate::types::Specialty>,
     pub(crate) r#type: ::std::option::Option<crate::types::Type>,
     pub(crate) show_speaker_label: ::std::option::Option<bool>,
     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) enable_channel_identification: ::std::option::Option<bool>,
     pub(crate) number_of_channels: ::std::option::Option<i32>,
     pub(crate) content_identification_type: ::std::option::Option<crate::types::MedicalContentIdentificationType>,
-497
+}

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

@@ -74,74 +404,498 @@

↥ Expand context

         &self,
     ) -> &crate::event_receiver::EventReceiver<crate::types::MedicalTranscriptResultStream, crate::types::error::MedicalTranscriptResultStreamError>
-76
+    {
         &self.transcript_result_stream
-78
+    }
     /// <p>Shows whether channel identification was enabled for your transcription.</p>
     pub fn enable_channel_identification(&self) -> bool {
         self.enable_channel_identification
-82
+    }
     /// <p>Provides the number of channels that you specified in your request.</p>
     pub fn number_of_channels(&self) -> ::std::option::Option<i32> {
         self.number_of_channels
-86
+    }
     /// <p>Shows whether content identification was enabled for your transcription.</p>
     pub fn content_identification_type(&self) -> ::std::option::Option<&crate::types::MedicalContentIdentificationType> {
         self.content_identification_type.as_ref()
-90
+    }
-91
+}
 static STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming.synthetic#StartMedicalStreamTranscriptionOutput",

     "com.amazonaws.transcribestreaming.synthetic",
     "StartMedicalStreamTranscriptionOutput",
 );
 static STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalStreamTranscriptionOutput$RequestId",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalStreamTranscriptionOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "request_id",
     "RequestId",
 ,
-106
+)
 .with_http_header("x-amzn-request-id");
 static STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_LANGUAGE_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalStreamTranscriptionOutput$LanguageCode",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalStreamTranscriptionOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "language_code",
     "LanguageCode",
 ,
-117
+)
 .with_http_header("x-amzn-transcribe-language-code");
 static STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_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#StartMedicalStreamTranscriptionOutput$MediaSampleRateHertz",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalStreamTranscriptionOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "media_sample_rate_hertz",
     "MediaSampleRateHertz",
 ,
-128
+)
 .with_http_header("x-amzn-transcribe-sample-rate");
 static STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_MEDIA_ENCODING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalStreamTranscriptionOutput$MediaEncoding",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalStreamTranscriptionOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "media_encoding",
     "MediaEncoding",
 ,
-139
+)
 .with_http_header("x-amzn-transcribe-media-encoding");
 static STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_VOCABULARY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalStreamTranscriptionOutput$VocabularyName",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalStreamTranscriptionOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vocabulary_name",
     "VocabularyName",
 ,
-150
+)
 .with_http_header("x-amzn-transcribe-vocabulary-name");
 static STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_SPECIALTY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalStreamTranscriptionOutput$Specialty",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalStreamTranscriptionOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "specialty",
     "Specialty",
 ,
-161
+)
 .with_http_header("x-amzn-transcribe-specialty");
 static STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalStreamTranscriptionOutput$Type",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalStreamTranscriptionOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "r##type",
     "Type",
 ,
-172
+)
 .with_http_header("x-amzn-transcribe-type");
 static STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_SHOW_SPEAKER_LABEL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalStreamTranscriptionOutput$ShowSpeakerLabel",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalStreamTranscriptionOutput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "show_speaker_label",
     "ShowSpeakerLabel",
 ,
-183
+)
 .with_http_header("x-amzn-transcribe-show-speaker-label");
 static STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_SESSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalStreamTranscriptionOutput$SessionId",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalStreamTranscriptionOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "session_id",
     "SessionId",
 ,
-194
+)
 .with_http_header("x-amzn-transcribe-session-id");
 static STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_TRANSCRIPT_RESULT_STREAM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalStreamTranscriptionOutput$TranscriptResultStream",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalStreamTranscriptionOutput",
     ),
     ::aws_smithy_schema::ShapeType::Union,
     "transcript_result_stream",
     "TranscriptResultStream",
 ,
-205
+)
 .with_http_payload();
 static STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_ENABLE_CHANNEL_IDENTIFICATION: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.transcribestreaming.synthetic#StartMedicalStreamTranscriptionOutput$EnableChannelIdentification",
             "com.amazonaws.transcribestreaming.synthetic",
             "StartMedicalStreamTranscriptionOutput",
         ),
         ::aws_smithy_schema::ShapeType::Boolean,
         "enable_channel_identification",
         "EnableChannelIdentification",
 ,
-217
+    )
     .with_http_header("x-amzn-transcribe-enable-channel-identification");
 static STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_NUMBER_OF_CHANNELS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming.synthetic#StartMedicalStreamTranscriptionOutput$NumberOfChannels",
         "com.amazonaws.transcribestreaming.synthetic",
         "StartMedicalStreamTranscriptionOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "number_of_channels",
     "NumberOfChannels",
 ,
-228
+)
 .with_http_header("x-amzn-transcribe-number-of-channels");
 static STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_CONTENT_IDENTIFICATION_TYPE: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.transcribestreaming.synthetic#StartMedicalStreamTranscriptionOutput$ContentIdentificationType",
             "com.amazonaws.transcribestreaming.synthetic",
             "StartMedicalStreamTranscriptionOutput",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "content_identification_type",
         "ContentIdentificationType",
 ,
-240
+    )
     .with_http_header("x-amzn-transcribe-content-identification-type");
 static STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_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 STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_REQUEST_ID,
         &STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_LANGUAGE_CODE,
         &STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_MEDIA_SAMPLE_RATE_HERTZ,
         &STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_MEDIA_ENCODING,
         &STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_VOCABULARY_NAME,
         &STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_SPECIALTY,
         &STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_TYPE,
         &STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_SHOW_SPEAKER_LABEL,
         &STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_SESSION_ID,
         &STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_TRANSCRIPT_RESULT_STREAM,
         &STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_ENABLE_CHANNEL_IDENTIFICATION,
         &STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_NUMBER_OF_CHANNELS,
         &STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_CONTENT_IDENTIFICATION_TYPE,
         &STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl StartMedicalStreamTranscriptionOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_SCHEMA;
-272
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StartMedicalStreamTranscriptionOutput {
     #[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.request_id {
             ser.write_string(&STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_REQUEST_ID, val)?;
-281
+        }
         if let Some(ref val) = self.language_code {
             ser.write_string(&STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_LANGUAGE_CODE, val.as_str())?;
-284
+        }
         if let Some(ref val) = self.media_sample_rate_hertz {
             ser.write_integer(&STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_MEDIA_SAMPLE_RATE_HERTZ, *val)?;
-287
+        }
         if let Some(ref val) = self.media_encoding {
             ser.write_string(&STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_MEDIA_ENCODING, val.as_str())?;
-290
+        }
         if let Some(ref val) = self.vocabulary_name {
             ser.write_string(&STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_VOCABULARY_NAME, val)?;
-293
+        }
         if let Some(ref val) = self.specialty {
             ser.write_string(&STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_SPECIALTY, val.as_str())?;
-296
+        }
         if let Some(ref val) = self.r#type {
             ser.write_string(&STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_TYPE, val.as_str())?;
-299
+        }
-300
+        {
             let val = &self.show_speaker_label;
             ser.write_boolean(&STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_SHOW_SPEAKER_LABEL, *val)?;
-303
+        }
         if let Some(ref val) = self.session_id {
             ser.write_string(&STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_SESSION_ID, val)?;
-306
+        }
--
+        {
             let val = &self.transcript_result_stream;
             ser.write_null(&STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_TRANSCRIPT_RESULT_STREAM)?;
--
+        }
-307
+        {
             let val = &self.enable_channel_identification;
             ser.write_boolean(&STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_ENABLE_CHANNEL_IDENTIFICATION, *val)?;
-310
+        }
         if let Some(ref val) = self.number_of_channels {
             ser.write_integer(&STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_NUMBER_OF_CHANNELS, *val)?;
-313
+        }
         if let Some(ref val) = self.content_identification_type {
             ser.write_string(&STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_MEMBER_CONTENT_IDENTIFICATION_TYPE, val.as_str())?;
-316
+        }
         Ok(())
-318
+    }
-319
+}
 impl StartMedicalStreamTranscriptionOutput {
     /// 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(&STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.request_id = Some(deser.read_string(member)?);
-338
+                }
                 Some(1) => {
                     builder.language_code = Some(crate::types::LanguageCode::from(deser.read_string(member)?.as_str()));
-341
+                }
                 Some(2) => {
                     builder.media_sample_rate_hertz = Some(deser.read_integer(member)?);
-344
+                }
                 Some(3) => {
                     builder.media_encoding = Some(crate::types::MediaEncoding::from(deser.read_string(member)?.as_str()));
-347
+                }
                 Some(4) => {
                     builder.vocabulary_name = Some(deser.read_string(member)?);
-350
+                }
                 Some(5) => {
                     builder.specialty = Some(crate::types::Specialty::from(deser.read_string(member)?.as_str()));
-353
+                }
                 Some(6) => {
                     builder.r#type = Some(crate::types::Type::from(deser.read_string(member)?.as_str()));
-356
+                }
                 Some(7) => {
                     builder.show_speaker_label = Some(deser.read_boolean(member)?);
-359
+                }
                 Some(8) => {
                     builder.session_id = Some(deser.read_string(member)?);
-362
+                }
                 Some(9) => {
                     builder.transcript_result_stream = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                         todo!("deserialize streaming union")
                     });
-368
+                }
                 Some(10) => {
                     builder.enable_channel_identification = Some(deser.read_boolean(member)?);
-371
+                }
                 Some(11) => {
                     builder.number_of_channels = Some(deser.read_integer(member)?);
-374
+                }
                 Some(12) => {
                     builder.content_identification_type =
                         Some(crate::types::MedicalContentIdentificationType::from(deser.read_string(member)?.as_str()));
-378
+                }
                 Some(13) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl StartMedicalStreamTranscriptionOutput {
     /// 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-request-id") {
             builder.request_id = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-language-code") {
             builder.language_code = Some(crate::types::LanguageCode::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-specialty") {
             builder.specialty = Some(crate::types::Specialty::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-type") {
             builder.r#type = Some(crate::types::Type::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-show-speaker-label") {
             builder.show_speaker_label = val.parse::<bool>().ok();
-+
+        }
         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-enable-channel-identification") {
             builder.enable_channel_identification = val.parse::<bool>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-number-of-channels") {
             builder.number_of_channels = val.parse::<i32>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amzn-transcribe-content-identification-type") {
             builder.content_identification_type = Some(crate::types::MedicalContentIdentificationType::from(val));
-+
+        }
         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(&STARTMEDICALSTREAMTRANSCRIPTIONOUTPUT_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) => { /* read from headers above */ }
                 Some(6) => { /* read from headers above */ }
                 Some(7) => { /* read from headers above */ }
                 Some(8) => { /* read from headers above */ }
                 Some(9) => {
                     builder.transcript_result_stream = Some({
                         let _ = member;
                         todo!("deserialize streaming union")
                     });
-+
+                }
                 Some(10) => { /* read from headers above */ }
                 Some(11) => { /* read from headers above */ }
                 Some(12) => { /* read from headers above */ }
                 _ => {}
-470
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-476
+    }
-477
+}
 impl ::aws_types::request_id::RequestId for StartMedicalStreamTranscriptionOutput {

↧ Expand context

     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-481
+    }
-482
+}
 impl StartMedicalStreamTranscriptionOutput {
     /// Creates a new builder-style object to manufacture [`StartMedicalStreamTranscriptionOutput`](crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionOutput).
     pub fn builder() -> crate::operation::start_medical_stream_transcription::builders::StartMedicalStreamTranscriptionOutputBuilder {
         crate::operation::start_medical_stream_transcription::builders::StartMedicalStreamTranscriptionOutputBuilder::default()
-487
+    }
-488
+}
-489
 /// A builder for [`StartMedicalStreamTranscriptionOutput`](crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionOutput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StartMedicalStreamTranscriptionOutputBuilder {
     pub(crate) request_id: ::std::option::Option<::std::string::String>,
     pub(crate) language_code: ::std::option::Option<crate::types::LanguageCode>,
     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>,

AWS SDK

Files changed:

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

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

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

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

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

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

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