AWS SDK

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

@@ -165,165 +555,0 @@

-165
+                )
             })?,
         );
         output = output.set_vocabulary_filter_names(
             crate::protocol_serde::shape_start_stream_transcription_output::de_vocabulary_filter_names_header(_response_headers).map_err(|_| {
                 crate::operation::start_stream_transcription::StartStreamTranscriptionError::unhandled(
                     "Failed to parse VocabularyFilterNames from header `x-amzn-transcribe-vocabulary-filter-names",
-172
+                )
             })?,
         );
         output = output.set_vocabulary_name(
             crate::protocol_serde::shape_start_stream_transcription_output::de_vocabulary_name_header(_response_headers).map_err(|_| {
                 crate::operation::start_stream_transcription::StartStreamTranscriptionError::unhandled(
                     "Failed to parse VocabularyName from header `x-amzn-transcribe-vocabulary-name",
-179
+                )
             })?,
         );
         output = output.set_vocabulary_names(
             crate::protocol_serde::shape_start_stream_transcription_output::de_vocabulary_names_header(_response_headers).map_err(|_| {
                 crate::operation::start_stream_transcription::StartStreamTranscriptionError::unhandled(

                     "Failed to parse VocabularyNames from header `x-amzn-transcribe-vocabulary-names",
-186
+                )
             })?,
         );
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         output
             .build()
             .map_err(crate::operation::start_stream_transcription::StartStreamTranscriptionError::unhandled)?
     })
-194
+}
--
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_start_stream_transcription_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::start_stream_transcription::StartStreamTranscriptionOutput,
     crate::operation::start_stream_transcription::StartStreamTranscriptionError,
 > {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::start_stream_transcription::StartStreamTranscriptionError::unhandled)?;
     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     let error_code = match generic.code() {
         Some(code) => code,
         None => {
             return Err(crate::operation::start_stream_transcription::StartStreamTranscriptionError::unhandled(
                 generic,
             ))
--
+        }
     };
--
     let _error_message = generic.message().map(|msg| msg.to_owned());
     Err(match error_code {
         "BadRequestException" => crate::operation::start_stream_transcription::StartStreamTranscriptionError::BadRequestException({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::BadRequestExceptionBuilder::default();
                 output = crate::protocol_serde::shape_bad_request_exception::de_bad_request_exception_json_err(_response_body, output)
                     .map_err(crate::operation::start_stream_transcription::StartStreamTranscriptionError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "ConflictException" => crate::operation::start_stream_transcription::StartStreamTranscriptionError::ConflictException({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ConflictExceptionBuilder::default();
                 output = crate::protocol_serde::shape_conflict_exception::de_conflict_exception_json_err(_response_body, output)
                     .map_err(crate::operation::start_stream_transcription::StartStreamTranscriptionError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "InternalFailureException" => crate::operation::start_stream_transcription::StartStreamTranscriptionError::InternalFailureException({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::InternalFailureExceptionBuilder::default();
                 output = crate::protocol_serde::shape_internal_failure_exception::de_internal_failure_exception_json_err(_response_body, output)
                     .map_err(crate::operation::start_stream_transcription::StartStreamTranscriptionError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "LimitExceededException" => crate::operation::start_stream_transcription::StartStreamTranscriptionError::LimitExceededException({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
                 output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
                     .map_err(crate::operation::start_stream_transcription::StartStreamTranscriptionError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         "ServiceUnavailableException" => crate::operation::start_stream_transcription::StartStreamTranscriptionError::ServiceUnavailableException({
             #[allow(unused_mut)]
             let mut tmp = {
                 #[allow(unused_mut)]
                 let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
                 output =
                     crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
                         .map_err(crate::operation::start_stream_transcription::StartStreamTranscriptionError::unhandled)?;
                 let output = output.meta(generic);
                 output.build()
             };
             if tmp.message.is_none() {
                 tmp.message = _error_message;
--
+            }
             tmp
         }),
         _ => crate::operation::start_stream_transcription::StartStreamTranscriptionError::generic(generic),
     })
--
+}
--
 pub fn ser_start_stream_transcription_headers(
     input: &crate::operation::start_stream_transcription::StartStreamTranscriptionInput,
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.language_code {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "language_code",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-language-code", header_value);
--
+    }
     if let ::std::option::Option::Some(inner_3) = &input.media_sample_rate_hertz {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_3);
         let formatted_4 = encoder.encode();
         let header_value = formatted_4;
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "media_sample_rate_hertz",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-sample-rate", header_value);
--
+    }
     if let ::std::option::Option::Some(inner_5) = &input.media_encoding {
         let formatted_6 = inner_5.as_str();
         let header_value = formatted_6;
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "media_encoding",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-media-encoding", header_value);
--
+    }
     if let ::std::option::Option::Some(inner_7) = &input.vocabulary_name {
         let formatted_8 = inner_7.as_str();
         let header_value = formatted_8;
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "vocabulary_name",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-vocabulary-name", header_value);
--
+    }
     if let ::std::option::Option::Some(inner_9) = &input.session_id {
         let formatted_10 = inner_9.as_str();
         let header_value = formatted_10;
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "session_id",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-session-id", header_value);
--
+    }
     if let ::std::option::Option::Some(inner_11) = &input.vocabulary_filter_name {
         let formatted_12 = inner_11.as_str();
         let header_value = formatted_12;
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "vocabulary_filter_name",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-vocabulary-filter-name", header_value);
--
+    }
     if let ::std::option::Option::Some(inner_13) = &input.vocabulary_filter_method {
         let formatted_14 = inner_13.as_str();
         let header_value = formatted_14;
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "vocabulary_filter_method",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-vocabulary-filter-method", header_value);
--
+    }
     if let ::std::option::Option::Some(inner_15) = &input.show_speaker_label {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_15);
         let formatted_16 = encoder.encode();
         let header_value = formatted_16;
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "show_speaker_label",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-show-speaker-label", header_value);
--
+    }
     if let ::std::option::Option::Some(inner_17) = &input.enable_channel_identification {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_17);
         let formatted_18 = encoder.encode();
         let header_value = formatted_18;
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "enable_channel_identification",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-enable-channel-identification", header_value);
--
+    }
     if let ::std::option::Option::Some(inner_19) = &input.number_of_channels {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_19);
         let formatted_20 = encoder.encode();
         let header_value = formatted_20;
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "number_of_channels",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-number-of-channels", header_value);
--
+    }
     if let ::std::option::Option::Some(inner_21) = &input.enable_partial_results_stabilization {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_21);
         let formatted_22 = encoder.encode();
         let header_value = formatted_22;
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "enable_partial_results_stabilization",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-enable-partial-results-stabilization", header_value);
--
+    }
     if let ::std::option::Option::Some(inner_23) = &input.partial_results_stability {
         let formatted_24 = inner_23.as_str();
         let header_value = formatted_24;
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "partial_results_stability",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-partial-results-stability", header_value);
--
+    }
     if let ::std::option::Option::Some(inner_25) = &input.content_identification_type {
         let formatted_26 = inner_25.as_str();
         let header_value = formatted_26;
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_identification_type",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-content-identification-type", header_value);
--
+    }
     if let ::std::option::Option::Some(inner_27) = &input.content_redaction_type {
         let formatted_28 = inner_27.as_str();
         let header_value = formatted_28;
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_redaction_type",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-content-redaction-type", header_value);
--
+    }
     if let ::std::option::Option::Some(inner_29) = &input.pii_entity_types {
         let formatted_30 = inner_29.as_str();
         let header_value = formatted_30;
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "pii_entity_types",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-pii-entity-types", header_value);
--
+    }
     if let ::std::option::Option::Some(inner_31) = &input.language_model_name {
         let formatted_32 = inner_31.as_str();
         let header_value = formatted_32;
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "language_model_name",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-language-model-name", header_value);
--
+    }
     if let ::std::option::Option::Some(inner_33) = &input.identify_language {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_33);
         let formatted_34 = encoder.encode();
         let header_value = formatted_34;
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "identify_language",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-identify-language", header_value);
--
+    }
     if let ::std::option::Option::Some(inner_35) = &input.language_options {
         let formatted_36 = inner_35.as_str();
         let header_value = formatted_36;
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "language_options",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-language-options", header_value);
--
+    }
     if let ::std::option::Option::Some(inner_37) = &input.preferred_language {
         let formatted_38 = inner_37.as_str();
         let header_value = formatted_38;
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "preferred_language",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-preferred-language", header_value);
--
+    }
     if let ::std::option::Option::Some(inner_39) = &input.identify_multiple_languages {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_39);
         let formatted_40 = encoder.encode();
         let header_value = formatted_40;
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "identify_multiple_languages",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-identify-multiple-languages", header_value);
--
+    }
     if let ::std::option::Option::Some(inner_41) = &input.vocabulary_names {
         let formatted_42 = inner_41.as_str();
         let header_value = formatted_42;
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "vocabulary_names",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-vocabulary-names", header_value);
--
+    }
     if let ::std::option::Option::Some(inner_43) = &input.vocabulary_filter_names {
         let formatted_44 = inner_43.as_str();
         let header_value = formatted_44;
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "vocabulary_filter_names",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amzn-transcribe-vocabulary-filter-names", header_value);
--
+    }
     Ok(builder)
--
+}

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

@@ -1,0 +42,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn medical_scribe_encryption_settings_correct_errors(
     mut builder: crate::types::builders::MedicalScribeEncryptionSettingsBuilder,
 ) -> crate::types::builders::MedicalScribeEncryptionSettingsBuilder {
     if builder.kms_key_id.is_none() {
         builder.kms_key_id = Some(Default::default())
--
+    }
     builder
--
+}
--
 pub(crate) fn medical_scribe_post_stream_analytics_settings_correct_errors(
     mut builder: crate::types::builders::MedicalScribePostStreamAnalyticsSettingsBuilder,
 ) -> crate::types::builders::MedicalScribePostStreamAnalyticsSettingsBuilder {
     if builder.clinical_note_generation_settings.is_none() {
         builder.clinical_note_generation_settings = {
             let builder = crate::types::builders::ClinicalNoteGenerationSettingsBuilder::default();
             crate::serde_util::clinical_note_generation_settings_correct_errors(builder).build().ok()
--
+        }
--
+    }
     builder
--
+}
--
 pub(crate) fn clinical_note_generation_settings_correct_errors(
     mut builder: crate::types::builders::ClinicalNoteGenerationSettingsBuilder,
 ) -> crate::types::builders::ClinicalNoteGenerationSettingsBuilder {
     if builder.output_bucket_name.is_none() {
         builder.output_bucket_name = Some(Default::default())
--
+    }
     builder
--
+}
--
 pub(crate) fn medical_scribe_channel_definition_correct_errors(
     mut builder: crate::types::builders::MedicalScribeChannelDefinitionBuilder,
 ) -> crate::types::builders::MedicalScribeChannelDefinitionBuilder {
     if builder.channel_id.is_none() {
         builder.channel_id = Some(Default::default())
--
+    }
     if builder.participant_role.is_none() {
         builder.participant_role = "no value was set".parse::<crate::types::MedicalScribeParticipantRole>().ok()
--
+    }
     builder
--
+}

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

@@ -1,0 +89,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
--
 #![allow(dead_code)]
--
 use aws_smithy_http::header::set_request_header_if_absent;
 use aws_smithy_types::config_bag::{Storable, StoreReplace};
 use http_1x::header::{HeaderName, CONTENT_LENGTH, CONTENT_TYPE};
--
 /// Configuration for how default protocol headers are serialized
 #[derive(Clone, Debug, Default)]
 pub(crate) struct HeaderSerializationSettings {
     omit_default_content_length: bool,
     omit_default_content_type: bool,
--
+}
--
 impl HeaderSerializationSettings {
     /// Creates new [`HeaderSerializationSettings`]
     pub(crate) fn new() -> Self {
         Default::default()
--
+    }
--
     /// Omit the default `Content-Length` header during serialization
     pub(crate) fn omit_default_content_length(self) -> Self {
         Self {
             omit_default_content_length: true,
             ..self
--
+        }
--
+    }
--
     /// Omit the default `Content-Type` header during serialization
     pub(crate) fn omit_default_content_type(self) -> Self {
         Self {
             omit_default_content_type: true,
             ..self
--
+        }
--
+    }
--
     /// Returns true if the given default header name should be serialized
     fn include_header(&self, header: &HeaderName) -> bool {
         (!self.omit_default_content_length || header != CONTENT_LENGTH) && (!self.omit_default_content_type || header != CONTENT_TYPE)
--
+    }
--
     /// Sets a default header on the given request builder if it should be serialized
     pub(crate) fn set_default_header(
         &self,
         mut request: http_1x::request::Builder,
         header_name: HeaderName,
         value: &str,
     ) -> http_1x::request::Builder {
         if self.include_header(&header_name) {
             request = set_request_header_if_absent(request, header_name, value);
--
+        }
         request
--
+    }
--
+}
--
 impl Storable for HeaderSerializationSettings {
     type Storer = StoreReplace<Self>;
--
+}
--
 #[cfg(test)]
 mod tests {
     use super::*;
--
     #[test]
     fn test_include_header() {
         let settings = HeaderSerializationSettings::default();
         assert!(settings.include_header(&CONTENT_LENGTH));
         assert!(settings.include_header(&CONTENT_TYPE));
--
         let settings = HeaderSerializationSettings::default().omit_default_content_length();
         assert!(!settings.include_header(&CONTENT_LENGTH));
         assert!(settings.include_header(&CONTENT_TYPE));
--
         let settings = HeaderSerializationSettings::default().omit_default_content_type();
         assert!(settings.include_header(&CONTENT_LENGTH));
         assert!(!settings.include_header(&CONTENT_TYPE));
--
         let settings = HeaderSerializationSettings::default()
             .omit_default_content_type()
             .omit_default_content_length();
         assert!(!settings.include_header(&CONTENT_LENGTH));
         assert!(!settings.include_header(&CONTENT_TYPE));
--
+    }
--
+}

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

@@ -14,14 +188,193 @@

↥ Expand context

 impl Alternative {
     /// <p>Contains transcribed text.</p>
     pub fn transcript(&self) -> ::std::option::Option<&str> {
         self.transcript.as_deref()
-18
+    }
     /// <p>Contains words, phrases, or punctuation marks in your transcription output.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.items.is_none()`.
     pub fn items(&self) -> &[crate::types::Item] {
         self.items.as_deref().unwrap_or_default()
-24
+    }
     /// <p>Contains entities identified as personally identifiable information (PII) in your transcription output.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.entities.is_none()`.
     pub fn entities(&self) -> &[crate::types::Entity] {
         self.entities.as_deref().unwrap_or_default()
-30
+    }
-31
+}
 static ALTERNATIVE_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming#Alternative",

     "com.amazonaws.transcribestreaming",
     "Alternative",
 );
 static ALTERNATIVE_MEMBER_TRANSCRIPT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#Alternative$Transcript",
         "com.amazonaws.transcribestreaming",
         "Alternative",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "transcript",
     "Transcript",
 ,
 );
 static ALTERNATIVE_MEMBER_ITEMS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#Alternative$Items",
         "com.amazonaws.transcribestreaming",
         "Alternative",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "items",
     "Items",
 ,
 );
 static ALTERNATIVE_MEMBER_ENTITIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#Alternative$Entities",
         "com.amazonaws.transcribestreaming",
         "Alternative",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "entities",
     "Entities",
 ,
 );
 static ALTERNATIVE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     ALTERNATIVE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&ALTERNATIVE_MEMBER_TRANSCRIPT, &ALTERNATIVE_MEMBER_ITEMS, &ALTERNATIVE_MEMBER_ENTITIES],
 );
 impl Alternative {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ALTERNATIVE_SCHEMA;
-75
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for Alternative {
     #[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.transcript {
             ser.write_string(&ALTERNATIVE_MEMBER_TRANSCRIPT, val)?;
-84
+        }
         if let Some(ref val) = self.items {
             ser.write_list(&ALTERNATIVE_MEMBER_ITEMS, &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                 for item in val {
                     ser.write_struct(crate::types::Item::SCHEMA, item)?;
-89
+                }
                 Ok(())
             })?;
-92
+        }
         if let Some(ref val) = self.entities {
             ser.write_list(
                 &ALTERNATIVE_MEMBER_ENTITIES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Entity::SCHEMA, item)?;
-99
+                    }
                     Ok(())
                 },
             )?;
