AWS SDK

AWS SDK

rev. 32b1b3c3761061baed26023be3219639e42d7d12

Files changed:

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

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

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

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

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

@@ -39,39 +268,279 @@
   59     59   
}
   60     60   
static ITEM_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   61     61   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.transcribestreaming#Item", "com.amazonaws.transcribestreaming", "Item");
   62     62   
static ITEM_MEMBER_START_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static(
   64     64   
        "com.amazonaws.transcribestreaming#Item$StartTime",
   65     65   
        "com.amazonaws.transcribestreaming",
   66     66   
        "Item",
   67     67   
    ),
   68     68   
    ::aws_smithy_schema::ShapeType::Double,
   69         -
    "start_time",
          69  +
    "StartTime",
   70     70   
    0,
   71     71   
);
   72     72   
static ITEM_MEMBER_END_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static(
   74     74   
        "com.amazonaws.transcribestreaming#Item$EndTime",
   75     75   
        "com.amazonaws.transcribestreaming",
   76     76   
        "Item",
   77     77   
    ),
   78     78   
    ::aws_smithy_schema::ShapeType::Double,
   79         -
    "end_time",
          79  +
    "EndTime",
   80     80   
    1,
   81     81   
);
   82     82   
static ITEM_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   83     83   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.transcribestreaming#Item$Type", "com.amazonaws.transcribestreaming", "Item"),
   84     84   
    ::aws_smithy_schema::ShapeType::String,
   85         -
    "r##type",
          85  +
    "Type",
   86     86   
    2,
   87     87   
);
   88     88   
static ITEM_MEMBER_CONTENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   89     89   
    ::aws_smithy_schema::ShapeId::from_static(
   90     90   
        "com.amazonaws.transcribestreaming#Item$Content",
   91     91   
        "com.amazonaws.transcribestreaming",
   92     92   
        "Item",
   93     93   
    ),
   94     94   
    ::aws_smithy_schema::ShapeType::String,
   95         -
    "content",
          95  +
    "Content",
   96     96   
    3,
   97     97   
);
   98     98   
static ITEM_MEMBER_VOCABULARY_FILTER_MATCH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   99     99   
    ::aws_smithy_schema::ShapeId::from_static(
  100    100   
        "com.amazonaws.transcribestreaming#Item$VocabularyFilterMatch",
  101    101   
        "com.amazonaws.transcribestreaming",
  102    102   
        "Item",
  103    103   
    ),
  104    104   
    ::aws_smithy_schema::ShapeType::Boolean,
  105         -
    "vocabulary_filter_match",
         105  +
    "VocabularyFilterMatch",
  106    106   
    4,
  107    107   
);
  108    108   
static ITEM_MEMBER_SPEAKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  109    109   
    ::aws_smithy_schema::ShapeId::from_static(
  110    110   
        "com.amazonaws.transcribestreaming#Item$Speaker",
  111    111   
        "com.amazonaws.transcribestreaming",
  112    112   
        "Item",
  113    113   
    ),
  114    114   
    ::aws_smithy_schema::ShapeType::String,
  115         -
    "speaker",
         115  +
    "Speaker",
  116    116   
    5,
  117    117   
);
  118    118   
static ITEM_MEMBER_CONFIDENCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  119    119   
    ::aws_smithy_schema::ShapeId::from_static(
  120    120   
        "com.amazonaws.transcribestreaming#Item$Confidence",
  121    121   
        "com.amazonaws.transcribestreaming",
  122    122   
        "Item",
  123    123   
    ),
  124    124   
    ::aws_smithy_schema::ShapeType::Double,
  125         -
    "confidence",
         125  +
    "Confidence",
  126    126   
    6,
  127    127   
);
  128    128   
static ITEM_MEMBER_STABLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  129    129   
    ::aws_smithy_schema::ShapeId::from_static(
  130    130   
        "com.amazonaws.transcribestreaming#Item$Stable",
  131    131   
        "com.amazonaws.transcribestreaming",
  132    132   
        "Item",
  133    133   
    ),
  134    134   
    ::aws_smithy_schema::ShapeType::Boolean,
  135         -
    "stable",
         135  +
    "Stable",
  136    136   
    7,
  137    137   
);
  138    138   
static ITEM_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  139    139   
    ITEM_SCHEMA_ID,
  140    140   
    ::aws_smithy_schema::ShapeType::Structure,
  141    141   
    &[
  142    142   
        &ITEM_MEMBER_START_TIME,
  143    143   
        &ITEM_MEMBER_END_TIME,
  144    144   
        &ITEM_MEMBER_TYPE,
  145    145   
        &ITEM_MEMBER_CONTENT,
  146    146   
        &ITEM_MEMBER_VOCABULARY_FILTER_MATCH,
  147    147   
        &ITEM_MEMBER_SPEAKER,
  148    148   
        &ITEM_MEMBER_CONFIDENCE,
  149    149   
        &ITEM_MEMBER_STABLE,
  150    150   
    ],
  151    151   
);
  152    152   
impl Item {
  153    153   
    /// The schema for this shape.
  154    154   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ITEM_SCHEMA;
  155    155   
}
  156    156   
impl ::aws_smithy_schema::serde::SerializableStruct for Item {
  157    157   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  158    158   
    fn serialize_members(
  159    159   
        &self,
  160    160   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  161    161   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  162    162   
        {
  163    163   
            let val = &self.start_time;
  164    164   
            ser.write_double(&ITEM_MEMBER_START_TIME, *val)?;
  165    165   
        }
  166    166   
        {
  167    167   
            let val = &self.end_time;
  168    168   
            ser.write_double(&ITEM_MEMBER_END_TIME, *val)?;
  169    169   
        }
  170    170   
        if let Some(ref val) = self.r#type {
  171    171   
            ser.write_string(&ITEM_MEMBER_TYPE, val.as_str())?;
  172    172   
        }
  173    173   
        if let Some(ref val) = self.content {
  174    174   
            ser.write_string(&ITEM_MEMBER_CONTENT, val)?;
  175    175   
        }
  176    176   
        {
  177    177   
            let val = &self.vocabulary_filter_match;
  178    178   
            ser.write_boolean(&ITEM_MEMBER_VOCABULARY_FILTER_MATCH, *val)?;
  179    179   
        }
  180    180   
        if let Some(ref val) = self.speaker {
  181    181   
            ser.write_string(&ITEM_MEMBER_SPEAKER, val)?;
  182    182   
        }
  183    183   
        if let Some(ref val) = self.confidence {
  184    184   
            ser.write_double(&ITEM_MEMBER_CONFIDENCE, *val)?;
  185    185   
        }
  186    186   
        if let Some(ref val) = self.stable {
  187    187   
            ser.write_boolean(&ITEM_MEMBER_STABLE, *val)?;
  188    188   
        }
  189    189   
        Ok(())
  190    190   
    }
  191    191   
}
  192    192   
impl Item {
  193    193   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  194         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  195         -
        deserializer: &mut D,
         194  +
    pub fn deserialize(
         195  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  196    196   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  197    197   
        #[allow(unused_variables, unused_mut)]
  198    198   
        let mut builder = Self::builder();
  199    199   
        #[allow(
  200    200   
            unused_variables,
  201    201   
            unreachable_code,
  202    202   
            clippy::single_match,
  203    203   
            clippy::match_single_binding,
  204    204   
            clippy::diverging_sub_expression
  205    205   
        )]
  206         -
        deserializer.read_struct(&ITEM_SCHEMA, (), |_, member, deser| {
         206  +
        deserializer.read_struct(&ITEM_SCHEMA, &mut |member, deser| {
  207    207   
            match member.member_index() {
  208    208   
                Some(0) => {
  209    209   
                    builder.start_time = Some(deser.read_double(member)?);
  210    210   
                }
  211    211   
                Some(1) => {
  212    212   
                    builder.end_time = Some(deser.read_double(member)?);
  213    213   
                }
  214    214   
                Some(2) => {
  215    215   
                    builder.r#type = Some(crate::types::ItemType::from(deser.read_string(member)?.as_str()));
  216    216   
                }
  217    217   
                Some(3) => {
  218    218   
                    builder.content = Some(deser.read_string(member)?);
  219    219   
                }
  220    220   
                Some(4) => {
  221    221   
                    builder.vocabulary_filter_match = Some(deser.read_boolean(member)?);
  222    222   
                }
  223    223   
                Some(5) => {
  224    224   
                    builder.speaker = Some(deser.read_string(member)?);
  225    225   
                }
  226    226   
                Some(6) => {
  227    227   
                    builder.confidence = Some(deser.read_double(member)?);
  228    228   
                }
  229    229   
                Some(7) => {
  230    230   
                    builder.stable = Some(deser.read_boolean(member)?);
  231    231   
                }
  232    232   
                _ => {}
  233    233   
            }
  234    234   
            Ok(())
  235    235   
        })?;
  236    236   
        Ok(builder.build())
  237    237   
    }
  238    238   
}
         239  +
