AWS SDK

AWS SDK

rev. 03f9d3736bb06bbe282d7bfe7c28721562f20a05

Files changed:

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/protocol_serde/shape_update_database.rs

@@ -28,28 +123,114 @@
   48     48   
        "InvalidEndpointException" => crate::operation::update_database::UpdateDatabaseError::InvalidEndpointException({
   49     49   
            #[allow(unused_mut)]
   50     50   
            let mut tmp = {
   51     51   
                #[allow(unused_mut)]
   52     52   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   53     53   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   54     54   
                    .map_err(crate::operation::update_database::UpdateDatabaseError::unhandled)?;
   55     55   
                let output = output.meta(generic);
   56     56   
                output.build()
   57     57   
            };
   58         -
            if tmp.message.is_none() {
   59         -
                tmp.message = _error_message;
   60         -
            }
   61     58   
            tmp
   62     59   
        }),
   63     60   
        "ResourceNotFoundException" => crate::operation::update_database::UpdateDatabaseError::ResourceNotFoundException({
   64     61   
            #[allow(unused_mut)]
   65     62   
            let mut tmp = {
   66     63   
                #[allow(unused_mut)]
   67     64   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   68     65   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   69     66   
                    .map_err(crate::operation::update_database::UpdateDatabaseError::unhandled)?;
   70     67   
                let output = output.meta(generic);
   71     68   
                output.build()
   72     69   
            };
   73         -
            if tmp.message.is_none() {
   74         -
                tmp.message = _error_message;
   75         -
            }
   76     70   
            tmp
   77     71   
        }),
   78     72   
        "ServiceQuotaExceededException" => crate::operation::update_database::UpdateDatabaseError::ServiceQuotaExceededException({
   79     73   
            #[allow(unused_mut)]
   80     74   
            let mut tmp = {
   81     75   
                #[allow(unused_mut)]
   82     76   
                let mut output = crate::types::error::builders::ServiceQuotaExceededExceptionBuilder::default();
   83     77   
                output = crate::protocol_serde::shape_service_quota_exceeded_exception::de_service_quota_exceeded_exception_json_err(
   84     78   
                    _response_body,
   85     79   
                    output,
   86     80   
                )
   87     81   
                .map_err(crate::operation::update_database::UpdateDatabaseError::unhandled)?;
   88     82   
                let output = output.meta(generic);
   89     83   
                output.build()
   90     84   
            };
   91         -
            if tmp.message.is_none() {
   92         -
                tmp.message = _error_message;
   93         -
            }
   94     85   
            tmp
   95     86   
        }),
   96     87   
        "ThrottlingException" => crate::operation::update_database::UpdateDatabaseError::ThrottlingException({
   97     88   
            #[allow(unused_mut)]
   98     89   
            let mut tmp = {
   99     90   
                #[allow(unused_mut)]
  100     91   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
  101     92   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
  102     93   
                    .map_err(crate::operation::update_database::UpdateDatabaseError::unhandled)?;
  103     94   
                let output = output.meta(generic);

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/protocol_serde/shape_update_table.rs

@@ -28,28 +105,99 @@
   48     48   
        "InvalidEndpointException" => crate::operation::update_table::UpdateTableError::InvalidEndpointException({
   49     49   
            #[allow(unused_mut)]
   50     50   
            let mut tmp = {
   51     51   
                #[allow(unused_mut)]
   52     52   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   53     53   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   54     54   
                    .map_err(crate::operation::update_table::UpdateTableError::unhandled)?;
   55     55   
                let output = output.meta(generic);
   56     56   
                output.build()
   57     57   
            };
   58         -
            if tmp.message.is_none() {
   59         -
                tmp.message = _error_message;
   60         -
            }
   61     58   
            tmp
   62     59   
        }),
   63     60   
        "ResourceNotFoundException" => crate::operation::update_table::UpdateTableError::ResourceNotFoundException({
   64     61   
            #[allow(unused_mut)]
   65     62   
            let mut tmp = {
   66     63   
                #[allow(unused_mut)]
   67     64   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   68     65   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   69     66   
                    .map_err(crate::operation::update_table::UpdateTableError::unhandled)?;
   70     67   
                let output = output.meta(generic);
   71     68   
                output.build()
   72     69   
            };
   73         -
            if tmp.message.is_none() {
   74         -
                tmp.message = _error_message;
   75         -
            }
   76     70   
            tmp
   77     71   
        }),
   78     72   
        "ThrottlingException" => crate::operation::update_table::UpdateTableError::ThrottlingException({
   79     73   
            #[allow(unused_mut)]
   80     74   
            let mut tmp = {
   81     75   
                #[allow(unused_mut)]
   82     76   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   83     77   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   84     78   
                    .map_err(crate::operation::update_table::UpdateTableError::unhandled)?;
   85     79   
                let output = output.meta(generic);

tmp-codegen-diff/aws-sdk/sdk/timestreamwrite/src/protocol_serde/shape_write_records.rs

@@ -28,28 +120,111 @@
   48     48   
        "InvalidEndpointException" => crate::operation::write_records::WriteRecordsError::InvalidEndpointException({
   49     49   
            #[allow(unused_mut)]
   50     50   
            let mut tmp = {
   51     51   
                #[allow(unused_mut)]
   52     52   
                let mut output = crate::types::error::builders::InvalidEndpointExceptionBuilder::default();
   53     53   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   54     54   
                    .map_err(crate::operation::write_records::WriteRecordsError::unhandled)?;
   55     55   
                let output = output.meta(generic);
   56     56   
                output.build()
   57     57   
            };
   58         -
            if tmp.message.is_none() {
   59         -
                tmp.message = _error_message;
   60         -
            }
   61     58   
            tmp
   62     59   
        }),
   63     60   
        "RejectedRecordsException" => crate::operation::write_records::WriteRecordsError::RejectedRecordsException({
   64     61   
            #[allow(unused_mut)]
   65     62   
            let mut tmp = {
   66     63   
                #[allow(unused_mut)]
   67     64   
                let mut output = crate::types::error::builders::RejectedRecordsExceptionBuilder::default();
   68     65   
                output = crate::protocol_serde::shape_rejected_records_exception::de_rejected_records_exception_json_err(_response_body, output)
   69     66   
                    .map_err(crate::operation::write_records::WriteRecordsError::unhandled)?;
   70     67   
                let output = output.meta(generic);
   71     68   
                output.build()
   72     69   
            };
   73         -
            if tmp.message.is_none() {
   74         -
                tmp.message = _error_message;
   75         -
            }
   76     70   
            tmp
   77     71   
        }),
   78     72   
        "ResourceNotFoundException" => crate::operation::write_records::WriteRecordsError::ResourceNotFoundException({
   79     73   
            #[allow(unused_mut)]
   80     74   
            let mut tmp = {
   81     75   
                #[allow(unused_mut)]
   82     76   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   83     77   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   84     78   
                    .map_err(crate::operation::write_records::WriteRecordsError::unhandled)?;
   85     79   
                let output = output.meta(generic);
   86     80   
                output.build()
   87     81   
            };
   88         -
            if tmp.message.is_none() {
   89         -
                tmp.message = _error_message;
   90         -
            }
   91     82   
            tmp
   92     83   
        }),
   93     84   
        "ThrottlingException" => crate::operation::write_records::WriteRecordsError::ThrottlingException({
   94     85   
            #[allow(unused_mut)]
   95     86   
            let mut tmp = {
   96     87   
                #[allow(unused_mut)]
   97     88   
                let mut output = crate::types::error::builders::ThrottlingExceptionBuilder::default();
   98     89   
                output = crate::protocol_serde::shape_throttling_exception::de_throttling_exception_json_err(_response_body, output)
   99     90   
                    .map_err(crate::operation::write_records::WriteRecordsError::unhandled)?;
  100     91   
                let output = output.meta(generic);

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

@@ -34,34 +93,110 @@
   54     54   
    /// </ul>
   55     55   
    /// <p>For more information, see <a href="https://docs.aws.amazon.com/timestream/latest/developerguide/ts-limits.html">Access Management</a> in the Timestream Developer Guide.</p>
   56     56   
    pub fn reason(&self) -> ::std::option::Option<&str> {
   57     57   
        self.reason.as_deref()
   58     58   
    }
   59     59   
    /// <p>The existing version of the record. This value is populated in scenarios where an identical record exists with a higher version than the version in the write request.</p>
   60     60   
    pub fn existing_version(&self) -> ::std::option::Option<i64> {
   61     61   
        self.existing_version
   62     62   
    }
   63     63   
}
          64  +
impl ::std::fmt::Display for RejectedRecord {
          65  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
          66  +
        ::std::write!(f, "RejectedRecord {{")?;
          67  +
        ::std::write!(f, "record_index={}", &self.record_index)?;
          68  +
        if let ::std::option::Option::Some(inner) = &self.reason {
          69  +
            ::std::write!(f, ", reason=Some({})", inner)?;
          70  +
        } else {
          71  +
            ::std::write!(f, ", reason=None")?;
          72  +
        }
          73  +
        if let ::std::option::Option::Some(inner) = &self.existing_version {
          74  +
            ::std::write!(f, ", existing_version=Some({})", inner)?;
          75  +
        } else {
          76  +
            ::std::write!(f, ", existing_version=None")?;
          77  +
        }
          78  +
        ::std::write!(f, "}}")
          79  +
    }
          80  +
}
   64     81   
impl RejectedRecord {
   65     82   
    /// Creates a new builder-style object to manufacture [`RejectedRecord`](crate::types::RejectedRecord).
   66     83   
    pub fn builder() -> crate::types::builders::RejectedRecordBuilder {
   67     84   
        crate::types::builders::RejectedRecordBuilder::default()
   68     85   
    }
   69     86   
}
   70     87   
   71     88   
/// A builder for [`RejectedRecord`](crate::types::RejectedRecord).
   72     89   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   73     90   
#[non_exhaustive]

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

@@ -155,155 +291,276 @@
  175    175   
                    #[allow(unused_mut)]
  176    176   
                    let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
  177    177   
                    output =
  178    178   
                        crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
  179    179   
                            .map_err(
  180    180   
                                crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::unhandled,
  181    181   
                            )?;
  182    182   
                    let output = output.meta(generic);
  183    183   
                    output.build()
  184    184   
                };
  185         -
                if tmp.message.is_none() {
  186         -
                    tmp.message = _error_message;
  187         -
                }
  188    185   
                tmp
  189    186   
            })
  190    187   
        }
  191    188   
        "BadRequestException" => {
  192    189   
            crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::BadRequestException({
  193    190   
                #[allow(unused_mut)]
  194    191   
                let mut tmp = {
  195    192   
                    #[allow(unused_mut)]
  196    193   
                    let mut output = crate::types::error::builders::BadRequestExceptionBuilder::default();
  197    194   
                    output = crate::protocol_serde::shape_bad_request_exception::de_bad_request_exception_json_err(_response_body, output).map_err(
  198    195   
                        crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::unhandled,
  199    196   
                    )?;
  200    197   
                    let output = output.meta(generic);
  201    198   
                    output.build()
  202    199   
                };
  203         -
                if tmp.message.is_none() {
  204         -
                    tmp.message = _error_message;
  205         -
                }
  206    200   
                tmp
  207    201   
            })
  208    202   
        }
  209    203   
        "InternalFailureException" => {
  210    204   
            crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::InternalFailureException({
  211    205   
                #[allow(unused_mut)]
  212    206   
                let mut tmp = {
  213    207   
                    #[allow(unused_mut)]
  214    208   
                    let mut output = crate::types::error::builders::InternalFailureExceptionBuilder::default();
  215    209   
                    output = crate::protocol_serde::shape_internal_failure_exception::de_internal_failure_exception_json_err(_response_body, output)
  216    210   
                        .map_err(
  217    211   
                            crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::unhandled,
  218    212   
                        )?;
  219    213   
                    let output = output.meta(generic);
  220    214   
                    output.build()
  221    215   
                };
  222         -
                if tmp.message.is_none() {
  223         -
                    tmp.message = _error_message;
  224         -
                }
  225    216   
                tmp
  226    217   
            })
  227    218   
        }
  228    219   
        "ConflictException" => {
  229    220   
            crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::ConflictException({
  230    221   
                #[allow(unused_mut)]
  231    222   
                let mut tmp = {
  232    223   
                    #[allow(unused_mut)]
  233    224   
                    let mut output = crate::types::error::builders::ConflictExceptionBuilder::default();
  234    225   
                    output = crate::protocol_serde::shape_conflict_exception::de_conflict_exception_json_err(_response_body, output).map_err(
  235    226   
                        crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::unhandled,
  236    227   
                    )?;
  237    228   
                    let output = output.meta(generic);
  238    229   
                    output.build()
  239    230   
                };
  240         -
                if tmp.message.is_none() {
  241         -
                    tmp.message = _error_message;
  242         -
                }
  243    231   
                tmp
  244    232   
            })
  245    233   
        }
  246    234   
        "LimitExceededException" => {
  247    235   
            crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::LimitExceededException({
  248    236   
                #[allow(unused_mut)]
  249    237   
                let mut tmp = {
  250    238   
                    #[allow(unused_mut)]
  251    239   
                    let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
  252    240   
                    output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
  253    241   
                        .map_err(
  254    242   
                            crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::unhandled,
  255    243   
                        )?;
  256    244   
                    let output = output.meta(generic);
  257    245   
                    output.build()
  258    246   
                };
  259         -
                if tmp.message.is_none() {
  260         -
                    tmp.message = _error_message;
  261         -
                }
  262    247   
                tmp
  263    248   
            })
  264    249   
        }
  265    250   
        _ => crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError::generic(generic),
  266    251   
    })
  267    252   
}
  268    253   
  269    254   