-103
+        }
         Ok(())
-105
+    }
-106
+}
 impl Alternative {
     /// 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(&ALTERNATIVE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&ALTERNATIVE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.transcript = Some(deser.read_string(member)?);
-125
+                }
                 Some(1) => {
                     builder.items = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::Item::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Item::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-135
+                }
                 Some(2) => {
                     builder.entities = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::Entity::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Entity::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-145
+                }
                 _ => {}
-147
+            }
             Ok(())
         })?;
         Ok(builder.build())
-151
+    }
-152
+}
 impl Alternative {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl Alternative {
     /// Creates a new builder-style object to manufacture [`Alternative`](crate::types::Alternative).
     pub fn builder() -> crate::types::builders::AlternativeBuilder {
         crate::types::builders::AlternativeBuilder::default()
-168
+    }
-169
+}
-170
 /// A builder for [`Alternative`](crate::types::Alternative).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct AlternativeBuilder {
     pub(crate) transcript: ::std::option::Option<::std::string::String>,
     pub(crate) items: ::std::option::Option<::std::vec::Vec<crate::types::Item>>,
     pub(crate) entities: ::std::option::Option<::std::vec::Vec<crate::types::Entity>>,
-178
+}
 impl AlternativeBuilder {
     /// <p>Contains transcribed text.</p>
     pub fn transcript(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.transcript = ::std::option::Option::Some(input.into());
         self
-184
+    }
     /// <p>Contains transcribed text.</p>
     pub fn set_transcript(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.transcript = input;
         self
-189
+    }
     /// <p>Contains transcribed text.</p>
     pub fn get_transcript(&self) -> &::std::option::Option<::std::string::String> {
         &self.transcript
-193
+    }

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

@@ -7,7 +117,128 @@

↥ Expand context

 pub struct AudioEvent {
     /// <p>An audio blob containing the next segment of audio from your application, with a maximum duration of 1 second. The maximum size in bytes varies based on audio properties.</p>
     /// <p>Find recommended size in <a href="https://docs.aws.amazon.com/transcribe/latest/dg/streaming.html#best-practices">Transcribing streaming best practices</a>.</p>
     /// <p>Size calculation: <code>Duration (s) * Sample Rate (Hz) * Number of Channels * 2 (Bytes per Sample)</code></p>
     /// <p>For example, a 1-second chunk of 16 kHz, 2-channel, 16-bit audio would be <code>1 * 16000 * 2 * 2 = 64000 bytes</code>.</p>
     /// <p>For 8 kHz, 1-channel, 16-bit audio, a 1-second chunk would be <code>1 * 8000 * 1 * 2 = 16000 bytes</code>.</p>
     pub audio_chunk: ::std::option::Option<::aws_smithy_types::Blob>,
-14
+}
 impl AudioEvent {
     /// <p>An audio blob containing the next segment of audio from your application, with a maximum duration of 1 second. The maximum size in bytes varies based on audio properties.</p>
     /// <p>Find recommended size in <a href="https://docs.aws.amazon.com/transcribe/latest/dg/streaming.html#best-practices">Transcribing streaming best practices</a>.</p>
     /// <p>Size calculation: <code>Duration (s) * Sample Rate (Hz) * Number of Channels * 2 (Bytes per Sample)</code></p>
     /// <p>For example, a 1-second chunk of 16 kHz, 2-channel, 16-bit audio would be <code>1 * 16000 * 2 * 2 = 64000 bytes</code>.</p>
     /// <p>For 8 kHz, 1-channel, 16-bit audio, a 1-second chunk would be <code>1 * 8000 * 1 * 2 = 16000 bytes</code>.</p>
     pub fn audio_chunk(&self) -> ::std::option::Option<&::aws_smithy_types::Blob> {
         self.audio_chunk.as_ref()
-23
+    }
-24
+}
 static AUDIOEVENT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming#AudioEvent",

     "com.amazonaws.transcribestreaming",
     "AudioEvent",
 );
 static AUDIOEVENT_MEMBER_AUDIO_CHUNK: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#AudioEvent$AudioChunk",
         "com.amazonaws.transcribestreaming",
         "AudioEvent",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "audio_chunk",
     "AudioChunk",
 ,