impl Item {
         240  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         241  +
    pub fn deserialize_with_response(
         242  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         243  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         244  +
        _status: u16,
         245  +
        _body: &[u8],
         246  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         247  +
        Self::deserialize(deserializer)
         248  +
    }
         249  +
}
  239    250   
impl Item {
  240    251   
    /// Creates a new builder-style object to manufacture [`Item`](crate::types::Item).
  241    252   
    pub fn builder() -> crate::types::builders::ItemBuilder {
  242    253   
        crate::types::builders::ItemBuilder::default()
  243    254   
    }
  244    255   
}
  245    256   
  246    257   
/// A builder for [`Item`](crate::types::Item).
  247    258   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  248    259   
#[non_exhaustive]

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

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

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

@@ -14,14 +195,200 @@
   34     34   
    "com.amazonaws.transcribestreaming",
   35     35   
    "MedicalAlternative",
   36     36   
);
   37     37   
static MEDICALALTERNATIVE_MEMBER_TRANSCRIPT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static(
   39     39   
        "com.amazonaws.transcribestreaming#MedicalAlternative$Transcript",
   40     40   
        "com.amazonaws.transcribestreaming",
   41     41   
        "MedicalAlternative",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::String,
   44         -
    "transcript",
          44  +
    "Transcript",
   45     45   
    0,
   46     46   
);
   47     47   
static MEDICALALTERNATIVE_MEMBER_ITEMS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   48     48   
    ::aws_smithy_schema::ShapeId::from_static(
   49     49   
        "com.amazonaws.transcribestreaming#MedicalAlternative$Items",
   50     50   
        "com.amazonaws.transcribestreaming",
   51     51   
        "MedicalAlternative",
   52     52   
    ),
   53     53   
    ::aws_smithy_schema::ShapeType::List,
   54         -
    "items",
          54  +
    "Items",
   55     55   
    1,
   56     56   
);
   57     57   
static MEDICALALTERNATIVE_MEMBER_ENTITIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static(
   59     59   
        "com.amazonaws.transcribestreaming#MedicalAlternative$Entities",
   60     60   
        "com.amazonaws.transcribestreaming",
   61     61   
        "MedicalAlternative",
   62     62   
    ),
   63     63   
    ::aws_smithy_schema::ShapeType::List,
   64         -
    "entities",
          64  +
    "Entities",
   65     65   
    2,
   66     66   
);
   67     67   
static MEDICALALTERNATIVE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   68     68   
    MEDICALALTERNATIVE_SCHEMA_ID,
   69     69   
    ::aws_smithy_schema::ShapeType::Structure,
   70     70   
    &[
   71     71   
        &MEDICALALTERNATIVE_MEMBER_TRANSCRIPT,
   72     72   
        &MEDICALALTERNATIVE_MEMBER_ITEMS,
   73     73   
        &MEDICALALTERNATIVE_MEMBER_ENTITIES,
   74     74   
    ],
   75     75   
);
   76     76   
impl MedicalAlternative {
   77     77   
    /// The schema for this shape.
   78     78   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MEDICALALTERNATIVE_SCHEMA;
   79     79   
}
   80     80   
impl ::aws_smithy_schema::serde::SerializableStruct for MedicalAlternative {
   81     81   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   82     82   
    fn serialize_members(
   83     83   
        &self,
   84     84   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   85     85   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   86     86   
        if let Some(ref val) = self.transcript {
   87     87   
            ser.write_string(&MEDICALALTERNATIVE_MEMBER_TRANSCRIPT, val)?;
   88     88   
        }
   89     89   
        if let Some(ref val) = self.items {
   90     90   
            ser.write_list(
   91     91   
                &MEDICALALTERNATIVE_MEMBER_ITEMS,
   92     92   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   93     93   
                    for item in val {
   94     94   
                        ser.write_struct(crate::types::MedicalItem::SCHEMA, item)?;
   95     95   
                    }
   96     96   
                    Ok(())
   97     97   
                },
   98     98   
            )?;
   99     99   
        }
  100    100   
        if let Some(ref val) = self.entities {
  101    101   
            ser.write_list(
  102    102   
                &MEDICALALTERNATIVE_MEMBER_ENTITIES,
  103    103   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  104    104   
                    for item in val {
  105    105   
                        ser.write_struct(crate::types::MedicalEntity::SCHEMA, item)?;
  106    106   
                    }
  107    107   
                    Ok(())
  108    108   
                },
  109    109   
            )?;
  110    110   
        }
  111    111   
        Ok(())
  112    112   
    }
  113    113   
}
  114    114   
impl MedicalAlternative {
  115    115   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  116         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  117         -
        deserializer: &mut D,
         116  +
    pub fn deserialize(
         117  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  118    118   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  119    119   
        #[allow(unused_variables, unused_mut)]
  120    120   
        let mut builder = Self::builder();
  121    121   
        #[allow(
  122    122   
            unused_variables,
  123    123   
            unreachable_code,
  124    124   
            clippy::single_match,
  125    125   
            clippy::match_single_binding,
  126    126   
            clippy::diverging_sub_expression
  127    127   
        )]
  128         -
        deserializer.read_struct(&MEDICALALTERNATIVE_SCHEMA, (), |_, member, deser| {
         128  +
        deserializer.read_struct(&MEDICALALTERNATIVE_SCHEMA, &mut |member, deser| {
  129    129   
            match member.member_index() {
  130    130   
                Some(0) => {
  131    131   
                    builder.transcript = Some(deser.read_string(member)?);
  132    132   
                }
  133    133   
                Some(1) => {
  134    134   
                    builder.items = Some({
  135         -
                        let container = if let Some(cap) = deser.container_size() {
  136         -
                            Vec::with_capacity(cap)
  137         -
                        } else {
  138         -
                            Vec::new()
  139         -
                        };
  140         -
                        deser.read_list(member, container, |mut list, deser| {
  141         -
                            list.push(crate::types::MedicalItem::deserialize(deser)?);
  142         -
                            Ok(list)
  143         -
                        })?
         135  +
                        let mut container = Vec::new();
         136  +
                        deser.read_list(member, &mut |deser| {
         137  +
                            container.push(crate::types::MedicalItem::deserialize(deser)?);
         138  +
                            Ok(())
         139  +
                        })?;
         140  +
                        container
  144    141   
                    });
  145    142   
                }
  146    143   
                Some(2) => {
  147    144   
                    builder.entities = Some({
  148         -
                        let container = if let Some(cap) = deser.container_size() {
  149         -
                            Vec::with_capacity(cap)
  150         -
                        } else {
  151         -
                            Vec::new()
  152         -
                        };
  153         -
                        deser.read_list(member, container, |mut list, deser| {
  154         -
                            list.push(crate::types::MedicalEntity::deserialize(deser)?);
  155         -
                            Ok(list)
  156         -
                        })?
         145  +
                        let mut container = Vec::new();
         146  +
                        deser.read_list(member, &mut |deser| {
         147  +
                            container.push(crate::types::MedicalEntity::deserialize(deser)?);
         148  +
                            Ok(())
         149  +
                        })?;
         150  +
                        container
  157    151   
                    });
  158    152   
                }
  159    153   
                _ => {}
  160    154   
            }
  161    155   
            Ok(())
  162    156   
        })?;
  163    157   
        Ok(builder.build())
  164    158   
    }
  165    159   
}
         160  +