pub fn ser_start_call_analytics_stream_transcription_headers(
  270    255   
    input: &crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionInput,
  271    256   
    mut builder: ::http::request::Builder,

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

@@ -123,123 +249,234 @@
  143    143   
                #[allow(unused_mut)]
  144    144   
                let mut tmp = {
  145    145   
                    #[allow(unused_mut)]
  146    146   
                    let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
  147    147   
                    output =
  148    148   
                        crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
  149    149   
                            .map_err(crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionError::unhandled)?;
  150    150   
                    let output = output.meta(generic);
  151    151   
                    output.build()
  152    152   
                };
  153         -
                if tmp.message.is_none() {
  154         -
                    tmp.message = _error_message;
  155         -
                }
  156    153   
                tmp
  157    154   
            })
  158    155   
        }
  159    156   
        "BadRequestException" => crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionError::BadRequestException({
  160    157   
            #[allow(unused_mut)]
  161    158   
            let mut tmp = {
  162    159   
                #[allow(unused_mut)]
  163    160   
                let mut output = crate::types::error::builders::BadRequestExceptionBuilder::default();
  164    161   
                output = crate::protocol_serde::shape_bad_request_exception::de_bad_request_exception_json_err(_response_body, output)
  165    162   
                    .map_err(crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionError::unhandled)?;
  166    163   
                let output = output.meta(generic);
  167    164   
                output.build()
  168    165   
            };
  169         -
            if tmp.message.is_none() {
  170         -
                tmp.message = _error_message;
  171         -
            }
  172    166   
            tmp
  173    167   
        }),
  174    168   
        "InternalFailureException" => {
  175    169   
            crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionError::InternalFailureException({
  176    170   
                #[allow(unused_mut)]
  177    171   
                let mut tmp = {
  178    172   
                    #[allow(unused_mut)]
  179    173   
                    let mut output = crate::types::error::builders::InternalFailureExceptionBuilder::default();
  180    174   
                    output = crate::protocol_serde::shape_internal_failure_exception::de_internal_failure_exception_json_err(_response_body, output)
  181    175   
                        .map_err(crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionError::unhandled)?;
  182    176   
                    let output = output.meta(generic);
  183    177   
                    output.build()
  184    178   
                };
  185         -
                if tmp.message.is_none() {
  186         -
                    tmp.message = _error_message;
  187         -
                }
  188    179   
                tmp
  189    180   
            })
  190    181   
        }
  191    182   
        "ConflictException" => crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionError::ConflictException({
  192    183   
            #[allow(unused_mut)]
  193    184   
            let mut tmp = {
  194    185   
                #[allow(unused_mut)]
  195    186   
                let mut output = crate::types::error::builders::ConflictExceptionBuilder::default();
  196    187   
                output = crate::protocol_serde::shape_conflict_exception::de_conflict_exception_json_err(_response_body, output)
  197    188   
                    .map_err(crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionError::unhandled)?;
  198    189   
                let output = output.meta(generic);
  199    190   
                output.build()
  200    191   
            };
  201         -
            if tmp.message.is_none() {
  202         -
                tmp.message = _error_message;
  203         -
            }
  204    192   
            tmp
  205    193   
        }),
  206    194   
        "LimitExceededException" => {
  207    195   
            crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionError::LimitExceededException({
  208    196   
                #[allow(unused_mut)]
  209    197   
                let mut tmp = {
  210    198   
                    #[allow(unused_mut)]
  211    199   
                    let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
  212    200   
                    output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
  213    201   
                        .map_err(crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionError::unhandled)?;
  214    202   
                    let output = output.meta(generic);
  215    203   
                    output.build()
  216    204   
                };
  217         -
                if tmp.message.is_none() {
  218         -
                    tmp.message = _error_message;
  219         -
                }
  220    205   
                tmp
  221    206   
            })
  222    207   
        }
  223    208   
        _ => crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionError::generic(generic),
  224    209   
    })
  225    210   
}
  226    211   
  227    212   
