AWS SDK

AWS SDK

rev. 96f5a1b4ad139d2f1ad1e8e40f300e1cd1ff574c

Files changed:

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

@@ -1,1 +108,119 @@
   19     19   
    "MedicalScribePostStreamAnalyticsSettings",
   20     20   
);
   21     21   
static MEDICALSCRIBEPOSTSTREAMANALYTICSSETTINGS_MEMBER_CLINICAL_NOTE_GENERATION_SETTINGS: ::aws_smithy_schema::Schema =
   22     22   
    ::aws_smithy_schema::Schema::new_member(
   23     23   
        ::aws_smithy_schema::ShapeId::from_static(
   24     24   
            "com.amazonaws.transcribestreaming#MedicalScribePostStreamAnalyticsSettings$ClinicalNoteGenerationSettings",
   25     25   
            "com.amazonaws.transcribestreaming",
   26     26   
            "MedicalScribePostStreamAnalyticsSettings",
   27     27   
        ),
   28     28   
        ::aws_smithy_schema::ShapeType::Structure,
   29         -
        "clinical_note_generation_settings",
          29  +
        "ClinicalNoteGenerationSettings",
   30     30   
        0,
   31     31   
    );
   32     32   
static MEDICALSCRIBEPOSTSTREAMANALYTICSSETTINGS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   33     33   
    MEDICALSCRIBEPOSTSTREAMANALYTICSSETTINGS_SCHEMA_ID,
   34     34   
    ::aws_smithy_schema::ShapeType::Structure,
   35     35   
    &[&MEDICALSCRIBEPOSTSTREAMANALYTICSSETTINGS_MEMBER_CLINICAL_NOTE_GENERATION_SETTINGS],
   36     36   
);
   37     37   
impl MedicalScribePostStreamAnalyticsSettings {
   38     38   
    /// The schema for this shape.
   39     39   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MEDICALSCRIBEPOSTSTREAMANALYTICSSETTINGS_SCHEMA;
   40     40   
}
   41     41   
impl ::aws_smithy_schema::serde::SerializableStruct for MedicalScribePostStreamAnalyticsSettings {
   42     42   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   43     43   
    fn serialize_members(
   44     44   
        &self,
   45     45   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   46     46   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   47     47   
        if let Some(ref val) = self.clinical_note_generation_settings {
   48     48   
            ser.write_struct(&MEDICALSCRIBEPOSTSTREAMANALYTICSSETTINGS_MEMBER_CLINICAL_NOTE_GENERATION_SETTINGS, val)?;
   49     49   
        }
   50     50   
        Ok(())
   51     51   
    }
   52     52   
}
   53     53   
impl MedicalScribePostStreamAnalyticsSettings {
   54     54   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   55         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   56         -
        deserializer: &mut D,
          55  +
    pub fn deserialize(
          56  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   57     57   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   58     58   
        #[allow(unused_variables, unused_mut)]
   59     59   
        let mut builder = Self::builder();
   60     60   
        #[allow(
   61     61   
            unused_variables,
   62     62   
            unreachable_code,
   63     63   
            clippy::single_match,
   64     64   
            clippy::match_single_binding,
   65     65   
            clippy::diverging_sub_expression
   66     66   
        )]
   67         -
        deserializer.read_struct(&MEDICALSCRIBEPOSTSTREAMANALYTICSSETTINGS_SCHEMA, (), |_, member, deser| {
          67  +
        deserializer.read_struct(&MEDICALSCRIBEPOSTSTREAMANALYTICSSETTINGS_SCHEMA, &mut |member, deser| {
   68     68   
            match member.member_index() {
   69     69   
                Some(0) => {
   70     70   
                    builder.clinical_note_generation_settings = Some(crate::types::ClinicalNoteGenerationSettings::deserialize(deser)?);
   71     71   
                }
   72     72   
                _ => {}
   73     73   
            }
   74     74   
            Ok(())
   75     75   
        })?;
   76     76   
        Ok(builder.build())
   77     77   
    }
   78     78   
}
          79  +
impl MedicalScribePostStreamAnalyticsSettings {
          80  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          81  +
    pub fn deserialize_with_response(
          82  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          83  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          84  +
        _status: u16,
          85  +
        _body: &[u8],
          86  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          87  +
        Self::deserialize(deserializer)
          88  +
    }
          89  +
}
   79     90   
impl MedicalScribePostStreamAnalyticsSettings {
   80     91   
    /// Creates a new builder-style object to manufacture [`MedicalScribePostStreamAnalyticsSettings`](crate::types::MedicalScribePostStreamAnalyticsSettings).
   81     92   
    pub fn builder() -> crate::types::builders::MedicalScribePostStreamAnalyticsSettingsBuilder {
   82     93   
        crate::types::builders::MedicalScribePostStreamAnalyticsSettingsBuilder::default()
   83     94   
    }
   84     95   
}
   85     96   
   86     97   
/// A builder for [`MedicalScribePostStreamAnalyticsSettings`](crate::types::MedicalScribePostStreamAnalyticsSettings).
   87     98   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   88     99   
#[non_exhaustive]

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

@@ -9,9 +0,95 @@
   29     29   
    }
   30     30   
    /// Returns true if this is a [`TranscriptEvent`](crate::types::MedicalScribeResultStream::TranscriptEvent).
   31     31   
    pub fn is_transcript_event(&self) -> bool {
   32     32   
        self.as_transcript_event().is_ok()
   33     33   
    }
   34     34   
    /// Returns true if the enum instance is the `Unknown` variant.
   35     35   
    pub fn is_unknown(&self) -> bool {
   36     36   
        matches!(self, Self::Unknown)
   37     37   
    }
   38     38   
}
          39  +
static MEDICALSCRIBERESULTSTREAM_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
          40  +
    "com.amazonaws.transcribestreaming#MedicalScribeResultStream",
          41  +
    "com.amazonaws.transcribestreaming",
          42  +
    "MedicalScribeResultStream",
          43  +
);
          44  +
static MEDICALSCRIBERESULTSTREAM_MEMBER_TRANSCRIPTEVENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          45  +
    ::aws_smithy_schema::ShapeId::from_static(
          46  +
        "com.amazonaws.transcribestreaming#MedicalScribeResultStream$TranscriptEvent",
          47  +
        "com.amazonaws.transcribestreaming",
          48  +
        "MedicalScribeResultStream",
          49  +
    ),
          50  +
    ::aws_smithy_schema::ShapeType::Structure,
          51  +
    "TranscriptEvent",
          52  +
    0,
          53  +
);
          54  +
static MEDICALSCRIBERESULTSTREAM_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
          55  +
    MEDICALSCRIBERESULTSTREAM_SCHEMA_ID,
          56  +
    ::aws_smithy_schema::ShapeType::Union,
          57  +
    &[&MEDICALSCRIBERESULTSTREAM_MEMBER_TRANSCRIPTEVENT],
          58  +
)
          59  +
.with_streaming();
          60  +
impl MedicalScribeResultStream {
          61  +
    /// The schema for this shape.
          62  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MEDICALSCRIBERESULTSTREAM_SCHEMA;
          63  +
}
          64  +
impl ::aws_smithy_schema::serde::SerializableStruct for MedicalScribeResultStream {
          65  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
          66  +
    fn serialize_members(
          67  +
        &self,
          68  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
          69  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
          70  +
        match self {
          71  +
            Self::TranscriptEvent(val) => {
          72  +
                ser.write_struct(&MEDICALSCRIBERESULTSTREAM_MEMBER_TRANSCRIPTEVENT, val)?;
          73  +
            }
          74  +
            Self::Unknown => return Err(::aws_smithy_schema::serde::SerdeError::custom("cannot serialize unknown union variant")),
          75  +
        }
          76  +
        Ok(())
          77  +
    }
          78  +
}
          79  +
impl MedicalScribeResultStream {
          80  +
    /// Deserializes this union from a [`ShapeDeserializer`].
          81  +
    pub fn deserialize(
          82  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          83  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          84  +
        let mut result: ::std::option::Option<Self> = ::std::option::Option::None;
          85  +
        #[allow(unused_variables, unreachable_code, clippy::single_match, clippy::match_single_binding)]
          86  +
        deserializer.read_struct(&MEDICALSCRIBERESULTSTREAM_SCHEMA, &mut |member, deser| {
          87  +
            result = ::std::option::Option::Some(match member.member_index() {
          88  +
                Some(0) => Self::TranscriptEvent(crate::types::MedicalScribeTranscriptEvent::deserialize(deser)?),
          89  +
                _ => Self::Unknown,
          90  +
            });
          91  +
            Ok(())
          92  +
        })?;
          93  +
        result.ok_or_else(|| ::aws_smithy_schema::serde::SerdeError::custom("expected a union variant"))
          94  +
    }
          95  +
}

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

@@ -8,8 +122,133 @@
   28     28   
    "com.amazonaws.transcribestreaming",
   29     29   
    "MedicalScribeSessionControlEvent",
   30     30   
);
   31     31   
static MEDICALSCRIBESESSIONCONTROLEVENT_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   32     32   
    ::aws_smithy_schema::ShapeId::from_static(
   33     33   
        "com.amazonaws.transcribestreaming#MedicalScribeSessionControlEvent$Type",
   34     34   
        "com.amazonaws.transcribestreaming",
   35     35   
        "MedicalScribeSessionControlEvent",
   36     36   
    ),
   37     37   
    ::aws_smithy_schema::ShapeType::String,
   38         -
    "r##type",
          38  +
    "Type",
   39     39   
    0,
   40     40   
);
   41     41   
static MEDICALSCRIBESESSIONCONTROLEVENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   42     42   
    MEDICALSCRIBESESSIONCONTROLEVENT_SCHEMA_ID,
   43     43   
    ::aws_smithy_schema::ShapeType::Structure,
   44     44   
    &[&MEDICALSCRIBESESSIONCONTROLEVENT_MEMBER_TYPE],
   45     45   
);
   46     46   
impl MedicalScribeSessionControlEvent {
   47     47   
    /// The schema for this shape.
   48     48   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MEDICALSCRIBESESSIONCONTROLEVENT_SCHEMA;
   49     49   
}
   50     50   
impl ::aws_smithy_schema::serde::SerializableStruct for MedicalScribeSessionControlEvent {
   51     51   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   52     52   
    fn serialize_members(
   53     53   
        &self,
   54     54   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   55     55   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   56     56   
        {
   57     57   
            let val = &self.r#type;
   58     58   
            ser.write_string(&MEDICALSCRIBESESSIONCONTROLEVENT_MEMBER_TYPE, val.as_str())?;
   59     59   
        }
   60     60   
        Ok(())
   61     61   
    }
   62     62   
}
   63     63   
impl MedicalScribeSessionControlEvent {
   64     64   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   65         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   66         -
        deserializer: &mut D,
          65  +
    pub fn deserialize(
          66  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   67     67   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   68     68   
        #[allow(unused_variables, unused_mut)]
   69     69   
        let mut builder = Self::builder();
   70     70   
        #[allow(
   71     71   
            unused_variables,
   72     72   
            unreachable_code,
   73     73   
            clippy::single_match,
   74     74   
            clippy::match_single_binding,
   75     75   
            clippy::diverging_sub_expression
   76     76   
        )]
   77         -
        deserializer.read_struct(&MEDICALSCRIBESESSIONCONTROLEVENT_SCHEMA, (), |_, member, deser| {
          77  +
        deserializer.read_struct(&MEDICALSCRIBESESSIONCONTROLEVENT_SCHEMA, &mut |member, deser| {
   78     78   
            match member.member_index() {
   79     79   
                Some(0) => {
   80     80   
                    builder.r#type = Some(crate::types::MedicalScribeSessionControlEventType::from(
   81     81   
                        deser.read_string(member)?.as_str(),
   82     82   
                    ));
   83     83   
                }
   84     84   
                _ => {}
   85     85   
            }
   86     86   
            Ok(())
   87     87   
        })?;
   88     88   
        builder
   89     89   
            .build()
   90     90   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   91     91   
    }
   92     92   
}
          93  +
impl MedicalScribeSessionControlEvent {
          94  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          95  +
    pub fn deserialize_with_response(
          96  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          97  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          98  +
        _status: u16,
          99  +
        _body: &[u8],
         100  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         101  +
        Self::deserialize(deserializer)
         102  +
    }
         103  +
}
   93    104   
impl MedicalScribeSessionControlEvent {
   94    105   
    /// Creates a new builder-style object to manufacture [`MedicalScribeSessionControlEvent`](crate::types::MedicalScribeSessionControlEvent).
   95    106   
    pub fn builder() -> crate::types::builders::MedicalScribeSessionControlEventBuilder {
   96    107   
        crate::types::builders::MedicalScribeSessionControlEventBuilder::default()
   97    108   
    }
   98    109   
}
   99    110   
  100    111   
/// A builder for [`MedicalScribeSessionControlEvent`](crate::types::MedicalScribeSessionControlEvent).
  101    112   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  102    113   
#[non_exhaustive]

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

@@ -116,116 +326,326 @@
  136    136   
    "com.amazonaws.transcribestreaming",
  137    137   
    "MedicalScribeStreamDetails",
  138    138   
);
  139    139   
static MEDICALSCRIBESTREAMDETAILS_MEMBER_SESSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  140    140   
    ::aws_smithy_schema::ShapeId::from_static(
  141    141   
        "com.amazonaws.transcribestreaming#MedicalScribeStreamDetails$SessionId",
  142    142   
        "com.amazonaws.transcribestreaming",
  143    143   
        "MedicalScribeStreamDetails",
  144    144   
    ),
  145    145   
    ::aws_smithy_schema::ShapeType::String,
  146         -
    "session_id",
         146  +
    "SessionId",
  147    147   
    0,
  148    148   
);
  149    149   
static MEDICALSCRIBESTREAMDETAILS_MEMBER_STREAM_CREATED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  150    150   
    ::aws_smithy_schema::ShapeId::from_static(
  151    151   
        "com.amazonaws.transcribestreaming#MedicalScribeStreamDetails$StreamCreatedAt",
  152    152   
        "com.amazonaws.transcribestreaming",
  153    153   
        "MedicalScribeStreamDetails",
  154    154   
    ),
  155    155   
    ::aws_smithy_schema::ShapeType::Timestamp,
  156         -
    "stream_created_at",
         156  +
    "StreamCreatedAt",
  157    157   
    1,
  158    158   
);
  159    159   
static MEDICALSCRIBESTREAMDETAILS_MEMBER_STREAM_ENDED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  160    160   
    ::aws_smithy_schema::ShapeId::from_static(
  161    161   
        "com.amazonaws.transcribestreaming#MedicalScribeStreamDetails$StreamEndedAt",
  162    162   
        "com.amazonaws.transcribestreaming",
  163    163   
        "MedicalScribeStreamDetails",
  164    164   
    ),
  165    165   
    ::aws_smithy_schema::ShapeType::Timestamp,
  166         -
    "stream_ended_at",
         166  +
    "StreamEndedAt",
  167    167   
    2,
  168    168   
);
  169    169   
static MEDICALSCRIBESTREAMDETAILS_MEMBER_LANGUAGE_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  170    170   
    ::aws_smithy_schema::ShapeId::from_static(
  171    171   
        "com.amazonaws.transcribestreaming#MedicalScribeStreamDetails$LanguageCode",
  172    172   
        "com.amazonaws.transcribestreaming",
  173    173   
        "MedicalScribeStreamDetails",
  174    174   
    ),
  175    175   
    ::aws_smithy_schema::ShapeType::String,
  176         -
    "language_code",
         176  +
    "LanguageCode",
  177    177   
    3,
  178    178   
);
  179    179   
static MEDICALSCRIBESTREAMDETAILS_MEMBER_MEDIA_SAMPLE_RATE_HERTZ: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  180    180   
    ::aws_smithy_schema::ShapeId::from_static(
  181    181   
        "com.amazonaws.transcribestreaming#MedicalScribeStreamDetails$MediaSampleRateHertz",
  182    182   
        "com.amazonaws.transcribestreaming",
  183    183   
        "MedicalScribeStreamDetails",
  184    184   
    ),
  185    185   
    ::aws_smithy_schema::ShapeType::Integer,
  186         -
    "media_sample_rate_hertz",
         186  +
    "MediaSampleRateHertz",
  187    187   
    4,
  188    188   
);
  189    189   
static MEDICALSCRIBESTREAMDETAILS_MEMBER_MEDIA_ENCODING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  190    190   
    ::aws_smithy_schema::ShapeId::from_static(
  191    191   
        "com.amazonaws.transcribestreaming#MedicalScribeStreamDetails$MediaEncoding",
  192    192   
        "com.amazonaws.transcribestreaming",
  193    193   
        "MedicalScribeStreamDetails",
  194    194   
    ),
  195    195   
    ::aws_smithy_schema::ShapeType::String,
  196         -
    "media_encoding",
         196  +
    "MediaEncoding",
  197    197   
    5,
  198    198   
);
  199    199   
static MEDICALSCRIBESTREAMDETAILS_MEMBER_VOCABULARY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  200    200   
    ::aws_smithy_schema::ShapeId::from_static(
  201    201   
        "com.amazonaws.transcribestreaming#MedicalScribeStreamDetails$VocabularyName",
  202    202   
        "com.amazonaws.transcribestreaming",
  203    203   
        "MedicalScribeStreamDetails",
  204    204   
    ),
  205    205   
    ::aws_smithy_schema::ShapeType::String,
  206         -
    "vocabulary_name",
         206  +
    "VocabularyName",
  207    207   
    6,
  208    208   
);
  209    209   
static MEDICALSCRIBESTREAMDETAILS_MEMBER_VOCABULARY_FILTER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  210    210   
    ::aws_smithy_schema::ShapeId::from_static(
  211    211   
        "com.amazonaws.transcribestreaming#MedicalScribeStreamDetails$VocabularyFilterName",
  212    212   
        "com.amazonaws.transcribestreaming",
  213    213   
        "MedicalScribeStreamDetails",
  214    214   
    ),
  215    215   
    ::aws_smithy_schema::ShapeType::String,
  216         -
    "vocabulary_filter_name",
         216  +
    "VocabularyFilterName",
  217    217   
    7,
  218    218   
);
  219    219   
static MEDICALSCRIBESTREAMDETAILS_MEMBER_VOCABULARY_FILTER_METHOD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  220    220   
    ::aws_smithy_schema::ShapeId::from_static(
  221    221   
        "com.amazonaws.transcribestreaming#MedicalScribeStreamDetails$VocabularyFilterMethod",
  222    222   
        "com.amazonaws.transcribestreaming",
  223    223   
        "MedicalScribeStreamDetails",
  224    224   
    ),
  225    225   
    ::aws_smithy_schema::ShapeType::String,
  226         -
    "vocabulary_filter_method",
         226  +
    "VocabularyFilterMethod",
  227    227   
    8,
  228    228   
);
  229    229   
static MEDICALSCRIBESTREAMDETAILS_MEMBER_RESOURCE_ACCESS_ROLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  230    230   
    ::aws_smithy_schema::ShapeId::from_static(
  231    231   
        "com.amazonaws.transcribestreaming#MedicalScribeStreamDetails$ResourceAccessRoleArn",
  232    232   
        "com.amazonaws.transcribestreaming",
  233    233   
        "MedicalScribeStreamDetails",
  234    234   
    ),
  235    235   
    ::aws_smithy_schema::ShapeType::String,
  236         -
    "resource_access_role_arn",
         236  +
    "ResourceAccessRoleArn",
  237    237   
    9,
  238    238   
);
  239    239   
static MEDICALSCRIBESTREAMDETAILS_MEMBER_CHANNEL_DEFINITIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  240    240   
    ::aws_smithy_schema::ShapeId::from_static(
  241    241   
        "com.amazonaws.transcribestreaming#MedicalScribeStreamDetails$ChannelDefinitions",
  242    242   
        "com.amazonaws.transcribestreaming",
  243    243   
        "MedicalScribeStreamDetails",
  244    244   
    ),
  245    245   
    ::aws_smithy_schema::ShapeType::List,
  246         -
    "channel_definitions",
         246  +
    "ChannelDefinitions",
  247    247   
    10,
  248    248   
);
  249    249   
static MEDICALSCRIBESTREAMDETAILS_MEMBER_ENCRYPTION_SETTINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  250    250   
    ::aws_smithy_schema::ShapeId::from_static(
  251    251   
        "com.amazonaws.transcribestreaming#MedicalScribeStreamDetails$EncryptionSettings",
  252    252   
        "com.amazonaws.transcribestreaming",
  253    253   
        "MedicalScribeStreamDetails",
  254    254   
    ),
  255    255   
    ::aws_smithy_schema::ShapeType::Structure,
  256         -
    "encryption_settings",
         256  +
    "EncryptionSettings",
  257    257   
    11,
  258    258   
);
  259    259   
static MEDICALSCRIBESTREAMDETAILS_MEMBER_STREAM_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  260    260   
    ::aws_smithy_schema::ShapeId::from_static(
  261    261   
        "com.amazonaws.transcribestreaming#MedicalScribeStreamDetails$StreamStatus",
  262    262   
        "com.amazonaws.transcribestreaming",
  263    263   
        "MedicalScribeStreamDetails",
  264    264   
    ),
  265    265   
    ::aws_smithy_schema::ShapeType::String,
  266         -
    "stream_status",
         266  +
    "StreamStatus",
  267    267   
    12,
  268    268   
);
  269    269   
static MEDICALSCRIBESTREAMDETAILS_MEMBER_POST_STREAM_ANALYTICS_SETTINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  270    270   
    ::aws_smithy_schema::ShapeId::from_static(
  271    271   
        "com.amazonaws.transcribestreaming#MedicalScribeStreamDetails$PostStreamAnalyticsSettings",
  272    272   
        "com.amazonaws.transcribestreaming",
  273    273   
        "MedicalScribeStreamDetails",
  274    274   
    ),
  275    275   
    ::aws_smithy_schema::ShapeType::Structure,
  276         -
    "post_stream_analytics_settings",
         276  +
    "PostStreamAnalyticsSettings",
  277    277   
    13,
  278    278   
);
  279    279   
static MEDICALSCRIBESTREAMDETAILS_MEMBER_POST_STREAM_ANALYTICS_RESULT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  280    280   
    ::aws_smithy_schema::ShapeId::from_static(
  281    281   
        "com.amazonaws.transcribestreaming#MedicalScribeStreamDetails$PostStreamAnalyticsResult",
  282    282   
        "com.amazonaws.transcribestreaming",
  283    283   
        "MedicalScribeStreamDetails",
  284    284   
    ),
  285    285   
    ::aws_smithy_schema::ShapeType::Structure,
  286         -
    "post_stream_analytics_result",
         286  +
    "PostStreamAnalyticsResult",
  287    287   
    14,
  288    288   
);
  289    289   
static MEDICALSCRIBESTREAMDETAILS_MEMBER_MEDICAL_SCRIBE_CONTEXT_PROVIDED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  290    290   
    ::aws_smithy_schema::ShapeId::from_static(
  291    291   
        "com.amazonaws.transcribestreaming#MedicalScribeStreamDetails$MedicalScribeContextProvided",
  292    292   
        "com.amazonaws.transcribestreaming",
  293    293   
        "MedicalScribeStreamDetails",
  294    294   
    ),
  295    295   
    ::aws_smithy_schema::ShapeType::Boolean,
  296         -
    "medical_scribe_context_provided",
         296  +
    "MedicalScribeContextProvided",
  297    297   
    15,
  298    298   
);
  299    299   
static MEDICALSCRIBESTREAMDETAILS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  300    300   
    MEDICALSCRIBESTREAMDETAILS_SCHEMA_ID,
  301    301   
    ::aws_smithy_schema::ShapeType::Structure,
  302    302   
    &[
  303    303   
        &MEDICALSCRIBESTREAMDETAILS_MEMBER_SESSION_ID,
  304    304   
        &MEDICALSCRIBESTREAMDETAILS_MEMBER_STREAM_CREATED_AT,
  305    305   
        &MEDICALSCRIBESTREAMDETAILS_MEMBER_STREAM_ENDED_AT,
  306    306   
        &MEDICALSCRIBESTREAMDETAILS_MEMBER_LANGUAGE_CODE,
@@ -362,362 +502,510 @@
  382    382   
            ser.write_struct(&MEDICALSCRIBESTREAMDETAILS_MEMBER_POST_STREAM_ANALYTICS_RESULT, val)?;
  383    383   
        }
  384    384   
        if let Some(ref val) = self.medical_scribe_context_provided {
  385    385   
            ser.write_boolean(&MEDICALSCRIBESTREAMDETAILS_MEMBER_MEDICAL_SCRIBE_CONTEXT_PROVIDED, *val)?;
  386    386   
        }
  387    387   
        Ok(())
  388    388   
    }
  389    389   
}
  390    390   
impl MedicalScribeStreamDetails {
  391    391   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  392         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  393         -
        deserializer: &mut D,
         392  +
    pub fn deserialize(
         393  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  394    394   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  395    395   
        #[allow(unused_variables, unused_mut)]
  396    396   
        let mut builder = Self::builder();
  397    397   
        #[allow(
  398    398   
            unused_variables,
  399    399   
            unreachable_code,
  400    400   
            clippy::single_match,
  401    401   
            clippy::match_single_binding,
  402    402   
            clippy::diverging_sub_expression
  403    403   
        )]
  404         -
        deserializer.read_struct(&MEDICALSCRIBESTREAMDETAILS_SCHEMA, (), |_, member, deser| {
         404  +
        deserializer.read_struct(&MEDICALSCRIBESTREAMDETAILS_SCHEMA, &mut |member, deser| {
  405    405   
            match member.member_index() {
  406    406   
                Some(0) => {
  407    407   
                    builder.session_id = Some(deser.read_string(member)?);
  408    408   
                }
  409    409   
                Some(1) => {
  410    410   
                    builder.stream_created_at = Some(deser.read_timestamp(member)?);
  411    411   
                }
  412    412   
                Some(2) => {
  413    413   
                    builder.stream_ended_at = Some(deser.read_timestamp(member)?);
  414    414   
                }
  415    415   
                Some(3) => {
  416    416   
                    builder.language_code = Some(crate::types::MedicalScribeLanguageCode::from(deser.read_string(member)?.as_str()));
  417    417   
                }
  418    418   
                Some(4) => {
  419    419   
                    builder.media_sample_rate_hertz = Some(deser.read_integer(member)?);
  420    420   
                }
  421    421   
                Some(5) => {
  422    422   
                    builder.media_encoding = Some(crate::types::MedicalScribeMediaEncoding::from(deser.read_string(member)?.as_str()));
  423    423   
                }
  424    424   
                Some(6) => {
  425    425   
                    builder.vocabulary_name = Some(deser.read_string(member)?);
  426    426   
                }
  427    427   
                Some(7) => {
  428    428   
                    builder.vocabulary_filter_name = Some(deser.read_string(member)?);
  429    429   
                }
  430    430   
                Some(8) => {
  431    431   
                    builder.vocabulary_filter_method = Some(crate::types::MedicalScribeVocabularyFilterMethod::from(
  432    432   
                        deser.read_string(member)?.as_str(),
  433    433   
                    ));
  434    434   
                }
  435    435   
                Some(9) => {
  436    436   
                    builder.resource_access_role_arn = Some(deser.read_string(member)?);
  437    437   
                }
  438    438   
                Some(10) => {
  439    439   
                    builder.channel_definitions = Some({
  440         -
                        let container = if let Some(cap) = deser.container_size() {
  441         -
                            Vec::with_capacity(cap)
  442         -
                        } else {
  443         -
                            Vec::new()
  444         -
                        };
  445         -
                        deser.read_list(member, container, |mut list, deser| {
  446         -
                            list.push(crate::types::MedicalScribeChannelDefinition::deserialize(deser)?);
  447         -
                            Ok(list)
  448         -
                        })?
         440  +
                        let mut container = Vec::new();
         441  +
                        deser.read_list(member, &mut |deser| {
         442  +
                            container.push(crate::types::MedicalScribeChannelDefinition::deserialize(deser)?);
         443  +
                            Ok(())
         444  +
                        })?;
         445  +
                        container
  449    446   
                    });
  450    447   
                }
  451    448   
                Some(11) => {
  452    449   
                    builder.encryption_settings = Some(crate::types::MedicalScribeEncryptionSettings::deserialize(deser)?);
  453    450   
                }
  454    451   
                Some(12) => {
  455    452   
                    builder.stream_status = Some(crate::types::MedicalScribeStreamStatus::from(deser.read_string(member)?.as_str()));
  456    453   
                }
  457    454   
                Some(13) => {
  458    455   
                    builder.post_stream_analytics_settings = Some(crate::types::MedicalScribePostStreamAnalyticsSettings::deserialize(deser)?);
  459    456   
                }
  460    457   
                Some(14) => {
  461    458   
                    builder.post_stream_analytics_result = Some(crate::types::MedicalScribePostStreamAnalyticsResult::deserialize(deser)?);
  462    459   
                }
  463    460   
                Some(15) => {
  464    461   
                    builder.medical_scribe_context_provided = Some(deser.read_boolean(member)?);
  465    462   
                }
  466    463   
                _ => {}
  467    464   
            }
  468    465   
            Ok(())
  469    466   
        })?;
  470    467   
        Ok(builder.build())
  471    468   
    }
  472    469   
}
         470  +
impl MedicalScribeStreamDetails {
         471  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         472  +
    pub fn deserialize_with_response(
         473  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         474  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         475  +
        _status: u16,
         476  +
        _body: &[u8],
         477  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         478  +
        Self::deserialize(deserializer)
         479  +
    }
         480  +
}
  473    481   
impl MedicalScribeStreamDetails {
  474    482   
    /// Creates a new builder-style object to manufacture [`MedicalScribeStreamDetails`](crate::types::MedicalScribeStreamDetails).
  475    483   
    pub fn builder() -> crate::types::builders::MedicalScribeStreamDetailsBuilder {
  476    484   
        crate::types::builders::MedicalScribeStreamDetailsBuilder::default()
  477    485   
    }
  478    486   
}
  479    487   
  480    488   
/// A builder for [`MedicalScribeStreamDetails`](crate::types::MedicalScribeStreamDetails).
  481    489   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  482    490   
#[non_exhaustive]

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

@@ -1,1 +108,119 @@
   19     19   
    "com.amazonaws.transcribestreaming",
   20     20   
    "MedicalScribeTranscriptEvent",
   21     21   
);
   22     22   
static MEDICALSCRIBETRANSCRIPTEVENT_MEMBER_TRANSCRIPT_SEGMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   23     23   
    ::aws_smithy_schema::ShapeId::from_static(
   24     24   
        "com.amazonaws.transcribestreaming#MedicalScribeTranscriptEvent$TranscriptSegment",
   25     25   
        "com.amazonaws.transcribestreaming",
   26     26   
        "MedicalScribeTranscriptEvent",
   27     27   
    ),
   28     28   
    ::aws_smithy_schema::ShapeType::Structure,
   29         -
    "transcript_segment",
          29  +
    "TranscriptSegment",
   30     30   
    0,
   31     31   
);
   32     32   
static MEDICALSCRIBETRANSCRIPTEVENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   33     33   
    MEDICALSCRIBETRANSCRIPTEVENT_SCHEMA_ID,
   34     34   
    ::aws_smithy_schema::ShapeType::Structure,
   35     35   
    &[&MEDICALSCRIBETRANSCRIPTEVENT_MEMBER_TRANSCRIPT_SEGMENT],
   36     36   
);
   37     37   
impl MedicalScribeTranscriptEvent {
   38     38   
    /// The schema for this shape.
   39     39   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MEDICALSCRIBETRANSCRIPTEVENT_SCHEMA;
   40     40   
}
   41     41   
impl ::aws_smithy_schema::serde::SerializableStruct for MedicalScribeTranscriptEvent {
   42     42   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   43     43   
    fn serialize_members(
   44     44   
        &self,
   45     45   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   46     46   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   47     47   
        if let Some(ref val) = self.transcript_segment {
   48     48   
            ser.write_struct(&MEDICALSCRIBETRANSCRIPTEVENT_MEMBER_TRANSCRIPT_SEGMENT, val)?;
   49     49   
        }
   50     50   
        Ok(())
   51     51   
    }
   52     52   
}
   53     53   
impl MedicalScribeTranscriptEvent {
   54     54   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   55         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   56         -
        deserializer: &mut D,
          55  +
    pub fn deserialize(
          56  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   57     57   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   58     58   
        #[allow(unused_variables, unused_mut)]
   59     59   
        let mut builder = Self::builder();
   60     60   
        #[allow(
   61     61   
            unused_variables,
   62     62   
            unreachable_code,
   63     63   
            clippy::single_match,
   64     64   
            clippy::match_single_binding,
   65     65   
            clippy::diverging_sub_expression
   66     66   
        )]
   67         -
        deserializer.read_struct(&MEDICALSCRIBETRANSCRIPTEVENT_SCHEMA, (), |_, member, deser| {
          67  +
        deserializer.read_struct(&MEDICALSCRIBETRANSCRIPTEVENT_SCHEMA, &mut |member, deser| {
   68     68   
            match member.member_index() {
   69     69   
                Some(0) => {
   70     70   
                    builder.transcript_segment = Some(crate::types::MedicalScribeTranscriptSegment::deserialize(deser)?);
   71     71   
                }
   72     72   
                _ => {}
   73     73   
            }
   74     74   
            Ok(())
   75     75   
        })?;
   76     76   
        Ok(builder.build())
   77     77   
    }
   78     78   
}
          79  +
impl MedicalScribeTranscriptEvent {
          80  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          81  +
    pub fn deserialize_with_response(
          82  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          83  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          84  +
        _status: u16,
          85  +
        _body: &[u8],
          86  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          87  +
        Self::deserialize(deserializer)
          88  +
    }
          89  +
}
   79     90   
impl MedicalScribeTranscriptEvent {
   80     91   
    /// Creates a new builder-style object to manufacture [`MedicalScribeTranscriptEvent`](crate::types::MedicalScribeTranscriptEvent).
   81     92   
    pub fn builder() -> crate::types::builders::MedicalScribeTranscriptEventBuilder {
   82     93   
        crate::types::builders::MedicalScribeTranscriptEventBuilder::default()
   83     94   
    }
   84     95   
}
   85     96   
   86     97   
/// A builder for [`MedicalScribeTranscriptEvent`](crate::types::MedicalScribeTranscriptEvent).
   87     98   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   88     99   
#[non_exhaustive]

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

@@ -30,30 +228,239 @@
   50     50   
    "com.amazonaws.transcribestreaming",
   51     51   
    "MedicalScribeTranscriptItem",
   52     52   
);
   53     53   
static MEDICALSCRIBETRANSCRIPTITEM_MEMBER_BEGIN_AUDIO_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   54     54   
    ::aws_smithy_schema::ShapeId::from_static(
   55     55   
        "com.amazonaws.transcribestreaming#MedicalScribeTranscriptItem$BeginAudioTime",
   56     56   
        "com.amazonaws.transcribestreaming",
   57     57   
        "MedicalScribeTranscriptItem",
   58     58   
    ),
   59     59   
    ::aws_smithy_schema::ShapeType::Double,
   60         -
    "begin_audio_time",
          60  +
    "BeginAudioTime",
   61     61   
    0,
   62     62   
);
   63     63   
static MEDICALSCRIBETRANSCRIPTITEM_MEMBER_END_AUDIO_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static(
   65     65   
        "com.amazonaws.transcribestreaming#MedicalScribeTranscriptItem$EndAudioTime",
   66     66   
        "com.amazonaws.transcribestreaming",
   67     67   
        "MedicalScribeTranscriptItem",
   68     68   
    ),
   69     69   
    ::aws_smithy_schema::ShapeType::Double,
   70         -
    "end_audio_time",
          70  +
    "EndAudioTime",
   71     71   
    1,
   72     72   
);
   73     73   
static MEDICALSCRIBETRANSCRIPTITEM_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "com.amazonaws.transcribestreaming#MedicalScribeTranscriptItem$Type",
   76     76   
        "com.amazonaws.transcribestreaming",
   77     77   
        "MedicalScribeTranscriptItem",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::String,
   80         -
    "r##type",
          80  +
    "Type",
   81     81   
    2,
   82     82   
);
   83     83   
static MEDICALSCRIBETRANSCRIPTITEM_MEMBER_CONFIDENCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   84     84   
    ::aws_smithy_schema::ShapeId::from_static(
   85     85   
        "com.amazonaws.transcribestreaming#MedicalScribeTranscriptItem$Confidence",
   86     86   
        "com.amazonaws.transcribestreaming",
   87     87   
        "MedicalScribeTranscriptItem",
   88     88   
    ),
   89     89   
    ::aws_smithy_schema::ShapeType::Double,
   90         -
    "confidence",
          90  +
    "Confidence",
   91     91   
    3,
   92     92   
);
   93     93   
static MEDICALSCRIBETRANSCRIPTITEM_MEMBER_CONTENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static(
   95     95   
        "com.amazonaws.transcribestreaming#MedicalScribeTranscriptItem$Content",
   96     96   
        "com.amazonaws.transcribestreaming",
   97     97   
        "MedicalScribeTranscriptItem",
   98     98   
    ),
   99     99   
    ::aws_smithy_schema::ShapeType::String,
  100         -
    "content",
         100  +
    "Content",
  101    101   
    4,
  102    102   
);
  103    103   
static MEDICALSCRIBETRANSCRIPTITEM_MEMBER_VOCABULARY_FILTER_MATCH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  104    104   
    ::aws_smithy_schema::ShapeId::from_static(
  105    105   
        "com.amazonaws.transcribestreaming#MedicalScribeTranscriptItem$VocabularyFilterMatch",
  106    106   
        "com.amazonaws.transcribestreaming",
  107    107   
        "MedicalScribeTranscriptItem",
  108    108   
    ),
  109    109   
    ::aws_smithy_schema::ShapeType::Boolean,
  110         -
    "vocabulary_filter_match",
         110  +
    "VocabularyFilterMatch",
  111    111   
    5,
  112    112   
);
  113    113   
static MEDICALSCRIBETRANSCRIPTITEM_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  114    114   
    MEDICALSCRIBETRANSCRIPTITEM_SCHEMA_ID,
  115    115   
    ::aws_smithy_schema::ShapeType::Structure,
  116    116   
    &[
  117    117   
        &MEDICALSCRIBETRANSCRIPTITEM_MEMBER_BEGIN_AUDIO_TIME,
  118    118   
        &MEDICALSCRIBETRANSCRIPTITEM_MEMBER_END_AUDIO_TIME,
  119    119   
        &MEDICALSCRIBETRANSCRIPTITEM_MEMBER_TYPE,
  120    120   
        &MEDICALSCRIBETRANSCRIPTITEM_MEMBER_CONFIDENCE,
  121    121   
        &MEDICALSCRIBETRANSCRIPTITEM_MEMBER_CONTENT,
  122    122   
        &MEDICALSCRIBETRANSCRIPTITEM_MEMBER_VOCABULARY_FILTER_MATCH,
  123    123   
    ],
  124    124   
);
  125    125   
impl MedicalScribeTranscriptItem {
  126    126   
    /// The schema for this shape.
  127    127   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MEDICALSCRIBETRANSCRIPTITEM_SCHEMA;
  128    128   
}
  129    129   
impl ::aws_smithy_schema::serde::SerializableStruct for MedicalScribeTranscriptItem {
  130    130   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  131    131   
    fn serialize_members(
  132    132   
        &self,
  133    133   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  134    134   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  135    135   
        {
  136    136   
            let val = &self.begin_audio_time;
  137    137   
            ser.write_double(&MEDICALSCRIBETRANSCRIPTITEM_MEMBER_BEGIN_AUDIO_TIME, *val)?;
  138    138   
        }
  139    139   
        {
  140    140   
            let val = &self.end_audio_time;
  141    141   
            ser.write_double(&MEDICALSCRIBETRANSCRIPTITEM_MEMBER_END_AUDIO_TIME, *val)?;
  142    142   
        }
  143    143   
        if let Some(ref val) = self.r#type {
  144    144   
            ser.write_string(&MEDICALSCRIBETRANSCRIPTITEM_MEMBER_TYPE, val.as_str())?;
  145    145   
        }
  146    146   
        if let Some(ref val) = self.confidence {
  147    147   
            ser.write_double(&MEDICALSCRIBETRANSCRIPTITEM_MEMBER_CONFIDENCE, *val)?;
  148    148   
        }
  149    149   
        if let Some(ref val) = self.content {
  150    150   
            ser.write_string(&MEDICALSCRIBETRANSCRIPTITEM_MEMBER_CONTENT, val)?;
  151    151   
        }
  152    152   
        if let Some(ref val) = self.vocabulary_filter_match {
  153    153   
            ser.write_boolean(&MEDICALSCRIBETRANSCRIPTITEM_MEMBER_VOCABULARY_FILTER_MATCH, *val)?;
  154    154   
        }
  155    155   
        Ok(())
  156    156   
    }
  157    157   
}
  158    158   
impl MedicalScribeTranscriptItem {
  159    159   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  160         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  161         -
        deserializer: &mut D,
         160  +
    pub fn deserialize(
         161  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  162    162   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  163    163   
        #[allow(unused_variables, unused_mut)]
  164    164   
        let mut builder = Self::builder();
  165    165   
        #[allow(
  166    166   
            unused_variables,
  167    167   
            unreachable_code,
  168    168   
            clippy::single_match,
  169    169   
            clippy::match_single_binding,
  170    170   
            clippy::diverging_sub_expression
  171    171   
        )]
  172         -
        deserializer.read_struct(&MEDICALSCRIBETRANSCRIPTITEM_SCHEMA, (), |_, member, deser| {
         172  +
        deserializer.read_struct(&MEDICALSCRIBETRANSCRIPTITEM_SCHEMA, &mut |member, deser| {
  173    173   
            match member.member_index() {
  174    174   
                Some(0) => {
  175    175   
                    builder.begin_audio_time = Some(deser.read_double(member)?);
  176    176   
                }
  177    177   
                Some(1) => {
  178    178   
                    builder.end_audio_time = Some(deser.read_double(member)?);
  179    179   
                }
  180    180   
                Some(2) => {
  181    181   
                    builder.r#type = Some(crate::types::MedicalScribeTranscriptItemType::from(deser.read_string(member)?.as_str()));
  182    182   
                }
  183    183   
                Some(3) => {
  184    184   
                    builder.confidence = Some(deser.read_double(member)?);
  185    185   
                }
  186    186   
                Some(4) => {
  187    187   
                    builder.content = Some(deser.read_string(member)?);
  188    188   
                }
  189    189   
                Some(5) => {
  190    190   
                    builder.vocabulary_filter_match = Some(deser.read_boolean(member)?);
  191    191   
                }
  192    192   
                _ => {}
  193    193   
            }
  194    194   
            Ok(())
  195    195   
        })?;
  196    196   
        Ok(builder.build())
  197    197   
    }
  198    198   
}
         199  +
impl MedicalScribeTranscriptItem {
         200  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         201  +
    pub fn deserialize_with_response(
         202  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         203  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         204  +
        _status: u16,
         205  +
        _body: &[u8],
         206  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         207  +
        Self::deserialize(deserializer)
         208  +
    }
         209  +
}
  199    210   
impl MedicalScribeTranscriptItem {
  200    211   
    /// Creates a new builder-style object to manufacture [`MedicalScribeTranscriptItem`](crate::types::MedicalScribeTranscriptItem).
  201    212   
    pub fn builder() -> crate::types::builders::MedicalScribeTranscriptItemBuilder {
  202    213   
        crate::types::builders::MedicalScribeTranscriptItemBuilder::default()
  203    214   
    }
  204    215   
}
  205    216   
  206    217   
/// A builder for [`MedicalScribeTranscriptItem`](crate::types::MedicalScribeTranscriptItem).
  207    218   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  208    219   
#[non_exhaustive]

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

@@ -40,40 +160,160 @@
   60     60   
    "com.amazonaws.transcribestreaming",
   61     61   
    "MedicalScribeTranscriptSegment",
   62     62   
);
   63     63   
static MEDICALSCRIBETRANSCRIPTSEGMENT_MEMBER_SEGMENT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static(
   65     65   
        "com.amazonaws.transcribestreaming#MedicalScribeTranscriptSegment$SegmentId",
   66     66   
        "com.amazonaws.transcribestreaming",
   67     67   
        "MedicalScribeTranscriptSegment",
   68     68   
    ),
   69     69   
    ::aws_smithy_schema::ShapeType::String,
   70         -
    "segment_id",
          70  +
    "SegmentId",
   71     71   
    0,
   72     72   
);
   73     73   
static MEDICALSCRIBETRANSCRIPTSEGMENT_MEMBER_BEGIN_AUDIO_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "com.amazonaws.transcribestreaming#MedicalScribeTranscriptSegment$BeginAudioTime",
   76     76   
        "com.amazonaws.transcribestreaming",
   77     77   
        "MedicalScribeTranscriptSegment",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::Double,
   80         -
    "begin_audio_time",
          80  +
    "BeginAudioTime",
   81     81   
    1,
   82     82   
);
   83     83   
static MEDICALSCRIBETRANSCRIPTSEGMENT_MEMBER_END_AUDIO_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   84     84   
    ::aws_smithy_schema::ShapeId::from_static(
   85     85   
        "com.amazonaws.transcribestreaming#MedicalScribeTranscriptSegment$EndAudioTime",
   86     86   
        "com.amazonaws.transcribestreaming",
   87     87   
        "MedicalScribeTranscriptSegment",
   88     88   
    ),
   89     89   
    ::aws_smithy_schema::ShapeType::Double,
   90         -
    "end_audio_time",
          90  +
    "EndAudioTime",
   91     91   
    2,
   92     92   
);
   93     93   
static MEDICALSCRIBETRANSCRIPTSEGMENT_MEMBER_CONTENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static(
   95     95   
        "com.amazonaws.transcribestreaming#MedicalScribeTranscriptSegment$Content",
   96     96   
        "com.amazonaws.transcribestreaming",
   97     97   
        "MedicalScribeTranscriptSegment",
   98     98   
    ),
   99     99   
    ::aws_smithy_schema::ShapeType::String,
  100         -
    "content",
         100  +
    "Content",
  101    101   
    3,
  102    102   
);
  103    103   
static MEDICALSCRIBETRANSCRIPTSEGMENT_MEMBER_ITEMS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  104    104   
    ::aws_smithy_schema::ShapeId::from_static(
  105    105   
        "com.amazonaws.transcribestreaming#MedicalScribeTranscriptSegment$Items",
  106    106   
        "com.amazonaws.transcribestreaming",
  107    107   
        "MedicalScribeTranscriptSegment",
  108    108   
    ),
  109    109   
    ::aws_smithy_schema::ShapeType::List,
  110         -
    "items",
         110  +
    "Items",
  111    111   
    4,
  112    112   
);
  113    113   
static MEDICALSCRIBETRANSCRIPTSEGMENT_MEMBER_IS_PARTIAL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  114    114   
    ::aws_smithy_schema::ShapeId::from_static(
  115    115   
        "com.amazonaws.transcribestreaming#MedicalScribeTranscriptSegment$IsPartial",
  116    116   
        "com.amazonaws.transcribestreaming",
  117    117   
        "MedicalScribeTranscriptSegment",
  118    118   
    ),
  119    119   
    ::aws_smithy_schema::ShapeType::Boolean,
  120         -
    "is_partial",
         120  +
    "IsPartial",
  121    121   
    5,
  122    122   
);
  123    123   
static MEDICALSCRIBETRANSCRIPTSEGMENT_MEMBER_CHANNEL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  124    124   
    ::aws_smithy_schema::ShapeId::from_static(
  125    125   
        "com.amazonaws.transcribestreaming#MedicalScribeTranscriptSegment$ChannelId",
  126    126   
        "com.amazonaws.transcribestreaming",
  127    127   
        "MedicalScribeTranscriptSegment",
  128    128   
    ),
  129    129   
    ::aws_smithy_schema::ShapeType::String,
  130         -
    "channel_id",
         130  +
    "ChannelId",
  131    131   
    6,
  132    132   
);
  133    133   
static MEDICALSCRIBETRANSCRIPTSEGMENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  134    134   
    MEDICALSCRIBETRANSCRIPTSEGMENT_SCHEMA_ID,
  135    135   
    ::aws_smithy_schema::ShapeType::Structure,
  136    136   
    &[
  137    137   
        &MEDICALSCRIBETRANSCRIPTSEGMENT_MEMBER_SEGMENT_ID,
  138    138   
        &MEDICALSCRIBETRANSCRIPTSEGMENT_MEMBER_BEGIN_AUDIO_TIME,
  139    139   
        &MEDICALSCRIBETRANSCRIPTSEGMENT_MEMBER_END_AUDIO_TIME,
  140    140   
        &MEDICALSCRIBETRANSCRIPTSEGMENT_MEMBER_CONTENT,
@@ -163,163 +274,282 @@
  183    183   
            ser.write_boolean(&MEDICALSCRIBETRANSCRIPTSEGMENT_MEMBER_IS_PARTIAL, *val)?;
  184    184   
        }
  185    185   
        if let Some(ref val) = self.channel_id {
  186    186   
            ser.write_string(&MEDICALSCRIBETRANSCRIPTSEGMENT_MEMBER_CHANNEL_ID, val)?;
  187    187   
        }
  188    188   
        Ok(())
  189    189   
    }
  190    190   
}
  191    191   
impl MedicalScribeTranscriptSegment {
  192    192   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  193         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  194         -
        deserializer: &mut D,
         193  +
    pub fn deserialize(
         194  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  195    195   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  196    196   
        #[allow(unused_variables, unused_mut)]
  197    197   
        let mut builder = Self::builder();
  198    198   
        #[allow(
  199    199   
            unused_variables,
  200    200   
            unreachable_code,
  201    201   
            clippy::single_match,
  202    202   
            clippy::match_single_binding,
  203    203   
            clippy::diverging_sub_expression
  204    204   
        )]
  205         -
        deserializer.read_struct(&MEDICALSCRIBETRANSCRIPTSEGMENT_SCHEMA, (), |_, member, deser| {
         205  +
        deserializer.read_struct(&MEDICALSCRIBETRANSCRIPTSEGMENT_SCHEMA, &mut |member, deser| {
  206    206   
            match member.member_index() {
  207    207   
                Some(0) => {
  208    208   
                    builder.segment_id = Some(deser.read_string(member)?);
  209    209   
                }
  210    210   
                Some(1) => {
  211    211   
                    builder.begin_audio_time = Some(deser.read_double(member)?);
  212    212   
                }
  213    213   
                Some(2) => {
  214    214   
                    builder.end_audio_time = Some(deser.read_double(member)?);
  215    215   
                }
  216    216   
                Some(3) => {
  217    217   
                    builder.content = Some(deser.read_string(member)?);
  218    218   
                }
  219    219   
                Some(4) => {
  220    220   
                    builder.items = Some({
  221         -
                        let container = if let Some(cap) = deser.container_size() {
  222         -
                            Vec::with_capacity(cap)
  223         -
                        } else {
  224         -
                            Vec::new()
  225         -
                        };
  226         -
                        deser.read_list(member, container, |mut list, deser| {
  227         -
                            list.push(crate::types::MedicalScribeTranscriptItem::deserialize(deser)?);
  228         -
                            Ok(list)
  229         -
                        })?
         221  +
                        let mut container = Vec::new();
         222  +
                        deser.read_list(member, &mut |deser| {
         223  +
                            container.push(crate::types::MedicalScribeTranscriptItem::deserialize(deser)?);
         224  +
                            Ok(())
         225  +
                        })?;
         226  +
                        container
  230    227   
                    });
  231    228   
                }
  232    229   
                Some(5) => {
  233    230   
                    builder.is_partial = Some(deser.read_boolean(member)?);
  234    231   
                }
  235    232   
                Some(6) => {
  236    233   
                    builder.channel_id = Some(deser.read_string(member)?);
  237    234   
                }
  238    235   
                _ => {}
  239    236   
            }
  240    237   
            Ok(())
  241    238   
        })?;
  242    239   
        Ok(builder.build())
  243    240   
    }
  244    241   
}
         242  +
impl MedicalScribeTranscriptSegment {
         243  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         244  +
    pub fn deserialize_with_response(
         245  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         246  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         247  +
        _status: u16,
         248  +
        _body: &[u8],
         249  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         250  +
        Self::deserialize(deserializer)
         251  +
    }
         252  +
}
  245    253   
impl MedicalScribeTranscriptSegment {
  246    254   
    /// Creates a new builder-style object to manufacture [`MedicalScribeTranscriptSegment`](crate::types::MedicalScribeTranscriptSegment).
  247    255   
    pub fn builder() -> crate::types::builders::MedicalScribeTranscriptSegmentBuilder {
  248    256   
        crate::types::builders::MedicalScribeTranscriptSegmentBuilder::default()
  249    257   
    }
  250    258   
}
  251    259   
  252    260   
/// A builder for [`MedicalScribeTranscriptSegment`](crate::types::MedicalScribeTranscriptSegment).
  253    261   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  254    262   
#[non_exhaustive]

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

@@ -1,1 +128,136 @@
   21     21   
    "com.amazonaws.transcribestreaming",
   22     22   
    "MedicalTranscript",
   23     23   
);
   24     24   
static MEDICALTRANSCRIPT_MEMBER_RESULTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static(
   26     26   
        "com.amazonaws.transcribestreaming#MedicalTranscript$Results",
   27     27   
        "com.amazonaws.transcribestreaming",
   28     28   
        "MedicalTranscript",
   29     29   
    ),
   30     30   
    ::aws_smithy_schema::ShapeType::List,
   31         -
    "results",
          31  +
    "Results",
   32     32   
    0,
   33     33   
);
   34     34   
static MEDICALTRANSCRIPT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   35     35   
    MEDICALTRANSCRIPT_SCHEMA_ID,
   36     36   
    ::aws_smithy_schema::ShapeType::Structure,
   37     37   
    &[&MEDICALTRANSCRIPT_MEMBER_RESULTS],
   38     38   
);
   39     39   
impl MedicalTranscript {
   40     40   
    /// The schema for this shape.
   41     41   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MEDICALTRANSCRIPT_SCHEMA;
   42     42   
}
   43     43   
impl ::aws_smithy_schema::serde::SerializableStruct for MedicalTranscript {
   44     44   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   45     45   
    fn serialize_members(
   46     46   
        &self,
   47     47   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   48     48   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   49     49   
        if let Some(ref val) = self.results {
   50     50   
            ser.write_list(
   51     51   
                &MEDICALTRANSCRIPT_MEMBER_RESULTS,
   52     52   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   53     53   
                    for item in val {
   54     54   
                        ser.write_struct(crate::types::MedicalResult::SCHEMA, item)?;
   55     55   
                    }
   56     56   
                    Ok(())
   57     57   
                },
   58     58   
            )?;
   59     59   
        }
   60     60   
        Ok(())
   61     61   
    }
   62     62   
}
   63     63   
impl MedicalTranscript {
   64     64   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   65         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   66         -
        deserializer: &mut D,
          65  +
    pub fn deserialize(
          66  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   67     67   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   68     68   
        #[allow(unused_variables, unused_mut)]
   69     69   
        let mut builder = Self::builder();
   70     70   
        #[allow(
   71     71   
            unused_variables,
   72     72   
            unreachable_code,
   73     73   
            clippy::single_match,
   74     74   
            clippy::match_single_binding,
   75     75   
            clippy::diverging_sub_expression
   76     76   
        )]
   77         -
        deserializer.read_struct(&MEDICALTRANSCRIPT_SCHEMA, (), |_, member, deser| {
          77  +
        deserializer.read_struct(&MEDICALTRANSCRIPT_SCHEMA, &mut |member, deser| {
   78     78   
            match member.member_index() {
   79     79   
                Some(0) => {
   80     80   
                    builder.results = Some({
   81         -
                        let container = if let Some(cap) = deser.container_size() {
   82         -
                            Vec::with_capacity(cap)
   83         -
                        } else {
   84         -
                            Vec::new()
   85         -
                        };
   86         -
                        deser.read_list(member, container, |mut list, deser| {
   87         -
                            list.push(crate::types::MedicalResult::deserialize(deser)?);
   88         -
                            Ok(list)
   89         -
                        })?
          81  +
                        let mut container = Vec::new();
          82  +
                        deser.read_list(member, &mut |deser| {
          83  +
                            container.push(crate::types::MedicalResult::deserialize(deser)?);
          84  +
                            Ok(())
          85  +
                        })?;
          86  +
                        container
   90     87   
                    });
   91     88   
                }
   92     89   
                _ => {}
   93     90   
            }
   94     91   
            Ok(())
   95     92   
        })?;
   96     93   
        Ok(builder.build())
   97     94   
    }
   98     95   
}
          96  +
impl MedicalTranscript {
          97  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          98  +
    pub fn deserialize_with_response(
          99  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         100  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         101  +
        _status: u16,
         102  +
        _body: &[u8],
         103  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         104  +
        Self::deserialize(deserializer)
         105  +
    }
         106  +
}
   99    107   
impl MedicalTranscript {
  100    108   
    /// Creates a new builder-style object to manufacture [`MedicalTranscript`](crate::types::MedicalTranscript).
  101    109   
    pub fn builder() -> crate::types::builders::MedicalTranscriptBuilder {
  102    110   
        crate::types::builders::MedicalTranscriptBuilder::default()
  103    111   
    }
  104    112   
}
  105    113   
  106    114   
/// A builder for [`MedicalTranscript`](crate::types::MedicalTranscript).
  107    115   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  108    116   
#[non_exhaustive]

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

@@ -1,1 +108,119 @@
   19     19   
    "com.amazonaws.transcribestreaming",
   20     20   
    "MedicalTranscriptEvent",
   21     21   
);
   22     22   
static MEDICALTRANSCRIPTEVENT_MEMBER_TRANSCRIPT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   23     23   
    ::aws_smithy_schema::ShapeId::from_static(
   24     24   
        "com.amazonaws.transcribestreaming#MedicalTranscriptEvent$Transcript",
   25     25   
        "com.amazonaws.transcribestreaming",
   26     26   
        "MedicalTranscriptEvent",
   27     27   
    ),
   28     28   
    ::aws_smithy_schema::ShapeType::Structure,
   29         -
    "transcript",
          29  +
    "Transcript",
   30     30   
    0,
   31     31   
);
   32     32   
static MEDICALTRANSCRIPTEVENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   33     33   
    MEDICALTRANSCRIPTEVENT_SCHEMA_ID,
   34     34   
    ::aws_smithy_schema::ShapeType::Structure,
   35     35   
    &[&MEDICALTRANSCRIPTEVENT_MEMBER_TRANSCRIPT],
   36     36   
);
   37     37   
impl MedicalTranscriptEvent {
   38     38   
    /// The schema for this shape.
   39     39   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MEDICALTRANSCRIPTEVENT_SCHEMA;
   40     40   
}
   41     41   
impl ::aws_smithy_schema::serde::SerializableStruct for MedicalTranscriptEvent {
   42     42   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   43     43   
    fn serialize_members(
   44     44   
        &self,
   45     45   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   46     46   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   47     47   
        if let Some(ref val) = self.transcript {
   48     48   
            ser.write_struct(&MEDICALTRANSCRIPTEVENT_MEMBER_TRANSCRIPT, val)?;
   49     49   
        }
   50     50   
        Ok(())
   51     51   
    }
   52     52   
}
   53     53   
impl MedicalTranscriptEvent {
   54     54   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   55         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   56         -
        deserializer: &mut D,
          55  +
    pub fn deserialize(
          56  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   57     57   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   58     58   
        #[allow(unused_variables, unused_mut)]
   59     59   
        let mut builder = Self::builder();
   60     60   
        #[allow(
   61     61   
            unused_variables,
   62     62   
            unreachable_code,
   63     63   
            clippy::single_match,
   64     64   
            clippy::match_single_binding,
   65     65   
            clippy::diverging_sub_expression
   66     66   
        )]
   67         -
        deserializer.read_struct(&MEDICALTRANSCRIPTEVENT_SCHEMA, (), |_, member, deser| {
          67  +
        deserializer.read_struct(&MEDICALTRANSCRIPTEVENT_SCHEMA, &mut |member, deser| {
   68     68   
            match member.member_index() {
   69     69   
                Some(0) => {
   70     70   
                    builder.transcript = Some(crate::types::MedicalTranscript::deserialize(deser)?);
   71     71   
                }
   72     72   
                _ => {}
   73     73   
            }
   74     74   
            Ok(())
   75     75   
        })?;
   76     76   
        Ok(builder.build())
   77     77   
    }
   78     78   
}
          79  +
impl MedicalTranscriptEvent {
          80  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          81  +
    pub fn deserialize_with_response(
          82  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          83  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          84  +
        _status: u16,
          85  +
        _body: &[u8],
          86  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          87  +
        Self::deserialize(deserializer)
          88  +
    }
          89  +
}
   79     90   
impl MedicalTranscriptEvent {
   80     91   
    /// Creates a new builder-style object to manufacture [`MedicalTranscriptEvent`](crate::types::MedicalTranscriptEvent).
   81     92   
    pub fn builder() -> crate::types::builders::MedicalTranscriptEventBuilder {
   82     93   
        crate::types::builders::MedicalTranscriptEventBuilder::default()
   83     94   
    }
   84     95   
}
   85     96   
   86     97   
/// A builder for [`MedicalTranscriptEvent`](crate::types::MedicalTranscriptEvent).
   87     98   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   88     99   
#[non_exhaustive]

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

@@ -10,10 +0,96 @@
   30     30   
    }
   31     31   
    /// Returns true if this is a [`TranscriptEvent`](crate::types::MedicalTranscriptResultStream::TranscriptEvent).
   32     32   
    pub fn is_transcript_event(&self) -> bool {
   33     33   
        self.as_transcript_event().is_ok()
   34     34   
    }
   35     35   
    /// Returns true if the enum instance is the `Unknown` variant.
   36     36   
    pub fn is_unknown(&self) -> bool {
   37     37   
        matches!(self, Self::Unknown)
   38     38   
    }
   39     39   
}
          40  +
static MEDICALTRANSCRIPTRESULTSTREAM_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
          41  +
    "com.amazonaws.transcribestreaming#MedicalTranscriptResultStream",
          42  +
    "com.amazonaws.transcribestreaming",
          43  +
    "MedicalTranscriptResultStream",
          44  +
);
          45  +
static MEDICALTRANSCRIPTRESULTSTREAM_MEMBER_TRANSCRIPTEVENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          46  +
    ::aws_smithy_schema::ShapeId::from_static(
          47  +
        "com.amazonaws.transcribestreaming#MedicalTranscriptResultStream$TranscriptEvent",
          48  +
        "com.amazonaws.transcribestreaming",
          49  +
        "MedicalTranscriptResultStream",
          50  +
    ),
          51  +
    ::aws_smithy_schema::ShapeType::Structure,
          52  +
    "TranscriptEvent",
          53  +
    0,
          54  +
);
          55  +
static MEDICALTRANSCRIPTRESULTSTREAM_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
          56  +
    MEDICALTRANSCRIPTRESULTSTREAM_SCHEMA_ID,
          57  +
    ::aws_smithy_schema::ShapeType::Union,
          58  +
    &[&MEDICALTRANSCRIPTRESULTSTREAM_MEMBER_TRANSCRIPTEVENT],
          59  +
)
          60  +
.with_streaming();
          61  +
impl MedicalTranscriptResultStream {
          62  +
    /// The schema for this shape.
          63  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MEDICALTRANSCRIPTRESULTSTREAM_SCHEMA;
          64  +
}
          65  +
impl ::aws_smithy_schema::serde::SerializableStruct for MedicalTranscriptResultStream {
          66  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
          67  +
    fn serialize_members(
          68  +
        &self,
          69  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
          70  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
          71  +
        match self {
          72  +
            Self::TranscriptEvent(val) => {
          73  +
                ser.write_struct(&MEDICALTRANSCRIPTRESULTSTREAM_MEMBER_TRANSCRIPTEVENT, val)?;
          74  +
            }
          75  +
            Self::Unknown => return Err(::aws_smithy_schema::serde::SerdeError::custom("cannot serialize unknown union variant")),
          76  +
        }
          77  +
        Ok(())
          78  +
    }
          79  +
}
          80  +
impl MedicalTranscriptResultStream {
          81  +
    /// Deserializes this union from a [`ShapeDeserializer`].
          82  +
    pub fn deserialize(
          83  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          84  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          85  +
        let mut result: ::std::option::Option<Self> = ::std::option::Option::None;
          86  +
        #[allow(unused_variables, unreachable_code, clippy::single_match, clippy::match_single_binding)]
          87  +
        deserializer.read_struct(&MEDICALTRANSCRIPTRESULTSTREAM_SCHEMA, &mut |member, deser| {
          88  +
            result = ::std::option::Option::Some(match member.member_index() {
          89  +
                Some(0) => Self::TranscriptEvent(crate::types::MedicalTranscriptEvent::deserialize(deser)?),
          90  +
                _ => Self::Unknown,
          91  +
            });
          92  +
            Ok(())
          93  +
        })?;
          94  +
        result.ok_or_else(|| ::aws_smithy_schema::serde::SerdeError::custom("expected a union variant"))
          95  +
    }
          96  +
}

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

@@ -1,1 +127,135 @@
   20     20   
    "com.amazonaws.transcribestreaming",
   21     21   
    "PointsOfInterest",
   22     22   
);
   23     23   
static POINTSOFINTEREST_MEMBER_TIMESTAMP_RANGES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   24     24   
    ::aws_smithy_schema::ShapeId::from_static(
   25     25   
        "com.amazonaws.transcribestreaming#PointsOfInterest$TimestampRanges",
   26     26   
        "com.amazonaws.transcribestreaming",
   27     27   
        "PointsOfInterest",
   28     28   
    ),
   29     29   
    ::aws_smithy_schema::ShapeType::List,
   30         -
    "timestamp_ranges",
          30  +
    "TimestampRanges",
   31     31   
    0,
   32     32   
);
   33     33   
static POINTSOFINTEREST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   34     34   
    POINTSOFINTEREST_SCHEMA_ID,
   35     35   
    ::aws_smithy_schema::ShapeType::Structure,
   36     36   
    &[&POINTSOFINTEREST_MEMBER_TIMESTAMP_RANGES],
   37     37   
);
   38     38   
impl PointsOfInterest {
   39     39   
    /// The schema for this shape.
   40     40   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &POINTSOFINTEREST_SCHEMA;
   41     41   
}
   42     42   
impl ::aws_smithy_schema::serde::SerializableStruct for PointsOfInterest {
   43     43   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   44     44   
    fn serialize_members(
   45     45   
        &self,
   46     46   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   47     47   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   48     48   
        if let Some(ref val) = self.timestamp_ranges {
   49     49   
            ser.write_list(
   50     50   
                &POINTSOFINTEREST_MEMBER_TIMESTAMP_RANGES,
   51     51   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   52     52   
                    for item in val {
   53     53   
                        ser.write_struct(crate::types::TimestampRange::SCHEMA, item)?;
   54     54   
                    }
   55     55   
                    Ok(())
   56     56   
                },
   57     57   
            )?;
   58     58   
        }
   59     59   
        Ok(())
   60     60   
    }
   61     61   
}
   62     62   
impl PointsOfInterest {
   63     63   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   64         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   65         -
        deserializer: &mut D,
          64  +
    pub fn deserialize(
          65  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   66     66   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   67     67   
        #[allow(unused_variables, unused_mut)]
   68     68   
        let mut builder = Self::builder();
   69     69   
        #[allow(
   70     70   
            unused_variables,
   71     71   
            unreachable_code,
   72     72   
            clippy::single_match,
   73     73   
            clippy::match_single_binding,
   74     74   
            clippy::diverging_sub_expression
   75     75   
        )]
   76         -
        deserializer.read_struct(&POINTSOFINTEREST_SCHEMA, (), |_, member, deser| {
          76  +
        deserializer.read_struct(&POINTSOFINTEREST_SCHEMA, &mut |member, deser| {
   77     77   
            match member.member_index() {
   78     78   
                Some(0) => {
   79     79   
                    builder.timestamp_ranges = Some({
   80         -
                        let container = if let Some(cap) = deser.container_size() {
   81         -
                            Vec::with_capacity(cap)
   82         -
                        } else {
   83         -
                            Vec::new()
   84         -
                        };
   85         -
                        deser.read_list(member, container, |mut list, deser| {
   86         -
                            list.push(crate::types::TimestampRange::deserialize(deser)?);
   87         -
                            Ok(list)
   88         -
                        })?
          80  +
                        let mut container = Vec::new();
          81  +
                        deser.read_list(member, &mut |deser| {
          82  +
                            container.push(crate::types::TimestampRange::deserialize(deser)?);
          83  +
                            Ok(())
          84  +
                        })?;
          85  +
                        container
   89     86   
                    });
   90     87   
                }
   91     88   
                _ => {}
   92     89   
            }
   93     90   
            Ok(())
   94     91   
        })?;
   95     92   
        Ok(builder.build())
   96     93   
    }
   97     94   
}
          95  +
impl PointsOfInterest {
          96  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          97  +
    pub fn deserialize_with_response(
          98  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          99  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         100  +
        _status: u16,
         101  +
        _body: &[u8],
         102  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         103  +
        Self::deserialize(deserializer)
         104  +
    }
         105  +
}
   98    106   
impl PointsOfInterest {
   99    107   
    /// Creates a new builder-style object to manufacture [`PointsOfInterest`](crate::types::PointsOfInterest).
  100    108   
    pub fn builder() -> crate::types::builders::PointsOfInterestBuilder {
  101    109   
        crate::types::builders::PointsOfInterestBuilder::default()
  102    110   
    }
  103    111   
}
  104    112   
  105    113   
/// A builder for [`PointsOfInterest`](crate::types::PointsOfInterest).
  106    114   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  107    115   
#[non_exhaustive]

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

@@ -78,78 +244,257 @@
   98     98   
    "com.amazonaws.transcribestreaming",
   99     99   
    "PostCallAnalyticsSettings",
  100    100   
);
  101    101   
static POSTCALLANALYTICSSETTINGS_MEMBER_OUTPUT_LOCATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static(
  103    103   
        "com.amazonaws.transcribestreaming#PostCallAnalyticsSettings$OutputLocation",
  104    104   
        "com.amazonaws.transcribestreaming",
  105    105   
        "PostCallAnalyticsSettings",
  106    106   
    ),
  107    107   
    ::aws_smithy_schema::ShapeType::String,
  108         -
    "output_location",
         108  +
    "OutputLocation",
  109    109   
    0,
  110    110   
);
  111    111   
static POSTCALLANALYTICSSETTINGS_MEMBER_DATA_ACCESS_ROLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  112    112   
    ::aws_smithy_schema::ShapeId::from_static(
  113    113   
        "com.amazonaws.transcribestreaming#PostCallAnalyticsSettings$DataAccessRoleArn",
  114    114   
        "com.amazonaws.transcribestreaming",
  115    115   
        "PostCallAnalyticsSettings",
  116    116   
    ),
  117    117   
    ::aws_smithy_schema::ShapeType::String,
  118         -
    "data_access_role_arn",
         118  +
    "DataAccessRoleArn",
  119    119   
    1,
  120    120   
);
  121    121   
static POSTCALLANALYTICSSETTINGS_MEMBER_CONTENT_REDACTION_OUTPUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  122    122   
    ::aws_smithy_schema::ShapeId::from_static(
  123    123   
        "com.amazonaws.transcribestreaming#PostCallAnalyticsSettings$ContentRedactionOutput",
  124    124   
        "com.amazonaws.transcribestreaming",
  125    125   
        "PostCallAnalyticsSettings",
  126    126   
    ),
  127    127   
    ::aws_smithy_schema::ShapeType::String,
  128         -
    "content_redaction_output",
         128  +
    "ContentRedactionOutput",
  129    129   
    2,
  130    130   
);
  131    131   
static POSTCALLANALYTICSSETTINGS_MEMBER_OUTPUT_ENCRYPTION_KMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  132    132   
    ::aws_smithy_schema::ShapeId::from_static(
  133    133   
        "com.amazonaws.transcribestreaming#PostCallAnalyticsSettings$OutputEncryptionKMSKeyId",
  134    134   
        "com.amazonaws.transcribestreaming",
  135    135   
        "PostCallAnalyticsSettings",
  136    136   
    ),
  137    137   
    ::aws_smithy_schema::ShapeType::String,
  138         -
    "output_encryption_kms_key_id",
         138  +
    "OutputEncryptionKMSKeyId",
  139    139   
    3,
  140    140   
);
  141    141   
static POSTCALLANALYTICSSETTINGS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  142    142   
    POSTCALLANALYTICSSETTINGS_SCHEMA_ID,
  143    143   
    ::aws_smithy_schema::ShapeType::Structure,
  144    144   
    &[
  145    145   
        &POSTCALLANALYTICSSETTINGS_MEMBER_OUTPUT_LOCATION,
  146    146   
        &POSTCALLANALYTICSSETTINGS_MEMBER_DATA_ACCESS_ROLE_ARN,
  147    147   
        &POSTCALLANALYTICSSETTINGS_MEMBER_CONTENT_REDACTION_OUTPUT,
  148    148   
        &POSTCALLANALYTICSSETTINGS_MEMBER_OUTPUT_ENCRYPTION_KMS_KEY_ID,
  149    149   
    ],
  150    150   
);
  151    151   
impl PostCallAnalyticsSettings {
  152    152   
    /// The schema for this shape.
  153    153   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &POSTCALLANALYTICSSETTINGS_SCHEMA;
  154    154   
}
  155    155   
impl ::aws_smithy_schema::serde::SerializableStruct for PostCallAnalyticsSettings {
  156    156   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  157    157   
    fn serialize_members(
  158    158   
        &self,
  159    159   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  160    160   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  161    161   
        {
  162    162   
            let val = &self.output_location;
  163    163   
            ser.write_string(&POSTCALLANALYTICSSETTINGS_MEMBER_OUTPUT_LOCATION, val)?;
  164    164   
        }
  165    165   
        {
  166    166   
            let val = &self.data_access_role_arn;
  167    167   
            ser.write_string(&POSTCALLANALYTICSSETTINGS_MEMBER_DATA_ACCESS_ROLE_ARN, val)?;
  168    168   
        }
  169    169   
        if let Some(ref val) = self.content_redaction_output {
  170    170   
            ser.write_string(&POSTCALLANALYTICSSETTINGS_MEMBER_CONTENT_REDACTION_OUTPUT, val.as_str())?;
  171    171   
        }
  172    172   
        if let Some(ref val) = self.output_encryption_kms_key_id {
  173    173   
            ser.write_string(&POSTCALLANALYTICSSETTINGS_MEMBER_OUTPUT_ENCRYPTION_KMS_KEY_ID, val)?;
  174    174   
        }
  175    175   
        Ok(())
  176    176   
    }
  177    177   
}
  178    178   
impl PostCallAnalyticsSettings {
  179    179   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  180         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  181         -
        deserializer: &mut D,
         180  +
    pub fn deserialize(
         181  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  182    182   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  183    183   
        #[allow(unused_variables, unused_mut)]
  184    184   
        let mut builder = Self::builder();
  185    185   
        #[allow(
  186    186   
            unused_variables,
  187    187   
            unreachable_code,
  188    188   
            clippy::single_match,
  189    189   
            clippy::match_single_binding,
  190    190   
            clippy::diverging_sub_expression
  191    191   
        )]
  192         -
        deserializer.read_struct(&POSTCALLANALYTICSSETTINGS_SCHEMA, (), |_, member, deser| {
         192  +
        deserializer.read_struct(&POSTCALLANALYTICSSETTINGS_SCHEMA, &mut |member, deser| {
  193    193   
            match member.member_index() {
  194    194   
                Some(0) => {
  195    195   
                    builder.output_location = Some(deser.read_string(member)?);
  196    196   
                }
  197    197   
                Some(1) => {
  198    198   
                    builder.data_access_role_arn = Some(deser.read_string(member)?);
  199    199   
                }
  200    200   
                Some(2) => {
  201    201   
                    builder.content_redaction_output = Some(crate::types::ContentRedactionOutput::from(deser.read_string(member)?.as_str()));
  202    202   
                }
  203    203   
                Some(3) => {
  204    204   
                    builder.output_encryption_kms_key_id = Some(deser.read_string(member)?);
  205    205   
                }
  206    206   
                _ => {}
  207    207   
            }
  208    208   
            Ok(())
  209    209   
        })?;
         210  +
        builder.output_location = builder.output_location.or(Some(String::new()));
         211  +
        builder.data_access_role_arn = builder.data_access_role_arn.or(Some(String::new()));
  210    212   
        builder
  211    213   
            .build()
  212    214   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  213    215   
    }
  214    216   
}
         217  +
impl PostCallAnalyticsSettings {
         218  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         219  +
    pub fn deserialize_with_response(
         220  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         221  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         222  +
        _status: u16,
         223  +
        _body: &[u8],
         224  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         225  +
        Self::deserialize(deserializer)
         226  +
    }
         227  +
}
  215    228   
impl PostCallAnalyticsSettings {
  216    229   
    /// Creates a new builder-style object to manufacture [`PostCallAnalyticsSettings`](crate::types::PostCallAnalyticsSettings).
  217    230   
    pub fn builder() -> crate::types::builders::PostCallAnalyticsSettingsBuilder {
  218    231   
        crate::types::builders::PostCallAnalyticsSettingsBuilder::default()
  219    232   
    }
  220    233   
}
  221    234   
  222    235   
/// A builder for [`PostCallAnalyticsSettings`](crate::types::PostCallAnalyticsSettings).
  223    236   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  224    237   
#[non_exhaustive]

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

@@ -46,46 +176,176 @@
   66     66   
}
   67     67   
static RESULT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   68     68   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.transcribestreaming#Result", "com.amazonaws.transcribestreaming", "Result");
   69     69   
static RESULT_MEMBER_RESULT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.transcribestreaming#Result$ResultId",
   72     72   
        "com.amazonaws.transcribestreaming",
   73     73   
        "Result",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::String,
   76         -
    "result_id",
          76  +
    "ResultId",
   77     77   
    0,
   78     78   
);
   79     79   
static RESULT_MEMBER_START_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static(
   81     81   
        "com.amazonaws.transcribestreaming#Result$StartTime",
   82     82   
        "com.amazonaws.transcribestreaming",
   83     83   
        "Result",
   84     84   
    ),
   85     85   
    ::aws_smithy_schema::ShapeType::Double,
   86         -
    "start_time",
          86  +
    "StartTime",
   87     87   
    1,
   88     88   
);
   89     89   
static RESULT_MEMBER_END_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   90     90   
    ::aws_smithy_schema::ShapeId::from_static(
   91     91   
        "com.amazonaws.transcribestreaming#Result$EndTime",
   92     92   
        "com.amazonaws.transcribestreaming",
   93     93   
        "Result",
   94     94   
    ),
   95     95   
    ::aws_smithy_schema::ShapeType::Double,
   96         -
    "end_time",
          96  +
    "EndTime",
   97     97   
    2,
   98     98   
);
   99     99   
static RESULT_MEMBER_IS_PARTIAL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  100    100   
    ::aws_smithy_schema::ShapeId::from_static(
  101    101   
        "com.amazonaws.transcribestreaming#Result$IsPartial",
  102    102   
        "com.amazonaws.transcribestreaming",
  103    103   
        "Result",
  104    104   
    ),
  105    105   
    ::aws_smithy_schema::ShapeType::Boolean,
  106         -
    "is_partial",
         106  +
    "IsPartial",
  107    107   
    3,
  108    108   
);
  109    109   
static RESULT_MEMBER_ALTERNATIVES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  110    110   
    ::aws_smithy_schema::ShapeId::from_static(
  111    111   
        "com.amazonaws.transcribestreaming#Result$Alternatives",
  112    112   
        "com.amazonaws.transcribestreaming",
  113    113   
        "Result",
  114    114   
    ),
  115    115   
    ::aws_smithy_schema::ShapeType::List,
  116         -
    "alternatives",
         116  +
    "Alternatives",
  117    117   
    4,
  118    118   
);
  119    119   
static RESULT_MEMBER_CHANNEL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  120    120   
    ::aws_smithy_schema::ShapeId::from_static(
  121    121   
        "com.amazonaws.transcribestreaming#Result$ChannelId",
  122    122   
        "com.amazonaws.transcribestreaming",
  123    123   
        "Result",
  124    124   
    ),
  125    125   
    ::aws_smithy_schema::ShapeType::String,
  126         -
    "channel_id",
         126  +
    "ChannelId",
  127    127   
    5,
  128    128   
);
  129    129   
static RESULT_MEMBER_LANGUAGE_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  130    130   
    ::aws_smithy_schema::ShapeId::from_static(
  131    131   
        "com.amazonaws.transcribestreaming#Result$LanguageCode",
  132    132   
        "com.amazonaws.transcribestreaming",
  133    133   
        "Result",
  134    134   
    ),
  135    135   
    ::aws_smithy_schema::ShapeType::String,
  136         -
    "language_code",
         136  +
    "LanguageCode",
  137    137   
    6,
  138    138   
);
  139    139   
static RESULT_MEMBER_LANGUAGE_IDENTIFICATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  140    140   
    ::aws_smithy_schema::ShapeId::from_static(
  141    141   
        "com.amazonaws.transcribestreaming#Result$LanguageIdentification",
  142    142   
        "com.amazonaws.transcribestreaming",
  143    143   
        "Result",
  144    144   
    ),
  145    145   
    ::aws_smithy_schema::ShapeType::List,
  146         -
    "language_identification",
         146  +
    "LanguageIdentification",
  147    147   
    7,
  148    148   
);
  149    149   
static RESULT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  150    150   
    RESULT_SCHEMA_ID,
  151    151   
    ::aws_smithy_schema::ShapeType::Structure,
  152    152   
    &[
  153    153   
        &RESULT_MEMBER_RESULT_ID,
  154    154   
        &RESULT_MEMBER_START_TIME,
  155    155   
        &RESULT_MEMBER_END_TIME,
  156    156   
        &RESULT_MEMBER_IS_PARTIAL,
@@ -191,191 +315,320 @@
  211    211   
                    }
  212    212   
                    Ok(())
  213    213   
                },
  214    214   
            )?;
  215    215   
        }
  216    216   
        Ok(())
  217    217   
    }
  218    218   
}
  219    219   
impl Result {
  220    220   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  221         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  222         -
        deserializer: &mut D,
         221  +
    pub fn deserialize(
         222  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  223    223   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  224    224   
        #[allow(unused_variables, unused_mut)]
  225    225   
        let mut builder = Self::builder();
  226    226   
        #[allow(
  227    227   
            unused_variables,
  228    228   
            unreachable_code,
  229    229   
            clippy::single_match,
  230    230   
            clippy::match_single_binding,
  231    231   
            clippy::diverging_sub_expression
  232    232   
        )]
  233         -
        deserializer.read_struct(&RESULT_SCHEMA, (), |_, member, deser| {
         233  +
        deserializer.read_struct(&RESULT_SCHEMA, &mut |member, deser| {
  234    234   
            match member.member_index() {
  235    235   
                Some(0) => {
  236    236   
                    builder.result_id = Some(deser.read_string(member)?);
  237    237   
                }
  238    238   
                Some(1) => {
  239    239   
                    builder.start_time = Some(deser.read_double(member)?);
  240    240   
                }
  241    241   
                Some(2) => {
  242    242   
                    builder.end_time = Some(deser.read_double(member)?);
  243    243   
                }
  244    244   
                Some(3) => {
  245    245   
                    builder.is_partial = Some(deser.read_boolean(member)?);
  246    246   
                }
  247    247   
                Some(4) => {
  248    248   
                    builder.alternatives = Some({
  249         -
                        let container = if let Some(cap) = deser.container_size() {
  250         -
                            Vec::with_capacity(cap)
  251         -
                        } else {
  252         -
                            Vec::new()
  253         -
                        };
  254         -
                        deser.read_list(member, container, |mut list, deser| {
  255         -
                            list.push(crate::types::Alternative::deserialize(deser)?);
  256         -
                            Ok(list)
  257         -
                        })?
         249  +
                        let mut container = Vec::new();
         250  +
                        deser.read_list(member, &mut |deser| {
         251  +
                            container.push(crate::types::Alternative::deserialize(deser)?);
         252  +
                            Ok(())
         253  +
                        })?;
         254  +
                        container
  258    255   
                    });
  259    256   
                }
  260    257   
                Some(5) => {
  261    258   
                    builder.channel_id = Some(deser.read_string(member)?);
  262    259   
                }
  263    260   
                Some(6) => {
  264    261   
                    builder.language_code = Some(crate::types::LanguageCode::from(deser.read_string(member)?.as_str()));
  265    262   
                }
  266    263   
                Some(7) => {
  267    264   
                    builder.language_identification = Some({
  268         -
                        let container = if let Some(cap) = deser.container_size() {
  269         -
                            Vec::with_capacity(cap)
  270         -
                        } else {
  271         -
                            Vec::new()
  272         -
                        };
  273         -
                        deser.read_list(member, container, |mut list, deser| {
  274         -
                            list.push(crate::types::LanguageWithScore::deserialize(deser)?);
  275         -
                            Ok(list)
  276         -
                        })?
         265  +
                        let mut container = Vec::new();
         266  +
                        deser.read_list(member, &mut |deser| {
         267  +
                            container.push(crate::types::LanguageWithScore::deserialize(deser)?);
         268  +
                            Ok(())
         269  +
                        })?;
         270  +
                        container
  277    271   
                    });
  278    272   
                }
  279    273   
                _ => {}
  280    274   
            }
  281    275   
            Ok(())
  282    276   
        })?;
  283    277   
        Ok(builder.build())
  284    278   
    }
  285    279   
}
         280  +
impl Result {
         281  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         282  +
    pub fn deserialize_with_response(
         283  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         284  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         285  +
        _status: u16,
         286  +
        _body: &[u8],
         287  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         288  +
        Self::deserialize(deserializer)
         289  +
    }
         290  +
}
  286    291   
impl Result {
  287    292   
    /// Creates a new builder-style object to manufacture [`Result`](crate::types::Result).
  288    293   
    pub fn builder() -> crate::types::builders::ResultBuilder {
  289    294   
        crate::types::builders::ResultBuilder::default()
  290    295   
    }
  291    296   
}
  292    297   
  293    298   
/// A builder for [`Result`](crate::types::Result).
  294    299   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  295    300   
#[non_exhaustive]

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

@@ -4,4 +129,140 @@
   24     24   
    "com.amazonaws.transcribestreaming",
   25     25   
    "TimestampRange",
   26     26   
);
   27     27   
static TIMESTAMPRANGE_MEMBER_BEGIN_OFFSET_MILLIS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static(
   29     29   
        "com.amazonaws.transcribestreaming#TimestampRange$BeginOffsetMillis",
   30     30   
        "com.amazonaws.transcribestreaming",
   31     31   
        "TimestampRange",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::Long,
   34         -
    "begin_offset_millis",
          34  +
    "BeginOffsetMillis",
   35     35   
    0,
   36     36   
);
   37     37   
static TIMESTAMPRANGE_MEMBER_END_OFFSET_MILLIS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static(
   39     39   
        "com.amazonaws.transcribestreaming#TimestampRange$EndOffsetMillis",
   40     40   
        "com.amazonaws.transcribestreaming",
   41     41   
        "TimestampRange",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::Long,
   44         -
    "end_offset_millis",
          44  +
    "EndOffsetMillis",
   45     45   
    1,
   46     46   
);
   47     47   
static TIMESTAMPRANGE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   48     48   
    TIMESTAMPRANGE_SCHEMA_ID,
   49     49   
    ::aws_smithy_schema::ShapeType::Structure,
   50     50   
    &[&TIMESTAMPRANGE_MEMBER_BEGIN_OFFSET_MILLIS, &TIMESTAMPRANGE_MEMBER_END_OFFSET_MILLIS],
   51     51   
);
   52     52   
impl TimestampRange {
   53     53   
    /// The schema for this shape.
   54     54   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TIMESTAMPRANGE_SCHEMA;
   55     55   
}
   56     56   
impl ::aws_smithy_schema::serde::SerializableStruct for TimestampRange {
   57     57   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   58     58   
    fn serialize_members(
   59     59   
        &self,
   60     60   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   61     61   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   62     62   
        if let Some(ref val) = self.begin_offset_millis {
   63     63   
            ser.write_long(&TIMESTAMPRANGE_MEMBER_BEGIN_OFFSET_MILLIS, *val)?;
   64     64   
        }
   65     65   
        if let Some(ref val) = self.end_offset_millis {
   66     66   
            ser.write_long(&TIMESTAMPRANGE_MEMBER_END_OFFSET_MILLIS, *val)?;
   67     67   
        }
   68     68   
        Ok(())
   69     69   
    }
   70     70   
}
   71     71   
impl TimestampRange {
   72     72   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   73         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   74         -
        deserializer: &mut D,
          73  +
    pub fn deserialize(
          74  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   75     75   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   76     76   
        #[allow(unused_variables, unused_mut)]
   77     77   
        let mut builder = Self::builder();
   78     78   
        #[allow(
   79     79   
            unused_variables,
   80     80   
            unreachable_code,
   81     81   
            clippy::single_match,
   82     82   
            clippy::match_single_binding,
   83     83   
            clippy::diverging_sub_expression
   84     84   
        )]
   85         -
        deserializer.read_struct(&TIMESTAMPRANGE_SCHEMA, (), |_, member, deser| {
          85  +
        deserializer.read_struct(&TIMESTAMPRANGE_SCHEMA, &mut |member, deser| {
   86     86   
            match member.member_index() {
   87     87   
                Some(0) => {
   88     88   
                    builder.begin_offset_millis = Some(deser.read_long(member)?);
   89     89   
                }
   90     90   
                Some(1) => {
   91     91   
                    builder.end_offset_millis = Some(deser.read_long(member)?);
   92     92   
                }
   93     93   
                _ => {}
   94     94   
            }
   95     95   
            Ok(())
   96     96   
        })?;
   97     97   
        Ok(builder.build())
   98     98   
    }
   99     99   
}
         100  +
impl TimestampRange {
         101  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         102  +
    pub fn deserialize_with_response(
         103  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         104  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         105  +
        _status: u16,
         106  +
        _body: &[u8],
         107  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         108  +
        Self::deserialize(deserializer)
         109  +
    }
         110  +
}
  100    111   
impl TimestampRange {
  101    112   
    /// Creates a new builder-style object to manufacture [`TimestampRange`](crate::types::TimestampRange).
  102    113   
    pub fn builder() -> crate::types::builders::TimestampRangeBuilder {
  103    114   
        crate::types::builders::TimestampRangeBuilder::default()
  104    115   
    }
  105    116   
}
  106    117   
  107    118   
/// A builder for [`TimestampRange`](crate::types::TimestampRange).
  108    119   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  109    120   
#[non_exhaustive]

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

@@ -1,1 +128,136 @@
   21     21   
    "com.amazonaws.transcribestreaming",
   22     22   
    "Transcript",
   23     23   
);
   24     24   
static TRANSCRIPT_MEMBER_RESULTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static(
   26     26   
        "com.amazonaws.transcribestreaming#Transcript$Results",
   27     27   
        "com.amazonaws.transcribestreaming",
   28     28   
        "Transcript",
   29     29   
    ),
   30     30   
    ::aws_smithy_schema::ShapeType::List,
   31         -
    "results",
          31  +
    "Results",
   32     32   
    0,
   33     33   
);
   34     34   
static TRANSCRIPT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   35     35   
    TRANSCRIPT_SCHEMA_ID,
   36     36   
    ::aws_smithy_schema::ShapeType::Structure,
   37     37   
    &[&TRANSCRIPT_MEMBER_RESULTS],
   38     38   
);
   39     39   
impl Transcript {
   40     40   
    /// The schema for this shape.
   41     41   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TRANSCRIPT_SCHEMA;
   42     42   
}
   43     43   
impl ::aws_smithy_schema::serde::SerializableStruct for Transcript {
   44     44   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   45     45   
    fn serialize_members(
   46     46   
        &self,
   47     47   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   48     48   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   49     49   
        if let Some(ref val) = self.results {
   50     50   
            ser.write_list(
   51     51   
                &TRANSCRIPT_MEMBER_RESULTS,
   52     52   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   53     53   
                    for item in val {
   54     54   
                        ser.write_struct(crate::types::Result::SCHEMA, item)?;
   55     55   
                    }
   56     56   
                    Ok(())
   57     57   
                },
   58     58   
            )?;
   59     59   
        }
   60     60   
        Ok(())
   61     61   
    }
   62     62   
}
   63     63   
impl Transcript {
   64     64   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   65         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   66         -
        deserializer: &mut D,
          65  +
    pub fn deserialize(
          66  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   67     67   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   68     68   
        #[allow(unused_variables, unused_mut)]
   69     69   
        let mut builder = Self::builder();
   70     70   
        #[allow(
   71     71   
            unused_variables,
   72     72   
            unreachable_code,
   73     73   
            clippy::single_match,
   74     74   
            clippy::match_single_binding,
   75     75   
            clippy::diverging_sub_expression
   76     76   
        )]
   77         -
        deserializer.read_struct(&TRANSCRIPT_SCHEMA, (), |_, member, deser| {
          77  +
        deserializer.read_struct(&TRANSCRIPT_SCHEMA, &mut |member, deser| {
   78     78   
            match member.member_index() {
   79     79   
                Some(0) => {
   80     80   
                    builder.results = Some({
   81         -
                        let container = if let Some(cap) = deser.container_size() {
   82         -
                            Vec::with_capacity(cap)
   83         -
                        } else {
   84         -
                            Vec::new()
   85         -
                        };
   86         -
                        deser.read_list(member, container, |mut list, deser| {
   87         -
                            list.push(crate::types::Result::deserialize(deser)?);
   88         -
                            Ok(list)
   89         -
                        })?
          81  +
                        let mut container = Vec::new();
          82  +
                        deser.read_list(member, &mut |deser| {
          83  +
                            container.push(crate::types::Result::deserialize(deser)?);
          84  +
                            Ok(())
          85  +
                        })?;
          86  +
                        container
   90     87   
                    });
   91     88   
                }
   92     89   
                _ => {}
   93     90   
            }
   94     91   
            Ok(())
   95     92   
        })?;
   96     93   
        Ok(builder.build())
   97     94   
    }
   98     95   
}
          96  +
impl Transcript {
          97  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          98  +
    pub fn deserialize_with_response(
          99  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         100  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         101  +
        _status: u16,
         102  +
        _body: &[u8],
         103  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         104  +
        Self::deserialize(deserializer)
         105  +
    }
         106  +
}
   99    107   
impl Transcript {
  100    108   
    /// Creates a new builder-style object to manufacture [`Transcript`](crate::types::Transcript).
  101    109   
    pub fn builder() -> crate::types::builders::TranscriptBuilder {
  102    110   
        crate::types::builders::TranscriptBuilder::default()
  103    111   
    }
  104    112   
}
  105    113   
  106    114   
/// A builder for [`Transcript`](crate::types::Transcript).
  107    115   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  108    116   
#[non_exhaustive]

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

@@ -1,1 +108,119 @@
   19     19   
    "com.amazonaws.transcribestreaming",
   20     20   
    "TranscriptEvent",
   21     21   
);
   22     22   
static TRANSCRIPTEVENT_MEMBER_TRANSCRIPT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   23     23   
    ::aws_smithy_schema::ShapeId::from_static(
   24     24   
        "com.amazonaws.transcribestreaming#TranscriptEvent$Transcript",
   25     25   
        "com.amazonaws.transcribestreaming",
   26     26   
        "TranscriptEvent",
   27     27   
    ),
   28     28   
    ::aws_smithy_schema::ShapeType::Structure,
   29         -
    "transcript",
          29  +
    "Transcript",
   30     30   
    0,
   31     31   
);
   32     32   
static TRANSCRIPTEVENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   33     33   
    TRANSCRIPTEVENT_SCHEMA_ID,
   34     34   
    ::aws_smithy_schema::ShapeType::Structure,
   35     35   
    &[&TRANSCRIPTEVENT_MEMBER_TRANSCRIPT],
   36     36   
);
   37     37   
impl TranscriptEvent {
   38     38   
    /// The schema for this shape.
   39     39   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TRANSCRIPTEVENT_SCHEMA;
   40     40   
}
   41     41   
impl ::aws_smithy_schema::serde::SerializableStruct for TranscriptEvent {
   42     42   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   43     43   
    fn serialize_members(
   44     44   
        &self,
   45     45   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   46     46   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   47     47   
        if let Some(ref val) = self.transcript {
   48     48   
            ser.write_struct(&TRANSCRIPTEVENT_MEMBER_TRANSCRIPT, val)?;
   49     49   
        }
   50     50   
        Ok(())
   51     51   
    }
   52     52   
}
   53     53   
impl TranscriptEvent {
   54     54   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   55         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   56         -
        deserializer: &mut D,
          55  +
    pub fn deserialize(
          56  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   57     57   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   58     58   
        #[allow(unused_variables, unused_mut)]
   59     59   
        let mut builder = Self::builder();
   60     60   
        #[allow(
   61     61   
            unused_variables,
   62     62   
            unreachable_code,
   63     63   
            clippy::single_match,
   64     64   
            clippy::match_single_binding,
   65     65   
            clippy::diverging_sub_expression
   66     66   
        )]
   67         -
        deserializer.read_struct(&TRANSCRIPTEVENT_SCHEMA, (), |_, member, deser| {
          67  +
        deserializer.read_struct(&TRANSCRIPTEVENT_SCHEMA, &mut |member, deser| {
   68     68   
            match member.member_index() {
   69     69   
                Some(0) => {
   70     70   
                    builder.transcript = Some(crate::types::Transcript::deserialize(deser)?);
   71     71   
                }
   72     72   
                _ => {}
   73     73   
            }
   74     74   
            Ok(())
   75     75   
        })?;
   76     76   
        Ok(builder.build())
   77     77   
    }
   78     78   
}
          79  +
impl TranscriptEvent {
          80  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          81  +
    pub fn deserialize_with_response(
          82  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          83  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          84  +
        _status: u16,
          85  +
        _body: &[u8],
          86  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          87  +
        Self::deserialize(deserializer)
          88  +
    }
          89  +
}
   79     90   
impl TranscriptEvent {
   80     91   
    /// Creates a new builder-style object to manufacture [`TranscriptEvent`](crate::types::TranscriptEvent).
   81     92   
    pub fn builder() -> crate::types::builders::TranscriptEventBuilder {
   82     93   
        crate::types::builders::TranscriptEventBuilder::default()
   83     94   
    }
   84     95   
}
   85     96   
   86     97   
/// A builder for [`TranscriptEvent`](crate::types::TranscriptEvent).
   87     98   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   88     99   
#[non_exhaustive]