impl MedicalAlternative {
         161  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         162  +
    pub fn deserialize_with_response(
         163  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         164  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         165  +
        _status: u16,
         166  +
        _body: &[u8],
         167  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         168  +
        Self::deserialize(deserializer)
         169  +
    }
         170  +
}
  166    171   
impl MedicalAlternative {
  167    172   
    /// Creates a new builder-style object to manufacture [`MedicalAlternative`](crate::types::MedicalAlternative).
  168    173   
    pub fn builder() -> crate::types::builders::MedicalAlternativeBuilder {
  169    174   
        crate::types::builders::MedicalAlternativeBuilder::default()
  170    175   
    }
  171    176   
}
  172    177   
  173    178   
/// A builder for [`MedicalAlternative`](crate::types::MedicalAlternative).
  174    179   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  175    180   
#[non_exhaustive]

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

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

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

@@ -30,30 +228,239 @@
   50     50   
    "com.amazonaws.transcribestreaming",
   51     51   
    "MedicalItem",
   52     52   
);
   53     53   
static MEDICALITEM_MEMBER_START_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   54     54   
    ::aws_smithy_schema::ShapeId::from_static(
   55     55   
        "com.amazonaws.transcribestreaming#MedicalItem$StartTime",
   56     56   
        "com.amazonaws.transcribestreaming",
   57     57   
        "MedicalItem",
   58     58   
    ),
   59     59   
    ::aws_smithy_schema::ShapeType::Double,
   60         -
    "start_time",
          60  +
    "StartTime",
   61     61   
    0,
   62     62   
);
   63     63   
static MEDICALITEM_MEMBER_END_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static(
   65     65   
        "com.amazonaws.transcribestreaming#MedicalItem$EndTime",
   66     66   
        "com.amazonaws.transcribestreaming",
   67     67   
        "MedicalItem",
   68     68   
    ),
   69     69   
    ::aws_smithy_schema::ShapeType::Double,
   70         -
    "end_time",
          70  +
    "EndTime",
   71     71   
    1,
   72     72   
);
   73     73   
static MEDICALITEM_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#MedicalItem$Type",
   76     76   
        "com.amazonaws.transcribestreaming",
   77     77   
        "MedicalItem",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::String,
   80         -
    "r##type",
          80  +
    "Type",
   81     81   
    2,
   82     82   
);
   83     83   
static MEDICALITEM_MEMBER_CONTENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   84     84   
    ::aws_smithy_schema::ShapeId::from_static(
   85     85   
        "com.amazonaws.transcribestreaming#MedicalItem$Content",
   86     86   
        "com.amazonaws.transcribestreaming",
   87     87   
        "MedicalItem",
   88     88   
    ),
   89     89   
    ::aws_smithy_schema::ShapeType::String,
   90         -
    "content",
          90  +
    "Content",
   91     91   
    3,
   92     92   
);
   93     93   
static MEDICALITEM_MEMBER_CONFIDENCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static(
   95     95   
        "com.amazonaws.transcribestreaming#MedicalItem$Confidence",
   96     96   
        "com.amazonaws.transcribestreaming",
   97     97   
        "MedicalItem",
   98     98   
    ),
   99     99   
    ::aws_smithy_schema::ShapeType::Double,
  100         -
    "confidence",
         100  +
    "Confidence",
  101    101   
    4,
  102    102   
);
  103    103   
static MEDICALITEM_MEMBER_SPEAKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  104    104   
    ::aws_smithy_schema::ShapeId::from_static(
  105    105   
        "com.amazonaws.transcribestreaming#MedicalItem$Speaker",
  106    106   
        "com.amazonaws.transcribestreaming",
  107    107   
        "MedicalItem",
  108    108   
    ),
  109    109   
    ::aws_smithy_schema::ShapeType::String,
  110         -
    "speaker",
         110  +
    "Speaker",
  111    111   
    5,
  112    112   
);
  113    113   
static MEDICALITEM_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  114    114   
    MEDICALITEM_SCHEMA_ID,
  115    115   
    ::aws_smithy_schema::ShapeType::Structure,
  116    116   
    &[
  117    117   
        &MEDICALITEM_MEMBER_START_TIME,
  118    118   
        &MEDICALITEM_MEMBER_END_TIME,
  119    119   
        &MEDICALITEM_MEMBER_TYPE,
  120    120   
        &MEDICALITEM_MEMBER_CONTENT,
  121    121   
        &MEDICALITEM_MEMBER_CONFIDENCE,
  122    122   
        &MEDICALITEM_MEMBER_SPEAKER,
  123    123   
    ],
  124    124   
);
  125    125   
impl MedicalItem {
  126    126   
    /// The schema for this shape.
  127    127   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MEDICALITEM_SCHEMA;
  128    128   
}
  129    129   
impl ::aws_smithy_schema::serde::SerializableStruct for MedicalItem {
  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.start_time;
  137    137   
            ser.write_double(&MEDICALITEM_MEMBER_START_TIME, *val)?;
  138    138   
        }
  139    139   
        {
  140    140   
            let val = &self.end_time;
  141    141   
            ser.write_double(&MEDICALITEM_MEMBER_END_TIME, *val)?;
  142    142   
        }
  143    143   
        if let Some(ref val) = self.r#type {
  144    144   
            ser.write_string(&MEDICALITEM_MEMBER_TYPE, val.as_str())?;
  145    145   
        }
  146    146   
        if let Some(ref val) = self.content {
  147    147   
            ser.write_string(&MEDICALITEM_MEMBER_CONTENT, val)?;
  148    148   
        }
  149    149   
        if let Some(ref val) = self.confidence {
  150    150   
            ser.write_double(&MEDICALITEM_MEMBER_CONFIDENCE, *val)?;
  151    151   
        }
  152    152   
        if let Some(ref val) = self.speaker {
  153    153   
            ser.write_string(&MEDICALITEM_MEMBER_SPEAKER, val)?;
  154    154   
        }
  155    155   
        Ok(())
  156    156   
    }
  157    157   
}
  158    158   
impl MedicalItem {
  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(&MEDICALITEM_SCHEMA, (), |_, member, deser| {
         172  +
        deserializer.read_struct(&MEDICALITEM_SCHEMA, &mut |member, deser| {
  173    173   
            match member.member_index() {
  174    174   
                Some(0) => {
  175    175   
                    builder.start_time = Some(deser.read_double(member)?);
  176    176   
                }
  177    177   
                Some(1) => {
  178    178   
                    builder.end_time = Some(deser.read_double(member)?);
  179    179   
                }
  180    180   
                Some(2) => {
  181    181   
                    builder.r#type = Some(crate::types::ItemType::from(deser.read_string(member)?.as_str()));
  182    182   
                }
  183    183   
                Some(3) => {
  184    184   
                    builder.content = Some(deser.read_string(member)?);
  185    185   
                }
  186    186   
                Some(4) => {
  187    187   
                    builder.confidence = Some(deser.read_double(member)?);
  188    188   
                }
  189    189   
                Some(5) => {
  190    190   
                    builder.speaker = Some(deser.read_string(member)?);
  191    191   
                }
  192    192   
                _ => {}
  193    193   
            }
  194    194   
            Ok(())
  195    195   
        })?;
  196    196   
        Ok(builder.build())
  197    197   
    }
  198    198   
}
         199  +
impl MedicalItem {
         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 MedicalItem {
  200    211   
    /// Creates a new builder-style object to manufacture [`MedicalItem`](crate::types::MedicalItem).
  201    212   
    pub fn builder() -> crate::types::builders::MedicalItemBuilder {
  202    213   
        crate::types::builders::MedicalItemBuilder::default()
  203    214   
    }
  204    215   
}
  205    216   
  206    217   
/// A builder for [`MedicalItem`](crate::types::MedicalItem).
  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_result.rs

@@ -33,33 +250,258 @@
   53     53   
    "com.amazonaws.transcribestreaming",
   54     54   
    "MedicalResult",
   55     55   
);
   56     56   
static MEDICALRESULT_MEMBER_RESULT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   57     57   
    ::aws_smithy_schema::ShapeId::from_static(
   58     58   
        "com.amazonaws.transcribestreaming#MedicalResult$ResultId",
   59     59   
        "com.amazonaws.transcribestreaming",
   60     60   
        "MedicalResult",
   61     61   
    ),
   62     62   
    ::aws_smithy_schema::ShapeType::String,
   63         -
    "result_id",
          63  +
    "ResultId",
   64     64   
    0,
   65     65   
);
   66     66   
static MEDICALRESULT_MEMBER_START_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   67     67   
    ::aws_smithy_schema::ShapeId::from_static(
   68     68   
        "com.amazonaws.transcribestreaming#MedicalResult$StartTime",
   69     69   
        "com.amazonaws.transcribestreaming",
   70     70   
        "MedicalResult",
   71     71   
    ),
   72     72   
    ::aws_smithy_schema::ShapeType::Double,
   73         -
    "start_time",
          73  +
    "StartTime",
   74     74   
    1,
   75     75   
);
   76     76   
static MEDICALRESULT_MEMBER_END_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   77     77   
    ::aws_smithy_schema::ShapeId::from_static(
   78     78   
        "com.amazonaws.transcribestreaming#MedicalResult$EndTime",
   79     79   
        "com.amazonaws.transcribestreaming",
   80     80   
        "MedicalResult",
   81     81   
    ),
   82     82   
    ::aws_smithy_schema::ShapeType::Double,
   83         -
    "end_time",
          83  +
    "EndTime",
   84     84   
    2,
   85     85   
);
   86     86   
static MEDICALRESULT_MEMBER_IS_PARTIAL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   87     87   
    ::aws_smithy_schema::ShapeId::from_static(
   88     88   
        "com.amazonaws.transcribestreaming#MedicalResult$IsPartial",
   89     89   
        "com.amazonaws.transcribestreaming",
   90     90   
        "MedicalResult",
   91     91   
    ),
   92     92   
    ::aws_smithy_schema::ShapeType::Boolean,
   93         -
    "is_partial",
          93  +
    "IsPartial",
   94     94   
    3,
   95     95   
);
   96     96   
static MEDICALRESULT_MEMBER_ALTERNATIVES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   97     97   
    ::aws_smithy_schema::ShapeId::from_static(
   98     98   
        "com.amazonaws.transcribestreaming#MedicalResult$Alternatives",
   99     99   
        "com.amazonaws.transcribestreaming",
  100    100   
        "MedicalResult",
  101    101   
    ),
  102    102   
    ::aws_smithy_schema::ShapeType::List,
  103         -
    "alternatives",
         103  +
    "Alternatives",
  104    104   
    4,
  105    105   
);
  106    106   
static MEDICALRESULT_MEMBER_CHANNEL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  107    107   
    ::aws_smithy_schema::ShapeId::from_static(
  108    108   
        "com.amazonaws.transcribestreaming#MedicalResult$ChannelId",
  109    109   
        "com.amazonaws.transcribestreaming",
  110    110   
        "MedicalResult",
  111    111   
    ),
  112    112   
    ::aws_smithy_schema::ShapeType::String,
  113         -
    "channel_id",
         113  +
    "ChannelId",
  114    114   
    5,
  115    115   
);
  116    116   
static MEDICALRESULT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  117    117   
    MEDICALRESULT_SCHEMA_ID,
  118    118   
    ::aws_smithy_schema::ShapeType::Structure,
  119    119   
    &[
  120    120   
        &MEDICALRESULT_MEMBER_RESULT_ID,
  121    121   
        &MEDICALRESULT_MEMBER_START_TIME,
  122    122   
        &MEDICALRESULT_MEMBER_END_TIME,
  123    123   
        &MEDICALRESULT_MEMBER_IS_PARTIAL,
  124    124   
        &MEDICALRESULT_MEMBER_ALTERNATIVES,
  125    125   
        &MEDICALRESULT_MEMBER_CHANNEL_ID,
  126    126   
    ],
  127    127   
);
  128    128   
impl MedicalResult {
  129    129   
    /// The schema for this shape.
  130    130   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MEDICALRESULT_SCHEMA;
  131    131   
}
  132    132   
impl ::aws_smithy_schema::serde::SerializableStruct for MedicalResult {
  133    133   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  134    134   
    fn serialize_members(
  135    135   
        &self,
  136    136   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  137    137   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  138    138   
        if let Some(ref val) = self.result_id {
  139    139   
            ser.write_string(&MEDICALRESULT_MEMBER_RESULT_ID, val)?;
  140    140   
        }
  141    141   
        {
  142    142   
            let val = &self.start_time;
  143    143   
            ser.write_double(&MEDICALRESULT_MEMBER_START_TIME, *val)?;
  144    144   
        }
  145    145   
        {
  146    146   
            let val = &self.end_time;
  147    147   
            ser.write_double(&MEDICALRESULT_MEMBER_END_TIME, *val)?;
  148    148   
        }
  149    149   
        {
  150    150   
            let val = &self.is_partial;
  151    151   
            ser.write_boolean(&MEDICALRESULT_MEMBER_IS_PARTIAL, *val)?;
  152    152   
        }
  153    153   
        if let Some(ref val) = self.alternatives {
  154    154   
            ser.write_list(
  155    155   
                &MEDICALRESULT_MEMBER_ALTERNATIVES,
  156    156   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  157    157   
                    for item in val {
  158    158   
                        ser.write_struct(crate::types::MedicalAlternative::SCHEMA, item)?;
  159    159   
                    }
  160    160   
                    Ok(())
  161    161   
                },
  162    162   
            )?;
  163    163   
        }
  164    164   
        if let Some(ref val) = self.channel_id {
  165    165   
            ser.write_string(&MEDICALRESULT_MEMBER_CHANNEL_ID, val)?;
  166    166   
        }
  167    167   
        Ok(())
  168    168   
    }
  169    169   
}
  170    170   
impl MedicalResult {
  171    171   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  172         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  173         -
        deserializer: &mut D,
         172  +
    pub fn deserialize(
         173  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  174    174   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  175    175   
        #[allow(unused_variables, unused_mut)]
  176    176   
        let mut builder = Self::builder();
  177    177   
        #[allow(
  178    178   
            unused_variables,
  179    179   
            unreachable_code,
  180    180   
            clippy::single_match,
  181    181   
            clippy::match_single_binding,
  182    182   
            clippy::diverging_sub_expression
  183    183   
        )]
  184         -
        deserializer.read_struct(&MEDICALRESULT_SCHEMA, (), |_, member, deser| {
         184  +
        deserializer.read_struct(&MEDICALRESULT_SCHEMA, &mut |member, deser| {
  185    185   
            match member.member_index() {
  186    186   
                Some(0) => {
  187    187   
                    builder.result_id = Some(deser.read_string(member)?);
  188    188   
                }
  189    189   
                Some(1) => {
  190    190   
                    builder.start_time = Some(deser.read_double(member)?);
  191    191   
                }
  192    192   
                Some(2) => {
  193    193   
                    builder.end_time = Some(deser.read_double(member)?);
  194    194   
                }
  195    195   
                Some(3) => {
  196    196   
                    builder.is_partial = Some(deser.read_boolean(member)?);
  197    197   
                }
  198    198   
                Some(4) => {
  199    199   
                    builder.alternatives = Some({
  200         -
                        let container = if let Some(cap) = deser.container_size() {
  201         -
                            Vec::with_capacity(cap)
  202         -
                        } else {
  203         -
                            Vec::new()
  204         -
                        };
  205         -
                        deser.read_list(member, container, |mut list, deser| {
  206         -
                            list.push(crate::types::MedicalAlternative::deserialize(deser)?);
  207         -
                            Ok(list)
  208         -
                        })?
         200  +
                        let mut container = Vec::new();
         201  +
                        deser.read_list(member, &mut |deser| {
         202  +
                            container.push(crate::types::MedicalAlternative::deserialize(deser)?);
         203  +
                            Ok(())
         204  +
                        })?;
         205  +
                        container
  209    206   
                    });
  210    207   
                }
  211    208   
                Some(5) => {
  212    209   
                    builder.channel_id = Some(deser.read_string(member)?);
  213    210   
                }
  214    211   
                _ => {}
  215    212   
            }
  216    213   
            Ok(())
  217    214   
        })?;
  218    215   
        Ok(builder.build())
  219    216   
    }
  220    217   
}
         218  +