pub fn ser_start_medical_stream_transcription_headers(
  228    213   
    input: &crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionInput,
  229    214   
    mut builder: ::http::request::Builder,

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

@@ -202,202 +324,309 @@
  222    222   
            #[allow(unused_mut)]
  223    223   
            let mut tmp = {
  224    224   
                #[allow(unused_mut)]
  225    225   
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
  226    226   
                output =
  227    227   
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
  228    228   
                        .map_err(crate::operation::start_stream_transcription::StartStreamTranscriptionError::unhandled)?;
  229    229   
                let output = output.meta(generic);
  230    230   
                output.build()
  231    231   
            };
  232         -
            if tmp.message.is_none() {
  233         -
                tmp.message = _error_message;
  234         -
            }
  235    232   
            tmp
  236    233   
        }),
  237    234   
        "BadRequestException" => crate::operation::start_stream_transcription::StartStreamTranscriptionError::BadRequestException({
  238    235   
            #[allow(unused_mut)]
  239    236   
            let mut tmp = {
  240    237   
                #[allow(unused_mut)]
  241    238   
                let mut output = crate::types::error::builders::BadRequestExceptionBuilder::default();
  242    239   
                output = crate::protocol_serde::shape_bad_request_exception::de_bad_request_exception_json_err(_response_body, output)
  243    240   
                    .map_err(crate::operation::start_stream_transcription::StartStreamTranscriptionError::unhandled)?;
  244    241   
                let output = output.meta(generic);
  245    242   
                output.build()
  246    243   
            };
  247         -
            if tmp.message.is_none() {
  248         -
                tmp.message = _error_message;
  249         -
            }
  250    244   
            tmp
  251    245   
        }),
  252    246   
        "InternalFailureException" => crate::operation::start_stream_transcription::StartStreamTranscriptionError::InternalFailureException({
  253    247   
            #[allow(unused_mut)]
  254    248   
            let mut tmp = {
  255    249   
                #[allow(unused_mut)]
  256    250   
                let mut output = crate::types::error::builders::InternalFailureExceptionBuilder::default();
  257    251   
                output = crate::protocol_serde::shape_internal_failure_exception::de_internal_failure_exception_json_err(_response_body, output)
  258    252   
                    .map_err(crate::operation::start_stream_transcription::StartStreamTranscriptionError::unhandled)?;
  259    253   
                let output = output.meta(generic);
  260    254   
                output.build()
  261    255   
            };
  262         -
            if tmp.message.is_none() {
  263         -
                tmp.message = _error_message;
  264         -
            }
  265    256   
            tmp
  266    257   
        }),
  267    258   
        "ConflictException" => crate::operation::start_stream_transcription::StartStreamTranscriptionError::ConflictException({
  268    259   
            #[allow(unused_mut)]
  269    260   
            let mut tmp = {
  270    261   
                #[allow(unused_mut)]
  271    262   
                let mut output = crate::types::error::builders::ConflictExceptionBuilder::default();
  272    263   
                output = crate::protocol_serde::shape_conflict_exception::de_conflict_exception_json_err(_response_body, output)
  273    264   
                    .map_err(crate::operation::start_stream_transcription::StartStreamTranscriptionError::unhandled)?;
  274    265   
                let output = output.meta(generic);
  275    266   
                output.build()
  276    267   
            };
  277         -
            if tmp.message.is_none() {
  278         -
                tmp.message = _error_message;
  279         -
            }
  280    268   
            tmp
  281    269   
        }),
  282    270   
        "LimitExceededException" => crate::operation::start_stream_transcription::StartStreamTranscriptionError::LimitExceededException({
  283    271   
            #[allow(unused_mut)]
  284    272   
            let mut tmp = {
  285    273   
                #[allow(unused_mut)]
  286    274   
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
  287    275   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
  288    276   
                    .map_err(crate::operation::start_stream_transcription::StartStreamTranscriptionError::unhandled)?;
  289    277   
                let output = output.meta(generic);
  290    278   
                output.build()
  291    279   
            };
  292         -
            if tmp.message.is_none() {
  293         -
                tmp.message = _error_message;
  294         -
            }
  295    280   
            tmp
  296    281   
        }),
  297    282   
        _ => crate::operation::start_stream_transcription::StartStreamTranscriptionError::generic(generic),
  298    283   
    })
  299    284   
}
  300    285   
  301    286   
pub fn ser_start_stream_transcription_headers(
  302    287   
    input: &crate::operation::start_stream_transcription::StartStreamTranscriptionInput,
  303    288   
    mut builder: ::http::request::Builder,
  304    289   
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {