AWS SDK

AWS SDK

rev. e063993ca0ab793f44c575dbe707d50a5e3e2406 (ignoring whitespace)

Files changed:

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

@@ -1,1 +105,117 @@
   13     13   
    "com.amazonaws.timestreamwrite",
   14     14   
    "ConflictException",
   15     15   
);
   16     16   
static CONFLICTEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   17     17   
    ::aws_smithy_schema::ShapeId::from_static(
   18     18   
        "com.amazonaws.timestreamwrite#ConflictException$Message",
   19     19   
        "com.amazonaws.timestreamwrite",
   20     20   
        "ConflictException",
   21     21   
    ),
   22     22   
    ::aws_smithy_schema::ShapeType::String,
   23         -
    "message",
          23  +
    "Message",
   24     24   
    0,
   25     25   
);
   26     26   
static CONFLICTEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   27     27   
    CONFLICTEXCEPTION_SCHEMA_ID,
   28     28   
    ::aws_smithy_schema::ShapeType::Structure,
   29     29   
    &[&CONFLICTEXCEPTION_MEMBER_MESSAGE],
   30     30   
);
   31     31   
impl ConflictException {
   32     32   
    /// The schema for this shape.
   33     33   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CONFLICTEXCEPTION_SCHEMA;
   34     34   
}
   35     35   
impl ::aws_smithy_schema::serde::SerializableStruct for ConflictException {
   36     36   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   37     37   
    fn serialize_members(
   38     38   
        &self,
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        {
   42     42   
            let val = &self.message;
   43     43   
            ser.write_string(&CONFLICTEXCEPTION_MEMBER_MESSAGE, val)?;
   44     44   
        }
   45     45   
        Ok(())
   46     46   
    }
   47     47   
}
   48     48   
impl ConflictException {
   49     49   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   50         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   51         -
        deserializer: &mut D,
          50  +
    pub fn deserialize(
          51  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   52     52   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   53     53   
        #[allow(unused_variables, unused_mut)]
   54     54   
        let mut builder = Self::builder();
   55     55   
        #[allow(
   56     56   
            unused_variables,
   57     57   
            unreachable_code,
   58     58   
            clippy::single_match,
   59     59   
            clippy::match_single_binding,
   60     60   
            clippy::diverging_sub_expression
   61     61   
        )]
   62         -
        deserializer.read_struct(&CONFLICTEXCEPTION_SCHEMA, (), |_, member, deser| {
          62  +
        deserializer.read_struct(&CONFLICTEXCEPTION_SCHEMA, &mut |member, deser| {
   63     63   
            match member.member_index() {
   64     64   
                Some(0) => {
   65     65   
                    builder.message = Some(deser.read_string(member)?);
   66     66   
                }
   67     67   
                _ => {}
   68     68   
            }
   69     69   
            Ok(())
   70     70   
        })?;
          71  +
        builder.message = builder.message.or(Some(String::new()));
   71     72   
        builder
   72     73   
            .build()
   73     74   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   74     75   
    }
   75     76   
}
          77  +
impl ConflictException {
          78  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          79  +
    pub fn deserialize_with_response(
          80  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          81  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          82  +
        _status: u16,
          83  +
        _body: &[u8],
          84  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          85  +
        Self::deserialize(deserializer)
          86  +
    }
          87  +
}
   76     88   
impl ConflictException {
   77     89   
    /// Returns the error message.
   78     90   
    pub fn message(&self) -> &str {
   79     91   
        &self.message
   80     92   
    }
   81     93   
}
   82     94   
impl ::std::fmt::Display for ConflictException {
   83     95   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   84     96   
        ::std::write!(f, "ConflictException")?;
   85     97   
        {

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/error/_internal_server_exception.rs

@@ -1,1 +105,117 @@
   13     13   
    "com.amazonaws.timestreamwrite",
   14     14   
    "InternalServerException",
   15     15   
);
   16     16   
static INTERNALSERVEREXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   17     17   
    ::aws_smithy_schema::ShapeId::from_static(
   18     18   
        "com.amazonaws.timestreamwrite#InternalServerException$Message",
   19     19   
        "com.amazonaws.timestreamwrite",
   20     20   
        "InternalServerException",
   21     21   
    ),
   22     22   
    ::aws_smithy_schema::ShapeType::String,
   23         -
    "message",
          23  +
    "Message",
   24     24   
    0,
   25     25   
);
   26     26   
static INTERNALSERVEREXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   27     27   
    INTERNALSERVEREXCEPTION_SCHEMA_ID,
   28     28   
    ::aws_smithy_schema::ShapeType::Structure,
   29     29   
    &[&INTERNALSERVEREXCEPTION_MEMBER_MESSAGE],
   30     30   
);
   31     31   
impl InternalServerException {
   32     32   
    /// The schema for this shape.
   33     33   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INTERNALSERVEREXCEPTION_SCHEMA;
   34     34   
}
   35     35   
impl ::aws_smithy_schema::serde::SerializableStruct for InternalServerException {
   36     36   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   37     37   
    fn serialize_members(
   38     38   
        &self,
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        {
   42     42   
            let val = &self.message;
   43     43   
            ser.write_string(&INTERNALSERVEREXCEPTION_MEMBER_MESSAGE, val)?;
   44     44   
        }
   45     45   
        Ok(())
   46     46   
    }
   47     47   
}
   48     48   
impl InternalServerException {
   49     49   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   50         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   51         -
        deserializer: &mut D,
          50  +
    pub fn deserialize(
          51  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   52     52   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   53     53   
        #[allow(unused_variables, unused_mut)]
   54     54   
        let mut builder = Self::builder();
   55     55   
        #[allow(
   56     56   
            unused_variables,
   57     57   
            unreachable_code,
   58     58   
            clippy::single_match,
   59     59   
            clippy::match_single_binding,
   60     60   
            clippy::diverging_sub_expression
   61     61   
        )]
   62         -
        deserializer.read_struct(&INTERNALSERVEREXCEPTION_SCHEMA, (), |_, member, deser| {
          62  +
        deserializer.read_struct(&INTERNALSERVEREXCEPTION_SCHEMA, &mut |member, deser| {
   63     63   
            match member.member_index() {
   64     64   
                Some(0) => {
   65     65   
                    builder.message = Some(deser.read_string(member)?);
   66     66   
                }
   67     67   
                _ => {}
   68     68   
            }
   69     69   
            Ok(())
   70     70   
        })?;
          71  +
        builder.message = builder.message.or(Some(String::new()));
   71     72   
        builder
   72     73   
            .build()
   73     74   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   74     75   
    }
   75     76   
}
          77  +
impl InternalServerException {
          78  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          79  +
    pub fn deserialize_with_response(
          80  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          81  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          82  +
        _status: u16,
          83  +
        _body: &[u8],
          84  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          85  +
        Self::deserialize(deserializer)
          86  +
    }
          87  +
}
   76     88   
impl InternalServerException {
   77     89   
    /// Returns the error message.
   78     90   
    pub fn message(&self) -> &str {
   79     91   
        &self.message
   80     92   
    }
   81     93   
}
   82     94   
impl ::std::fmt::Display for InternalServerException {
   83     95   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   84     96   
        ::std::write!(f, "InternalServerException")?;
   85     97   
        {

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/error/_invalid_endpoint_exception.rs

@@ -1,1 +102,113 @@
   13     13   
    "com.amazonaws.timestreamwrite",
   14     14   
    "InvalidEndpointException",
   15     15   
);
   16     16   
static INVALIDENDPOINTEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   17     17   
    ::aws_smithy_schema::ShapeId::from_static(
   18     18   
        "com.amazonaws.timestreamwrite#InvalidEndpointException$Message",
   19     19   
        "com.amazonaws.timestreamwrite",
   20     20   
        "InvalidEndpointException",
   21     21   
    ),
   22     22   
    ::aws_smithy_schema::ShapeType::String,
   23         -
    "message",
          23  +
    "Message",
   24     24   
    0,
   25     25   
);
   26     26   
static INVALIDENDPOINTEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   27     27   
    INVALIDENDPOINTEXCEPTION_SCHEMA_ID,
   28     28   
    ::aws_smithy_schema::ShapeType::Structure,
   29     29   
    &[&INVALIDENDPOINTEXCEPTION_MEMBER_MESSAGE],
   30     30   
);
   31     31   
impl InvalidEndpointException {
   32     32   
    /// The schema for this shape.
   33     33   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INVALIDENDPOINTEXCEPTION_SCHEMA;
   34     34   
}
   35     35   
impl ::aws_smithy_schema::serde::SerializableStruct for InvalidEndpointException {
   36     36   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   37     37   
    fn serialize_members(
   38     38   
        &self,
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&INVALIDENDPOINTEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl InvalidEndpointException {
   48     48   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   49         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   50         -
        deserializer: &mut D,
          49  +
    pub fn deserialize(
          50  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   51     51   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        #[allow(unused_variables, unused_mut)]
   53     53   
        let mut builder = Self::builder();
   54     54   
        #[allow(
   55     55   
            unused_variables,
   56     56   
            unreachable_code,
   57     57   
            clippy::single_match,
   58     58   
            clippy::match_single_binding,
   59     59   
            clippy::diverging_sub_expression
   60     60   
        )]
   61         -
        deserializer.read_struct(&INVALIDENDPOINTEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&INVALIDENDPOINTEXCEPTION_SCHEMA, &mut |member, deser| {
   62     62   
            match member.member_index() {
   63     63   
                Some(0) => {
   64     64   
                    builder.message = Some(deser.read_string(member)?);
   65     65   
                }
   66     66   
                _ => {}
   67     67   
            }
   68     68   
            Ok(())
   69     69   
        })?;
   70     70   
        Ok(builder.build())
   71     71   
    }
   72     72   
}
          73  +
impl InvalidEndpointException {
          74  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          75  +
    pub fn deserialize_with_response(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          77  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          78  +
        _status: u16,
          79  +
        _body: &[u8],
          80  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          81  +
        Self::deserialize(deserializer)
          82  +
    }
          83  +
}
   73     84   
impl InvalidEndpointException {
   74     85   
    /// Returns the error message.
   75     86   
    pub fn message(&self) -> ::std::option::Option<&str> {
   76     87   
        self.message.as_deref()
   77     88   
    }
   78     89   
}
   79     90   
impl ::std::fmt::Display for InvalidEndpointException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "InvalidEndpointException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/error/_rejected_records_exception.rs

@@ -19,19 +165,173 @@
   39     39   
    "com.amazonaws.timestreamwrite",
   40     40   
    "RejectedRecordsException",
   41     41   
);
   42     42   
static REJECTEDRECORDSEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   43     43   
    ::aws_smithy_schema::ShapeId::from_static(
   44     44   
        "com.amazonaws.timestreamwrite#RejectedRecordsException$Message",
   45     45   
        "com.amazonaws.timestreamwrite",
   46     46   
        "RejectedRecordsException",
   47     47   
    ),
   48     48   
    ::aws_smithy_schema::ShapeType::String,
   49         -
    "message",
          49  +
    "Message",
   50     50   
    0,
   51     51   
);
   52     52   
static REJECTEDRECORDSEXCEPTION_MEMBER_REJECTED_RECORDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   53     53   
    ::aws_smithy_schema::ShapeId::from_static(
   54     54   
        "com.amazonaws.timestreamwrite#RejectedRecordsException$RejectedRecords",
   55     55   
        "com.amazonaws.timestreamwrite",
   56     56   
        "RejectedRecordsException",
   57     57   
    ),
   58     58   
    ::aws_smithy_schema::ShapeType::List,
   59         -
    "rejected_records",
          59  +
    "RejectedRecords",
   60     60   
    1,
   61     61   
);
   62     62   
static REJECTEDRECORDSEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   63     63   
    REJECTEDRECORDSEXCEPTION_SCHEMA_ID,
   64     64   
    ::aws_smithy_schema::ShapeType::Structure,
   65     65   
    &[
   66     66   
        &REJECTEDRECORDSEXCEPTION_MEMBER_MESSAGE,
   67     67   
        &REJECTEDRECORDSEXCEPTION_MEMBER_REJECTED_RECORDS,
   68     68   
    ],
   69     69   
);
   70     70   
impl RejectedRecordsException {
   71     71   
    /// The schema for this shape.
   72     72   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &REJECTEDRECORDSEXCEPTION_SCHEMA;
   73     73   
}
   74     74   
impl ::aws_smithy_schema::serde::SerializableStruct for RejectedRecordsException {
   75     75   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   76     76   
    fn serialize_members(
   77     77   
        &self,
   78     78   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   79     79   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   80     80   
        if let Some(ref val) = self.message {
   81     81   
            ser.write_string(&REJECTEDRECORDSEXCEPTION_MEMBER_MESSAGE, val)?;
   82     82   
        }
   83     83   
        if let Some(ref val) = self.rejected_records {
   84     84   
            ser.write_list(
   85     85   
                &REJECTEDRECORDSEXCEPTION_MEMBER_REJECTED_RECORDS,
   86     86   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   87     87   
                    for item in val {
   88     88   
                        ser.write_struct(crate::types::RejectedRecord::SCHEMA, item)?;
   89     89   
                    }
   90     90   
                    Ok(())
   91     91   
                },
   92     92   
            )?;
   93     93   
        }
   94     94   
        Ok(())
   95     95   
    }
   96     96   
}
   97     97   
impl RejectedRecordsException {
   98     98   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   99         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  100         -
        deserializer: &mut D,
          99  +
    pub fn deserialize(
         100  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  101    101   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  102    102   
        #[allow(unused_variables, unused_mut)]
  103    103   
        let mut builder = Self::builder();
  104    104   
        #[allow(
  105    105   
            unused_variables,
  106    106   
            unreachable_code,
  107    107   
            clippy::single_match,
  108    108   
            clippy::match_single_binding,
  109    109   
            clippy::diverging_sub_expression
  110    110   
        )]
  111         -
        deserializer.read_struct(&REJECTEDRECORDSEXCEPTION_SCHEMA, (), |_, member, deser| {
         111  +
        deserializer.read_struct(&REJECTEDRECORDSEXCEPTION_SCHEMA, &mut |member, deser| {
  112    112   
            match member.member_index() {
  113    113   
                Some(0) => {
  114    114   
                    builder.message = Some(deser.read_string(member)?);
  115    115   
                }
  116    116   
                Some(1) => {
  117    117   
                    builder.rejected_records = Some({
  118         -
                        let container = if let Some(cap) = deser.container_size() {
  119         -
                            Vec::with_capacity(cap)
  120         -
                        } else {
  121         -
                            Vec::new()
  122         -
                        };
  123         -
                        deser.read_list(member, container, |mut list, deser| {
  124         -
                            list.push(crate::types::RejectedRecord::deserialize(deser)?);
  125         -
                            Ok(list)
  126         -
                        })?
         118  +
                        let mut container = Vec::new();
         119  +
                        deser.read_list(member, &mut |deser| {
         120  +
                            container.push(crate::types::RejectedRecord::deserialize(deser)?);
         121  +
                            Ok(())
         122  +
                        })?;
         123  +
                        container
  127    124   
                    });
  128    125   
                }
  129    126   
                _ => {}
  130    127   
            }
  131    128   
            Ok(())
  132    129   
        })?;
  133    130   
        Ok(builder.build())
  134    131   
    }
  135    132   
}
         133  +
impl RejectedRecordsException {
         134  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         135  +
    pub fn deserialize_with_response(
         136  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         137  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         138  +
        _status: u16,
         139  +
        _body: &[u8],
         140  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         141  +
        Self::deserialize(deserializer)
         142  +
    }
         143  +
}
  136    144   
impl RejectedRecordsException {
  137    145   
    /// Returns the error message.
  138    146   
    pub fn message(&self) -> ::std::option::Option<&str> {
  139    147   
        self.message.as_deref()
  140    148   
    }
  141    149   
}
  142    150   
impl ::std::fmt::Display for RejectedRecordsException {
  143    151   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  144    152   
        ::std::write!(f, "RejectedRecordsException")?;
  145    153   
        if let ::std::option::Option::Some(inner_1) = &self.message {

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

@@ -1,1 +102,113 @@
   13     13   
    "com.amazonaws.timestreamwrite",
   14     14   
    "ResourceNotFoundException",
   15     15   
);
   16     16   
static RESOURCENOTFOUNDEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   17     17   
    ::aws_smithy_schema::ShapeId::from_static(
   18     18   
        "com.amazonaws.timestreamwrite#ResourceNotFoundException$Message",
   19     19   
        "com.amazonaws.timestreamwrite",
   20     20   
        "ResourceNotFoundException",
   21     21   
    ),
   22     22   
    ::aws_smithy_schema::ShapeType::String,
   23         -
    "message",
          23  +
    "Message",
   24     24   
    0,
   25     25   
);
   26     26   
static RESOURCENOTFOUNDEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   27     27   
    RESOURCENOTFOUNDEXCEPTION_SCHEMA_ID,
   28     28   
    ::aws_smithy_schema::ShapeType::Structure,
   29     29   
    &[&RESOURCENOTFOUNDEXCEPTION_MEMBER_MESSAGE],
   30     30   
);
   31     31   
impl ResourceNotFoundException {
   32     32   
    /// The schema for this shape.
   33     33   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RESOURCENOTFOUNDEXCEPTION_SCHEMA;
   34     34   
}
   35     35   
impl ::aws_smithy_schema::serde::SerializableStruct for ResourceNotFoundException {
   36     36   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   37     37   
    fn serialize_members(
   38     38   
        &self,
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&RESOURCENOTFOUNDEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl ResourceNotFoundException {
   48     48   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   49         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   50         -
        deserializer: &mut D,
          49  +
    pub fn deserialize(
          50  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   51     51   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        #[allow(unused_variables, unused_mut)]
   53     53   
        let mut builder = Self::builder();
   54     54   
        #[allow(
   55     55   
            unused_variables,
   56     56   
            unreachable_code,
   57     57   
            clippy::single_match,
   58     58   
            clippy::match_single_binding,
   59     59   
            clippy::diverging_sub_expression
   60     60   
        )]
   61         -
        deserializer.read_struct(&RESOURCENOTFOUNDEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&RESOURCENOTFOUNDEXCEPTION_SCHEMA, &mut |member, deser| {
   62     62   
            match member.member_index() {
   63     63   
                Some(0) => {
   64     64   
                    builder.message = Some(deser.read_string(member)?);
   65     65   
                }
   66     66   
                _ => {}
   67     67   
            }
   68     68   
            Ok(())
   69     69   
        })?;
   70     70   
        Ok(builder.build())
   71     71   
    }
   72     72   
}
          73  +
impl ResourceNotFoundException {
          74  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          75  +
    pub fn deserialize_with_response(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          77  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          78  +
        _status: u16,
          79  +
        _body: &[u8],
          80  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          81  +
        Self::deserialize(deserializer)
          82  +
    }
          83  +
}
   73     84   
impl ResourceNotFoundException {
   74     85   
    /// Returns the error message.
   75     86   
    pub fn message(&self) -> ::std::option::Option<&str> {
   76     87   
        self.message.as_deref()
   77     88   
    }
   78     89   
}
   79     90   
impl ::std::fmt::Display for ResourceNotFoundException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "ResourceNotFoundException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/error/_service_quota_exceeded_exception.rs

@@ -1,1 +102,113 @@
   13     13   
    "com.amazonaws.timestreamwrite",
   14     14   
    "ServiceQuotaExceededException",
   15     15   
);
   16     16   
static SERVICEQUOTAEXCEEDEDEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   17     17   
    ::aws_smithy_schema::ShapeId::from_static(
   18     18   
        "com.amazonaws.timestreamwrite#ServiceQuotaExceededException$Message",
   19     19   
        "com.amazonaws.timestreamwrite",
   20     20   
        "ServiceQuotaExceededException",
   21     21   
    ),
   22     22   
    ::aws_smithy_schema::ShapeType::String,
   23         -
    "message",
          23  +
    "Message",
   24     24   
    0,
   25     25   
);
   26     26   
static SERVICEQUOTAEXCEEDEDEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   27     27   
    SERVICEQUOTAEXCEEDEDEXCEPTION_SCHEMA_ID,
   28     28   
    ::aws_smithy_schema::ShapeType::Structure,
   29     29   
    &[&SERVICEQUOTAEXCEEDEDEXCEPTION_MEMBER_MESSAGE],
   30     30   
);
   31     31   
impl ServiceQuotaExceededException {
   32     32   
    /// The schema for this shape.
   33     33   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SERVICEQUOTAEXCEEDEDEXCEPTION_SCHEMA;
   34     34   
}
   35     35   
impl ::aws_smithy_schema::serde::SerializableStruct for ServiceQuotaExceededException {
   36     36   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   37     37   
    fn serialize_members(
   38     38   
        &self,
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&SERVICEQUOTAEXCEEDEDEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl ServiceQuotaExceededException {
   48     48   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   49         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   50         -
        deserializer: &mut D,
          49  +
    pub fn deserialize(
          50  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   51     51   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        #[allow(unused_variables, unused_mut)]
   53     53   
        let mut builder = Self::builder();
   54     54   
        #[allow(
   55     55   
            unused_variables,
   56     56   
            unreachable_code,
   57     57   
            clippy::single_match,
   58     58   
            clippy::match_single_binding,
   59     59   
            clippy::diverging_sub_expression
   60     60   
        )]
   61         -
        deserializer.read_struct(&SERVICEQUOTAEXCEEDEDEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&SERVICEQUOTAEXCEEDEDEXCEPTION_SCHEMA, &mut |member, deser| {
   62     62   
            match member.member_index() {
   63     63   
                Some(0) => {
   64     64   
                    builder.message = Some(deser.read_string(member)?);
   65     65   
                }
   66     66   
                _ => {}
   67     67   
            }
   68     68   
            Ok(())
   69     69   
        })?;
   70     70   
        Ok(builder.build())
   71     71   
    }
   72     72   
}
          73  +
impl ServiceQuotaExceededException {
          74  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          75  +
    pub fn deserialize_with_response(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          77  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          78  +
        _status: u16,
          79  +
        _body: &[u8],
          80  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          81  +
        Self::deserialize(deserializer)
          82  +
    }
          83  +
}
   73     84   
impl ServiceQuotaExceededException {
   74     85   
    /// Returns the error message.
   75     86   
    pub fn message(&self) -> ::std::option::Option<&str> {
   76     87   
        self.message.as_deref()
   77     88   
    }
   78     89   
}
   79     90   
impl ::std::fmt::Display for ServiceQuotaExceededException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "ServiceQuotaExceededException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/error/_throttling_exception.rs

@@ -1,1 +105,117 @@
   13     13   
    "com.amazonaws.timestreamwrite",
   14     14   
    "ThrottlingException",
   15     15   
);
   16     16   
static THROTTLINGEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   17     17   
    ::aws_smithy_schema::ShapeId::from_static(
   18     18   
        "com.amazonaws.timestreamwrite#ThrottlingException$Message",
   19     19   
        "com.amazonaws.timestreamwrite",
   20     20   
        "ThrottlingException",
   21     21   
    ),
   22     22   
    ::aws_smithy_schema::ShapeType::String,
   23         -
    "message",
          23  +
    "Message",
   24     24   
    0,
   25     25   
);
   26     26   
static THROTTLINGEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   27     27   
    THROTTLINGEXCEPTION_SCHEMA_ID,
   28     28   
    ::aws_smithy_schema::ShapeType::Structure,
   29     29   
    &[&THROTTLINGEXCEPTION_MEMBER_MESSAGE],
   30     30   
);
   31     31   
impl ThrottlingException {
   32     32   
    /// The schema for this shape.
   33     33   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &THROTTLINGEXCEPTION_SCHEMA;
   34     34   
}
   35     35   
impl ::aws_smithy_schema::serde::SerializableStruct for ThrottlingException {
   36     36   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   37     37   
    fn serialize_members(
   38     38   
        &self,
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        {
   42     42   
            let val = &self.message;
   43     43   
            ser.write_string(&THROTTLINGEXCEPTION_MEMBER_MESSAGE, val)?;
   44     44   
        }
   45     45   
        Ok(())
   46     46   
    }
   47     47   
}
   48     48   
impl ThrottlingException {
   49     49   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   50         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   51         -
        deserializer: &mut D,
          50  +
    pub fn deserialize(
          51  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   52     52   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   53     53   
        #[allow(unused_variables, unused_mut)]
   54     54   
        let mut builder = Self::builder();
   55     55   
        #[allow(
   56     56   
            unused_variables,
   57     57   
            unreachable_code,
   58     58   
            clippy::single_match,
   59     59   
            clippy::match_single_binding,
   60     60   
            clippy::diverging_sub_expression
   61     61   
        )]
   62         -
        deserializer.read_struct(&THROTTLINGEXCEPTION_SCHEMA, (), |_, member, deser| {
          62  +
        deserializer.read_struct(&THROTTLINGEXCEPTION_SCHEMA, &mut |member, deser| {
   63     63   
            match member.member_index() {
   64     64   
                Some(0) => {
   65     65   
                    builder.message = Some(deser.read_string(member)?);
   66     66   
                }
   67     67   
                _ => {}
   68     68   
            }
   69     69   
            Ok(())
   70     70   
        })?;
          71  +
        builder.message = builder.message.or(Some(String::new()));
   71     72   
        builder
   72     73   
            .build()
   73     74   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   74     75   
    }
   75     76   
}
          77  +
impl ThrottlingException {
          78  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          79  +
    pub fn deserialize_with_response(
          80  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          81  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          82  +
        _status: u16,
          83  +
        _body: &[u8],
          84  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          85  +
        Self::deserialize(deserializer)
          86  +
    }
          87  +
}
   76     88   
impl ThrottlingException {
   77     89   
    /// Returns the error message.
   78     90   
    pub fn message(&self) -> &str {
   79     91   
        &self.message
   80     92   
    }
   81     93   
}
   82     94   
impl ::std::fmt::Display for ThrottlingException {
   83     95   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   84     96   
        ::std::write!(f, "ThrottlingException")?;
   85     97   
        {

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/types/error/_validation_exception.rs

@@ -1,1 +105,117 @@
   13     13   
    "com.amazonaws.timestreamwrite",
   14     14   
    "ValidationException",
   15     15   
);
   16     16   
static VALIDATIONEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   17     17   
    ::aws_smithy_schema::ShapeId::from_static(
   18     18   
        "com.amazonaws.timestreamwrite#ValidationException$Message",
   19     19   
        "com.amazonaws.timestreamwrite",
   20     20   
        "ValidationException",
   21     21   
    ),
   22     22   
    ::aws_smithy_schema::ShapeType::String,
   23         -
    "message",
          23  +
    "Message",
   24     24   
    0,
   25     25   
);
   26     26   
static VALIDATIONEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   27     27   
    VALIDATIONEXCEPTION_SCHEMA_ID,
   28     28   
    ::aws_smithy_schema::ShapeType::Structure,
   29     29   
    &[&VALIDATIONEXCEPTION_MEMBER_MESSAGE],
   30     30   
);
   31     31   
impl ValidationException {
   32     32   
    /// The schema for this shape.
   33     33   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &VALIDATIONEXCEPTION_SCHEMA;
   34     34   
}
   35     35   
impl ::aws_smithy_schema::serde::SerializableStruct for ValidationException {
   36     36   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   37     37   
    fn serialize_members(
   38     38   
        &self,
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        {
   42     42   
            let val = &self.message;
   43     43   
            ser.write_string(&VALIDATIONEXCEPTION_MEMBER_MESSAGE, val)?;
   44     44   
        }
   45     45   
        Ok(())
   46     46   
    }
   47     47   
}
   48     48   
impl ValidationException {
   49     49   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   50         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   51         -
        deserializer: &mut D,
          50  +
    pub fn deserialize(
          51  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   52     52   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   53     53   
        #[allow(unused_variables, unused_mut)]
   54     54   
        let mut builder = Self::builder();
   55     55   
        #[allow(
   56     56   
            unused_variables,
   57     57   
            unreachable_code,
   58     58   
            clippy::single_match,
   59     59   
            clippy::match_single_binding,
   60     60   
            clippy::diverging_sub_expression
   61     61   
        )]
   62         -
        deserializer.read_struct(&VALIDATIONEXCEPTION_SCHEMA, (), |_, member, deser| {
          62  +
        deserializer.read_struct(&VALIDATIONEXCEPTION_SCHEMA, &mut |member, deser| {
   63     63   
            match member.member_index() {
   64     64   
                Some(0) => {
   65     65   
                    builder.message = Some(deser.read_string(member)?);
   66     66   
                }
   67     67   
                _ => {}
   68     68   
            }
   69     69   
            Ok(())
   70     70   
        })?;
          71  +
        builder.message = builder.message.or(Some(String::new()));
   71     72   
        builder
   72     73   
            .build()
   73     74   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   74     75   
    }
   75     76   
}
          77  +
impl ValidationException {
          78  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          79  +
    pub fn deserialize_with_response(
          80  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          81  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          82  +
        _status: u16,
          83  +
        _body: &[u8],
          84  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          85  +
        Self::deserialize(deserializer)
          86  +
    }
          87  +
}
   76     88   
impl ValidationException {
   77     89   
    /// Returns the error message.
   78     90   
    pub fn message(&self) -> &str {
   79     91   
        &self.message
   80     92   
    }
   81     93   
}
   82     94   
impl ::std::fmt::Display for ValidationException {
   83     95   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   84     96   
        ::std::write!(f, "ValidationException")?;
   85     97   
        {

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/Cargo.toml

@@ -1,1 +170,170 @@
   15     15   
[package.metadata.docs.rs]
   16     16   
all-features = true
   17     17   
targets = ["x86_64-unknown-linux-gnu"]
   18     18   
[dependencies.aws-credential-types]
   19     19   
path = "../aws-credential-types"
   20     20   
version = "1.2.14"
   21     21   
   22     22   
[dependencies.aws-runtime]
   23     23   
path = "../aws-runtime"
   24     24   
features = ["event-stream"]
   25         -
version = "1.7.3"
          25  +
version = "1.7.4"
   26     26   
   27     27   
[dependencies.aws-sigv4]
   28     28   
path = "../aws-sigv4"
   29     29   
version = "1.4.2"
   30     30   
   31     31   
[dependencies.aws-smithy-async]
   32     32   
path = "../aws-smithy-async"
   33     33   
version = "1.2.14"
   34     34   
   35     35   
[dependencies.aws-smithy-eventstream]
   36     36   
path = "../aws-smithy-eventstream"
   37     37   
version = "0.60.20"
   38     38   
   39     39   
[dependencies.aws-smithy-http]
   40     40   
path = "../aws-smithy-http"
   41     41   
features = ["event-stream"]
   42     42   
version = "0.63.6"
   43     43   
   44     44   
[dependencies.aws-smithy-json]
   45     45   
path = "../aws-smithy-json"
   46     46   
version = "0.62.6"
   47     47   
   48     48   
[dependencies.aws-smithy-observability]
   49     49   
path = "../aws-smithy-observability"
   50     50   
version = "0.2.6"
   51     51   
   52     52   
[dependencies.aws-smithy-runtime]
   53     53   
path = "../aws-smithy-runtime"
   54     54   
features = ["client"]
   55         -
version = "1.10.3"
          55  +
version = "1.10.4"
   56     56   
   57     57   
[dependencies.aws-smithy-runtime-api]
   58     58   
path = "../aws-smithy-runtime-api"
   59     59   
features = ["client", "http-1x"]
   60         -
version = "1.11.6"
          60  +
version = "1.11.7"
   61     61   
   62     62   
[dependencies.aws-smithy-schema]
   63     63   
path = "../aws-smithy-schema"
   64     64   
version = "1.0.0"
   65     65   
   66     66   
[dependencies.aws-smithy-types]
   67     67   
path = "../aws-smithy-types"
   68     68   
features = ["http-body-1-x"]
   69     69   
version = "1.4.7"
   70     70   
   71     71   
[dependencies.aws-types]
   72     72   
path = "../aws-types"
   73     73   
version = "1.4.0"
   74     74   
   75     75   
[dependencies.bytes]
   76     76   
version = "1.4.0"
   77     77   
   78     78   
[dependencies.fastrand]
   79     79   
version = "2.0.0"
   80     80   
   81     81   
[dependencies.http]
   82     82   
version = "0.2.9"
   83     83   
   84     84   
[dependencies.http-1x]
   85     85   
version = "1"
   86     86   
package = "http"
   87     87   
   88     88   
[dependencies.http-body-util]
   89     89   
version = "0.1.3"
   90     90   
   91     91   
[dependencies.regex-lite]
   92     92   
version = "0.1.5"
   93     93   
   94     94   
[dependencies.tracing]
   95     95   
version = "0.1"
   96     96   
[dev-dependencies.async-stream]
   97     97   
version = "0.3.0"
   98     98   
   99     99   
[dev-dependencies.aws-config]
  100    100   
path = "../aws-config"
  101    101   
version = "1.9.0"
  102    102   
  103    103   
[dev-dependencies.aws-credential-types]
  104    104   
path = "../aws-credential-types"
  105    105   
features = ["test-util"]
  106    106   
version = "1.2.14"
  107    107   
  108    108   
[dev-dependencies.aws-runtime]
  109    109   
path = "../aws-runtime"
  110    110   
features = ["test-util"]
  111         -
version = "1.7.3"
         111  +
version = "1.7.4"
  112    112   
  113    113   
[dev-dependencies.aws-smithy-async]
  114    114   
path = "../aws-smithy-async"
  115    115   
features = ["test-util"]
  116    116   
version = "1.2.14"
  117    117   
  118    118   
[dev-dependencies.aws-smithy-eventstream]
  119    119   
path = "../aws-smithy-eventstream"
  120    120   
features = ["test-util"]
  121    121   
version = "0.60.20"
  122    122   
  123    123   
[dev-dependencies.aws-smithy-http-client]
  124    124   
path = "../aws-smithy-http-client"
  125    125   
features = ["test-util", "wire-mock"]
  126    126   
version = "1.1.12"
  127    127   
  128    128   
[dev-dependencies.aws-smithy-protocol-test]
  129    129   
path = "../aws-smithy-protocol-test"
  130    130   
version = "0.63.14"
  131    131   
  132    132   
[dev-dependencies.aws-smithy-runtime]
  133    133   
path = "../aws-smithy-runtime"
  134    134   
features = ["test-util"]
  135         -
version = "1.10.3"
         135  +
version = "1.10.4"
  136    136   
  137    137   
[dev-dependencies.aws-smithy-runtime-api]
  138    138   
path = "../aws-smithy-runtime-api"
  139    139   
features = ["test-util"]
  140         -
version = "1.11.6"
         140  +
version = "1.11.7"
  141    141   
  142    142   
[dev-dependencies.aws-smithy-types]
  143    143   
path = "../aws-smithy-types"
  144    144   
features = ["http-body-1-x", "test-util"]
  145    145   
version = "1.4.7"
  146    146   
  147    147   
[dev-dependencies.futures-core]
  148    148   
version = "0.3.25"
  149    149   
  150    150   
[dev-dependencies.futures-util]

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

@@ -23,23 +82,86 @@
   43     43   
            config: self.cloneable.clone(),
   44     44   
            runtime_components: self.runtime_components.clone(),
   45     45   
            runtime_plugins: self.runtime_plugins.clone(),
   46     46   
            behavior_version: self.behavior_version,
   47     47   
        }
   48     48   
    }
   49     49   
    /// Return a reference to the stalled stream protection configuration contained in this config, if any.
   50     50   
    pub fn stalled_stream_protection(&self) -> ::std::option::Option<&crate::config::StalledStreamProtectionConfig> {
   51     51   
        self.config.load::<crate::config::StalledStreamProtectionConfig>()
   52     52   
    }
          53  +
    /// Returns the client protocol used for serialization and deserialization.
          54  +
    pub fn protocol(&self) -> ::std::option::Option<&::aws_smithy_schema::protocol::SharedClientProtocol> {
          55  +
        self.config.load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
          56  +
    }
   53     57   
    /// Return the [`SharedHttpClient`](crate::config::SharedHttpClient) to use when making requests, if any.
   54     58   
    pub fn http_client(&self) -> Option<crate::config::SharedHttpClient> {
   55     59   
        self.runtime_components.http_client()
   56     60   
    }
   57     61   
    /// Return the auth schemes configured on this service config
   58     62   
    pub fn auth_schemes(&self) -> impl Iterator<Item = ::aws_smithy_runtime_api::client::auth::SharedAuthScheme> + '_ {
   59     63   
        self.runtime_components.auth_schemes()
   60     64   
    }
   61     65   
   62     66   
    /// Return the auth scheme resolver configured on this service config
@@ -153,157 +238,261 @@
  173    177   
    ///
  174    178   
    pub fn new() -> Self {
  175    179   
        Self::default()
  176    180   
    }
  177    181   
    /// Constructs a config builder from the given `config_bag`, setting only fields stored in the config bag,
  178    182   
    /// but not those in runtime components.
  179    183   
    #[allow(unused)]
  180    184   
    pub(crate) fn from_config_bag(config_bag: &::aws_smithy_types::config_bag::ConfigBag) -> Self {
  181    185   
        let mut builder = Self::new();
  182    186   
        builder.set_stalled_stream_protection(config_bag.load::<crate::config::StalledStreamProtectionConfig>().cloned());
         187  +
        if let ::std::option::Option::Some(protocol) = config_bag.load::<::aws_smithy_schema::protocol::SharedClientProtocol>().cloned() {
         188  +
            builder.set_protocol(::std::option::Option::Some(protocol));
         189  +
        }
  183    190   
        builder.set_auth_scheme_preference(config_bag.load::<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>().cloned());
  184    191   
        builder.set_retry_config(config_bag.load::<::aws_smithy_types::retry::RetryConfig>().cloned());
  185    192   
        builder.set_timeout_config(config_bag.load::<::aws_smithy_types::timeout::TimeoutConfig>().cloned());
  186    193   
        builder.set_retry_partition(config_bag.load::<::aws_smithy_runtime::client::retries::RetryPartition>().cloned());
  187    194   
        builder.set_app_name(config_bag.load::<::aws_types::app_name::AppName>().cloned());
  188    195   
        builder.set_endpoint_url(config_bag.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()));
  189    196   
        builder.set_use_dual_stack(config_bag.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0));
  190    197   
        builder.set_use_fips(config_bag.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0));
  191    198   
        builder.set_region(config_bag.load::<crate::config::Region>().cloned());
  192    199   
        builder
  193    200   
    }
  194    201   
    /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
  195    202   
    /// to configure protection for stalled streams.
  196    203   
    pub fn stalled_stream_protection(mut self, stalled_stream_protection_config: crate::config::StalledStreamProtectionConfig) -> Self {
  197    204   
        self.set_stalled_stream_protection(::std::option::Option::Some(stalled_stream_protection_config));
  198    205   
        self
  199    206   
    }
  200    207   
    /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
  201    208   
    /// to configure protection for stalled streams.
  202    209   
    pub fn set_stalled_stream_protection(
  203    210   
        &mut self,
  204    211   
        stalled_stream_protection_config: ::std::option::Option<crate::config::StalledStreamProtectionConfig>,
  205    212   
    ) -> &mut Self {
  206    213   
        self.config.store_or_unset(stalled_stream_protection_config);
  207    214   
        self
  208    215   
    }
         216  +
    /// Sets the client protocol to use for serialization and deserialization.
         217  +
    ///
         218  +
    /// This overrides the default protocol determined by the service model,
         219  +
    /// enabling runtime protocol selection.
         220  +
    pub fn protocol(mut self, protocol: impl ::aws_smithy_schema::protocol::ClientProtocol + 'static) -> Self {
         221  +
        self.set_protocol(::std::option::Option::Some(::aws_smithy_schema::protocol::SharedClientProtocol::new(
         222  +
            protocol,
         223  +
        )));
         224  +
        self
         225  +
    }
         226  +
         227  +
    /// Sets the client protocol to use for serialization and deserialization.
         228  +
    pub fn set_protocol(&mut self, protocol: ::std::option::Option<::aws_smithy_schema::protocol::SharedClientProtocol>) -> &mut Self {
         229  +
        self.config.store_or_unset(protocol);
         230  +
        self
         231  +
    }
  209    232   
    /// Sets the HTTP client to use when making requests.
  210    233   
    ///
  211    234   
    /// # Examples
  212    235   
    /// ```no_run
  213    236   
    /// # #[cfg(test)]
  214    237   
    /// # mod tests {
  215    238   
    /// # #[test]
  216    239   
    /// # fn example() {
  217    240   
    /// use std::time::Duration;
  218    241   
    /// use aws_sdk_transcribestreaming::config::Config;
@@ -1272,1295 +1331,1359 @@
 1292   1315   
#[derive(::std::fmt::Debug)]
 1293   1316   
pub(crate) struct ServiceRuntimePlugin {
 1294   1317   
    config: ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer>,
 1295   1318   
    runtime_components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
 1296   1319   
}
 1297   1320   
 1298   1321   
impl ServiceRuntimePlugin {
 1299   1322   
    pub fn new(_service_config: crate::config::Config) -> Self {
 1300   1323   
        let config = {
 1301   1324   
            let mut cfg = ::aws_smithy_types::config_bag::Layer::new("Transcribe");
        1325  +
            if _service_config.protocol().is_none() {
        1326  +
                cfg.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
        1327  +
                    ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
        1328  +
                ));
        1329  +
            }
 1302   1330   
            cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
 1303   1331   
            ::std::option::Option::Some(cfg.freeze())
 1304   1332   
        };
 1305   1333   
        let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
 1306   1334   
        runtime_components.set_auth_scheme_option_resolver(::std::option::Option::Some({
 1307   1335   
            use crate::config::auth::ResolveAuthScheme;
 1308   1336   
            crate::config::auth::DefaultAuthSchemeResolver::default().into_shared_resolver()
 1309   1337   
        }));
 1310   1338   
        runtime_components.set_endpoint_resolver(::std::option::Option::Some({
 1311   1339   
            use crate::config::endpoint::ResolveEndpoint;
@@ -1407,1435 +1466,1497 @@
 1427   1455   
        }
 1428   1456   
        // resiliency
 1429   1457   
        builder.set_retry_config(input.retry_config().cloned());
 1430   1458   
        builder.set_timeout_config(input.timeout_config().cloned());
 1431   1459   
        builder.set_sleep_impl(input.sleep_impl());
 1432   1460   
 1433   1461   
        builder.set_http_client(input.http_client());
 1434   1462   
        builder.set_time_source(input.time_source());
 1435   1463   
        builder.set_behavior_version(input.behavior_version());
 1436   1464   
        builder.set_auth_scheme_preference(input.auth_scheme_preference().cloned());
        1465  +
        if let Some(protocol) = input.protocol() {
        1466  +
            builder.set_protocol(Some(protocol.clone()));
        1467  +
        }
 1437   1468   
        // setting `None` here removes the default
 1438   1469   
        if let Some(config) = input.stalled_stream_protection() {
 1439   1470   
            builder.set_stalled_stream_protection(Some(config));
 1440   1471   
        }
 1441   1472   
 1442   1473   
        if let Some(cache) = input.identity_cache() {
 1443   1474   
            builder.set_identity_cache(cache);
 1444   1475   
        }
 1445   1476   
        builder.set_app_name(input.app_name().cloned());
 1446   1477

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

@@ -176,176 +215,211 @@
  196    196   
mod event_receiver;
  197    197   
  198    198   
mod event_stream_serde;
  199    199   
  200    200   
mod observability_feature;
  201    201   
  202    202   
pub(crate) mod protocol_serde;
  203    203   
  204    204   
mod sdk_feature_tracker;
  205    205   
  206         -
mod serialization_settings;
  207         -
  208    206   
mod endpoint_lib;
  209    207   
  210    208   
mod json_errors;
  211    209   
  212         -
mod serde_util;
  213         -
  214    210   
#[doc(inline)]
  215    211   
pub use client::Client;

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

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `GetMedicalScribeStream`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetMedicalScribeStream;
    6      6   
impl GetMedicalScribeStream {
    7      7   
    /// Creates a new `GetMedicalScribeStream`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamOutput::SCHEMA;
   11     15   
    pub(crate) async fn orchestrate(
   12     16   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     17   
        input: crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -124,128 +253,364 @@
  144    148   
                crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamError,
  145    149   
            >::new());
  146    150   
  147    151   
        ::std::borrow::Cow::Owned(rcb)
  148    152   
    }
  149    153   
}
  150    154   
  151    155   
#[derive(Debug)]
  152    156   
struct GetMedicalScribeStreamResponseDeserializer;
  153    157   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetMedicalScribeStreamResponseDeserializer {
  154         -
    fn deserialize_nonstreaming(
         158  +
    fn deserialize_nonstreaming_with_config(
  155    159   
        &self,
  156    160   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         161  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  157    162   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  158    163   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  159         -
        let headers = response.headers();
  160         -
        let body = response.body().bytes().expect("body loaded");
  161    164   
        #[allow(unused_mut)]
  162    165   
        let mut force_error = false;
  163    166   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  164         -
        let parse_result = if !success && status != 200 || force_error {
  165         -
            crate::protocol_serde::shape_get_medical_scribe_stream::de_get_medical_scribe_stream_http_error(status, headers, body)
  166         -
        } else {
  167         -
            crate::protocol_serde::shape_get_medical_scribe_stream::de_get_medical_scribe_stream_http_response(status, headers, body)
         167  +
        if !success && status != 200 || force_error {
         168  +
            let headers = response.headers();
         169  +
            let body = response.body().bytes().expect("body loaded");
         170  +
            #[allow(unused_mut)]
         171  +
            let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
         172  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         173  +
            })?;
         174  +
            generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
         175  +
            let generic = generic_builder.build();
         176  +
            let error_code = match generic.code() {
         177  +
                ::std::option::Option::Some(code) => code,
         178  +
                ::std::option::Option::None => {
         179  +
                    return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         180  +
                        ::aws_smithy_runtime_api::box_error::BoxError::from(
         181  +
                            crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamError::unhandled(generic),
         182  +
                        ),
         183  +
                    ))
         184  +
                }
         185  +
            };
         186  +
            let _error_message = generic.message().map(|msg| msg.to_owned());
         187  +
            let protocol = _cfg
         188  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         189  +
                .expect("a SharedClientProtocol is required");
         190  +
            let err = match error_code {
         191  +
                "BadRequestException" => crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamError::BadRequestException({
         192  +
                    let mut tmp = match protocol
         193  +
                        .deserialize_response(response, crate::types::error::BadRequestException::SCHEMA, _cfg)
         194  +
                        .and_then(|mut deser| {
         195  +
                            crate::types::error::BadRequestException::deserialize_with_response(
         196  +
                                &mut *deser,
         197  +
                                response.headers(),
         198  +
                                response.status().into(),
         199  +
                                body,
         200  +
                            )
         201  +
                        }) {
         202  +
                        ::std::result::Result::Ok(val) => val,
         203  +
                        ::std::result::Result::Err(e) => {
         204  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         205  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         206  +
                            ))
         207  +
                        }
         208  +
                    };
         209  +
                    tmp.meta = generic;
         210  +
                    if tmp.message.is_none() {
         211  +
                        tmp.message = _error_message;
         212  +
                    }
         213  +
                    tmp
         214  +
                }),
         215  +
                "InternalFailureException" => crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamError::InternalFailureException({
         216  +
                    let mut tmp = match protocol
         217  +
                        .deserialize_response(response, crate::types::error::InternalFailureException::SCHEMA, _cfg)
         218  +
                        .and_then(|mut deser| {
         219  +
                            crate::types::error::InternalFailureException::deserialize_with_response(
         220  +
                                &mut *deser,
         221  +
                                response.headers(),
         222  +
                                response.status().into(),
         223  +
                                body,
         224  +
                            )
         225  +
                        }) {
         226  +
                        ::std::result::Result::Ok(val) => val,
         227  +
                        ::std::result::Result::Err(e) => {
         228  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         229  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         230  +
                            ))
         231  +
                        }
  168    232   
                    };
  169         -
        crate::protocol_serde::type_erase_result(parse_result)
         233  +
                    tmp.meta = generic;
         234  +
                    if tmp.message.is_none() {
         235  +
                        tmp.message = _error_message;
         236  +
                    }
         237  +
                    tmp
         238  +
                }),
         239  +
                "LimitExceededException" => crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamError::LimitExceededException({
         240  +
                    let mut tmp = match protocol
         241  +
                        .deserialize_response(response, crate::types::error::LimitExceededException::SCHEMA, _cfg)
         242  +
                        .and_then(|mut deser| {
         243  +
                            crate::types::error::LimitExceededException::deserialize_with_response(
         244  +
                                &mut *deser,
         245  +
                                response.headers(),
         246  +
                                response.status().into(),
         247  +
                                body,
         248  +
                            )
         249  +
                        }) {
         250  +
                        ::std::result::Result::Ok(val) => val,
         251  +
                        ::std::result::Result::Err(e) => {
         252  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         253  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         254  +
                            ))
         255  +
                        }
         256  +
                    };
         257  +
                    tmp.meta = generic;
         258  +
                    if tmp.message.is_none() {
         259  +
                        tmp.message = _error_message;
         260  +
                    }
         261  +
                    tmp
         262  +
                }),
         263  +
                "ResourceNotFoundException" => crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamError::ResourceNotFoundException({
         264  +
                    let mut tmp = match protocol
         265  +
                        .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
         266  +
                        .and_then(|mut deser| {
         267  +
                            crate::types::error::ResourceNotFoundException::deserialize_with_response(
         268  +
                                &mut *deser,
         269  +
                                response.headers(),
         270  +
                                response.status().into(),
         271  +
                                body,
         272  +
                            )
         273  +
                        }) {
         274  +
                        ::std::result::Result::Ok(val) => val,
         275  +
                        ::std::result::Result::Err(e) => {
         276  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         277  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         278  +
                            ))
         279  +
                        }
         280  +
                    };
         281  +
                    tmp.meta = generic;
         282  +
                    if tmp.message.is_none() {
         283  +
                        tmp.message = _error_message;
         284  +
                    }
         285  +
                    tmp
         286  +
                }),
         287  +
                _ => crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamError::generic(generic),
         288  +
            };
         289  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         290  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         291  +
            ))
         292  +
        } else {
         293  +
            let protocol = _cfg
         294  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         295  +
                .expect("a SharedClientProtocol is required");
         296  +
            let mut deser = protocol
         297  +
                .deserialize_response(response, GetMedicalScribeStream::OUTPUT_SCHEMA, _cfg)
         298  +
                .map_err(|e| {
         299  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         300  +
                })?;
         301  +
            let body = response.body().bytes().expect("body loaded");
         302  +
            let output = crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamOutput::deserialize_with_response(
         303  +
                &mut *deser,
         304  +
                response.headers(),
         305  +
                response.status().into(),
         306  +
                body,
         307  +
            )
         308  +
            .map_err(|e| {
         309  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         310  +
            })?;
         311  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         312  +
        }
  170    313   
    }
  171    314   
}
  172    315   
#[derive(Debug)]
  173    316   
struct GetMedicalScribeStreamRequestSerializer;
  174    317   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetMedicalScribeStreamRequestSerializer {
  175    318   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  176    319   
    fn serialize_input(
  177    320   
        &self,
  178    321   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  179    322   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  180    323   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  181    324   
        let input = input
  182    325   
            .downcast::<crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamInput>()
  183    326   
            .expect("correct type");
  184         -
        let _header_serialization_settings = _cfg
  185         -
            .load::<crate::serialization_settings::HeaderSerializationSettings>()
  186         -
            .cloned()
  187         -
            .unwrap_or_default();
  188         -
        let mut request_builder = {
  189         -
            #[allow(clippy::uninlined_format_args)]
  190         -
            fn uri_base(
  191         -
                _input: &crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamInput,
  192         -
                output: &mut ::std::string::String,
  193         -
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  194         -
                use ::std::fmt::Write as _;
  195         -
                let input_1 = &_input.session_id;
  196         -
                let input_1 = input_1
  197         -
                    .as_ref()
  198         -
                    .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("session_id", "cannot be empty or unset"))?;
  199         -
                let session_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
  200         -
                if session_id.is_empty() {
  201         -
                    return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
  202         -
                        "session_id",
  203         -
                        "cannot be empty or unset",
  204         -
                    ));
  205         -
                }
  206         -
                ::std::write!(output, "/medical-scribe-stream/{SessionId}", SessionId = session_id).expect("formatting should succeed");
  207         -
                ::std::result::Result::Ok(())
  208         -
            }
  209         -
            #[allow(clippy::unnecessary_wraps)]
  210         -
            fn update_http_builder(
  211         -
                input: &crate::operation::get_medical_scribe_stream::GetMedicalScribeStreamInput,
  212         -
                builder: ::http_1x::request::Builder,
  213         -
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  214         -
                let mut uri = ::std::string::String::new();
  215         -
                uri_base(input, &mut uri)?;
  216         -
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  217         -
            }
  218         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  219         -
            builder
  220         -
        };
  221         -
        let body = ::aws_smithy_types::body::SdkBody::from("");
         327  +
        let protocol = _cfg
         328  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         329  +
            .expect("a SharedClientProtocol is required");
         330  +
        let mut request = protocol
         331  +
            .serialize_request(&input, GetMedicalScribeStream::INPUT_SCHEMA, "", _cfg)
         332  +
            .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
  222    333   
  223         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         334  +
        return ::std::result::Result::Ok(request);
  224    335   
    }
  225    336   
}
  226    337   
#[derive(Debug)]
  227    338   
struct GetMedicalScribeStreamEndpointParamsInterceptor;
  228    339   
  229    340   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetMedicalScribeStreamEndpointParamsInterceptor {
  230    341   
    fn name(&self) -> &'static str {
  231    342   
        "GetMedicalScribeStreamEndpointParamsInterceptor"
  232    343   
    }
  233    344

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

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

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

@@ -1,1 +96,143 @@
   18     18   
    "com.amazonaws.transcribestreaming.synthetic",
   19     19   
    "GetMedicalScribeStreamOutput",
   20     20   
);
   21     21   
static GETMEDICALSCRIBESTREAMOUTPUT_MEMBER_MEDICAL_SCRIBE_STREAM_DETAILS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   22     22   
    ::aws_smithy_schema::ShapeId::from_static(
   23     23   
        "com.amazonaws.transcribestreaming.synthetic#GetMedicalScribeStreamOutput$MedicalScribeStreamDetails",
   24     24   
        "com.amazonaws.transcribestreaming.synthetic",
   25     25   
        "GetMedicalScribeStreamOutput",
   26     26   
    ),
   27     27   
    ::aws_smithy_schema::ShapeType::Structure,
   28         -
    "medical_scribe_stream_details",
          28  +
    "MedicalScribeStreamDetails",
   29     29   
    0,
   30     30   
);
          31  +
static GETMEDICALSCRIBESTREAMOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          32  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          33  +
    ::aws_smithy_schema::ShapeType::String,
          34  +
    "request_id",
          35  +
    1,
          36  +
)
          37  +
.with_http_header("x-amzn-requestid");
   31     38   
static GETMEDICALSCRIBESTREAMOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   32     39   
    GETMEDICALSCRIBESTREAMOUTPUT_SCHEMA_ID,
   33     40   
    ::aws_smithy_schema::ShapeType::Structure,
   34         -
    &[&GETMEDICALSCRIBESTREAMOUTPUT_MEMBER_MEDICAL_SCRIBE_STREAM_DETAILS],
          41  +
    &[
          42  +
        &GETMEDICALSCRIBESTREAMOUTPUT_MEMBER_MEDICAL_SCRIBE_STREAM_DETAILS,
          43  +
        &GETMEDICALSCRIBESTREAMOUTPUT_MEMBER__REQUEST_ID,
          44  +
    ],
   35     45   
);
   36     46   
impl GetMedicalScribeStreamOutput {
   37     47   
    /// The schema for this shape.
   38     48   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETMEDICALSCRIBESTREAMOUTPUT_SCHEMA;
   39     49   
}
   40     50   
impl ::aws_smithy_schema::serde::SerializableStruct for GetMedicalScribeStreamOutput {
   41     51   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   42     52   
    fn serialize_members(
   43     53   
        &self,
   44     54   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   45     55   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   46     56   
        if let Some(ref val) = self.medical_scribe_stream_details {
   47     57   
            ser.write_struct(&GETMEDICALSCRIBESTREAMOUTPUT_MEMBER_MEDICAL_SCRIBE_STREAM_DETAILS, val)?;
   48     58   
        }
   49     59   
        Ok(())
   50     60   
    }
   51     61   
}
   52     62   
impl GetMedicalScribeStreamOutput {
   53     63   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   54         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   55         -
        deserializer: &mut D,
          64  +
    pub fn deserialize(
          65  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   56     66   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   57     67   
        #[allow(unused_variables, unused_mut)]
   58     68   
        let mut builder = Self::builder();
   59     69   
        #[allow(
   60     70   
            unused_variables,
   61     71   
            unreachable_code,
   62     72   
            clippy::single_match,
   63     73   
            clippy::match_single_binding,
   64     74   
            clippy::diverging_sub_expression
   65     75   
        )]
   66         -
        deserializer.read_struct(&GETMEDICALSCRIBESTREAMOUTPUT_SCHEMA, (), |_, member, deser| {
          76  +
        deserializer.read_struct(&GETMEDICALSCRIBESTREAMOUTPUT_SCHEMA, &mut |member, deser| {
          77  +
            match member.member_index() {
          78  +
                Some(0) => {
          79  +
                    builder.medical_scribe_stream_details = Some(crate::types::MedicalScribeStreamDetails::deserialize(deser)?);
          80  +
                }
          81  +
                Some(1) => {
          82  +
                    builder._request_id = Some(deser.read_string(member)?);
          83  +
                }
          84  +
                _ => {}
          85  +
            }
          86  +
            Ok(())
          87  +
        })?;
          88  +
        Ok(builder.build())
          89  +
    }
          90  +
}
          91  +
impl GetMedicalScribeStreamOutput {
          92  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
          93  +
    /// Header-bound members are read directly from headers, avoiding runtime
          94  +
    /// member iteration overhead. Body members are read via the deserializer.
          95  +
    pub fn deserialize_with_response(
          96  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          97  +
        headers: &::aws_smithy_runtime_api::http::Headers,
          98  +
        _status: u16,
          99  +
        _body: &[u8],
         100  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         101  +
        #[allow(unused_variables, unused_mut)]
         102  +
        let mut builder = Self::builder();
         103  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         104  +
            builder._request_id = Some(val.to_string());
         105  +
        }
         106  +
        #[allow(
         107  +
            unused_variables,
         108  +
            unreachable_code,
         109  +
            clippy::single_match,
         110  +
            clippy::match_single_binding,
         111  +
            clippy::diverging_sub_expression
         112  +
        )]
         113  +
        deserializer.read_struct(&GETMEDICALSCRIBESTREAMOUTPUT_SCHEMA, &mut |member, deser| {
   67    114   
            match member.member_index() {
   68    115   
                Some(0) => {
   69    116   
                    builder.medical_scribe_stream_details = Some(crate::types::MedicalScribeStreamDetails::deserialize(deser)?);
   70    117   
                }
   71    118   
                _ => {}
   72    119   
            }
   73    120   
            Ok(())
   74    121   
        })?;
   75    122   
        Ok(builder.build())
   76    123   
    }

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

@@ -1,1 +40,46 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `StartCallAnalyticsStreamTranscription`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct StartCallAnalyticsStreamTranscription;
    6      6   
impl StartCallAnalyticsStreamTranscription {
    7      7   
    /// Creates a new `StartCallAnalyticsStreamTranscription`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          13  +
        crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionOutput::SCHEMA;
   11     17   
    pub(crate) async fn orchestrate(
   12     18   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     19   
        input: crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -142,148 +276,411 @@
  162    168   
        if (!response.status().is_success() && response.status().as_u16() != 200) || force_error {
  163    169   
            return ::std::option::Option::None;
  164    170   
        }
  165    171   
        ::std::option::Option::Some(crate::protocol_serde::type_erase_result(
  166    172   
            crate::protocol_serde::shape_start_call_analytics_stream_transcription::de_start_call_analytics_stream_transcription_http_response(
  167    173   
                response,
  168    174   
            ),
  169    175   
        ))
  170    176   
    }
  171    177   
  172         -
    fn deserialize_nonstreaming(
         178  +
    fn deserialize_nonstreaming_with_config(
  173    179   
        &self,
  174    180   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         181  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  175    182   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  176    183   
        // For streaming operations, we only hit this case if its an error
  177    184   
        let body = response.body().bytes().expect("body loaded");
  178         -
        crate::protocol_serde::type_erase_result(
  179         -
            crate::protocol_serde::shape_start_call_analytics_stream_transcription::de_start_call_analytics_stream_transcription_http_error(
  180         -
                response.status().as_u16(),
         185  +
        let status = response.status().as_u16();
         186  +
        let headers = response.headers();
         187  +
        #[allow(unused_mut)]
         188  +
        let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
         189  +
            ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         190  +
        })?;
         191  +
        generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
         192  +
        let generic = generic_builder.build();
         193  +
        let error_code = match generic.code() {
         194  +
            ::std::option::Option::Some(code) => code,
         195  +
            ::std::option::Option::None => {
         196  +
                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         197  +
                    ::aws_smithy_runtime_api::box_error::BoxError::from(
         198  +
                        crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::unhandled(generic),
         199  +
                    ),
         200  +
                ))
         201  +
            }
         202  +
        };
         203  +
        let _error_message = generic.message().map(|msg| msg.to_owned());
         204  +
        let protocol = _cfg
         205  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         206  +
            .expect("a SharedClientProtocol is required");
         207  +
        let err = match error_code {
         208  +
            "BadRequestException" => {
         209  +
                crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::BadRequestException({
         210  +
                    let mut tmp = match protocol
         211  +
                        .deserialize_response(response, crate::types::error::BadRequestException::SCHEMA, _cfg)
         212  +
                        .and_then(|mut deser| {
         213  +
                            crate::types::error::BadRequestException::deserialize_with_response(
         214  +
                                &mut *deser,
  181    215   
                                response.headers(),
         216  +
                                response.status().into(),
         217  +
                                body,
         218  +
                            )
         219  +
                        }) {
         220  +
                        ::std::result::Result::Ok(val) => val,
         221  +
                        ::std::result::Result::Err(e) => {
         222  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         223  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         224  +
                            ))
         225  +
                        }
         226  +
                    };
         227  +
                    tmp.meta = generic;
         228  +
                    if tmp.message.is_none() {
         229  +
                        tmp.message = _error_message;
         230  +
                    }
         231  +
                    tmp
         232  +
                })
         233  +
            }
         234  +
            "ConflictException" => {
         235  +
                crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::ConflictException({
         236  +
                    let mut tmp = match protocol
         237  +
                        .deserialize_response(response, crate::types::error::ConflictException::SCHEMA, _cfg)
         238  +
                        .and_then(|mut deser| {
         239  +
                            crate::types::error::ConflictException::deserialize_with_response(
         240  +
                                &mut *deser,
         241  +
                                response.headers(),
         242  +
                                response.status().into(),
         243  +
                                body,
         244  +
                            )
         245  +
                        }) {
         246  +
                        ::std::result::Result::Ok(val) => val,
         247  +
                        ::std::result::Result::Err(e) => {
         248  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         249  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         250  +
                            ))
         251  +
                        }
         252  +
                    };
         253  +
                    tmp.meta = generic;
         254  +
                    if tmp.message.is_none() {
         255  +
                        tmp.message = _error_message;
         256  +
                    }
         257  +
                    tmp
         258  +
                })
         259  +
            }
         260  +
            "InternalFailureException" => {
         261  +
                crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::InternalFailureException({
         262  +
                    let mut tmp = match protocol
         263  +
                        .deserialize_response(response, crate::types::error::InternalFailureException::SCHEMA, _cfg)
         264  +
                        .and_then(|mut deser| {
         265  +
                            crate::types::error::InternalFailureException::deserialize_with_response(
         266  +
                                &mut *deser,
         267  +
                                response.headers(),
         268  +
                                response.status().into(),
         269  +
                                body,
         270  +
                            )
         271  +
                        }) {
         272  +
                        ::std::result::Result::Ok(val) => val,
         273  +
                        ::std::result::Result::Err(e) => {
         274  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         275  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         276  +
                            ))
         277  +
                        }
         278  +
                    };
         279  +
                    tmp.meta = generic;
         280  +
                    if tmp.message.is_none() {
         281  +
                        tmp.message = _error_message;
         282  +
                    }
         283  +
                    tmp
         284  +
                })
         285  +
            }
         286  +
            "LimitExceededException" => {
         287  +
                crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::LimitExceededException({
         288  +
                    let mut tmp = match protocol
         289  +
                        .deserialize_response(response, crate::types::error::LimitExceededException::SCHEMA, _cfg)
         290  +
                        .and_then(|mut deser| {
         291  +
                            crate::types::error::LimitExceededException::deserialize_with_response(
         292  +
                                &mut *deser,
         293  +
                                response.headers(),
         294  +
                                response.status().into(),
         295  +
                                body,
         296  +
                            )
         297  +
                        }) {
         298  +
                        ::std::result::Result::Ok(val) => val,
         299  +
                        ::std::result::Result::Err(e) => {
         300  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         301  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         302  +
                            ))
         303  +
                        }
         304  +
                    };
         305  +
                    tmp.meta = generic;
         306  +
                    if tmp.message.is_none() {
         307  +
                        tmp.message = _error_message;
         308  +
                    }
         309  +
                    tmp
         310  +
                })
         311  +
            }
         312  +
            "ServiceUnavailableException" => {
         313  +
                crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::ServiceUnavailableException(
         314  +
                    {
         315  +
                        let mut tmp = match protocol
         316  +
                            .deserialize_response(response, crate::types::error::ServiceUnavailableException::SCHEMA, _cfg)
         317  +
                            .and_then(|mut deser| {
         318  +
                                crate::types::error::ServiceUnavailableException::deserialize_with_response(
         319  +
                                    &mut *deser,
         320  +
                                    response.headers(),
         321  +
                                    response.status().into(),
  182    322   
                                    body,
  183         -
            ),
  184    323   
                                )
         324  +
                            }) {
         325  +
                            ::std::result::Result::Ok(val) => val,
         326  +
                            ::std::result::Result::Err(e) => {
         327  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         328  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         329  +
                                ))
         330  +
                            }
         331  +
                        };
         332  +
                        tmp.meta = generic;
         333  +
                        if tmp.message.is_none() {
         334  +
                            tmp.message = _error_message;
         335  +
                        }
         336  +
                        tmp
         337  +
                    },
         338  +
                )
         339  +
            }
         340  +
            _ => crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::generic(generic),
         341  +
        };
         342  +
        ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         343  +
            ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         344  +
        ))
  185    345   
    }
  186    346   
}
  187    347   
#[derive(Debug)]
  188    348   
struct StartCallAnalyticsStreamTranscriptionRequestSerializer;
  189    349   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for StartCallAnalyticsStreamTranscriptionRequestSerializer {
  190    350   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  191    351   
    fn serialize_input(
  192    352   
        &self,
  193    353   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  194    354   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  195    355   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  196    356   
        let input = input
  197    357   
            .downcast::<crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionInput>()
  198    358   
            .expect("correct type");
  199         -
        let _header_serialization_settings = _cfg
  200         -
            .load::<crate::serialization_settings::HeaderSerializationSettings>()
  201         -
            .cloned()
  202         -
            .unwrap_or_default();
  203         -
        let mut request_builder = {
  204         -
            #[allow(clippy::uninlined_format_args)]
  205         -
            fn uri_base(
  206         -
                _input: &crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionInput,
  207         -
                output: &mut ::std::string::String,
  208         -
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  209         -
                use ::std::fmt::Write as _;
  210         -
                ::std::write!(output, "/call-analytics-stream-transcription").expect("formatting should succeed");
  211         -
                ::std::result::Result::Ok(())
  212         -
            }
  213         -
            #[allow(clippy::unnecessary_wraps)]
  214         -
            fn update_http_builder(
  215         -
                input: &crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionInput,
  216         -
                builder: ::http_1x::request::Builder,
  217         -
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  218         -
                let mut uri = ::std::string::String::new();
  219         -
                uri_base(input, &mut uri)?;
  220         -
                let builder =
  221         -
                    crate::protocol_serde::shape_start_call_analytics_stream_transcription::ser_start_call_analytics_stream_transcription_headers(
  222         -
                        input, builder,
  223         -
                    )?;
  224         -
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  225         -
            }
  226         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  227         -
            builder =
  228         -
                _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/vnd.amazon.eventstream");
  229         -
            builder
  230         -
        };
  231         -
        let body = ::aws_smithy_types::body::SdkBody::from({
         359  +
        let protocol = _cfg
         360  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         361  +
            .expect("a SharedClientProtocol is required");
         362  +
        let mut request = protocol
         363  +
            .serialize_request(&input, StartCallAnalyticsStreamTranscription::INPUT_SCHEMA, "", _cfg)
         364  +
            .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         365  +
        *request.body_mut() = ::aws_smithy_types::body::SdkBody::from({
  232    366   
            let error_marshaller = crate::event_stream_serde::AudioStreamErrorMarshaller::new();
  233    367   
            let marshaller = crate::event_stream_serde::AudioStreamMarshaller::new();
  234    368   
            let (signer, signer_sender) = ::aws_smithy_eventstream::frame::DeferredSigner::new();
  235    369   
            _cfg.interceptor_state().store_put(signer_sender);
  236    370   
            ::aws_smithy_types::body::SdkBody::from_body_1_x(::http_body_util::StreamBody::new(input.audio_stream.into_body_stream(
  237    371   
                marshaller,
  238    372   
                error_marshaller,
  239    373   
                signer,
  240    374   
            )))
  241    375   
        });
  242         -
        if let Some(content_length) = body.content_length() {
  243         -
            let content_length = content_length.to_string();
  244         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  245         -
        }
  246         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         376  +
        // The protocol may have set Content-Length based on the initial empty body.
         377  +
        // Remove it since the event stream body has unknown length.
         378  +
        request.headers_mut().remove("Content-Length");
         379  +
        request.headers_mut().insert("Content-Type", "application/vnd.amazon.eventstream");
         380  +
         381  +
        return ::std::result::Result::Ok(request);
  247    382   
    }
  248    383   
}
  249    384   
#[derive(Debug)]
  250    385   
struct StartCallAnalyticsStreamTranscriptionEndpointParamsInterceptor;
  251    386   
  252    387   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StartCallAnalyticsStreamTranscriptionEndpointParamsInterceptor {
  253    388   
    fn name(&self) -> &'static str {
  254    389   
        "StartCallAnalyticsStreamTranscriptionEndpointParamsInterceptor"
  255    390   
    }
  256    391

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

@@ -203,203 +654,764 @@
  223    223   
    "com.amazonaws.transcribestreaming.synthetic",
  224    224   
    "StartCallAnalyticsStreamTranscriptionInput",
  225    225   
);
  226    226   
static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_LANGUAGE_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  227    227   
    ::aws_smithy_schema::ShapeId::from_static(
  228    228   
        "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$LanguageCode",
  229    229   
        "com.amazonaws.transcribestreaming.synthetic",
  230    230   
        "StartCallAnalyticsStreamTranscriptionInput",
  231    231   
    ),
  232    232   
    ::aws_smithy_schema::ShapeType::String,
  233         -
    "language_code",
         233  +
    "LanguageCode",
  234    234   
    0,
  235    235   
)
  236    236   
.with_http_header("x-amzn-transcribe-language-code");
  237    237   
static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_MEDIA_SAMPLE_RATE_HERTZ: ::aws_smithy_schema::Schema =
  238    238   
    ::aws_smithy_schema::Schema::new_member(
  239    239   
        ::aws_smithy_schema::ShapeId::from_static(
  240    240   
            "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$MediaSampleRateHertz",
  241    241   
            "com.amazonaws.transcribestreaming.synthetic",
  242    242   
            "StartCallAnalyticsStreamTranscriptionInput",
  243    243   
        ),
  244    244   
        ::aws_smithy_schema::ShapeType::Integer,
  245         -
        "media_sample_rate_hertz",
         245  +
        "MediaSampleRateHertz",
  246    246   
        1,
  247    247   
    )
  248    248   
    .with_http_header("x-amzn-transcribe-sample-rate");
  249    249   
static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_MEDIA_ENCODING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  250    250   
    ::aws_smithy_schema::ShapeId::from_static(
  251    251   
        "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$MediaEncoding",
  252    252   
        "com.amazonaws.transcribestreaming.synthetic",
  253    253   
        "StartCallAnalyticsStreamTranscriptionInput",
  254    254   
    ),
  255    255   
    ::aws_smithy_schema::ShapeType::String,
  256         -
    "media_encoding",
         256  +
    "MediaEncoding",
  257    257   
    2,
  258    258   
)
  259    259   
.with_http_header("x-amzn-transcribe-media-encoding");
  260    260   
static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  261    261   
    ::aws_smithy_schema::ShapeId::from_static(
  262    262   
        "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$VocabularyName",
  263    263   
        "com.amazonaws.transcribestreaming.synthetic",
  264    264   
        "StartCallAnalyticsStreamTranscriptionInput",
  265    265   
    ),
  266    266   
    ::aws_smithy_schema::ShapeType::String,
  267         -
    "vocabulary_name",
         267  +
    "VocabularyName",
  268    268   
    3,
  269    269   
)
  270    270   
.with_http_header("x-amzn-transcribe-vocabulary-name");
  271    271   
static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_SESSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  272    272   
    ::aws_smithy_schema::ShapeId::from_static(
  273    273   
        "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$SessionId",
  274    274   
        "com.amazonaws.transcribestreaming.synthetic",
  275    275   
        "StartCallAnalyticsStreamTranscriptionInput",
  276    276   
    ),
  277    277   
    ::aws_smithy_schema::ShapeType::String,
  278         -
    "session_id",
         278  +
    "SessionId",
  279    279   
    4,
  280    280   
)
  281    281   
.with_http_header("x-amzn-transcribe-session-id");
  282    282   
static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_AUDIO_STREAM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  283    283   
    ::aws_smithy_schema::ShapeId::from_static(
  284    284   
        "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$AudioStream",
  285    285   
        "com.amazonaws.transcribestreaming.synthetic",
  286    286   
        "StartCallAnalyticsStreamTranscriptionInput",
  287    287   
    ),
  288    288   
    ::aws_smithy_schema::ShapeType::Union,
  289         -
    "audio_stream",
         289  +
    "AudioStream",
  290    290   
    5,
  291    291   
)
  292    292   
.with_http_payload();
  293    293   
static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_FILTER_NAME: ::aws_smithy_schema::Schema =
  294    294   
    ::aws_smithy_schema::Schema::new_member(
  295    295   
        ::aws_smithy_schema::ShapeId::from_static(
  296    296   
            "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$VocabularyFilterName",
  297    297   
            "com.amazonaws.transcribestreaming.synthetic",
  298    298   
            "StartCallAnalyticsStreamTranscriptionInput",
  299    299   
        ),
  300    300   
        ::aws_smithy_schema::ShapeType::String,
  301         -
        "vocabulary_filter_name",
         301  +
        "VocabularyFilterName",
  302    302   
        6,
  303    303   
    )
  304    304   
    .with_http_header("x-amzn-transcribe-vocabulary-filter-name");
  305    305   
static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_FILTER_METHOD: ::aws_smithy_schema::Schema =
  306    306   
    ::aws_smithy_schema::Schema::new_member(
  307    307   
        ::aws_smithy_schema::ShapeId::from_static(
  308    308   
            "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$VocabularyFilterMethod",
  309    309   
            "com.amazonaws.transcribestreaming.synthetic",
  310    310   
            "StartCallAnalyticsStreamTranscriptionInput",
  311    311   
        ),
  312    312   
        ::aws_smithy_schema::ShapeType::String,
  313         -
        "vocabulary_filter_method",
         313  +
        "VocabularyFilterMethod",
  314    314   
        7,
  315    315   
    )
  316    316   
    .with_http_header("x-amzn-transcribe-vocabulary-filter-method");
  317    317   
static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_LANGUAGE_MODEL_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  318    318   
    ::aws_smithy_schema::ShapeId::from_static(
  319    319   
        "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$LanguageModelName",
  320    320   
        "com.amazonaws.transcribestreaming.synthetic",
  321    321   
        "StartCallAnalyticsStreamTranscriptionInput",
  322    322   
    ),
  323    323   
    ::aws_smithy_schema::ShapeType::String,
  324         -
    "language_model_name",
         324  +
    "LanguageModelName",
  325    325   
    8,
  326    326   
)
  327    327   
.with_http_header("x-amzn-transcribe-language-model-name");
  328    328   
static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_IDENTIFY_LANGUAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  329    329   
    ::aws_smithy_schema::ShapeId::from_static(
  330    330   
        "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$IdentifyLanguage",
  331    331   
        "com.amazonaws.transcribestreaming.synthetic",
  332    332   
        "StartCallAnalyticsStreamTranscriptionInput",
  333    333   
    ),
  334    334   
    ::aws_smithy_schema::ShapeType::Boolean,
  335         -
    "identify_language",
         335  +
    "IdentifyLanguage",
  336    336   
    9,
  337    337   
)
  338    338   
.with_http_header("x-amzn-transcribe-identify-language");
  339    339   
static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_LANGUAGE_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  340    340   
    ::aws_smithy_schema::ShapeId::from_static(
  341    341   
        "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$LanguageOptions",
  342    342   
        "com.amazonaws.transcribestreaming.synthetic",
  343    343   
        "StartCallAnalyticsStreamTranscriptionInput",
  344    344   
    ),
  345    345   
    ::aws_smithy_schema::ShapeType::String,
  346         -
    "language_options",
         346  +
    "LanguageOptions",
  347    347   
    10,
  348    348   
)
  349    349   
.with_http_header("x-amzn-transcribe-language-options");
  350    350   
static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_PREFERRED_LANGUAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  351    351   
    ::aws_smithy_schema::ShapeId::from_static(
  352    352   
        "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$PreferredLanguage",
  353    353   
        "com.amazonaws.transcribestreaming.synthetic",
  354    354   
        "StartCallAnalyticsStreamTranscriptionInput",
  355    355   
    ),
  356    356   
    ::aws_smithy_schema::ShapeType::String,
  357         -
    "preferred_language",
         357  +
    "PreferredLanguage",
  358    358   
    11,
  359    359   
)
  360    360   
.with_http_header("x-amzn-transcribe-preferred-language");
  361    361   
static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_NAMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  362    362   
    ::aws_smithy_schema::ShapeId::from_static(
  363    363   
        "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$VocabularyNames",
  364    364   
        "com.amazonaws.transcribestreaming.synthetic",
  365    365   
        "StartCallAnalyticsStreamTranscriptionInput",
  366    366   
    ),
  367    367   
    ::aws_smithy_schema::ShapeType::String,
  368         -
    "vocabulary_names",
         368  +
    "VocabularyNames",
  369    369   
    12,
  370    370   
)
  371    371   
.with_http_header("x-amzn-transcribe-vocabulary-names");
  372    372   
static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_FILTER_NAMES: ::aws_smithy_schema::Schema =
  373    373   
    ::aws_smithy_schema::Schema::new_member(
  374    374   
        ::aws_smithy_schema::ShapeId::from_static(
  375    375   
            "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$VocabularyFilterNames",
  376    376   
            "com.amazonaws.transcribestreaming.synthetic",
  377    377   
            "StartCallAnalyticsStreamTranscriptionInput",
  378    378   
        ),
  379    379   
        ::aws_smithy_schema::ShapeType::String,
  380         -
        "vocabulary_filter_names",
         380  +
        "VocabularyFilterNames",
  381    381   
        13,
  382    382   
    )
  383    383   
    .with_http_header("x-amzn-transcribe-vocabulary-filter-names");
  384    384   
static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_ENABLE_PARTIAL_RESULTS_STABILIZATION: ::aws_smithy_schema::Schema =
  385    385   
    ::aws_smithy_schema::Schema::new_member(
  386    386   
        ::aws_smithy_schema::ShapeId::from_static(
  387    387   
            "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$EnablePartialResultsStabilization",
  388    388   
            "com.amazonaws.transcribestreaming.synthetic",
  389    389   
            "StartCallAnalyticsStreamTranscriptionInput",
  390    390   
        ),
  391    391   
        ::aws_smithy_schema::ShapeType::Boolean,
  392         -
        "enable_partial_results_stabilization",
         392  +
        "EnablePartialResultsStabilization",
  393    393   
        14,
  394    394   
    )
  395    395   
    .with_http_header("x-amzn-transcribe-enable-partial-results-stabilization");
  396    396   
static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_PARTIAL_RESULTS_STABILITY: ::aws_smithy_schema::Schema =
  397    397   
    ::aws_smithy_schema::Schema::new_member(
  398    398   
        ::aws_smithy_schema::ShapeId::from_static(
  399    399   
            "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$PartialResultsStability",
  400    400   
            "com.amazonaws.transcribestreaming.synthetic",
  401    401   
            "StartCallAnalyticsStreamTranscriptionInput",
  402    402   
        ),
  403    403   
        ::aws_smithy_schema::ShapeType::String,
  404         -
        "partial_results_stability",
         404  +
        "PartialResultsStability",
  405    405   
        15,
  406    406   
    )
  407    407   
    .with_http_header("x-amzn-transcribe-partial-results-stability");
  408    408   
static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_CONTENT_IDENTIFICATION_TYPE: ::aws_smithy_schema::Schema =
  409    409   
    ::aws_smithy_schema::Schema::new_member(
  410    410   
        ::aws_smithy_schema::ShapeId::from_static(
  411    411   
            "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$ContentIdentificationType",
  412    412   
            "com.amazonaws.transcribestreaming.synthetic",
  413    413   
            "StartCallAnalyticsStreamTranscriptionInput",
  414    414   
        ),
  415    415   
        ::aws_smithy_schema::ShapeType::String,
  416         -
        "content_identification_type",
         416  +
        "ContentIdentificationType",
  417    417   
        16,
  418    418   
    )
  419    419   
    .with_http_header("x-amzn-transcribe-content-identification-type");
  420    420   
static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_CONTENT_REDACTION_TYPE: ::aws_smithy_schema::Schema =
  421    421   
    ::aws_smithy_schema::Schema::new_member(
  422    422   
        ::aws_smithy_schema::ShapeId::from_static(
  423    423   
            "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$ContentRedactionType",
  424    424   
            "com.amazonaws.transcribestreaming.synthetic",
  425    425   
            "StartCallAnalyticsStreamTranscriptionInput",
  426    426   
        ),
  427    427   
        ::aws_smithy_schema::ShapeType::String,
  428         -
        "content_redaction_type",
         428  +
        "ContentRedactionType",
  429    429   
        17,
  430    430   
    )
  431    431   
    .with_http_header("x-amzn-transcribe-content-redaction-type");
  432    432   
static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_PII_ENTITY_TYPES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  433    433   
    ::aws_smithy_schema::ShapeId::from_static(
  434    434   
        "com.amazonaws.transcribestreaming.synthetic#StartCallAnalyticsStreamTranscriptionInput$PiiEntityTypes",
  435    435   
        "com.amazonaws.transcribestreaming.synthetic",
  436    436   
        "StartCallAnalyticsStreamTranscriptionInput",
  437    437   
    ),
  438    438   
    ::aws_smithy_schema::ShapeType::String,
  439         -
    "pii_entity_types",
         439  +
    "PiiEntityTypes",
  440    440   
    18,
  441    441   
)
  442    442   
.with_http_header("x-amzn-transcribe-pii-entity-types");
  443    443   
static STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  444    444   
    STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_SCHEMA_ID,
  445    445   
    ::aws_smithy_schema::ShapeType::Structure,
  446    446   
    &[
  447    447   
        &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_LANGUAGE_CODE,
  448    448   
        &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_MEDIA_SAMPLE_RATE_HERTZ,
  449    449   
        &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_MEDIA_ENCODING,
  450    450   
        &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_NAME,
  451    451   
        &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_SESSION_ID,
  452    452   
        &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_AUDIO_STREAM,
  453    453   
        &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_FILTER_NAME,
  454    454   
        &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_FILTER_METHOD,
  455    455   
        &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_LANGUAGE_MODEL_NAME,
  456    456   
        &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_IDENTIFY_LANGUAGE,
  457    457   
        &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_LANGUAGE_OPTIONS,
  458    458   
        &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_PREFERRED_LANGUAGE,
  459    459   
        &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_NAMES,
  460    460   
        &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_FILTER_NAMES,
  461    461   
        &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_ENABLE_PARTIAL_RESULTS_STABILIZATION,
  462    462   
        &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_PARTIAL_RESULTS_STABILITY,
  463    463   
        &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_CONTENT_IDENTIFICATION_TYPE,
  464    464   
        &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_CONTENT_REDACTION_TYPE,
  465    465   
        &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_PII_ENTITY_TYPES,
  466    466   
    ],
  467         -
);
         467  +
)
         468  +
.with_http(aws_smithy_schema::traits::HttpTrait::new(
         469  +
    "POST",
         470  +
    "/call-analytics-stream-transcription",
         471  +
    None,
         472  +
));
  468    473   
impl StartCallAnalyticsStreamTranscriptionInput {
  469    474   
    /// The schema for this shape.
  470    475   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_SCHEMA;
  471    476   
}
  472    477   
impl ::aws_smithy_schema::serde::SerializableStruct for StartCallAnalyticsStreamTranscriptionInput {
  473    478   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  474    479   
    fn serialize_members(
  475    480   
        &self,
  476    481   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  477    482   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  478    483   
        if let Some(ref val) = self.language_code {
  479    484   
            ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_LANGUAGE_CODE, val.as_str())?;
  480    485   
        }
  481    486   
        if let Some(ref val) = self.media_sample_rate_hertz {
  482    487   
            ser.write_integer(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_MEDIA_SAMPLE_RATE_HERTZ, *val)?;
  483    488   
        }
  484    489   
        if let Some(ref val) = self.media_encoding {
  485    490   
            ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_MEDIA_ENCODING, val.as_str())?;
  486    491   
        }
  487    492   
        if let Some(ref val) = self.vocabulary_name {
  488    493   
            ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_NAME, val)?;
  489    494   
        }
  490    495   
        if let Some(ref val) = self.session_id {
  491    496   
            ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_SESSION_ID, val)?;
  492    497   
        }
  493         -
        {
  494         -
            let val = &self.audio_stream;
  495         -
            ser.write_null(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_AUDIO_STREAM)?;
  496         -
        }
  497    498   
        if let Some(ref val) = self.vocabulary_filter_name {
  498    499   
            ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_FILTER_NAME, val)?;
  499    500   
        }
  500    501   
        if let Some(ref val) = self.vocabulary_filter_method {
  501    502   
            ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_FILTER_METHOD, val.as_str())?;
  502    503   
        }
  503    504   
        if let Some(ref val) = self.language_model_name {
  504    505   
            ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_LANGUAGE_MODEL_NAME, val)?;
  505    506   
        }
  506    507   
        if let Some(ref val) = self.identify_language {
  507    508   
            ser.write_boolean(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_IDENTIFY_LANGUAGE, *val)?;
  508    509   
        }
  509    510   
        if let Some(ref val) = self.language_options {
  510    511   
            ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_LANGUAGE_OPTIONS, val)?;
  511    512   
        }
  512    513   
        if let Some(ref val) = self.preferred_language {
  513    514   
            ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_PREFERRED_LANGUAGE, val.as_str())?;
  514    515   
        }
  515    516   
        if let Some(ref val) = self.vocabulary_names {
  516    517   
            ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_NAMES, val)?;
  517    518   
        }
  518    519   
        if let Some(ref val) = self.vocabulary_filter_names {
  519    520   
            ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_VOCABULARY_FILTER_NAMES, val)?;
  520    521   
        }
  521    522   
        if let Some(ref val) = self.enable_partial_results_stabilization {
  522    523   
            ser.write_boolean(
  523    524   
                &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_ENABLE_PARTIAL_RESULTS_STABILIZATION,
  524    525   
                *val,
  525    526   
            )?;
  526    527   
        }
  527    528   
        if let Some(ref val) = self.partial_results_stability {
  528    529   
            ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_PARTIAL_RESULTS_STABILITY, val.as_str())?;
  529    530   
        }
  530    531   
        if let Some(ref val) = self.content_identification_type {
  531    532   
            ser.write_string(
  532    533   
                &STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_CONTENT_IDENTIFICATION_TYPE,
  533    534   
                val.as_str(),
  534    535   
            )?;
  535    536   
        }
  536    537   
        if let Some(ref val) = self.content_redaction_type {
  537    538   
            ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_CONTENT_REDACTION_TYPE, val.as_str())?;
  538    539   
        }
  539    540   
        if let Some(ref val) = self.pii_entity_types {
  540    541   
            ser.write_string(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_MEMBER_PII_ENTITY_TYPES, val)?;
  541    542   
        }
  542    543   
        Ok(())
  543    544   
    }
  544    545   
}
  545    546   
impl StartCallAnalyticsStreamTranscriptionInput {
  546    547   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  547         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  548         -
        deserializer: &mut D,
         548  +
    pub fn deserialize(
         549  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  549    550   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  550    551   
        #[allow(unused_variables, unused_mut)]
  551    552   
        let mut builder = Self::builder();
  552    553   
        #[allow(
  553    554   
            unused_variables,
  554    555   
            unreachable_code,
  555    556   
            clippy::single_match,
  556    557   
            clippy::match_single_binding,
  557    558   
            clippy::diverging_sub_expression
  558    559   
        )]
  559         -
        deserializer.read_struct(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_SCHEMA, (), |_, member, deser| {
         560  +
        deserializer.read_struct(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_SCHEMA, &mut |member, deser| {
  560    561   
            match member.member_index() {
  561    562   
                Some(0) => {
  562    563   
                    builder.language_code = Some(crate::types::CallAnalyticsLanguageCode::from(deser.read_string(member)?.as_str()));
  563    564   
                }
  564    565   
                Some(1) => {
  565    566   
                    builder.media_sample_rate_hertz = Some(deser.read_integer(member)?);
  566    567   
                }
  567    568   
                Some(2) => {
  568    569   
                    builder.media_encoding = Some(crate::types::MediaEncoding::from(deser.read_string(member)?.as_str()));
  569    570   
                }
  570    571   
                Some(3) => {
  571    572   
                    builder.vocabulary_name = Some(deser.read_string(member)?);
  572    573   
                }
  573    574   
                Some(4) => {
  574    575   
                    builder.session_id = Some(deser.read_string(member)?);
  575    576   
                }
  576    577   
                Some(5) => {
  577    578   
                    builder.audio_stream = Some({
  578    579   
                        let _ = member;
  579         -
                        todo!("deserialize aggregate")
         580  +
                        todo!("deserialize streaming union")
  580    581   
                    });
  581    582   
                }
  582    583   
                Some(6) => {
  583    584   
                    builder.vocabulary_filter_name = Some(deser.read_string(member)?);
  584    585   
                }
  585    586   
                Some(7) => {
  586    587   
                    builder.vocabulary_filter_method = Some(crate::types::VocabularyFilterMethod::from(deser.read_string(member)?.as_str()));
  587    588   
                }
  588    589   
                Some(8) => {
  589    590   
                    builder.language_model_name = Some(deser.read_string(member)?);
  590    591   
                }
  591    592   
                Some(9) => {
  592    593   
                    builder.identify_language = Some(deser.read_boolean(member)?);
  593    594   
                }
  594    595   
                Some(10) => {
  595    596   
                    builder.language_options = Some(deser.read_string(member)?);
  596    597   
                }
  597    598   
                Some(11) => {
  598    599   
                    builder.preferred_language = Some(crate::types::CallAnalyticsLanguageCode::from(deser.read_string(member)?.as_str()));
  599    600   
                }
  600    601   
                Some(12) => {
  601    602   
                    builder.vocabulary_names = Some(deser.read_string(member)?);
  602    603   
                }
  603    604   
                Some(13) => {
  604    605   
                    builder.vocabulary_filter_names = Some(deser.read_string(member)?);
  605    606   
                }
  606    607   
                Some(14) => {
  607    608   
                    builder.enable_partial_results_stabilization = Some(deser.read_boolean(member)?);
  608    609   
                }
  609    610   
                Some(15) => {
  610    611   
                    builder.partial_results_stability = Some(crate::types::PartialResultsStability::from(deser.read_string(member)?.as_str()));
  611    612   
                }
  612    613   
                Some(16) => {
  613    614   
                    builder.content_identification_type = Some(crate::types::ContentIdentificationType::from(deser.read_string(member)?.as_str()));
  614    615   
                }
  615    616   
                Some(17) => {
  616    617   
                    builder.content_redaction_type = Some(crate::types::ContentRedactionType::from(deser.read_string(member)?.as_str()));
  617    618   
                }
  618    619   
                Some(18) => {
  619    620   
                    builder.pii_entity_types = Some(deser.read_string(member)?);
  620    621   
                }
  621    622   
                _ => {}
  622    623   
            }
  623    624   
            Ok(())
  624    625   
        })?;
         626  +
        builder.media_sample_rate_hertz = builder.media_sample_rate_hertz.or(Some(0i32));
         627  +
        builder
         628  +
            .build()
         629  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         630  +
    }
         631  +
}
         632  +
impl StartCallAnalyticsStreamTranscriptionInput {
         633  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         634  +
    /// Header-bound members are read directly from headers, avoiding runtime
         635  +
    /// member iteration overhead. Body members are read via the deserializer.
         636  +
    pub fn deserialize_with_response(
         637  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         638  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         639  +
        _status: u16,
         640  +
        _body: &[u8],
         641  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         642  +
        #[allow(unused_variables, unused_mut)]
         643  +
        let mut builder = Self::builder();
         644  +
        if let Some(val) = headers.get("x-amzn-transcribe-language-code") {
         645  +
            builder.language_code = Some(crate::types::CallAnalyticsLanguageCode::from(val));
         646  +
        }
         647  +
        if let Some(val) = headers.get("x-amzn-transcribe-sample-rate") {
         648  +
            builder.media_sample_rate_hertz = val.parse::<i32>().ok();
         649  +
        }
         650  +
        if let Some(val) = headers.get("x-amzn-transcribe-media-encoding") {
         651  +
            builder.media_encoding = Some(crate::types::MediaEncoding::from(val));
         652  +
        }
         653  +
        if let Some(val) = headers.get("x-amzn-transcribe-vocabulary-name") {
         654  +
            builder.vocabulary_name = Some(val.to_string());
         655  +
        }
         656  +
        if let Some(val) = headers.get("x-amzn-transcribe-session-id") {
         657  +
            builder.session_id = Some(val.to_string());
         658  +
        }
         659  +
        if let Some(val) = headers.get("x-amzn-transcribe-vocabulary-filter-name") {
         660  +
            builder.vocabulary_filter_name = Some(val.to_string());
         661  +
        }
         662  +
        if let Some(val) = headers.get("x-amzn-transcribe-vocabulary-filter-method") {
         663  +
            builder.vocabulary_filter_method = Some(crate::types::VocabularyFilterMethod::from(val));
         664  +
        }
         665  +
        if let Some(val) = headers.get("x-amzn-transcribe-language-model-name") {
         666  +
            builder.language_model_name = Some(val.to_string());
         667  +
        }
         668  +
        if let Some(val) = headers.get("x-amzn-transcribe-identify-language") {
         669  +
            builder.identify_language = val.parse::<bool>().ok();
         670  +
        }
         671  +
        if let Some(val) = headers.get("x-amzn-transcribe-language-options") {
         672  +
            builder.language_options = Some(val.to_string());
         673  +
        }
         674  +
        if let Some(val) = headers.get("x-amzn-transcribe-preferred-language") {
         675  +
            builder.preferred_language = Some(crate::types::CallAnalyticsLanguageCode::from(val));
         676  +
        }
         677  +
        if let Some(val) = headers.get("x-amzn-transcribe-vocabulary-names") {
         678  +
            builder.vocabulary_names = Some(val.to_string());
         679  +
        }
         680  +
        if let Some(val) = headers.get("x-amzn-transcribe-vocabulary-filter-names") {
         681  +
            builder.vocabulary_filter_names = Some(val.to_string());
         682  +
        }
         683  +
        if let Some(val) = headers.get("x-amzn-transcribe-enable-partial-results-stabilization") {
         684  +
            builder.enable_partial_results_stabilization = val.parse::<bool>().ok();
         685  +
        }
         686  +
        if let Some(val) = headers.get("x-amzn-transcribe-partial-results-stability") {
         687  +
            builder.partial_results_stability = Some(crate::types::PartialResultsStability::from(val));
         688  +
        }
         689  +
        if let Some(val) = headers.get("x-amzn-transcribe-content-identification-type") {
         690  +
            builder.content_identification_type = Some(crate::types::ContentIdentificationType::from(val));
         691  +
        }
         692  +
        if let Some(val) = headers.get("x-amzn-transcribe-content-redaction-type") {
         693  +
            builder.content_redaction_type = Some(crate::types::ContentRedactionType::from(val));
         694  +
        }
         695  +
        if let Some(val) = headers.get("x-amzn-transcribe-pii-entity-types") {
         696  +
            builder.pii_entity_types = Some(val.to_string());
         697  +
        }
         698  +
        #[allow(
         699  +
            unused_variables,
         700  +
            unreachable_code,
         701  +
            clippy::single_match,
         702  +
            clippy::match_single_binding,
         703  +
            clippy::diverging_sub_expression
         704  +
        )]
         705  +
        deserializer.read_struct(&STARTCALLANALYTICSSTREAMTRANSCRIPTIONINPUT_SCHEMA, &mut |member, deser| {
         706  +
            match member.member_index() {
         707  +
                Some(0) => { /* read from headers above */ }
         708  +
                Some(1) => { /* read from headers above */ }
         709  +
                Some(2) => { /* read from headers above */ }
         710  +
                Some(3) => { /* read from headers above */ }
         711  +
                Some(4) => { /* read from headers above */ }
         712  +
                Some(5) => {
         713  +
                    builder.audio_stream = Some({
         714  +
                        let _ = member;
         715  +
                        todo!("deserialize streaming union")
         716  +
                    });
         717  +
                }
         718  +
                Some(6) => { /* read from headers above */ }
         719  +
                Some(7) => { /* read from headers above */ }
         720  +
                Some(8) => { /* read from headers above */ }
         721  +
                Some(9) => { /* read from headers above */ }
         722  +
                Some(10) => { /* read from headers above */ }
         723  +
                Some(11) => { /* read from headers above */ }
         724  +
                Some(12) => { /* read from headers above */ }
         725  +
                Some(13) => { /* read from headers above */ }
         726  +
                Some(14) => { /* read from headers above */ }
         727  +
                Some(15) => { /* read from headers above */ }
         728  +
                Some(16) => { /* read from headers above */ }
         729  +
                Some(17) => { /* read from headers above */ }
         730  +
                Some(18) => { /* read from headers above */ }
         731  +
                _ => {}
         732  +
            }
         733  +
            Ok(())
         734  +
        })?;
  625    735   
        builder
  626    736   
            .build()
  627    737   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  628    738   
    }
  629    739   
}
  630    740   
impl StartCallAnalyticsStreamTranscriptionInput {
  631    741   
    /// Creates a new builder-style object to manufacture [`StartCallAnalyticsStreamTranscriptionInput`](crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionInput).
  632    742   
    pub fn builder() -> crate::operation::start_call_analytics_stream_transcription::builders::StartCallAnalyticsStreamTranscriptionInputBuilder {
  633    743   
        crate::operation::start_call_analytics_stream_transcription::builders::StartCallAnalyticsStreamTranscriptionInputBuilder::default()
  634    744   
    }