impl MedicalResult {
         219  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         220  +
    pub fn deserialize_with_response(
         221  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         222  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         223  +
        _status: u16,
         224  +
        _body: &[u8],
         225  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         226  +
        Self::deserialize(deserializer)
         227  +
    }
         228  +
}
  221    229   
impl MedicalResult {
  222    230   
    /// Creates a new builder-style object to manufacture [`MedicalResult`](crate::types::MedicalResult).
  223    231   
    pub fn builder() -> crate::types::builders::MedicalResultBuilder {
  224    232   
        crate::types::builders::MedicalResultBuilder::default()
  225    233   
    }
  226    234   
}
  227    235   
  228    236   
/// A builder for [`MedicalResult`](crate::types::MedicalResult).
  229    237   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  230    238   
#[non_exhaustive]

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

@@ -7,7 +120,132 @@
   27     27   
    "com.amazonaws.transcribestreaming",
   28     28   
    "MedicalScribeAudioEvent",
   29     29   
);
   30     30   
static MEDICALSCRIBEAUDIOEVENT_MEMBER_AUDIO_CHUNK: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   31     31   
    ::aws_smithy_schema::ShapeId::from_static(
   32     32   
        "com.amazonaws.transcribestreaming#MedicalScribeAudioEvent$AudioChunk",
   33     33   
        "com.amazonaws.transcribestreaming",
   34     34   
        "MedicalScribeAudioEvent",
   35     35   
    ),
   36     36   
    ::aws_smithy_schema::ShapeType::Blob,
   37         -
    "audio_chunk",
          37  +
    "AudioChunk",
   38     38   
    0,
   39     39   
)
   40     40   
.with_event_payload();
   41     41   
static MEDICALSCRIBEAUDIOEVENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   42     42   
    MEDICALSCRIBEAUDIOEVENT_SCHEMA_ID,
   43     43   
    ::aws_smithy_schema::ShapeType::Structure,
   44     44   
    &[&MEDICALSCRIBEAUDIOEVENT_MEMBER_AUDIO_CHUNK],
   45     45   
);
   46     46   
impl MedicalScribeAudioEvent {
   47     47   
    /// The schema for this shape.
   48     48   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MEDICALSCRIBEAUDIOEVENT_SCHEMA;
   49     49   
}
   50     50   
impl ::aws_smithy_schema::serde::SerializableStruct for MedicalScribeAudioEvent {
   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.audio_chunk;
   58     58   
            ser.write_blob(&MEDICALSCRIBEAUDIOEVENT_MEMBER_AUDIO_CHUNK, val)?;
   59     59   
        }
   60     60   
        Ok(())
   61     61   
    }
   62     62   
}
   63     63   
impl MedicalScribeAudioEvent {
   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(&MEDICALSCRIBEAUDIOEVENT_SCHEMA, (), |_, member, deser| {
          77  +
        deserializer.read_struct(&MEDICALSCRIBEAUDIOEVENT_SCHEMA, &mut |member, deser| {
   78     78   
            match member.member_index() {
   79     79   
                Some(0) => {
   80     80   
                    builder.audio_chunk = Some(deser.read_blob(member)?);
   81     81   
                }
   82     82   
                _ => {}
   83     83   
            }
   84     84   
            Ok(())
   85     85   
        })?;
          86  +
        builder.audio_chunk = builder.audio_chunk.or(Some(::aws_smithy_types::Blob::new("")));
   86     87   
        builder
   87     88   
            .build()
   88     89   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   89     90   
    }
   90     91   
}
          92  +
impl MedicalScribeAudioEvent {
          93  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          94  +
    pub fn deserialize_with_response(
          95  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          96  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          97  +
        _status: u16,
          98  +
        _body: &[u8],
          99  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         100  +
        Self::deserialize(deserializer)
         101  +
    }
         102  +
}
   91    103   
impl MedicalScribeAudioEvent {
   92    104   
    /// Creates a new builder-style object to manufacture [`MedicalScribeAudioEvent`](crate::types::MedicalScribeAudioEvent).
   93    105   
    pub fn builder() -> crate::types::builders::MedicalScribeAudioEventBuilder {
   94    106   
        crate::types::builders::MedicalScribeAudioEventBuilder::default()
   95    107   
    }
   96    108   
}
   97    109   
   98    110   
/// A builder for [`MedicalScribeAudioEvent`](crate::types::MedicalScribeAudioEvent).
   99    111   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  100    112   
#[non_exhaustive]

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

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

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

@@ -56,56 +186,186 @@
   76     76   
    "com.amazonaws.transcribestreaming",
   77     77   
    "MedicalScribeConfigurationEvent",
   78     78   
);
   79     79   
static MEDICALSCRIBECONFIGURATIONEVENT_MEMBER_VOCABULARY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static(
   81     81   
        "com.amazonaws.transcribestreaming#MedicalScribeConfigurationEvent$VocabularyName",
   82     82   
        "com.amazonaws.transcribestreaming",
   83     83   
        "MedicalScribeConfigurationEvent",
   84     84   
    ),
   85     85   
    ::aws_smithy_schema::ShapeType::String,
   86         -
    "vocabulary_name",
          86  +
    "VocabularyName",
   87     87   
    0,
   88     88   
);
   89     89   
static MEDICALSCRIBECONFIGURATIONEVENT_MEMBER_VOCABULARY_FILTER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   90     90   
    ::aws_smithy_schema::ShapeId::from_static(
   91     91   
        "com.amazonaws.transcribestreaming#MedicalScribeConfigurationEvent$VocabularyFilterName",
   92     92   
        "com.amazonaws.transcribestreaming",
   93     93   
        "MedicalScribeConfigurationEvent",
   94     94   
    ),
   95     95   
    ::aws_smithy_schema::ShapeType::String,
   96         -
    "vocabulary_filter_name",
          96  +
    "VocabularyFilterName",
   97     97   
    1,
   98     98   
);
   99     99   
static MEDICALSCRIBECONFIGURATIONEVENT_MEMBER_VOCABULARY_FILTER_METHOD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  100    100   
    ::aws_smithy_schema::ShapeId::from_static(
  101    101   
        "com.amazonaws.transcribestreaming#MedicalScribeConfigurationEvent$VocabularyFilterMethod",
  102    102   
        "com.amazonaws.transcribestreaming",
  103    103   
        "MedicalScribeConfigurationEvent",
  104    104   
    ),
  105    105   
    ::aws_smithy_schema::ShapeType::String,
  106         -
    "vocabulary_filter_method",
         106  +
    "VocabularyFilterMethod",
  107    107   
    2,
  108    108   
);
  109    109   
static MEDICALSCRIBECONFIGURATIONEVENT_MEMBER_RESOURCE_ACCESS_ROLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  110    110   
    ::aws_smithy_schema::ShapeId::from_static(
  111    111   
        "com.amazonaws.transcribestreaming#MedicalScribeConfigurationEvent$ResourceAccessRoleArn",
  112    112   
        "com.amazonaws.transcribestreaming",
  113    113   
        "MedicalScribeConfigurationEvent",
  114    114   
    ),
  115    115   
    ::aws_smithy_schema::ShapeType::String,
  116         -
    "resource_access_role_arn",
         116  +
    "ResourceAccessRoleArn",
  117    117   
    3,
  118    118   
);
  119    119   
static MEDICALSCRIBECONFIGURATIONEVENT_MEMBER_CHANNEL_DEFINITIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  120    120   
    ::aws_smithy_schema::ShapeId::from_static(
  121    121   
        "com.amazonaws.transcribestreaming#MedicalScribeConfigurationEvent$ChannelDefinitions",
  122    122   
        "com.amazonaws.transcribestreaming",
  123    123   
        "MedicalScribeConfigurationEvent",
  124    124   
    ),
  125    125   
    ::aws_smithy_schema::ShapeType::List,
  126         -
    "channel_definitions",
         126  +
    "ChannelDefinitions",
  127    127   
    4,
  128    128   
);
  129    129   
static MEDICALSCRIBECONFIGURATIONEVENT_MEMBER_ENCRYPTION_SETTINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  130    130   
    ::aws_smithy_schema::ShapeId::from_static(
  131    131   
        "com.amazonaws.transcribestreaming#MedicalScribeConfigurationEvent$EncryptionSettings",
  132    132   
        "com.amazonaws.transcribestreaming",
  133    133   
        "MedicalScribeConfigurationEvent",
  134    134   
    ),
  135    135   
    ::aws_smithy_schema::ShapeType::Structure,
  136         -
    "encryption_settings",
         136  +
    "EncryptionSettings",
  137    137   
    5,
  138    138   
);
  139    139   
static MEDICALSCRIBECONFIGURATIONEVENT_MEMBER_POST_STREAM_ANALYTICS_SETTINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  140    140   
    ::aws_smithy_schema::ShapeId::from_static(
  141    141   
        "com.amazonaws.transcribestreaming#MedicalScribeConfigurationEvent$PostStreamAnalyticsSettings",
  142    142   
        "com.amazonaws.transcribestreaming",
  143    143   
        "MedicalScribeConfigurationEvent",
  144    144   
    ),
  145    145   
    ::aws_smithy_schema::ShapeType::Structure,
  146         -
    "post_stream_analytics_settings",
         146  +
    "PostStreamAnalyticsSettings",
  147    147   
    6,
  148    148   
);
  149    149   
static MEDICALSCRIBECONFIGURATIONEVENT_MEMBER_MEDICAL_SCRIBE_CONTEXT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  150    150   
    ::aws_smithy_schema::ShapeId::from_static(
  151    151   
        "com.amazonaws.transcribestreaming#MedicalScribeConfigurationEvent$MedicalScribeContext",
  152    152   
        "com.amazonaws.transcribestreaming",
  153    153   
        "MedicalScribeConfigurationEvent",
  154    154   
    ),
  155    155   
    ::aws_smithy_schema::ShapeType::Structure,
  156         -
    "medical_scribe_context",
         156  +
    "MedicalScribeContext",
  157    157   
    7,
  158    158   
);
  159    159   
static MEDICALSCRIBECONFIGURATIONEVENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  160    160   
    MEDICALSCRIBECONFIGURATIONEVENT_SCHEMA_ID,
  161    161   
    ::aws_smithy_schema::ShapeType::Structure,
  162    162   
    &[
  163    163   
        &MEDICALSCRIBECONFIGURATIONEVENT_MEMBER_VOCABULARY_NAME,
  164    164   
        &MEDICALSCRIBECONFIGURATIONEVENT_MEMBER_VOCABULARY_FILTER_NAME,
  165    165   
        &MEDICALSCRIBECONFIGURATIONEVENT_MEMBER_VOCABULARY_FILTER_METHOD,
  166    166   
        &MEDICALSCRIBECONFIGURATIONEVENT_MEMBER_RESOURCE_ACCESS_ROLE_ARN,
@@ -191,191 +309,318 @@
  211    211   
            ser.write_struct(&MEDICALSCRIBECONFIGURATIONEVENT_MEMBER_POST_STREAM_ANALYTICS_SETTINGS, val)?;
  212    212   
        }
  213    213   
        if let Some(ref val) = self.medical_scribe_context {
  214    214   
            ser.write_struct(&MEDICALSCRIBECONFIGURATIONEVENT_MEMBER_MEDICAL_SCRIBE_CONTEXT, val)?;
  215    215   
        }
  216    216   
        Ok(())
  217    217   
    }
  218    218   
}
  219    219   
impl MedicalScribeConfigurationEvent {
  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(&MEDICALSCRIBECONFIGURATIONEVENT_SCHEMA, (), |_, member, deser| {
         233  +
        deserializer.read_struct(&MEDICALSCRIBECONFIGURATIONEVENT_SCHEMA, &mut |member, deser| {
  234    234   
            match member.member_index() {
  235    235   
                Some(0) => {
  236    236   
                    builder.vocabulary_name = Some(deser.read_string(member)?);
  237    237   
                }
  238    238   
                Some(1) => {
  239    239   
                    builder.vocabulary_filter_name = Some(deser.read_string(member)?);
  240    240   
                }
  241    241   
                Some(2) => {
  242    242   
                    builder.vocabulary_filter_method = Some(crate::types::MedicalScribeVocabularyFilterMethod::from(
  243    243   
                        deser.read_string(member)?.as_str(),
  244    244   
                    ));
  245    245   
                }
  246    246   
                Some(3) => {
  247    247   
                    builder.resource_access_role_arn = Some(deser.read_string(member)?);
  248    248   
                }
  249    249   
                Some(4) => {
  250    250   
                    builder.channel_definitions = Some({
  251         -
                        let container = if let Some(cap) = deser.container_size() {
  252         -
                            Vec::with_capacity(cap)
  253         -
                        } else {
  254         -
                            Vec::new()
  255         -
                        };
  256         -
                        deser.read_list(member, container, |mut list, deser| {
  257         -
                            list.push(crate::types::MedicalScribeChannelDefinition::deserialize(deser)?);
  258         -
                            Ok(list)
  259         -
                        })?
         251  +
                        let mut container = Vec::new();
         252  +
                        deser.read_list(member, &mut |deser| {
         253  +
                            container.push(crate::types::MedicalScribeChannelDefinition::deserialize(deser)?);
         254  +
                            Ok(())
         255  +
                        })?;
         256  +
                        container
  260    257   
                    });
  261    258   
                }
  262    259   
                Some(5) => {
  263    260   
                    builder.encryption_settings = Some(crate::types::MedicalScribeEncryptionSettings::deserialize(deser)?);
  264    261   
                }
  265    262   
                Some(6) => {
  266    263   
                    builder.post_stream_analytics_settings = Some(crate::types::MedicalScribePostStreamAnalyticsSettings::deserialize(deser)?);
  267    264   
                }
  268    265   
                Some(7) => {
  269    266   
                    builder.medical_scribe_context = Some(crate::types::MedicalScribeContext::deserialize(deser)?);
  270    267   
                }
  271    268   
                _ => {}
  272    269   
            }
  273    270   
            Ok(())
  274    271   
        })?;
         272  +
        builder.resource_access_role_arn = builder.resource_access_role_arn.or(Some(String::new()));
  275    273   
        builder
  276    274   
            .build()
  277    275   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  278    276   
    }
  279    277   
}
         278  +
impl MedicalScribeConfigurationEvent {
         279  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         280  +
    pub fn deserialize_with_response(
         281  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         282  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         283  +
        _status: u16,
         284  +
        _body: &[u8],
         285  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         286  +
        Self::deserialize(deserializer)
         287  +
    }
         288  +
}
  280    289   
impl MedicalScribeConfigurationEvent {
  281    290   
    /// Creates a new builder-style object to manufacture [`MedicalScribeConfigurationEvent`](crate::types::MedicalScribeConfigurationEvent).
  282    291   
    pub fn builder() -> crate::types::builders::MedicalScribeConfigurationEventBuilder {
  283    292   
        crate::types::builders::MedicalScribeConfigurationEventBuilder::default()
  284    293   
    }
  285    294   
}
  286    295   
  287    296   
/// A builder for [`MedicalScribeConfigurationEvent`](crate::types::MedicalScribeConfigurationEvent).
  288    297   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  289    298   
#[non_exhaustive]

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

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

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

@@ -31,31 +181,183 @@
   51     51   
    "com.amazonaws.transcribestreaming",
   52     52   
    "MedicalScribeEncryptionSettings",
   53     53   
);
   54     54   
static MEDICALSCRIBEENCRYPTIONSETTINGS_MEMBER_KMS_ENCRYPTION_CONTEXT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   55     55   
    ::aws_smithy_schema::ShapeId::from_static(
   56     56   
        "com.amazonaws.transcribestreaming#MedicalScribeEncryptionSettings$KmsEncryptionContext",
   57     57   
        "com.amazonaws.transcribestreaming",
   58     58   
        "MedicalScribeEncryptionSettings",
   59     59   
    ),
   60     60   
    ::aws_smithy_schema::ShapeType::Map,
   61         -
    "kms_encryption_context",
          61  +
    "KmsEncryptionContext",
   62     62   
    0,
   63     63   
);
   64     64   
static MEDICALSCRIBEENCRYPTIONSETTINGS_MEMBER_KMS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   65     65   
    ::aws_smithy_schema::ShapeId::from_static(
   66     66   
        "com.amazonaws.transcribestreaming#MedicalScribeEncryptionSettings$KmsKeyId",
   67     67   
        "com.amazonaws.transcribestreaming",
   68     68   
        "MedicalScribeEncryptionSettings",
   69     69   
    ),
   70     70   
    ::aws_smithy_schema::ShapeType::String,
   71         -
    "kms_key_id",
          71  +
    "KmsKeyId",
   72     72   
    1,
   73     73   
);
   74     74   
static MEDICALSCRIBEENCRYPTIONSETTINGS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   75     75   
    MEDICALSCRIBEENCRYPTIONSETTINGS_SCHEMA_ID,
   76     76   
    ::aws_smithy_schema::ShapeType::Structure,
   77     77   
    &[
   78     78   
        &MEDICALSCRIBEENCRYPTIONSETTINGS_MEMBER_KMS_ENCRYPTION_CONTEXT,
   79     79   
        &MEDICALSCRIBEENCRYPTIONSETTINGS_MEMBER_KMS_KEY_ID,
   80     80   
    ],
   81     81   
);
   82     82   
impl MedicalScribeEncryptionSettings {
   83     83   
    /// The schema for this shape.
   84     84   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MEDICALSCRIBEENCRYPTIONSETTINGS_SCHEMA;
   85     85   
}
   86     86   
impl ::aws_smithy_schema::serde::SerializableStruct for MedicalScribeEncryptionSettings {
   87     87   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   88     88   
    fn serialize_members(
   89     89   
        &self,
   90     90   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   91     91   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   92     92   
        if let Some(ref val) = self.kms_encryption_context {
   93     93   
            ser.write_map(
   94     94   
                &MEDICALSCRIBEENCRYPTIONSETTINGS_MEMBER_KMS_ENCRYPTION_CONTEXT,
   95     95   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   96     96   
                    for (key, value) in val {
   97     97   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
   98     98   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
   99     99   
                    }
  100    100   
                    Ok(())
  101    101   
                },
  102    102   
            )?;
  103    103   
        }
  104    104   
        {
  105    105   
            let val = &self.kms_key_id;
  106    106   
            ser.write_string(&MEDICALSCRIBEENCRYPTIONSETTINGS_MEMBER_KMS_KEY_ID, val)?;
  107    107   
        }
  108    108   
        Ok(())
  109    109   
    }
  110    110   
}
  111    111   
impl MedicalScribeEncryptionSettings {
  112    112   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  113         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  114         -
        deserializer: &mut D,
         113  +
    pub fn deserialize(
         114  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  115    115   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  116    116   
        #[allow(unused_variables, unused_mut)]
  117    117   
        let mut builder = Self::builder();
  118    118   
        #[allow(
  119    119   
            unused_variables,
  120    120   
            unreachable_code,
  121    121   
            clippy::single_match,
  122    122   
            clippy::match_single_binding,
  123    123   
            clippy::diverging_sub_expression
  124    124   
        )]
  125         -
        deserializer.read_struct(&MEDICALSCRIBEENCRYPTIONSETTINGS_SCHEMA, (), |_, member, deser| {
         125  +
        deserializer.read_struct(&MEDICALSCRIBEENCRYPTIONSETTINGS_SCHEMA, &mut |member, deser| {
  126    126   
            match member.member_index() {
  127    127   
                Some(0) => {
  128         -
                    builder.kms_encryption_context = Some({
  129         -
                        let container = if let Some(cap) = deser.container_size() {
  130         -
                            std::collections::HashMap::with_capacity(cap)
  131         -
                        } else {
  132         -
                            std::collections::HashMap::new()
  133         -
                        };
  134         -
                        deser.read_map(member, container, |mut map, key, deser| {
  135         -
                            map.insert(key, deser.read_string(member)?);
  136         -
                            Ok(map)
  137         -
                        })?
  138         -
                    });
         128  +
                    builder.kms_encryption_context = Some(deser.read_string_string_map(member)?);
  139    129   
                }
  140    130   
                Some(1) => {
  141    131   
                    builder.kms_key_id = Some(deser.read_string(member)?);
  142    132   
                }
  143    133   
                _ => {}
  144    134   
            }
  145    135   
            Ok(())
  146    136   
        })?;
         137  +
        builder.kms_key_id = builder.kms_key_id.or(Some(String::new()));
  147    138   
        builder
  148    139   
            .build()
  149    140   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  150    141   
    }
  151    142   
}
         143  +
impl MedicalScribeEncryptionSettings {
         144  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         145  +
    pub fn deserialize_with_response(
         146  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         147  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         148  +
        _status: u16,
         149  +
        _body: &[u8],
         150  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         151  +
        Self::deserialize(deserializer)
         152  +
    }
         153  +
}
  152    154   
impl MedicalScribeEncryptionSettings {
  153    155   
    /// Creates a new builder-style object to manufacture [`MedicalScribeEncryptionSettings`](crate::types::MedicalScribeEncryptionSettings).
  154    156   
    pub fn builder() -> crate::types::builders::MedicalScribeEncryptionSettingsBuilder {
  155    157   
        crate::types::builders::MedicalScribeEncryptionSettingsBuilder::default()
  156    158   
    }
  157    159   
}
  158    160   
  159    161   
/// A builder for [`MedicalScribeEncryptionSettings`](crate::types::MedicalScribeEncryptionSettings).
  160    162   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  161    163   
#[non_exhaustive]

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

@@ -49,49 +0,167 @@
   69     69   
    }
   70     70   
    /// Returns true if this is a [`SessionControlEvent`](crate::types::MedicalScribeInputStream::SessionControlEvent).
   71     71   
    pub fn is_session_control_event(&self) -> bool {
   72     72   
        self.as_session_control_event().is_ok()
   73     73   
    }
   74     74   
    /// Returns true if the enum instance is the `Unknown` variant.
   75     75   
    pub fn is_unknown(&self) -> bool {
   76     76   
        matches!(self, Self::Unknown)
   77     77   
    }
   78     78   
}
          79  +
static MEDICALSCRIBEINPUTSTREAM_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
          80  +
    "com.amazonaws.transcribestreaming#MedicalScribeInputStream",
          81  +
    "com.amazonaws.transcribestreaming",
          82  +
    "MedicalScribeInputStream",
          83  +
);
          84  +
static MEDICALSCRIBEINPUTSTREAM_MEMBER_AUDIOEVENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          85  +
    ::aws_smithy_schema::ShapeId::from_static(
          86  +
        "com.amazonaws.transcribestreaming#MedicalScribeInputStream$AudioEvent",
          87  +
        "com.amazonaws.transcribestreaming",
          88  +
        "MedicalScribeInputStream",
          89  +
    ),
          90  +
    ::aws_smithy_schema::ShapeType::Structure,
          91  +
    "AudioEvent",
          92  +
    0,
          93  +
);
          94  +
static MEDICALSCRIBEINPUTSTREAM_MEMBER_SESSIONCONTROLEVENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          95  +
    ::aws_smithy_schema::ShapeId::from_static(
          96  +
        "com.amazonaws.transcribestreaming#MedicalScribeInputStream$SessionControlEvent",
          97  +
        "com.amazonaws.transcribestreaming",
          98  +
        "MedicalScribeInputStream",
          99  +
    ),
         100  +
    ::aws_smithy_schema::ShapeType::Structure,
         101  +
    "SessionControlEvent",
         102  +
    1,
         103  +
);
         104  +
static MEDICALSCRIBEINPUTSTREAM_MEMBER_CONFIGURATIONEVENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         105  +
    ::aws_smithy_schema::ShapeId::from_static(
         106  +
        "com.amazonaws.transcribestreaming#MedicalScribeInputStream$ConfigurationEvent",
         107  +
        "com.amazonaws.transcribestreaming",
         108  +
        "MedicalScribeInputStream",
         109  +
    ),
         110  +
    ::aws_smithy_schema::ShapeType::Structure,
         111  +
    "ConfigurationEvent",
         112  +
    2,
         113  +
);
         114  +
static MEDICALSCRIBEINPUTSTREAM_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
         115  +
    MEDICALSCRIBEINPUTSTREAM_SCHEMA_ID,
         116  +
    ::aws_smithy_schema::ShapeType::Union,
         117  +
    &[
         118  +
        &MEDICALSCRIBEINPUTSTREAM_MEMBER_AUDIOEVENT,
         119  +
        &MEDICALSCRIBEINPUTSTREAM_MEMBER_SESSIONCONTROLEVENT,
         120  +
        &MEDICALSCRIBEINPUTSTREAM_MEMBER_CONFIGURATIONEVENT,
         121  +
    ],
         122  +
)
         123  +
.with_streaming();
         124  +
impl MedicalScribeInputStream {
         125  +
    /// The schema for this shape.
         126  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MEDICALSCRIBEINPUTSTREAM_SCHEMA;
         127  +
}
         128  +
impl ::aws_smithy_schema::serde::SerializableStruct for MedicalScribeInputStream {
         129  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
         130  +
    fn serialize_members(
         131  +
        &self,
         132  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
         133  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         134  +
        match self {
         135  +
            Self::AudioEvent(val) => {
         136  +
                ser.write_struct(&MEDICALSCRIBEINPUTSTREAM_MEMBER_AUDIOEVENT, val)?;
         137  +
            }
         138  +
            Self::SessionControlEvent(val) => {
         139  +
                ser.write_struct(&MEDICALSCRIBEINPUTSTREAM_MEMBER_SESSIONCONTROLEVENT, val)?;
         140  +
            }
         141  +
            Self::ConfigurationEvent(val) => {
         142  +
                ser.write_struct(&MEDICALSCRIBEINPUTSTREAM_MEMBER_CONFIGURATIONEVENT, val)?;
         143  +
            }
         144  +
            Self::Unknown => return Err(::aws_smithy_schema::serde::SerdeError::custom("cannot serialize unknown union variant")),
         145  +
        }
         146  +
        Ok(())
         147  +
    }
         148  +
}
         149  +
impl MedicalScribeInputStream {
         150  +
    /// Deserializes this union from a [`ShapeDeserializer`].
         151  +
    pub fn deserialize(
         152  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         153  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         154  +
        let mut result: ::std::option::Option<Self> = ::std::option::Option::None;
         155  +
        #[allow(unused_variables, unreachable_code, clippy::single_match, clippy::match_single_binding)]
         156  +
        deserializer.read_struct(&MEDICALSCRIBEINPUTSTREAM_SCHEMA, &mut |member, deser| {
         157  +
            result = ::std::option::Option::Some(match member.member_index() {
         158  +
                Some(0) => Self::AudioEvent(crate::types::MedicalScribeAudioEvent::deserialize(deser)?),
         159  +
                Some(1) => Self::SessionControlEvent(crate::types::MedicalScribeSessionControlEvent::deserialize(deser)?),
         160  +
                Some(2) => Self::ConfigurationEvent(crate::types::MedicalScribeConfigurationEvent::deserialize(deser)?),
         161  +
                _ => Self::Unknown,
         162  +
            });
         163  +
            Ok(())
         164  +
        })?;
         165  +
        result.ok_or_else(|| ::aws_smithy_schema::serde::SerdeError::custom("expected a union variant"))
         166  +
    }
         167  +
}

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

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

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

@@ -1,1 +108,119 @@
   19     19   
    "MedicalScribePostStreamAnalyticsResult",
   20     20   
);
   21     21   
static MEDICALSCRIBEPOSTSTREAMANALYTICSRESULT_MEMBER_CLINICAL_NOTE_GENERATION_RESULT: ::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#MedicalScribePostStreamAnalyticsResult$ClinicalNoteGenerationResult",
   25     25   
            "com.amazonaws.transcribestreaming",
   26     26   
            "MedicalScribePostStreamAnalyticsResult",
   27     27   
        ),
   28     28   
        ::aws_smithy_schema::ShapeType::Structure,
   29         -
        "clinical_note_generation_result",
          29  +
        "ClinicalNoteGenerationResult",
   30     30   
        0,
   31     31   
    );
   32     32   
static MEDICALSCRIBEPOSTSTREAMANALYTICSRESULT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   33     33   
    MEDICALSCRIBEPOSTSTREAMANALYTICSRESULT_SCHEMA_ID,
   34     34   
    ::aws_smithy_schema::ShapeType::Structure,
   35     35   
    &[&MEDICALSCRIBEPOSTSTREAMANALYTICSRESULT_MEMBER_CLINICAL_NOTE_GENERATION_RESULT],
   36     36   
);
   37     37   
impl MedicalScribePostStreamAnalyticsResult {
   38     38   
    /// The schema for this shape.
   39     39   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MEDICALSCRIBEPOSTSTREAMANALYTICSRESULT_SCHEMA;
   40     40   
}
   41     41   
impl ::aws_smithy_schema::serde::SerializableStruct for MedicalScribePostStreamAnalyticsResult {
   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_result {
   48     48   
            ser.write_struct(&MEDICALSCRIBEPOSTSTREAMANALYTICSRESULT_MEMBER_CLINICAL_NOTE_GENERATION_RESULT, val)?;
   49     49   
        }
   50     50   
        Ok(())
   51     51   
    }
   52     52   
}
   53     53   
impl MedicalScribePostStreamAnalyticsResult {
   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(&MEDICALSCRIBEPOSTSTREAMANALYTICSRESULT_SCHEMA, (), |_, member, deser| {
          67  +
        deserializer.read_struct(&MEDICALSCRIBEPOSTSTREAMANALYTICSRESULT_SCHEMA, &mut |member, deser| {
   68     68   
            match member.member_index() {
   69     69   
                Some(0) => {
   70     70   
                    builder.clinical_note_generation_result = Some(crate::types::ClinicalNoteGenerationResult::deserialize(deser)?);
   71     71   
                }
   72     72   
                _ => {}
   73     73   
            }
   74     74   
            Ok(())
   75     75   
        })?;
   76     76   
        Ok(builder.build())
   77     77   
    }
   78     78   
}
          79  +
impl MedicalScribePostStreamAnalyticsResult {
          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 MedicalScribePostStreamAnalyticsResult {
   80     91   
    /// Creates a new builder-style object to manufacture [`MedicalScribePostStreamAnalyticsResult`](crate::types::MedicalScribePostStreamAnalyticsResult).
   81     92   
    pub fn builder() -> crate::types::builders::MedicalScribePostStreamAnalyticsResultBuilder {
   82     93   
        crate::types::builders::MedicalScribePostStreamAnalyticsResultBuilder::default()
   83     94   
    }
   84     95   
}
   85     96   
   86     97   
/// A builder for [`MedicalScribePostStreamAnalyticsResult`](crate::types::MedicalScribePostStreamAnalyticsResult).
   87     98   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   88     99   
#[non_exhaustive]