-39
+)
 .with_event_payload();
 static AUDIOEVENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     AUDIOEVENT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&AUDIOEVENT_MEMBER_AUDIO_CHUNK],
 );
 impl AudioEvent {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &AUDIOEVENT_SCHEMA;
-49
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for AudioEvent {
     #[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.audio_chunk {
             ser.write_blob(&AUDIOEVENT_MEMBER_AUDIO_CHUNK, val)?;
-58
+        }
         Ok(())
-60
+    }
-61
+}
 impl AudioEvent {
     /// 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(&AUDIOEVENT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&AUDIOEVENT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.audio_chunk = Some(deser.read_blob(member)?);
-80
+                }
                 _ => {}
-82
+            }
             Ok(())
         })?;
         Ok(builder.build())
-86
+    }
-87
+}
 impl AudioEvent {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl AudioEvent {
     /// Creates a new builder-style object to manufacture [`AudioEvent`](crate::types::AudioEvent).
     pub fn builder() -> crate::types::builders::AudioEventBuilder {
         crate::types::builders::AudioEventBuilder::default()
-103
+    }
-104
+}
-105
 /// A builder for [`AudioEvent`](crate::types::AudioEvent).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct AudioEventBuilder {
     pub(crate) audio_chunk: ::std::option::Option<::aws_smithy_types::Blob>,
-111
+}
 impl AudioEventBuilder {
     /// <p>An audio blob containing the next segment of audio from your application, with a maximum duration of 1 second. The maximum size in bytes varies based on audio properties.</p>
     /// <p>Find recommended size in <a href="https://docs.aws.amazon.com/transcribe/latest/dg/streaming.html#best-practices">Transcribing streaming best practices</a>.</p>
     /// <p>Size calculation: <code>Duration (s) * Sample Rate (Hz) * Number of Channels * 2 (Bytes per Sample)</code></p>
     /// <p>For example, a 1-second chunk of 16 kHz, 2-channel, 16-bit audio would be <code>1 * 16000 * 2 * 2 = 64000 bytes</code>.</p>
     /// <p>For 8 kHz, 1-channel, 16-bit audio, a 1-second chunk would be <code>1 * 8000 * 1 * 2 = 16000 bytes</code>.</p>
     pub fn audio_chunk(mut self, input: ::aws_smithy_types::Blob) -> Self {
         self.audio_chunk = ::std::option::Option::Some(input);
         self
-121
+    }
     /// <p>An audio blob containing the next segment of audio from your application, with a maximum duration of 1 second. The maximum size in bytes varies based on audio properties.</p>
     /// <p>Find recommended size in <a href="https://docs.aws.amazon.com/transcribe/latest/dg/streaming.html#best-practices">Transcribing streaming best practices</a>.</p>
     /// <p>Size calculation: <code>Duration (s) * Sample Rate (Hz) * Number of Channels * 2 (Bytes per Sample)</code></p>
     /// <p>For example, a 1-second chunk of 16 kHz, 2-channel, 16-bit audio would be <code>1 * 16000 * 2 * 2 = 64000 bytes</code>.</p>
     /// <p>For 8 kHz, 1-channel, 16-bit audio, a 1-second chunk would be <code>1 * 8000 * 1 * 2 = 16000 bytes</code>.</p>
     pub fn set_audio_chunk(mut self, input: ::std::option::Option<::aws_smithy_types::Blob>) -> Self {
         self.audio_chunk = input;

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

@@ -25,25 +0,125 @@

↥ Expand context

     /// Returns `Err(&Self)` if it can't be converted.
     pub fn as_audio_event(&self) -> ::std::result::Result<&crate::types::AudioEvent, &Self> {
         if let AudioStream::AudioEvent(val) = &self {
             ::std::result::Result::Ok(val)
         } else {
             ::std::result::Result::Err(self)
-31
+        }
-32
+    }
     /// Returns true if this is a [`AudioEvent`](crate::types::AudioStream::AudioEvent).
     pub fn is_audio_event(&self) -> bool {
         self.as_audio_event().is_ok()
-36
+    }
     /// Tries to convert the enum instance into [`ConfigurationEvent`](crate::types::AudioStream::ConfigurationEvent), extracting the inner [`ConfigurationEvent`](crate::types::ConfigurationEvent).
     /// Returns `Err(&Self)` if it can't be converted.
     pub fn as_configuration_event(&self) -> ::std::result::Result<&crate::types::ConfigurationEvent, &Self> {
         if let AudioStream::ConfigurationEvent(val) = &self {
             ::std::result::Result::Ok(val)
         } else {
             ::std::result::Result::Err(self)
-44
+        }

-45
+    }
     /// Returns true if this is a [`ConfigurationEvent`](crate::types::AudioStream::ConfigurationEvent).
     pub fn is_configuration_event(&self) -> bool {
         self.as_configuration_event().is_ok()
-49
+    }
     /// Returns true if the enum instance is the `Unknown` variant.
     pub fn is_unknown(&self) -> bool {
         matches!(self, Self::Unknown)
-53
+    }
-54
+}
 static AUDIOSTREAM_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming#AudioStream",
     "com.amazonaws.transcribestreaming",
     "AudioStream",
 );
 static AUDIOSTREAM_MEMBER_AUDIOEVENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#AudioStream$AudioEvent",
         "com.amazonaws.transcribestreaming",
         "AudioStream",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "AudioEvent",
 ,
 );
 static AUDIOSTREAM_MEMBER_CONFIGURATIONEVENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#AudioStream$ConfigurationEvent",
         "com.amazonaws.transcribestreaming",
         "AudioStream",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "ConfigurationEvent",
 ,
 );
 static AUDIOSTREAM_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     AUDIOSTREAM_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Union,
     &[&AUDIOSTREAM_MEMBER_AUDIOEVENT, &AUDIOSTREAM_MEMBER_CONFIGURATIONEVENT],
-+
+)
 .with_streaming();
 impl AudioStream {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &AUDIOSTREAM_SCHEMA;
-+
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for AudioStream {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         match self {
             Self::AudioEvent(val) => {
                 ser.write_struct(&AUDIOSTREAM_MEMBER_AUDIOEVENT, val)?;
-+
+            }
             Self::ConfigurationEvent(val) => {
                 ser.write_struct(&AUDIOSTREAM_MEMBER_CONFIGURATIONEVENT, val)?;
-+
+            }
             Self::Unknown => return Err(::aws_smithy_schema::serde::SerdeError::custom("cannot serialize unknown union variant")),
-+
+        }
         Ok(())
-+
+    }
-+
+}
 impl AudioStream {
     /// Deserializes this union from a [`ShapeDeserializer`].
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         let mut result: ::std::option::Option<Self> = ::std::option::Option::None;
         #[allow(unused_variables, unreachable_code, clippy::single_match, clippy::match_single_binding)]
         deserializer.read_struct(&AUDIOSTREAM_SCHEMA, &mut |member, deser| {
             result = ::std::option::Option::Some(match member.member_index() {
                 Some(0) => Self::AudioEvent(crate::types::AudioEvent::deserialize(deser)?),
                 Some(1) => Self::ConfigurationEvent(crate::types::ConfigurationEvent::deserialize(deser)?),
                 _ => Self::Unknown,
             });
             Ok(())
         })?;
         result.ok_or_else(|| ::aws_smithy_schema::serde::SerdeError::custom("expected a union variant"))
-+
+    }
-+
+}

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

@@ -30,30 +226,237 @@

↥ Expand context

     /// <p>The category of information identified. For example, <code>PII</code>.</p>
     pub fn category(&self) -> ::std::option::Option<&str> {
         self.category.as_deref()
-33
+    }
     /// <p>The type of PII identified. For example, <code>NAME</code> or <code>CREDIT_DEBIT_NUMBER</code>.</p>
     pub fn r#type(&self) -> ::std::option::Option<&str> {
         self.r#type.as_deref()
-37
+    }
     /// <p>The word or words that represent the identified entity.</p>
     pub fn content(&self) -> ::std::option::Option<&str> {
         self.content.as_deref()
-41
+    }
     /// <p>The confidence score associated with the identification of an entity in your transcript.</p>
     /// <p>Confidence scores are values between 0 and 1. A larger value indicates a higher probability that the identified entity correctly matches the entity spoken in your media.</p>
     pub fn confidence(&self) -> ::std::option::Option<f64> {
         self.confidence
-46
+    }
-47
+}
 static CALLANALYTICSENTITY_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming#CallAnalyticsEntity",

     "com.amazonaws.transcribestreaming",
     "CallAnalyticsEntity",
 );
 static CALLANALYTICSENTITY_MEMBER_BEGIN_OFFSET_MILLIS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#CallAnalyticsEntity$BeginOffsetMillis",
         "com.amazonaws.transcribestreaming",
         "CallAnalyticsEntity",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "begin_offset_millis",
     "BeginOffsetMillis",
 ,
 );
 static CALLANALYTICSENTITY_MEMBER_END_OFFSET_MILLIS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#CallAnalyticsEntity$EndOffsetMillis",
         "com.amazonaws.transcribestreaming",
         "CallAnalyticsEntity",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "end_offset_millis",
     "EndOffsetMillis",
 ,
 );
 static CALLANALYTICSENTITY_MEMBER_CATEGORY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#CallAnalyticsEntity$Category",
         "com.amazonaws.transcribestreaming",
         "CallAnalyticsEntity",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "category",
     "Category",
 ,
 );
 static CALLANALYTICSENTITY_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#CallAnalyticsEntity$Type",
         "com.amazonaws.transcribestreaming",
         "CallAnalyticsEntity",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "r##type",
     "Type",
 ,
 );
 static CALLANALYTICSENTITY_MEMBER_CONTENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#CallAnalyticsEntity$Content",
         "com.amazonaws.transcribestreaming",
         "CallAnalyticsEntity",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content",
     "Content",
 ,
 );
 static CALLANALYTICSENTITY_MEMBER_CONFIDENCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#CallAnalyticsEntity$Confidence",
         "com.amazonaws.transcribestreaming",
         "CallAnalyticsEntity",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "confidence",
     "Confidence",
 ,
 );
 static CALLANALYTICSENTITY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CALLANALYTICSENTITY_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CALLANALYTICSENTITY_MEMBER_BEGIN_OFFSET_MILLIS,
         &CALLANALYTICSENTITY_MEMBER_END_OFFSET_MILLIS,
         &CALLANALYTICSENTITY_MEMBER_CATEGORY,
         &CALLANALYTICSENTITY_MEMBER_TYPE,
         &CALLANALYTICSENTITY_MEMBER_CONTENT,
         &CALLANALYTICSENTITY_MEMBER_CONFIDENCE,
     ],
 );
 impl CallAnalyticsEntity {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CALLANALYTICSENTITY_SCHEMA;
-128
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CallAnalyticsEntity {
     #[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.begin_offset_millis {
             ser.write_long(&CALLANALYTICSENTITY_MEMBER_BEGIN_OFFSET_MILLIS, *val)?;
-137
+        }
         if let Some(ref val) = self.end_offset_millis {
             ser.write_long(&CALLANALYTICSENTITY_MEMBER_END_OFFSET_MILLIS, *val)?;
-140
+        }
         if let Some(ref val) = self.category {
             ser.write_string(&CALLANALYTICSENTITY_MEMBER_CATEGORY, val)?;
-143
+        }
         if let Some(ref val) = self.r#type {
             ser.write_string(&CALLANALYTICSENTITY_MEMBER_TYPE, val)?;
-146
+        }
         if let Some(ref val) = self.content {
             ser.write_string(&CALLANALYTICSENTITY_MEMBER_CONTENT, val)?;
-149
+        }
         if let Some(ref val) = self.confidence {
             ser.write_double(&CALLANALYTICSENTITY_MEMBER_CONFIDENCE, *val)?;
-152
+        }
         Ok(())
-154
+    }
-155
+}
 impl CallAnalyticsEntity {
     /// 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(&CALLANALYTICSENTITY_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CALLANALYTICSENTITY_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.begin_offset_millis = Some(deser.read_long(member)?);
-174
+                }
                 Some(1) => {
                     builder.end_offset_millis = Some(deser.read_long(member)?);
-177
+                }
                 Some(2) => {
                     builder.category = Some(deser.read_string(member)?);
-180
+                }
                 Some(3) => {
                     builder.r#type = Some(deser.read_string(member)?);
-183
+                }
                 Some(4) => {
                     builder.content = Some(deser.read_string(member)?);
-186
+                }
                 Some(5) => {
                     builder.confidence = Some(deser.read_double(member)?);
-189
+                }
                 _ => {}
-191
+            }
             Ok(())
         })?;
         Ok(builder.build())
-195
+    }
-196
+}
 impl CallAnalyticsEntity {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl CallAnalyticsEntity {
     /// Creates a new builder-style object to manufacture [`CallAnalyticsEntity`](crate::types::CallAnalyticsEntity).
     pub fn builder() -> crate::types::builders::CallAnalyticsEntityBuilder {
         crate::types::builders::CallAnalyticsEntityBuilder::default()
-212
+    }
-213
+}
-214
 /// A builder for [`CallAnalyticsEntity`](crate::types::CallAnalyticsEntity).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct CallAnalyticsEntityBuilder {
     pub(crate) begin_offset_millis: ::std::option::Option<i64>,
     pub(crate) end_offset_millis: ::std::option::Option<i64>,
     pub(crate) category: ::std::option::Option<::std::string::String>,
     pub(crate) r#type: ::std::option::Option<::std::string::String>,
     pub(crate) content: ::std::option::Option<::std::string::String>,
     pub(crate) confidence: ::std::option::Option<f64>,
-225
+}
 impl CallAnalyticsEntityBuilder {
     /// <p>The time, in milliseconds, from the beginning of the audio stream to the start of the identified entity.</p>
     pub fn begin_offset_millis(mut self, input: i64) -> Self {
         self.begin_offset_millis = ::std::option::Option::Some(input);
         self
-231
+    }
     /// <p>The time, in milliseconds, from the beginning of the audio stream to the start of the identified entity.</p>
     pub fn set_begin_offset_millis(mut self, input: ::std::option::Option<i64>) -> Self {
         self.begin_offset_millis = input;
         self
-236
+    }
     /// <p>The time, in milliseconds, from the beginning of the audio stream to the start of the identified entity.</p>

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

@@ -36,36 +250,261 @@

↥ Expand context

     /// <p>The word or punctuation that was transcribed.</p>
     pub fn content(&self) -> ::std::option::Option<&str> {
         self.content.as_deref()
-39
+    }
     /// <p>The confidence score associated with a word or phrase in your transcript.</p>
     /// <p>Confidence scores are values between 0 and 1. A larger value indicates a higher probability that the identified item correctly matches the item spoken in your media.</p>
     pub fn confidence(&self) -> ::std::option::Option<f64> {
         self.confidence
-44
+    }
     /// <p>Indicates whether the specified item matches a word in the vocabulary filter included in your Call Analytics request. If <code>true</code>, there is a vocabulary filter match.</p>
     pub fn vocabulary_filter_match(&self) -> bool {
         self.vocabulary_filter_match
-48
+    }
     /// <p>If partial result stabilization is enabled, <code>Stable</code> indicates whether the specified item is stable (<code>true</code>) or if it may change when the segment is complete (<code>false</code>).</p>
     pub fn stable(&self) -> ::std::option::Option<bool> {
         self.stable
-52
+    }
-53
+}
 static CALLANALYTICSITEM_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming#CallAnalyticsItem",

     "com.amazonaws.transcribestreaming",
     "CallAnalyticsItem",
 );
 static CALLANALYTICSITEM_MEMBER_BEGIN_OFFSET_MILLIS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#CallAnalyticsItem$BeginOffsetMillis",
         "com.amazonaws.transcribestreaming",
         "CallAnalyticsItem",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "begin_offset_millis",
     "BeginOffsetMillis",
 ,
 );
 static CALLANALYTICSITEM_MEMBER_END_OFFSET_MILLIS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#CallAnalyticsItem$EndOffsetMillis",
         "com.amazonaws.transcribestreaming",
         "CallAnalyticsItem",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "end_offset_millis",
     "EndOffsetMillis",
 ,
 );
 static CALLANALYTICSITEM_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#CallAnalyticsItem$Type",
         "com.amazonaws.transcribestreaming",
         "CallAnalyticsItem",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "r##type",
     "Type",
 ,
 );
 static CALLANALYTICSITEM_MEMBER_CONTENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#CallAnalyticsItem$Content",
         "com.amazonaws.transcribestreaming",
         "CallAnalyticsItem",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "content",
     "Content",
 ,
 );
 static CALLANALYTICSITEM_MEMBER_CONFIDENCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#CallAnalyticsItem$Confidence",
         "com.amazonaws.transcribestreaming",
         "CallAnalyticsItem",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "confidence",
     "Confidence",
 ,
 );
 static CALLANALYTICSITEM_MEMBER_VOCABULARY_FILTER_MATCH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#CallAnalyticsItem$VocabularyFilterMatch",
         "com.amazonaws.transcribestreaming",
         "CallAnalyticsItem",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "vocabulary_filter_match",
     "VocabularyFilterMatch",
 ,
 );
 static CALLANALYTICSITEM_MEMBER_STABLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#CallAnalyticsItem$Stable",
         "com.amazonaws.transcribestreaming",
         "CallAnalyticsItem",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "stable",
     "Stable",
 ,
 );
 static CALLANALYTICSITEM_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CALLANALYTICSITEM_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CALLANALYTICSITEM_MEMBER_BEGIN_OFFSET_MILLIS,
         &CALLANALYTICSITEM_MEMBER_END_OFFSET_MILLIS,
         &CALLANALYTICSITEM_MEMBER_TYPE,
         &CALLANALYTICSITEM_MEMBER_CONTENT,
         &CALLANALYTICSITEM_MEMBER_CONFIDENCE,
         &CALLANALYTICSITEM_MEMBER_VOCABULARY_FILTER_MATCH,
         &CALLANALYTICSITEM_MEMBER_STABLE,
     ],
 );
 impl CallAnalyticsItem {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CALLANALYTICSITEM_SCHEMA;
-145
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CallAnalyticsItem {
     #[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.begin_offset_millis {
             ser.write_long(&CALLANALYTICSITEM_MEMBER_BEGIN_OFFSET_MILLIS, *val)?;
-154
+        }
         if let Some(ref val) = self.end_offset_millis {
             ser.write_long(&CALLANALYTICSITEM_MEMBER_END_OFFSET_MILLIS, *val)?;
-157
+        }
         if let Some(ref val) = self.r#type {
             ser.write_string(&CALLANALYTICSITEM_MEMBER_TYPE, val.as_str())?;
-160
+        }
         if let Some(ref val) = self.content {
             ser.write_string(&CALLANALYTICSITEM_MEMBER_CONTENT, val)?;
-163
+        }
         if let Some(ref val) = self.confidence {
             ser.write_double(&CALLANALYTICSITEM_MEMBER_CONFIDENCE, *val)?;
-166
+        }
-167
+        {
             let val = &self.vocabulary_filter_match;
             ser.write_boolean(&CALLANALYTICSITEM_MEMBER_VOCABULARY_FILTER_MATCH, *val)?;
-170
+        }
         if let Some(ref val) = self.stable {
             ser.write_boolean(&CALLANALYTICSITEM_MEMBER_STABLE, *val)?;
-173
+        }
         Ok(())
-175
+    }
-176
+}
 impl CallAnalyticsItem {
     /// 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(&CALLANALYTICSITEM_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CALLANALYTICSITEM_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.begin_offset_millis = Some(deser.read_long(member)?);
-195
+                }
                 Some(1) => {
                     builder.end_offset_millis = Some(deser.read_long(member)?);
-198
+                }
                 Some(2) => {
                     builder.r#type = Some(crate::types::ItemType::from(deser.read_string(member)?.as_str()));
-201
+                }
                 Some(3) => {
                     builder.content = Some(deser.read_string(member)?);
-204
+                }
                 Some(4) => {
                     builder.confidence = Some(deser.read_double(member)?);
-207
+                }
                 Some(5) => {
                     builder.vocabulary_filter_match = Some(deser.read_boolean(member)?);
-210
+                }
                 Some(6) => {
                     builder.stable = Some(deser.read_boolean(member)?);
-213
+                }
                 _ => {}
-215
+            }
             Ok(())
         })?;
         Ok(builder.build())
-219
+    }
-220
+}
 impl CallAnalyticsItem {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl CallAnalyticsItem {
     /// Creates a new builder-style object to manufacture [`CallAnalyticsItem`](crate::types::CallAnalyticsItem).
     pub fn builder() -> crate::types::builders::CallAnalyticsItemBuilder {
         crate::types::builders::CallAnalyticsItemBuilder::default()
-236
+    }
-237
+}
-238
 /// A builder for [`CallAnalyticsItem`](crate::types::CallAnalyticsItem).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct CallAnalyticsItemBuilder {
     pub(crate) begin_offset_millis: ::std::option::Option<i64>,
     pub(crate) end_offset_millis: ::std::option::Option<i64>,
     pub(crate) r#type: ::std::option::Option<crate::types::ItemType>,
     pub(crate) content: ::std::option::Option<::std::string::String>,
     pub(crate) confidence: ::std::option::Option<f64>,
     pub(crate) vocabulary_filter_match: ::std::option::Option<bool>,
     pub(crate) stable: ::std::option::Option<bool>,
-250
+}
 impl CallAnalyticsItemBuilder {
     /// <p>The time, in milliseconds, from the beginning of the audio stream to the start of the identified item.</p>
     pub fn begin_offset_millis(mut self, input: i64) -> Self {
         self.begin_offset_millis = ::std::option::Option::Some(input);
         self
-256
+    }
     /// <p>The time, in milliseconds, from the beginning of the audio stream to the start of the identified item.</p>
     pub fn set_begin_offset_millis(mut self, input: ::std::option::Option<i64>) -> Self {
         self.begin_offset_millis = input;
         self
-261
+    }

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

@@ -4,4 +133,144 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct CallAnalyticsLanguageWithScore {
     /// <p>The language code of the identified language.</p>
     pub language_code: ::std::option::Option<crate::types::CallAnalyticsLanguageCode>,
     /// <p>The confidence score associated with the identified language code. Confidence scores are values between zero and one; larger values indicate a higher confidence in the identified language.</p>
     pub score: f64,
-11
+}
 impl CallAnalyticsLanguageWithScore {
     /// <p>The language code of the identified language.</p>
     pub fn language_code(&self) -> ::std::option::Option<&crate::types::CallAnalyticsLanguageCode> {
         self.language_code.as_ref()
-16
+    }
     /// <p>The confidence score associated with the identified language code. Confidence scores are values between zero and one; larger values indicate a higher confidence in the identified language.</p>
     pub fn score(&self) -> f64 {
         self.score
-20
+    }
-21
+}
 static CALLANALYTICSLANGUAGEWITHSCORE_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming#CallAnalyticsLanguageWithScore",

     "com.amazonaws.transcribestreaming",
     "CallAnalyticsLanguageWithScore",
 );
 static CALLANALYTICSLANGUAGEWITHSCORE_MEMBER_LANGUAGE_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#CallAnalyticsLanguageWithScore$LanguageCode",
         "com.amazonaws.transcribestreaming",
         "CallAnalyticsLanguageWithScore",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "language_code",
     "LanguageCode",
 ,
 );
 static CALLANALYTICSLANGUAGEWITHSCORE_MEMBER_SCORE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#CallAnalyticsLanguageWithScore$Score",
         "com.amazonaws.transcribestreaming",
         "CallAnalyticsLanguageWithScore",
     ),
     ::aws_smithy_schema::ShapeType::Double,
     "score",
     "Score",
 ,
 );
 static CALLANALYTICSLANGUAGEWITHSCORE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CALLANALYTICSLANGUAGEWITHSCORE_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CALLANALYTICSLANGUAGEWITHSCORE_MEMBER_LANGUAGE_CODE,
         &CALLANALYTICSLANGUAGEWITHSCORE_MEMBER_SCORE,
     ],
 );
 impl CallAnalyticsLanguageWithScore {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CALLANALYTICSLANGUAGEWITHSCORE_SCHEMA;
-58
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CallAnalyticsLanguageWithScore {
     #[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(&CALLANALYTICSLANGUAGEWITHSCORE_MEMBER_LANGUAGE_CODE, val.as_str())?;
-67
+        }
-68
+        {
             let val = &self.score;
             ser.write_double(&CALLANALYTICSLANGUAGEWITHSCORE_MEMBER_SCORE, *val)?;
-71
+        }
         Ok(())
-73
+    }
-74
+}
 impl CallAnalyticsLanguageWithScore {
     /// 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(&CALLANALYTICSLANGUAGEWITHSCORE_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CALLANALYTICSLANGUAGEWITHSCORE_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.language_code = Some(crate::types::CallAnalyticsLanguageCode::from(deser.read_string(member)?.as_str()));
-93
+                }
                 Some(1) => {
                     builder.score = Some(deser.read_double(member)?);
-96
+                }
                 _ => {}
-98
+            }
             Ok(())
         })?;
         Ok(builder.build())
-102
+    }
-103
+}
 impl CallAnalyticsLanguageWithScore {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl CallAnalyticsLanguageWithScore {
     /// Creates a new builder-style object to manufacture [`CallAnalyticsLanguageWithScore`](crate::types::CallAnalyticsLanguageWithScore).
     pub fn builder() -> crate::types::builders::CallAnalyticsLanguageWithScoreBuilder {
         crate::types::builders::CallAnalyticsLanguageWithScoreBuilder::default()
-119
+    }
-120
+}
-121
 /// A builder for [`CallAnalyticsLanguageWithScore`](crate::types::CallAnalyticsLanguageWithScore).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct CallAnalyticsLanguageWithScoreBuilder {
     pub(crate) language_code: ::std::option::Option<crate::types::CallAnalyticsLanguageCode>,
     pub(crate) score: ::std::option::Option<f64>,
-128
+}
 impl CallAnalyticsLanguageWithScoreBuilder {
     /// <p>The language code of the identified language.</p>
     pub fn language_code(mut self, input: crate::types::CallAnalyticsLanguageCode) -> Self {
         self.language_code = ::std::option::Option::Some(input);
         self
-134
+    }
     /// <p>The language code of the identified language.</p>
     pub fn set_language_code(mut self, input: ::std::option::Option<crate::types::CallAnalyticsLanguageCode>) -> Self {
         self.language_code = input;
         self
-139
+    }
     /// <p>The language code of the identified language.</p>
     pub fn get_language_code(&self) -> &::std::option::Option<crate::types::CallAnalyticsLanguageCode> {
         &self.language_code
-143
+    }
     /// <p>The confidence score associated with the identified language code. Confidence scores are values between zero and one; larger values indicate a higher confidence in the identified language.</p>

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

@@ -23,23 +0,126 @@

↥ Expand context

     /// Returns `Err(&Self)` if it can't be converted.
     pub fn as_category_event(&self) -> ::std::result::Result<&crate::types::CategoryEvent, &Self> {
         if let CallAnalyticsTranscriptResultStream::CategoryEvent(val) = &self {
             ::std::result::Result::Ok(val)
         } else {
             ::std::result::Result::Err(self)
-29
+        }
-30
+    }
     /// Returns true if this is a [`CategoryEvent`](crate::types::CallAnalyticsTranscriptResultStream::CategoryEvent).
     pub fn is_category_event(&self) -> bool {
         self.as_category_event().is_ok()
-34
+    }
     /// Tries to convert the enum instance into [`UtteranceEvent`](crate::types::CallAnalyticsTranscriptResultStream::UtteranceEvent), extracting the inner [`UtteranceEvent`](crate::types::UtteranceEvent).
     /// Returns `Err(&Self)` if it can't be converted.
     pub fn as_utterance_event(&self) -> ::std::result::Result<&crate::types::UtteranceEvent, &Self> {
         if let CallAnalyticsTranscriptResultStream::UtteranceEvent(val) = &self {
             ::std::result::Result::Ok(val)
         } else {
             ::std::result::Result::Err(self)
-42
+        }

-43
+    }
     /// Returns true if this is a [`UtteranceEvent`](crate::types::CallAnalyticsTranscriptResultStream::UtteranceEvent).
     pub fn is_utterance_event(&self) -> bool {
         self.as_utterance_event().is_ok()
-47
+    }
     /// Returns true if the enum instance is the `Unknown` variant.
     pub fn is_unknown(&self) -> bool {
         matches!(self, Self::Unknown)
-51
+    }
-52
+}
 static CALLANALYTICSTRANSCRIPTRESULTSTREAM_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming#CallAnalyticsTranscriptResultStream",
     "com.amazonaws.transcribestreaming",
     "CallAnalyticsTranscriptResultStream",
 );
 static CALLANALYTICSTRANSCRIPTRESULTSTREAM_MEMBER_UTTERANCEEVENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#CallAnalyticsTranscriptResultStream$UtteranceEvent",
         "com.amazonaws.transcribestreaming",
         "CallAnalyticsTranscriptResultStream",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "UtteranceEvent",
 ,
 );
 static CALLANALYTICSTRANSCRIPTRESULTSTREAM_MEMBER_CATEGORYEVENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#CallAnalyticsTranscriptResultStream$CategoryEvent",
         "com.amazonaws.transcribestreaming",
         "CallAnalyticsTranscriptResultStream",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "CategoryEvent",
 ,
 );
 static CALLANALYTICSTRANSCRIPTRESULTSTREAM_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CALLANALYTICSTRANSCRIPTRESULTSTREAM_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Union,
     &[
         &CALLANALYTICSTRANSCRIPTRESULTSTREAM_MEMBER_UTTERANCEEVENT,
         &CALLANALYTICSTRANSCRIPTRESULTSTREAM_MEMBER_CATEGORYEVENT,
     ],
-+
+)
 .with_streaming();
 impl CallAnalyticsTranscriptResultStream {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CALLANALYTICSTRANSCRIPTRESULTSTREAM_SCHEMA;
-+
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CallAnalyticsTranscriptResultStream {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         match self {
             Self::UtteranceEvent(val) => {
                 ser.write_struct(&CALLANALYTICSTRANSCRIPTRESULTSTREAM_MEMBER_UTTERANCEEVENT, val)?;
-+
+            }
             Self::CategoryEvent(val) => {
                 ser.write_struct(&CALLANALYTICSTRANSCRIPTRESULTSTREAM_MEMBER_CATEGORYEVENT, val)?;
-+
+            }
             Self::Unknown => return Err(::aws_smithy_schema::serde::SerdeError::custom("cannot serialize unknown union variant")),
-+
+        }
         Ok(())
-+
+    }
-+
+}
 impl CallAnalyticsTranscriptResultStream {
     /// Deserializes this union from a [`ShapeDeserializer`].
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         let mut result: ::std::option::Option<Self> = ::std::option::Option::None;
         #[allow(unused_variables, unreachable_code, clippy::single_match, clippy::match_single_binding)]
         deserializer.read_struct(&CALLANALYTICSTRANSCRIPTRESULTSTREAM_SCHEMA, &mut |member, deser| {
             result = ::std::option::Option::Some(match member.member_index() {
                 Some(0) => Self::UtteranceEvent(crate::types::UtteranceEvent::deserialize(deser)?),
                 Some(1) => Self::CategoryEvent(crate::types::CategoryEvent::deserialize(deser)?),
                 _ => Self::Unknown,
             });
             Ok(())
         })?;
         result.ok_or_else(|| ::aws_smithy_schema::serde::SerdeError::custom("expected a union variant"))
-+
+    }
-+
+}

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

@@ -6,6 +168,166 @@

↥ Expand context

 pub struct CategoryEvent {
     /// <p>Lists the categories that were matched in your audio segment.</p>
     pub matched_categories: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     /// <p>Contains information about the matched categories, including category names and timestamps.</p>
     pub matched_details: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::PointsOfInterest>>,
-11
+}
 impl CategoryEvent {
     /// <p>Lists the categories that were matched in your audio segment.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.matched_categories.is_none()`.
     pub fn matched_categories(&self) -> &[::std::string::String] {
         self.matched_categories.as_deref().unwrap_or_default()
-18
+    }
     /// <p>Contains information about the matched categories, including category names and timestamps.</p>
     pub fn matched_details(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, crate::types::PointsOfInterest>> {
         self.matched_details.as_ref()
-22
+    }
-23
+}
 static CATEGORYEVENT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming#CategoryEvent",

     "com.amazonaws.transcribestreaming",
     "CategoryEvent",
 );
 static CATEGORYEVENT_MEMBER_MATCHED_CATEGORIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#CategoryEvent$MatchedCategories",
         "com.amazonaws.transcribestreaming",
         "CategoryEvent",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "matched_categories",
     "MatchedCategories",
 ,
 );
 static CATEGORYEVENT_MEMBER_MATCHED_DETAILS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#CategoryEvent$MatchedDetails",
         "com.amazonaws.transcribestreaming",
         "CategoryEvent",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "matched_details",
     "MatchedDetails",
 ,
 );
 static CATEGORYEVENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CATEGORYEVENT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&CATEGORYEVENT_MEMBER_MATCHED_CATEGORIES, &CATEGORYEVENT_MEMBER_MATCHED_DETAILS],
 );
 impl CategoryEvent {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CATEGORYEVENT_SCHEMA;
-57
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CategoryEvent {
     #[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.matched_categories {
             ser.write_list(
                 &CATEGORYEVENT_MEMBER_MATCHED_CATEGORIES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-70
+                    }
                     Ok(())
                 },
             )?;
-74
+        }
         if let Some(ref val) = self.matched_details {
             ser.write_map(
                 &CATEGORYEVENT_MEMBER_MATCHED_DETAILS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_struct(crate::types::PointsOfInterest::SCHEMA, value)?;
-82
+                    }
                     Ok(())
                 },
             )?;
-86
+        }
         Ok(())
-88
+    }
-89
+}
 impl CategoryEvent {
     /// 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(&CATEGORYEVENT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CATEGORYEVENT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.matched_categories = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.matched_categories = Some(deser.read_string_list(member)?);
-108
+                }
                 Some(1) => {
                     builder.matched_details = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, crate::types::PointsOfInterest::deserialize(deser)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::PointsOfInterest::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-118
+                }
                 _ => {}
-120
+            }
             Ok(())
         })?;
         Ok(builder.build())
-124
+    }
-125
+}
 impl CategoryEvent {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl CategoryEvent {
     /// Creates a new builder-style object to manufacture [`CategoryEvent`](crate::types::CategoryEvent).
     pub fn builder() -> crate::types::builders::CategoryEventBuilder {
         crate::types::builders::CategoryEventBuilder::default()
-141
+    }
-142
+}
-143
 /// A builder for [`CategoryEvent`](crate::types::CategoryEvent).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct CategoryEventBuilder {
     pub(crate) matched_categories: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) matched_details: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::PointsOfInterest>>,
-150
+}
 impl CategoryEventBuilder {
     /// Appends an item to `matched_categories`.
     ///
     /// To override the contents of this collection use [`set_matched_categories`](Self::set_matched_categories).
     ///
     /// <p>Lists the categories that were matched in your audio segment.</p>
     pub fn matched_categories(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         let mut v = self.matched_categories.unwrap_or_default();
         v.push(input.into());
         self.matched_categories = ::std::option::Option::Some(v);
         self
-162
+    }
     /// <p>Lists the categories that were matched in your audio segment.</p>
     pub fn set_matched_categories(mut self, input: ::std::option::Option<::std::vec::Vec<::std::string::String>>) -> Self {
         self.matched_categories = input;
         self

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

@@ -4,4 +133,145 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct ChannelDefinition {
     /// <p>Specify the audio channel you want to define.</p>
     pub channel_id: i32,
     /// <p>Specify the speaker you want to define. Omitting this parameter is equivalent to specifying both participants.</p>
     pub participant_role: crate::types::ParticipantRole,
-11
+}
 impl ChannelDefinition {
     /// <p>Specify the audio channel you want to define.</p>
     pub fn channel_id(&self) -> i32 {
         self.channel_id
-16
+    }
     /// <p>Specify the speaker you want to define. Omitting this parameter is equivalent to specifying both participants.</p>
     pub fn participant_role(&self) -> &crate::types::ParticipantRole {
         &self.participant_role
-20
+    }
-21
+}
 static CHANNELDEFINITION_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming#ChannelDefinition",

     "com.amazonaws.transcribestreaming",
     "ChannelDefinition",
 );
 static CHANNELDEFINITION_MEMBER_CHANNEL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#ChannelDefinition$ChannelId",
         "com.amazonaws.transcribestreaming",
         "ChannelDefinition",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "channel_id",
     "ChannelId",
 ,
 );
 static CHANNELDEFINITION_MEMBER_PARTICIPANT_ROLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#ChannelDefinition$ParticipantRole",
         "com.amazonaws.transcribestreaming",
         "ChannelDefinition",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "participant_role",
     "ParticipantRole",
 ,
 );
 static CHANNELDEFINITION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CHANNELDEFINITION_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&CHANNELDEFINITION_MEMBER_CHANNEL_ID, &CHANNELDEFINITION_MEMBER_PARTICIPANT_ROLE],
 );
 impl ChannelDefinition {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CHANNELDEFINITION_SCHEMA;
-55
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ChannelDefinition {
     #[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> {
-62
+        {
             let val = &self.channel_id;
             ser.write_integer(&CHANNELDEFINITION_MEMBER_CHANNEL_ID, *val)?;
-65
+        }
-66
+        {
             let val = &self.participant_role;
             ser.write_string(&CHANNELDEFINITION_MEMBER_PARTICIPANT_ROLE, val.as_str())?;
-69
+        }
         Ok(())
-71
+    }
-72
+}
 impl ChannelDefinition {
     /// 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(&CHANNELDEFINITION_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CHANNELDEFINITION_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.channel_id = Some(deser.read_integer(member)?);
-91
+                }
                 Some(1) => {
                     builder.participant_role = Some(crate::types::ParticipantRole::from(deser.read_string(member)?.as_str()));
-94
+                }
                 _ => {}
-96
+            }
             Ok(())
         })?;
         builder.channel_id = builder.channel_id.or(Some(0i32));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-103
+    }
-104
+}
 impl ChannelDefinition {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl ChannelDefinition {
     /// Creates a new builder-style object to manufacture [`ChannelDefinition`](crate::types::ChannelDefinition).
     pub fn builder() -> crate::types::builders::ChannelDefinitionBuilder {
         crate::types::builders::ChannelDefinitionBuilder::default()
-120
+    }
-121
+}
-122
 /// A builder for [`ChannelDefinition`](crate::types::ChannelDefinition).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ChannelDefinitionBuilder {
     pub(crate) channel_id: ::std::option::Option<i32>,
     pub(crate) participant_role: ::std::option::Option<crate::types::ParticipantRole>,
-129
+}
 impl ChannelDefinitionBuilder {
     /// <p>Specify the audio channel you want to define.</p>
     /// This field is required.
     pub fn channel_id(mut self, input: i32) -> Self {
         self.channel_id = ::std::option::Option::Some(input);
         self
-136
+    }
     /// <p>Specify the audio channel you want to define.</p>
     pub fn set_channel_id(mut self, input: ::std::option::Option<i32>) -> Self {
         self.channel_id = input;
         self
-141
+    }
     /// <p>Specify the audio channel you want to define.</p>
     pub fn get_channel_id(&self) -> &::std::option::Option<i32> {
         &self.channel_id
-145
+    }

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

@@ -4,4 +129,140 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct CharacterOffsets {
     /// <p>Provides the character count of the first character where a match is identified. For example, the first character associated with an issue or a category match in a segment transcript.</p>
     pub begin: ::std::option::Option<i32>,
     /// <p>Provides the character count of the last character where a match is identified. For example, the last character associated with an issue or a category match in a segment transcript.</p>
     pub end: ::std::option::Option<i32>,
-11
+}
 impl CharacterOffsets {
     /// <p>Provides the character count of the first character where a match is identified. For example, the first character associated with an issue or a category match in a segment transcript.</p>
     pub fn begin(&self) -> ::std::option::Option<i32> {
         self.begin
-16
+    }
     /// <p>Provides the character count of the last character where a match is identified. For example, the last character associated with an issue or a category match in a segment transcript.</p>
     pub fn end(&self) -> ::std::option::Option<i32> {
         self.end
-20
+    }
-21
+}
 static CHARACTEROFFSETS_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming#CharacterOffsets",

     "com.amazonaws.transcribestreaming",
     "CharacterOffsets",
 );
 static CHARACTEROFFSETS_MEMBER_BEGIN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#CharacterOffsets$Begin",
         "com.amazonaws.transcribestreaming",
         "CharacterOffsets",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "begin",
     "Begin",
 ,
 );
 static CHARACTEROFFSETS_MEMBER_END: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#CharacterOffsets$End",
         "com.amazonaws.transcribestreaming",
         "CharacterOffsets",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "end",
     "End",
 ,
 );
 static CHARACTEROFFSETS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CHARACTEROFFSETS_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&CHARACTEROFFSETS_MEMBER_BEGIN, &CHARACTEROFFSETS_MEMBER_END],
 );
 impl CharacterOffsets {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CHARACTEROFFSETS_SCHEMA;
-55
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CharacterOffsets {
     #[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.begin {
             ser.write_integer(&CHARACTEROFFSETS_MEMBER_BEGIN, *val)?;
-64
+        }
         if let Some(ref val) = self.end {
             ser.write_integer(&CHARACTEROFFSETS_MEMBER_END, *val)?;
-67
+        }
         Ok(())
-69
+    }
-70
+}
 impl CharacterOffsets {
     /// 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(&CHARACTEROFFSETS_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CHARACTEROFFSETS_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.begin = Some(deser.read_integer(member)?);
-89
+                }
                 Some(1) => {
                     builder.end = Some(deser.read_integer(member)?);
-92
+                }
                 _ => {}
-94
+            }
             Ok(())
         })?;
         Ok(builder.build())
-98
+    }
-99
+}
 impl CharacterOffsets {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl CharacterOffsets {
     /// Creates a new builder-style object to manufacture [`CharacterOffsets`](crate::types::CharacterOffsets).
     pub fn builder() -> crate::types::builders::CharacterOffsetsBuilder {
         crate::types::builders::CharacterOffsetsBuilder::default()
-115
+    }
-116
+}
-117
 /// A builder for [`CharacterOffsets`](crate::types::CharacterOffsets).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct CharacterOffsetsBuilder {
     pub(crate) begin: ::std::option::Option<i32>,
     pub(crate) end: ::std::option::Option<i32>,
-124
+}
 impl CharacterOffsetsBuilder {
     /// <p>Provides the character count of the first character where a match is identified. For example, the first character associated with an issue or a category match in a segment transcript.</p>
     pub fn begin(mut self, input: i32) -> Self {
         self.begin = ::std::option::Option::Some(input);
         self
-130
+    }
     /// <p>Provides the character count of the first character where a match is identified. For example, the first character associated with an issue or a category match in a segment transcript.</p>
     pub fn set_begin(mut self, input: ::std::option::Option<i32>) -> Self {
         self.begin = input;
         self
-135
+    }
     /// <p>Provides the character count of the first character where a match is identified. For example, the first character associated with an issue or a category match in a segment transcript.</p>
     pub fn get_begin(&self) -> &::std::option::Option<i32> {
         &self.begin
-139
+    }
     /// <p>Provides the character count of the last character where a match is identified. For example, the last character associated with an issue or a category match in a segment transcript.</p>

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

@@ -36,36 +198,209 @@

↥ Expand context

     /// <p>Possible Values:</p>
     /// <ul>
     /// <li>
     /// <p><code>IN_PROGRESS</code></p></li>
     /// <li>
     /// <p><code>FAILED</code></p></li>
     /// <li>
     /// <p><code>COMPLETED</code></p></li>
     /// </ul>
     /// <p>After audio streaming finishes, and you send a <code>MedicalScribeSessionControlEvent</code> event (with END_OF_SESSION as the Type), the status is set to <code>IN_PROGRESS</code>. If the status is <code>COMPLETED</code>, the analytics completed successfully, and you can find the results at the locations specified in <code>ClinicalNoteOutputLocation</code> and <code>TranscriptOutputLocation</code>. If the status is <code>FAILED</code>, <code>FailureReason</code> provides details about the failure.</p>
     pub fn status(&self) -> ::std::option::Option<&crate::types::ClinicalNoteGenerationStatus> {
         self.status.as_ref()
-48
+    }
     /// <p>If <code>ClinicalNoteGenerationResult</code> is <code>FAILED</code>, information about why it failed.</p>
     pub fn failure_reason(&self) -> ::std::option::Option<&str> {
         self.failure_reason.as_deref()
-52
+    }
-53
+}
 static CLINICALNOTEGENERATIONRESULT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming#ClinicalNoteGenerationResult",

     "com.amazonaws.transcribestreaming",
     "ClinicalNoteGenerationResult",
 );
 static CLINICALNOTEGENERATIONRESULT_MEMBER_CLINICAL_NOTE_OUTPUT_LOCATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#ClinicalNoteGenerationResult$ClinicalNoteOutputLocation",
         "com.amazonaws.transcribestreaming",
         "ClinicalNoteGenerationResult",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "clinical_note_output_location",
     "ClinicalNoteOutputLocation",
 ,
 );
 static CLINICALNOTEGENERATIONRESULT_MEMBER_TRANSCRIPT_OUTPUT_LOCATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#ClinicalNoteGenerationResult$TranscriptOutputLocation",
         "com.amazonaws.transcribestreaming",
         "ClinicalNoteGenerationResult",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "transcript_output_location",
     "TranscriptOutputLocation",
 ,
 );
 static CLINICALNOTEGENERATIONRESULT_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#ClinicalNoteGenerationResult$Status",
         "com.amazonaws.transcribestreaming",
         "ClinicalNoteGenerationResult",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "status",
     "Status",
 ,
 );
 static CLINICALNOTEGENERATIONRESULT_MEMBER_FAILURE_REASON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#ClinicalNoteGenerationResult$FailureReason",
         "com.amazonaws.transcribestreaming",
         "ClinicalNoteGenerationResult",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "failure_reason",
     "FailureReason",
 ,
 );
 static CLINICALNOTEGENERATIONRESULT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CLINICALNOTEGENERATIONRESULT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CLINICALNOTEGENERATIONRESULT_MEMBER_CLINICAL_NOTE_OUTPUT_LOCATION,
         &CLINICALNOTEGENERATIONRESULT_MEMBER_TRANSCRIPT_OUTPUT_LOCATION,
         &CLINICALNOTEGENERATIONRESULT_MEMBER_STATUS,
         &CLINICALNOTEGENERATIONRESULT_MEMBER_FAILURE_REASON,
     ],
 );
 impl ClinicalNoteGenerationResult {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CLINICALNOTEGENERATIONRESULT_SCHEMA;
-112
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ClinicalNoteGenerationResult {
     #[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.clinical_note_output_location {
             ser.write_string(&CLINICALNOTEGENERATIONRESULT_MEMBER_CLINICAL_NOTE_OUTPUT_LOCATION, val)?;
-121
+        }
         if let Some(ref val) = self.transcript_output_location {
             ser.write_string(&CLINICALNOTEGENERATIONRESULT_MEMBER_TRANSCRIPT_OUTPUT_LOCATION, val)?;
-124
+        }
         if let Some(ref val) = self.status {
             ser.write_string(&CLINICALNOTEGENERATIONRESULT_MEMBER_STATUS, val.as_str())?;
-127
+        }
         if let Some(ref val) = self.failure_reason {
             ser.write_string(&CLINICALNOTEGENERATIONRESULT_MEMBER_FAILURE_REASON, val)?;
-130
+        }
         Ok(())
-132
+    }
-133
+}
 impl ClinicalNoteGenerationResult {
     /// 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(&CLINICALNOTEGENERATIONRESULT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CLINICALNOTEGENERATIONRESULT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.clinical_note_output_location = Some(deser.read_string(member)?);
-152
+                }
                 Some(1) => {
                     builder.transcript_output_location = Some(deser.read_string(member)?);
-155
+                }
                 Some(2) => {
                     builder.status = Some(crate::types::ClinicalNoteGenerationStatus::from(deser.read_string(member)?.as_str()));
-158
+                }
                 Some(3) => {
                     builder.failure_reason = Some(deser.read_string(member)?);
-161
+                }
                 _ => {}
-163
+            }
             Ok(())
         })?;
         Ok(builder.build())
-167
+    }
-168
+}
 impl ClinicalNoteGenerationResult {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl ClinicalNoteGenerationResult {
     /// Creates a new builder-style object to manufacture [`ClinicalNoteGenerationResult`](crate::types::ClinicalNoteGenerationResult).
     pub fn builder() -> crate::types::builders::ClinicalNoteGenerationResultBuilder {
         crate::types::builders::ClinicalNoteGenerationResultBuilder::default()
-184
+    }
-185
+}
-186
 /// A builder for [`ClinicalNoteGenerationResult`](crate::types::ClinicalNoteGenerationResult).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ClinicalNoteGenerationResultBuilder {
     pub(crate) clinical_note_output_location: ::std::option::Option<::std::string::String>,
     pub(crate) transcript_output_location: ::std::option::Option<::std::string::String>,
     pub(crate) status: ::std::option::Option<crate::types::ClinicalNoteGenerationStatus>,
     pub(crate) failure_reason: ::std::option::Option<::std::string::String>,
-195
+}
 impl ClinicalNoteGenerationResultBuilder {
     /// <p>Holds the Amazon S3 URI for the output Clinical Note.</p>
     pub fn clinical_note_output_location(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.clinical_note_output_location = ::std::option::Option::Some(input.into());
         self
-201
+    }
     /// <p>Holds the Amazon S3 URI for the output Clinical Note.</p>
     pub fn set_clinical_note_output_location(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.clinical_note_output_location = input;
         self
-206
+    }
     /// <p>Holds the Amazon S3 URI for the output Clinical Note.</p>
     pub fn get_clinical_note_output_location(&self) -> &::std::option::Option<::std::string::String> {
         &self.clinical_note_output_location

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

@@ -41,41 +172,184 @@

↥ Expand context

     /// <p>HISTORY_AND_PHYSICAL: Provides summaries for key sections of the clinical documentation. Examples of sections include Chief Complaint, History of Present Illness, Review of Systems, Past Medical History, Assessment, and Plan.</p></li>
     /// <li>
     /// <p>GIRPP: Provides summaries based on the patients progress toward goals. Examples of sections include Goal, Intervention, Response, Progress, and Plan.</p></li>
     /// <li>
     /// <p>BIRP: Focuses on the patient's behavioral patterns and responses. Examples of sections include Behavior, Intervention, Response, and Plan.</p></li>
     /// <li>
     /// <p>SIRP: Emphasizes the situational context of therapy. Examples of sections include Situation, Intervention, Response, and Plan.</p></li>
     /// <li>
     /// <p>DAP: Provides a simplified format for clinical documentation. Examples of sections include Data, Assessment, and Plan.</p></li>
     /// <li>
     /// <p>BEHAVIORAL_SOAP: Behavioral health focused documentation format. Examples of sections include Subjective, Objective, Assessment, and Plan.</p></li>
     /// <li>
     /// <p>PHYSICAL_SOAP: Physical health focused documentation format. Examples of sections include Subjective, Objective, Assessment, and Plan.</p></li>
     /// </ul>
     pub fn note_template(&self) -> ::std::option::Option<&crate::types::MedicalScribeNoteTemplate> {
         self.note_template.as_ref()
-57
+    }
-58
+}
 static CLINICALNOTEGENERATIONSETTINGS_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming#ClinicalNoteGenerationSettings",

     "com.amazonaws.transcribestreaming",
     "ClinicalNoteGenerationSettings",
 );
 static CLINICALNOTEGENERATIONSETTINGS_MEMBER_OUTPUT_BUCKET_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#ClinicalNoteGenerationSettings$OutputBucketName",
         "com.amazonaws.transcribestreaming",
         "ClinicalNoteGenerationSettings",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "output_bucket_name",
     "OutputBucketName",
 ,
 );
 static CLINICALNOTEGENERATIONSETTINGS_MEMBER_NOTE_TEMPLATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#ClinicalNoteGenerationSettings$NoteTemplate",
         "com.amazonaws.transcribestreaming",
         "ClinicalNoteGenerationSettings",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "note_template",
     "NoteTemplate",
 ,
 );
 static CLINICALNOTEGENERATIONSETTINGS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CLINICALNOTEGENERATIONSETTINGS_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CLINICALNOTEGENERATIONSETTINGS_MEMBER_OUTPUT_BUCKET_NAME,
         &CLINICALNOTEGENERATIONSETTINGS_MEMBER_NOTE_TEMPLATE,
     ],
 );
 impl ClinicalNoteGenerationSettings {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CLINICALNOTEGENERATIONSETTINGS_SCHEMA;
-95
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ClinicalNoteGenerationSettings {
     #[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> {
-102
+        {
             let val = &self.output_bucket_name;
             ser.write_string(&CLINICALNOTEGENERATIONSETTINGS_MEMBER_OUTPUT_BUCKET_NAME, val)?;
-105
+        }
         if let Some(ref val) = self.note_template {
             ser.write_string(&CLINICALNOTEGENERATIONSETTINGS_MEMBER_NOTE_TEMPLATE, val.as_str())?;
-108
+        }
         Ok(())
-110
+    }
-111
+}
 impl ClinicalNoteGenerationSettings {
     /// 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(&CLINICALNOTEGENERATIONSETTINGS_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CLINICALNOTEGENERATIONSETTINGS_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.output_bucket_name = Some(deser.read_string(member)?);
-130
+                }
                 Some(1) => {
                     builder.note_template = Some(crate::types::MedicalScribeNoteTemplate::from(deser.read_string(member)?.as_str()));
-133
+                }
                 _ => {}
-135
+            }
             Ok(())
         })?;
         builder.output_bucket_name = builder.output_bucket_name.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-142
+    }
-143
+}
 impl ClinicalNoteGenerationSettings {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl ClinicalNoteGenerationSettings {
     /// Creates a new builder-style object to manufacture [`ClinicalNoteGenerationSettings`](crate::types::ClinicalNoteGenerationSettings).
     pub fn builder() -> crate::types::builders::ClinicalNoteGenerationSettingsBuilder {
         crate::types::builders::ClinicalNoteGenerationSettingsBuilder::default()
-159
+    }
-160
+}
-161
 /// A builder for [`ClinicalNoteGenerationSettings`](crate::types::ClinicalNoteGenerationSettings).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ClinicalNoteGenerationSettingsBuilder {
     pub(crate) output_bucket_name: ::std::option::Option<::std::string::String>,
     pub(crate) note_template: ::std::option::Option<crate::types::MedicalScribeNoteTemplate>,
-168
+}
 impl ClinicalNoteGenerationSettingsBuilder {
     /// <p>The name of the Amazon S3 bucket where you want the output of Amazon Web Services HealthScribe post-stream analytics stored. Don't include the <code>S3://</code> prefix of the specified bucket.</p>
     /// <p>HealthScribe outputs transcript and clinical note files under the prefix: <code>S3://$output-bucket-name/healthscribe-streaming/session-id/post-stream-analytics/clinical-notes</code></p>
     /// <p>The role <code>ResourceAccessRoleArn</code> specified in the <code>MedicalScribeConfigurationEvent</code> must have permission to use the specified location. You can change Amazon S3 permissions using the <a href="https://console.aws.amazon.com/s3"> Amazon Web Services Management Console </a>. See also <a href="https://docs.aws.amazon.com/transcribe/latest/dg/security_iam_id-based-policy-examples.html#auth-role-iam-user">Permissions Required for IAM User Roles </a> .</p>
     /// This field is required.
     pub fn output_bucket_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.output_bucket_name = ::std::option::Option::Some(input.into());
         self
-177
+    }
     /// <p>The name of the Amazon S3 bucket where you want the output of Amazon Web Services HealthScribe post-stream analytics stored. Don't include the <code>S3://</code> prefix of the specified bucket.</p>
     /// <p>HealthScribe outputs transcript and clinical note files under the prefix: <code>S3://$output-bucket-name/healthscribe-streaming/session-id/post-stream-analytics/clinical-notes</code></p>
     /// <p>The role <code>ResourceAccessRoleArn</code> specified in the <code>MedicalScribeConfigurationEvent</code> must have permission to use the specified location. You can change Amazon S3 permissions using the <a href="https://console.aws.amazon.com/s3"> Amazon Web Services Management Console </a>. See also <a href="https://docs.aws.amazon.com/transcribe/latest/dg/security_iam_id-based-policy-examples.html#auth-role-iam-user">Permissions Required for IAM User Roles </a> .</p>
     pub fn set_output_bucket_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.output_bucket_name = input;
         self
-184
+    }

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

@@ -8,8 +154,162 @@

↥ Expand context

     pub channel_definitions: ::std::option::Option<::std::vec::Vec<crate::types::ChannelDefinition>>,
     /// <p>Provides additional optional settings for your Call Analytics post-call request, including encryption and output locations for your redacted transcript.</p>
     /// <p><code>PostCallAnalyticsSettings</code> provides you with the same insights as a Call Analytics post-call transcription. Refer to <a href="https://docs.aws.amazon.com/transcribe/latest/dg/tca-post-call.html">Post-call analytics</a> for more information on this feature.</p>
     pub post_call_analytics_settings: ::std::option::Option<crate::types::PostCallAnalyticsSettings>,
-12
+}
 impl ConfigurationEvent {
     /// <p>Indicates which speaker is on which audio channel.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.channel_definitions.is_none()`.
     pub fn channel_definitions(&self) -> &[crate::types::ChannelDefinition] {
         self.channel_definitions.as_deref().unwrap_or_default()
-19
+    }
     /// <p>Provides additional optional settings for your Call Analytics post-call request, including encryption and output locations for your redacted transcript.</p>
     /// <p><code>PostCallAnalyticsSettings</code> provides you with the same insights as a Call Analytics post-call transcription. Refer to <a href="https://docs.aws.amazon.com/transcribe/latest/dg/tca-post-call.html">Post-call analytics</a> for more information on this feature.</p>
     pub fn post_call_analytics_settings(&self) -> ::std::option::Option<&crate::types::PostCallAnalyticsSettings> {
         self.post_call_analytics_settings.as_ref()
-24
+    }
-25
+}
 static CONFIGURATIONEVENT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.transcribestreaming#ConfigurationEvent",

     "com.amazonaws.transcribestreaming",
     "ConfigurationEvent",
 );
 static CONFIGURATIONEVENT_MEMBER_CHANNEL_DEFINITIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#ConfigurationEvent$ChannelDefinitions",
         "com.amazonaws.transcribestreaming",
         "ConfigurationEvent",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "channel_definitions",
     "ChannelDefinitions",
 ,
 );
 static CONFIGURATIONEVENT_MEMBER_POST_CALL_ANALYTICS_SETTINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.transcribestreaming#ConfigurationEvent$PostCallAnalyticsSettings",
         "com.amazonaws.transcribestreaming",
         "ConfigurationEvent",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "post_call_analytics_settings",
     "PostCallAnalyticsSettings",
 ,
 );
 static CONFIGURATIONEVENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CONFIGURATIONEVENT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CONFIGURATIONEVENT_MEMBER_CHANNEL_DEFINITIONS,
         &CONFIGURATIONEVENT_MEMBER_POST_CALL_ANALYTICS_SETTINGS,
     ],
 );
 impl ConfigurationEvent {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CONFIGURATIONEVENT_SCHEMA;
-62
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ConfigurationEvent {
     #[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.channel_definitions {
             ser.write_list(
                 &CONFIGURATIONEVENT_MEMBER_CHANNEL_DEFINITIONS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::ChannelDefinition::SCHEMA, item)?;
-75
+                    }
                     Ok(())
                 },
             )?;
-79
+        }
         if let Some(ref val) = self.post_call_analytics_settings {
             ser.write_struct(&CONFIGURATIONEVENT_MEMBER_POST_CALL_ANALYTICS_SETTINGS, val)?;
-82
+        }
         Ok(())
-84
+    }
-85
+}
 impl ConfigurationEvent {
     /// 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(&CONFIGURATIONEVENT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CONFIGURATIONEVENT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.channel_definitions = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::ChannelDefinition::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::ChannelDefinition::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-111
+                }
                 Some(1) => {
                     builder.post_call_analytics_settings = Some(crate::types::PostCallAnalyticsSettings::deserialize(deser)?);
-114
+                }
                 _ => {}
-116
+            }
             Ok(())
         })?;
         Ok(builder.build())
-120
+    }
-121
+}
 impl ConfigurationEvent {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl ConfigurationEvent {
     /// Creates a new builder-style object to manufacture [`ConfigurationEvent`](crate::types::ConfigurationEvent).
     pub fn builder() -> crate::types::builders::ConfigurationEventBuilder {
         crate::types::builders::ConfigurationEventBuilder::default()
-137
+    }
-138
+}
-139
 /// A builder for [`ConfigurationEvent`](crate::types::ConfigurationEvent).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ConfigurationEventBuilder {
     pub(crate) channel_definitions: ::std::option::Option<::std::vec::Vec<crate::types::ChannelDefinition>>,
     pub(crate) post_call_analytics_settings: ::std::option::Option<crate::types::PostCallAnalyticsSettings>,
-146
+}
 impl ConfigurationEventBuilder {
     /// Appends an item to `channel_definitions`.
     ///
     /// To override the contents of this collection use [`set_channel_definitions`](Self::set_channel_definitions).
     ///
     /// <p>Indicates which speaker is on which audio channel.</p>
     pub fn channel_definitions(mut self, input: crate::types::ChannelDefinition) -> Self {
         let mut v = self.channel_definitions.unwrap_or_default();
         v.push(input);
         self.channel_definitions = ::std::option::Option::Some(v);
         self
-158
+    }
     /// <p>Indicates which speaker is on which audio channel.</p>
     pub fn set_channel_definitions(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::ChannelDefinition>>) -> Self {
         self.channel_definitions = input;
         self

AWS SDK

Files changed: