Client Test

Client Test

rev. 03f9d3736bb06bbe282d7bfe7c28721562f20a05

Files changed:

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/protocol_serde/shape_update_item.rs

@@ -2,2 +170,146 @@
   22     22   
                #[allow(unused_mut)]
   23     23   
                let mut output = crate::types::error::builders::ConditionalCheckFailedErrorBuilder::default();
   24     24   
                output = crate::protocol_serde::shape_conditional_check_failed_exception::de_conditional_check_failed_exception_json_err(
   25     25   
                    _response_body,
   26     26   
                    output,
   27     27   
                )
   28     28   
                .map_err(crate::operation::update_item::UpdateItemError::unhandled)?;
   29     29   
                let output = output.meta(generic);
   30     30   
                output.build()
   31     31   
            };
   32         -
            if tmp.message.is_none() {
   33         -
                tmp.message = _error_message;
   34         -
            }
   35     32   
            tmp
   36     33   
        }),
   37     34   
        "InternalServerError" => crate::operation::update_item::UpdateItemError::InternalServerError({
   38     35   
            #[allow(unused_mut)]
   39     36   
            let mut tmp = {
   40     37   
                #[allow(unused_mut)]
   41     38   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   42     39   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   43     40   
                    .map_err(crate::operation::update_item::UpdateItemError::unhandled)?;
   44     41   
                let output = output.meta(generic);
   45     42   
                output.build()
   46     43   
            };
   47         -
            if tmp.message.is_none() {
   48         -
                tmp.message = _error_message;
   49         -
            }
   50     44   
            tmp
   51     45   
        }),
   52     46   
        "InvalidEndpointException" => crate::operation::update_item::UpdateItemError::InvalidEndpointError({
   53     47   
            #[allow(unused_mut)]
   54     48   
            let mut tmp = {
   55     49   
                #[allow(unused_mut)]
   56     50   
                let mut output = crate::types::error::builders::InvalidEndpointErrorBuilder::default();
   57     51   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   58     52   
                    .map_err(crate::operation::update_item::UpdateItemError::unhandled)?;
   59     53   
                let output = output.meta(generic);
   60     54   
                output.build()
   61     55   
            };
   62         -
            if tmp.message.is_none() {
   63         -
                tmp.message = _error_message;
   64         -
            }
   65     56   
            tmp
   66     57   
        }),
   67     58   
        "ItemCollectionSizeLimitExceededException" => crate::operation::update_item::UpdateItemError::ItemCollectionSizeLimitExceededError({
   68     59   
            #[allow(unused_mut)]
   69     60   
            let mut tmp = {
   70     61   
                #[allow(unused_mut)]
   71     62   
                let mut output = crate::types::error::builders::ItemCollectionSizeLimitExceededErrorBuilder::default();
   72     63   
                output = crate::protocol_serde::shape_item_collection_size_limit_exceeded_exception::de_item_collection_size_limit_exceeded_exception_json_err(_response_body, output).map_err(crate::operation::update_item::UpdateItemError::unhandled)?;
   73     64   
                let output = output.meta(generic);
   74     65   
                output.build()
   75     66   
            };
   76         -
            if tmp.message.is_none() {
   77         -
                tmp.message = _error_message;
   78         -
            }
   79     67   
            tmp
   80     68   
        }),
   81     69   
        "ProvisionedThroughputExceededException" => {
   82     70   
            crate::operation::update_item::UpdateItemError::ProvisionedThroughputExceededError({
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut tmp = {
   85     73   
                    #[allow(unused_mut)]
   86     74   
                    let mut output = crate::types::error::builders::ProvisionedThroughputExceededErrorBuilder::default();
   87     75   
                    output = crate::protocol_serde::shape_provisioned_throughput_exceeded_exception::de_provisioned_throughput_exceeded_exception_json_err(_response_body, output).map_err(crate::operation::update_item::UpdateItemError::unhandled)?;
   88     76   
                    let output = output.meta(generic);
   89     77   
                    output.build()
   90     78   
                };
   91         -
                if tmp.message.is_none() {
   92         -
                    tmp.message = _error_message;
   93         -
                }
   94     79   
                tmp
   95     80   
            })
   96     81   
        }
   97     82   
        "RequestLimitExceeded" => crate::operation::update_item::UpdateItemError::RequestLimitExceeded({
   98     83   
            #[allow(unused_mut)]
   99     84   
            let mut tmp = {
  100     85   
                #[allow(unused_mut)]
  101     86   
                let mut output = crate::types::error::builders::RequestLimitExceededBuilder::default();
  102     87   
                output = crate::protocol_serde::shape_request_limit_exceeded::de_request_limit_exceeded_json_err(_response_body, output)
  103     88   
                    .map_err(crate::operation::update_item::UpdateItemError::unhandled)?;
  104     89   
                let output = output.meta(generic);
  105     90   
                output.build()
  106     91   
            };
  107         -
            if tmp.message.is_none() {
  108         -
                tmp.message = _error_message;
  109         -
            }
  110     92   
            tmp
  111     93   
        }),
  112     94   
        "ResourceNotFoundException" => crate::operation::update_item::UpdateItemError::ResourceNotFoundError({
  113     95   
            #[allow(unused_mut)]
  114     96   
            let mut tmp = {
  115     97   
                #[allow(unused_mut)]
  116     98   
                let mut output = crate::types::error::builders::ResourceNotFoundErrorBuilder::default();
  117     99   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
  118    100   
                    .map_err(crate::operation::update_item::UpdateItemError::unhandled)?;
  119    101   
                let output = output.meta(generic);
  120    102   
                output.build()
  121    103   
            };
  122         -
            if tmp.message.is_none() {
  123         -
                tmp.message = _error_message;
  124         -
            }
  125    104   
            tmp
  126    105   
        }),
  127    106   
        "TransactionConflictException" => crate::operation::update_item::UpdateItemError::TransactionConflictError({
  128    107   
            #[allow(unused_mut)]
  129    108   
            let mut tmp = {
  130    109   
                #[allow(unused_mut)]
  131    110   
                let mut output = crate::types::error::builders::TransactionConflictErrorBuilder::default();
  132    111   
                output =
  133    112   
                    crate::protocol_serde::shape_transaction_conflict_exception::de_transaction_conflict_exception_json_err(_response_body, output)
  134    113   
                        .map_err(crate::operation::update_item::UpdateItemError::unhandled)?;
  135    114   
                let output = output.meta(generic);
  136    115   
                output.build()
  137    116   
            };
  138         -
            if tmp.message.is_none() {
  139         -
                tmp.message = _error_message;
  140         -
            }
  141    117   
            tmp
  142    118   
        }),
  143    119   
        _ => crate::operation::update_item::UpdateItemError::generic(generic),
  144    120   
    })
  145    121   
}
  146    122   
  147    123   
#[allow(clippy::unnecessary_wraps)]
  148    124   
pub fn de_update_item_http_response(
  149    125   
    _response_status: u16,
  150    126   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/protocol_serde/shape_update_table.rs

@@ -1,1 +121,106 @@
   19     19   
        "InternalServerError" => crate::operation::update_table::UpdateTableError::InternalServerError({
   20     20   
            #[allow(unused_mut)]
   21     21   
            let mut tmp = {
   22     22   
                #[allow(unused_mut)]
   23     23   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   24     24   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   25     25   
                    .map_err(crate::operation::update_table::UpdateTableError::unhandled)?;
   26     26   
                let output = output.meta(generic);
   27     27   
                output.build()
   28     28   
            };
   29         -
            if tmp.message.is_none() {
   30         -
                tmp.message = _error_message;
   31         -
            }
   32     29   
            tmp
   33     30   
        }),
   34     31   
        "InvalidEndpointException" => crate::operation::update_table::UpdateTableError::InvalidEndpointError({
   35     32   
            #[allow(unused_mut)]
   36     33   
            let mut tmp = {
   37     34   
                #[allow(unused_mut)]
   38     35   
                let mut output = crate::types::error::builders::InvalidEndpointErrorBuilder::default();
   39     36   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   40     37   
                    .map_err(crate::operation::update_table::UpdateTableError::unhandled)?;
   41     38   
                let output = output.meta(generic);
   42     39   
                output.build()
   43     40   
            };
   44         -
            if tmp.message.is_none() {
   45         -
                tmp.message = _error_message;
   46         -
            }
   47     41   
            tmp
   48     42   
        }),
   49     43   
        "LimitExceededException" => crate::operation::update_table::UpdateTableError::LimitExceededError({
   50     44   
            #[allow(unused_mut)]
   51     45   
            let mut tmp = {
   52     46   
                #[allow(unused_mut)]
   53     47   
                let mut output = crate::types::error::builders::LimitExceededErrorBuilder::default();
   54     48   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   55     49   
                    .map_err(crate::operation::update_table::UpdateTableError::unhandled)?;
   56     50   
                let output = output.meta(generic);
   57     51   
                output.build()
   58     52   
            };
   59         -
            if tmp.message.is_none() {
   60         -
                tmp.message = _error_message;
   61         -
            }
   62     53   
            tmp
   63     54   
        }),
   64     55   
        "ResourceInUseException" => crate::operation::update_table::UpdateTableError::ResourceInUseError({
   65     56   
            #[allow(unused_mut)]
   66     57   
            let mut tmp = {
   67     58   
                #[allow(unused_mut)]
   68     59   
                let mut output = crate::types::error::builders::ResourceInUseErrorBuilder::default();
   69     60   
                output = crate::protocol_serde::shape_resource_in_use_exception::de_resource_in_use_exception_json_err(_response_body, output)
   70     61   
                    .map_err(crate::operation::update_table::UpdateTableError::unhandled)?;
   71     62   
                let output = output.meta(generic);
   72     63   
                output.build()
   73     64   
            };
   74         -
            if tmp.message.is_none() {
   75         -
                tmp.message = _error_message;
   76         -
            }
   77     65   
            tmp
   78     66   
        }),
   79     67   
        "ResourceNotFoundException" => crate::operation::update_table::UpdateTableError::ResourceNotFoundError({
   80     68   
            #[allow(unused_mut)]
   81     69   
            let mut tmp = {
   82     70   
                #[allow(unused_mut)]
   83     71   
                let mut output = crate::types::error::builders::ResourceNotFoundErrorBuilder::default();
   84     72   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   85     73   
                    .map_err(crate::operation::update_table::UpdateTableError::unhandled)?;
   86     74   
                let output = output.meta(generic);
   87     75   
                output.build()
   88     76   
            };
   89         -
            if tmp.message.is_none() {
   90         -
                tmp.message = _error_message;
   91         -
            }
   92     77   
            tmp
   93     78   
        }),
   94     79   
        _ => crate::operation::update_table::UpdateTableError::generic(generic),
   95     80   
    })
   96     81   
}
   97     82   
   98     83   
#[allow(clippy::unnecessary_wraps)]
   99     84   
pub fn de_update_table_http_response(
  100     85   
    _response_status: u16,
  101     86   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/protocol_serde/shape_update_table_replica_auto_scaling.rs

@@ -2,2 +111,99 @@
   22     22   
        "InternalServerError" => crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError::InternalServerError({
   23     23   
            #[allow(unused_mut)]
   24     24   
            let mut tmp = {
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   27     27   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   28     28   
                    .map_err(crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError::unhandled)?;
   29     29   
                let output = output.meta(generic);
   30     30   
                output.build()
   31     31   
            };
   32         -
            if tmp.message.is_none() {
   33         -
                tmp.message = _error_message;
   34         -
            }
   35     32   
            tmp
   36     33   
        }),
   37     34   
        "LimitExceededException" => crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError::LimitExceededError({
   38     35   
            #[allow(unused_mut)]
   39     36   
            let mut tmp = {
   40     37   
                #[allow(unused_mut)]
   41     38   
                let mut output = crate::types::error::builders::LimitExceededErrorBuilder::default();
   42     39   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   43     40   
                    .map_err(crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError::unhandled)?;
   44     41   
                let output = output.meta(generic);
   45     42   
                output.build()
   46     43   
            };
   47         -
            if tmp.message.is_none() {
   48         -
                tmp.message = _error_message;
   49         -
            }
   50     44   
            tmp
   51     45   
        }),
   52     46   
        "ResourceInUseException" => crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError::ResourceInUseError({
   53     47   
            #[allow(unused_mut)]
   54     48   
            let mut tmp = {
   55     49   
                #[allow(unused_mut)]
   56     50   
                let mut output = crate::types::error::builders::ResourceInUseErrorBuilder::default();
   57     51   
                output = crate::protocol_serde::shape_resource_in_use_exception::de_resource_in_use_exception_json_err(_response_body, output)
   58     52   
                    .map_err(crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError::unhandled)?;
   59     53   
                let output = output.meta(generic);
   60     54   
                output.build()
   61     55   
            };
   62         -
            if tmp.message.is_none() {
   63         -
                tmp.message = _error_message;
   64         -
            }
   65     56   
            tmp
   66     57   
        }),
   67     58   
        "ResourceNotFoundException" => {
   68     59   
            crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError::ResourceNotFoundError({
   69     60   
                #[allow(unused_mut)]
   70     61   
                let mut tmp = {
   71     62   
                    #[allow(unused_mut)]
   72     63   
                    let mut output = crate::types::error::builders::ResourceNotFoundErrorBuilder::default();
   73     64   
                    output =
   74     65   
                        crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   75     66   
                            .map_err(crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError::unhandled)?;
   76     67   
                    let output = output.meta(generic);
   77     68   
                    output.build()
   78     69   
                };
   79         -
                if tmp.message.is_none() {
   80         -
                    tmp.message = _error_message;
   81         -
                }
   82     70   
                tmp
   83     71   
            })
   84     72   
        }
   85     73   
        _ => crate::operation::update_table_replica_auto_scaling::UpdateTableReplicaAutoScalingError::generic(generic),
   86     74   
    })
   87     75   
}
   88     76   
   89     77   
#[allow(clippy::unnecessary_wraps)]
   90     78   
pub fn de_update_table_replica_auto_scaling_http_response(
   91     79   
    _response_status: u16,

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/protocol_serde/shape_update_time_to_live.rs

@@ -1,1 +122,107 @@
   20     20   
        "InternalServerError" => crate::operation::update_time_to_live::UpdateTimeToLiveError::InternalServerError({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::update_time_to_live::UpdateTimeToLiveError::unhandled)?;
   27     27   
                let output = output.meta(generic);
   28     28   
                output.build()
   29     29   
            };
   30         -
            if tmp.message.is_none() {
   31         -
                tmp.message = _error_message;
   32         -
            }
   33     30   
            tmp
   34     31   
        }),
   35     32   
        "InvalidEndpointException" => crate::operation::update_time_to_live::UpdateTimeToLiveError::InvalidEndpointError({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InvalidEndpointErrorBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::update_time_to_live::UpdateTimeToLiveError::unhandled)?;
   42     39   
                let output = output.meta(generic);
   43     40   
                output.build()
   44     41   
            };
   45         -
            if tmp.message.is_none() {
   46         -
                tmp.message = _error_message;
   47         -
            }
   48     42   
            tmp
   49     43   
        }),
   50     44   
        "LimitExceededException" => crate::operation::update_time_to_live::UpdateTimeToLiveError::LimitExceededError({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::LimitExceededErrorBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::update_time_to_live::UpdateTimeToLiveError::unhandled)?;
   57     51   
                let output = output.meta(generic);
   58     52   
                output.build()
   59     53   
            };
   60         -
            if tmp.message.is_none() {
   61         -
                tmp.message = _error_message;
   62         -
            }
   63     54   
            tmp
   64     55   
        }),
   65     56   
        "ResourceInUseException" => crate::operation::update_time_to_live::UpdateTimeToLiveError::ResourceInUseError({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::ResourceInUseErrorBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_resource_in_use_exception::de_resource_in_use_exception_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::update_time_to_live::UpdateTimeToLiveError::unhandled)?;
   72     63   
                let output = output.meta(generic);
   73     64   
                output.build()
   74     65   
            };
   75         -
            if tmp.message.is_none() {
   76         -
                tmp.message = _error_message;
   77         -
            }
   78     66   
            tmp
   79     67   
        }),
   80     68   
        "ResourceNotFoundException" => crate::operation::update_time_to_live::UpdateTimeToLiveError::ResourceNotFoundError({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::ResourceNotFoundErrorBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::update_time_to_live::UpdateTimeToLiveError::unhandled)?;
   87     75   
                let output = output.meta(generic);
   88     76   
                output.build()
   89     77   
            };
   90         -
            if tmp.message.is_none() {
   91         -
                tmp.message = _error_message;
   92         -
            }
   93     78   
            tmp
   94     79   
        }),
   95     80   
        _ => crate::operation::update_time_to_live::UpdateTimeToLiveError::generic(generic),
   96     81   
    })
   97     82   
}
   98     83   
   99     84   
#[allow(clippy::unnecessary_wraps)]
  100     85   
pub fn de_update_time_to_live_http_response(
  101     86   
    _response_status: u16,
  102     87   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_cancellation_reason.rs

@@ -1,1 +57,78 @@
   18     18   
    }
   19     19   
    /// <p>Status code for the result of the cancelled transaction.</p>
   20     20   
    pub fn code(&self) -> ::std::option::Option<&str> {
   21     21   
        self.code.as_deref()
   22     22   
    }
   23     23   
    /// <p>Cancellation reason message description.</p>
   24     24   
    pub fn message(&self) -> ::std::option::Option<&str> {
   25     25   
        self.message.as_deref()
   26     26   
    }
   27     27   
}
          28  +
impl ::std::fmt::Display for CancellationReason {
          29  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
          30  +
        ::std::write!(f, "CancellationReason {{")?;
          31  +
        if let ::std::option::Option::Some(_) = &self.item {
          32  +
            ::std::write!(f, "item=Some()")?;
          33  +
        } else {
          34  +
            ::std::write!(f, "item=None")?;
          35  +
        }
          36  +
        if let ::std::option::Option::Some(inner) = &self.code {
          37  +
            ::std::write!(f, ", code=Some({})", inner)?;
          38  +
        } else {
          39  +
            ::std::write!(f, ", code=None")?;
          40  +
        }
          41  +
        if let ::std::option::Option::Some(inner) = &self.message {
          42  +
            ::std::write!(f, ", message=Some({})", inner)?;
          43  +
        } else {
          44  +
            ::std::write!(f, ", message=None")?;
          45  +
        }
          46  +
        ::std::write!(f, "}}")
          47  +
    }
          48  +
}
   28     49   
impl CancellationReason {
   29     50   
    /// Creates a new builder-style object to manufacture [`CancellationReason`](crate::types::CancellationReason).
   30     51   
    pub fn builder() -> crate::types::builders::CancellationReasonBuilder {
   31     52   
        crate::types::builders::CancellationReasonBuilder::default()
   32     53   
    }
   33     54   
}
   34     55   
   35     56   
/// A builder for [`CancellationReason`](crate::types::CancellationReason).
   36     57   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   37     58   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/protocol_serde/shape_complete_snapshot.rs

@@ -1,1 +141,123 @@
   21     21   
            let mut tmp = {
   22     22   
                #[allow(unused_mut)]
   23     23   
                let mut output = crate::types::error::builders::AccessDeniedErrorBuilder::default();
   24     24   
                output = crate::protocol_serde::shape_access_denied_exception::de_access_denied_exception_json_err(_response_body, output)
   25     25   
                    .map_err(crate::operation::complete_snapshot::CompleteSnapshotError::unhandled)?;
   26     26   
                let output = output.meta(generic);
   27     27   
                crate::serde_util::access_denied_exception_correct_errors(output)
   28     28   
                    .build()
   29     29   
                    .map_err(crate::operation::complete_snapshot::CompleteSnapshotError::unhandled)?
   30     30   
            };
   31         -
            if tmp.message.is_none() {
   32         -
                tmp.message = _error_message;
   33         -
            }
   34     31   
            tmp
   35     32   
        }),
   36     33   
        "InternalServerException" => crate::operation::complete_snapshot::CompleteSnapshotError::InternalServerError({
   37     34   
            #[allow(unused_mut)]
   38     35   
            let mut tmp = {
   39     36   
                #[allow(unused_mut)]
   40     37   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   41     38   
                output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
   42     39   
                    .map_err(crate::operation::complete_snapshot::CompleteSnapshotError::unhandled)?;
   43     40   
                let output = output.meta(generic);
   44     41   
                output.build()
   45     42   
            };
   46         -
            if tmp.message.is_none() {
   47         -
                tmp.message = _error_message;
   48         -
            }
   49     43   
            tmp
   50     44   
        }),
   51     45   
        "RequestThrottledException" => crate::operation::complete_snapshot::CompleteSnapshotError::RequestThrottledError({
   52     46   
            #[allow(unused_mut)]
   53     47   
            let mut tmp = {
   54     48   
                #[allow(unused_mut)]
   55     49   
                let mut output = crate::types::error::builders::RequestThrottledErrorBuilder::default();
   56     50   
                output = crate::protocol_serde::shape_request_throttled_exception::de_request_throttled_exception_json_err(_response_body, output)
   57     51   
                    .map_err(crate::operation::complete_snapshot::CompleteSnapshotError::unhandled)?;
   58     52   
                let output = output.meta(generic);
   59     53   
                output.build()
   60     54   
            };
   61         -
            if tmp.message.is_none() {
   62         -
                tmp.message = _error_message;
   63         -
            }
   64     55   
            tmp
   65     56   
        }),
   66     57   
        "ResourceNotFoundException" => crate::operation::complete_snapshot::CompleteSnapshotError::ResourceNotFoundError({
   67     58   
            #[allow(unused_mut)]
   68     59   
            let mut tmp = {
   69     60   
                #[allow(unused_mut)]
   70     61   
                let mut output = crate::types::error::builders::ResourceNotFoundErrorBuilder::default();
   71     62   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   72     63   
                    .map_err(crate::operation::complete_snapshot::CompleteSnapshotError::unhandled)?;
   73     64   
                let output = output.meta(generic);
   74     65   
                output.build()
   75     66   
            };
   76         -
            if tmp.message.is_none() {
   77         -
                tmp.message = _error_message;
   78         -
            }
   79     67   
            tmp
   80     68   
        }),
   81     69   
        "ServiceQuotaExceededException" => crate::operation::complete_snapshot::CompleteSnapshotError::ServiceQuotaExceededError({
   82     70   
            #[allow(unused_mut)]
   83     71   
            let mut tmp = {
   84     72   
                #[allow(unused_mut)]
   85     73   
                let mut output = crate::types::error::builders::ServiceQuotaExceededErrorBuilder::default();
   86     74   
                output = crate::protocol_serde::shape_service_quota_exceeded_exception::de_service_quota_exceeded_exception_json_err(
   87     75   
                    _response_body,
   88     76   
                    output,
   89     77   
                )
   90     78   
                .map_err(crate::operation::complete_snapshot::CompleteSnapshotError::unhandled)?;
   91     79   
                let output = output.meta(generic);
   92     80   
                output.build()
   93     81   
            };
   94         -
            if tmp.message.is_none() {
   95         -
                tmp.message = _error_message;
   96         -
            }
   97     82   
            tmp
   98     83   
        }),
   99     84   
        "ValidationException" => crate::operation::complete_snapshot::CompleteSnapshotError::ValidationError({
  100     85   
            #[allow(unused_mut)]
  101     86   
            let mut tmp = {
  102     87   
                #[allow(unused_mut)]
  103     88   
                let mut output = crate::types::error::builders::ValidationErrorBuilder::default();
  104     89   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
  105     90   
                    .map_err(crate::operation::complete_snapshot::CompleteSnapshotError::unhandled)?;
  106     91   
                let output = output.meta(generic);
  107     92   
                output.build()
  108     93   
            };
  109         -
            if tmp.message.is_none() {
  110         -
                tmp.message = _error_message;
  111         -
            }
  112     94   
            tmp
  113     95   
        }),
  114     96   
        _ => crate::operation::complete_snapshot::CompleteSnapshotError::generic(generic),
  115     97   
    })
  116     98   
}
  117     99   
  118    100   
#[allow(clippy::unnecessary_wraps)]
  119    101   
pub fn de_complete_snapshot_http_response(
  120    102   
    _response_status: u16,
  121    103   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/protocol_serde/shape_get_snapshot_block.rs

@@ -38,38 +153,135 @@
   58     58   
            let mut tmp = {
   59     59   
                #[allow(unused_mut)]
   60     60   
                let mut output = crate::types::error::builders::AccessDeniedErrorBuilder::default();
   61     61   
                output = crate::protocol_serde::shape_access_denied_exception::de_access_denied_exception_json_err(_response_body, output)
   62     62   
                    .map_err(crate::operation::get_snapshot_block::GetSnapshotBlockError::unhandled)?;
   63     63   
                let output = output.meta(generic);
   64     64   
                crate::serde_util::access_denied_exception_correct_errors(output)
   65     65   
                    .build()
   66     66   
                    .map_err(crate::operation::get_snapshot_block::GetSnapshotBlockError::unhandled)?
   67     67   
            };
   68         -
            if tmp.message.is_none() {
   69         -
                tmp.message = _error_message;
   70         -
            }
   71     68   
            tmp
   72     69   
        }),
   73     70   
        "InternalServerException" => crate::operation::get_snapshot_block::GetSnapshotBlockError::InternalServerError({
   74     71   
            #[allow(unused_mut)]
   75     72   
            let mut tmp = {
   76     73   
                #[allow(unused_mut)]
   77     74   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   78     75   
                output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
   79     76   
                    .map_err(crate::operation::get_snapshot_block::GetSnapshotBlockError::unhandled)?;
   80     77   
                let output = output.meta(generic);
   81     78   
                output.build()
   82     79   
            };
   83         -
            if tmp.message.is_none() {
   84         -
                tmp.message = _error_message;
   85         -
            }
   86     80   
            tmp
   87     81   
        }),
   88     82   
        "RequestThrottledException" => crate::operation::get_snapshot_block::GetSnapshotBlockError::RequestThrottledError({
   89     83   
            #[allow(unused_mut)]
   90     84   
            let mut tmp = {
   91     85   
                #[allow(unused_mut)]
   92     86   
                let mut output = crate::types::error::builders::RequestThrottledErrorBuilder::default();
   93     87   
                output = crate::protocol_serde::shape_request_throttled_exception::de_request_throttled_exception_json_err(_response_body, output)
   94     88   
                    .map_err(crate::operation::get_snapshot_block::GetSnapshotBlockError::unhandled)?;
   95     89   
                let output = output.meta(generic);
   96     90   
                output.build()
   97     91   
            };
   98         -
            if tmp.message.is_none() {
   99         -
                tmp.message = _error_message;
  100         -
            }
  101     92   
            tmp
  102     93   
        }),
  103     94   
        "ResourceNotFoundException" => crate::operation::get_snapshot_block::GetSnapshotBlockError::ResourceNotFoundError({
  104     95   
            #[allow(unused_mut)]
  105     96   
            let mut tmp = {
  106     97   
                #[allow(unused_mut)]
  107     98   
                let mut output = crate::types::error::builders::ResourceNotFoundErrorBuilder::default();
  108     99   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
  109    100   
                    .map_err(crate::operation::get_snapshot_block::GetSnapshotBlockError::unhandled)?;
  110    101   
                let output = output.meta(generic);
  111    102   
                output.build()
  112    103   
            };
  113         -
            if tmp.message.is_none() {
  114         -
                tmp.message = _error_message;
  115         -
            }
  116    104   
            tmp
  117    105   
        }),
  118    106   
        "ServiceQuotaExceededException" => crate::operation::get_snapshot_block::GetSnapshotBlockError::ServiceQuotaExceededError({
  119    107   
            #[allow(unused_mut)]
  120    108   
            let mut tmp = {
  121    109   
                #[allow(unused_mut)]
  122    110   
                let mut output = crate::types::error::builders::ServiceQuotaExceededErrorBuilder::default();
  123    111   
                output = crate::protocol_serde::shape_service_quota_exceeded_exception::de_service_quota_exceeded_exception_json_err(
  124    112   
                    _response_body,
  125    113   
                    output,
  126    114   
                )
  127    115   
                .map_err(crate::operation::get_snapshot_block::GetSnapshotBlockError::unhandled)?;
  128    116   
                let output = output.meta(generic);
  129    117   
                output.build()
  130    118   
            };
  131         -
            if tmp.message.is_none() {
  132         -
                tmp.message = _error_message;
  133         -
            }
  134    119   
            tmp
  135    120   
        }),
  136    121   
        "ValidationException" => crate::operation::get_snapshot_block::GetSnapshotBlockError::ValidationError({
  137    122   
            #[allow(unused_mut)]
  138    123   
            let mut tmp = {
  139    124   
                #[allow(unused_mut)]
  140    125   
                let mut output = crate::types::error::builders::ValidationErrorBuilder::default();
  141    126   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
  142    127   
                    .map_err(crate::operation::get_snapshot_block::GetSnapshotBlockError::unhandled)?;
  143    128   
                let output = output.meta(generic);
  144    129   
                output.build()
  145    130   
            };
  146         -
            if tmp.message.is_none() {
  147         -
                tmp.message = _error_message;
  148         -
            }
  149    131   
            tmp
  150    132   
        }),
  151    133   
        _ => crate::operation::get_snapshot_block::GetSnapshotBlockError::generic(generic),
  152    134   
    })
  153    135   
}

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/protocol_serde/shape_list_changed_blocks.rs

@@ -2,2 +142,124 @@
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::AccessDeniedErrorBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_access_denied_exception::de_access_denied_exception_json_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::list_changed_blocks::ListChangedBlocksError::unhandled)?;
   27     27   
                let output = output.meta(generic);
   28     28   
                crate::serde_util::access_denied_exception_correct_errors(output)
   29     29   
                    .build()
   30     30   
                    .map_err(crate::operation::list_changed_blocks::ListChangedBlocksError::unhandled)?
   31     31   
            };
   32         -
            if tmp.message.is_none() {
   33         -
                tmp.message = _error_message;
   34         -
            }
   35     32   
            tmp
   36     33   
        }),
   37     34   
        "InternalServerException" => crate::operation::list_changed_blocks::ListChangedBlocksError::InternalServerError({
   38     35   
            #[allow(unused_mut)]
   39     36   
            let mut tmp = {
   40     37   
                #[allow(unused_mut)]
   41     38   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   42     39   
                output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
   43     40   
                    .map_err(crate::operation::list_changed_blocks::ListChangedBlocksError::unhandled)?;
   44     41   
                let output = output.meta(generic);
   45     42   
                output.build()
   46     43   
            };
   47         -
            if tmp.message.is_none() {
   48         -
                tmp.message = _error_message;
   49         -
            }
   50     44   
            tmp
   51     45   
        }),
   52     46   
        "RequestThrottledException" => crate::operation::list_changed_blocks::ListChangedBlocksError::RequestThrottledError({
   53     47   
            #[allow(unused_mut)]
   54     48   
            let mut tmp = {
   55     49   
                #[allow(unused_mut)]
   56     50   
                let mut output = crate::types::error::builders::RequestThrottledErrorBuilder::default();
   57     51   
                output = crate::protocol_serde::shape_request_throttled_exception::de_request_throttled_exception_json_err(_response_body, output)
   58     52   
                    .map_err(crate::operation::list_changed_blocks::ListChangedBlocksError::unhandled)?;
   59     53   
                let output = output.meta(generic);
   60     54   
                output.build()
   61     55   
            };
   62         -
            if tmp.message.is_none() {
   63         -
                tmp.message = _error_message;
   64         -
            }
   65     56   
            tmp
   66     57   
        }),
   67     58   
        "ResourceNotFoundException" => crate::operation::list_changed_blocks::ListChangedBlocksError::ResourceNotFoundError({
   68     59   
            #[allow(unused_mut)]
   69     60   
            let mut tmp = {
   70     61   
                #[allow(unused_mut)]
   71     62   
                let mut output = crate::types::error::builders::ResourceNotFoundErrorBuilder::default();
   72     63   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   73     64   
                    .map_err(crate::operation::list_changed_blocks::ListChangedBlocksError::unhandled)?;
   74     65   
                let output = output.meta(generic);
   75     66   
                output.build()
   76     67   
            };
   77         -
            if tmp.message.is_none() {
   78         -
                tmp.message = _error_message;
   79         -
            }
   80     68   
            tmp
   81     69   
        }),
   82     70   
        "ServiceQuotaExceededException" => crate::operation::list_changed_blocks::ListChangedBlocksError::ServiceQuotaExceededError({
   83     71   
            #[allow(unused_mut)]
   84     72   
            let mut tmp = {
   85     73   
                #[allow(unused_mut)]
   86     74   
                let mut output = crate::types::error::builders::ServiceQuotaExceededErrorBuilder::default();
   87     75   
                output = crate::protocol_serde::shape_service_quota_exceeded_exception::de_service_quota_exceeded_exception_json_err(
   88     76   
                    _response_body,
   89     77   
                    output,
   90     78   
                )
   91     79   
                .map_err(crate::operation::list_changed_blocks::ListChangedBlocksError::unhandled)?;
   92     80   
                let output = output.meta(generic);
   93     81   
                output.build()
   94     82   
            };
   95         -
            if tmp.message.is_none() {
   96         -
                tmp.message = _error_message;
   97         -
            }
   98     83   
            tmp
   99     84   
        }),
  100     85   
        "ValidationException" => crate::operation::list_changed_blocks::ListChangedBlocksError::ValidationError({
  101     86   
            #[allow(unused_mut)]
  102     87   
            let mut tmp = {
  103     88   
                #[allow(unused_mut)]
  104     89   
                let mut output = crate::types::error::builders::ValidationErrorBuilder::default();
  105     90   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
  106     91   
                    .map_err(crate::operation::list_changed_blocks::ListChangedBlocksError::unhandled)?;
  107     92   
                let output = output.meta(generic);
  108     93   
                output.build()
  109     94   
            };
  110         -
            if tmp.message.is_none() {
  111         -
                tmp.message = _error_message;
  112         -
            }
  113     95   
            tmp
  114     96   
        }),
  115     97   
        _ => crate::operation::list_changed_blocks::ListChangedBlocksError::generic(generic),
  116     98   
    })
  117     99   
}
  118    100   
  119    101   
#[allow(clippy::unnecessary_wraps)]
  120    102   
pub fn de_list_changed_blocks_http_response(
  121    103   
    _response_status: u16,
  122    104   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/protocol_serde/shape_list_snapshot_blocks.rs

@@ -4,4 +144,126 @@
   24     24   
            let mut tmp = {
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut output = crate::types::error::builders::AccessDeniedErrorBuilder::default();
   27     27   
                output = crate::protocol_serde::shape_access_denied_exception::de_access_denied_exception_json_err(_response_body, output)
   28     28   
                    .map_err(crate::operation::list_snapshot_blocks::ListSnapshotBlocksError::unhandled)?;
   29     29   
                let output = output.meta(generic);
   30     30   
                crate::serde_util::access_denied_exception_correct_errors(output)
   31     31   
                    .build()
   32     32   
                    .map_err(crate::operation::list_snapshot_blocks::ListSnapshotBlocksError::unhandled)?
   33     33   
            };
   34         -
            if tmp.message.is_none() {
   35         -
                tmp.message = _error_message;
   36         -
            }
   37     34   
            tmp
   38     35   
        }),
   39     36   
        "InternalServerException" => crate::operation::list_snapshot_blocks::ListSnapshotBlocksError::InternalServerError({
   40     37   
            #[allow(unused_mut)]
   41     38   
            let mut tmp = {
   42     39   
                #[allow(unused_mut)]
   43     40   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   44     41   
                output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
   45     42   
                    .map_err(crate::operation::list_snapshot_blocks::ListSnapshotBlocksError::unhandled)?;
   46     43   
                let output = output.meta(generic);
   47     44   
                output.build()
   48     45   
            };
   49         -
            if tmp.message.is_none() {
   50         -
                tmp.message = _error_message;
   51         -
            }
   52     46   
            tmp
   53     47   
        }),
   54     48   
        "RequestThrottledException" => crate::operation::list_snapshot_blocks::ListSnapshotBlocksError::RequestThrottledError({
   55     49   
            #[allow(unused_mut)]
   56     50   
            let mut tmp = {
   57     51   
                #[allow(unused_mut)]
   58     52   
                let mut output = crate::types::error::builders::RequestThrottledErrorBuilder::default();
   59     53   
                output = crate::protocol_serde::shape_request_throttled_exception::de_request_throttled_exception_json_err(_response_body, output)
   60     54   
                    .map_err(crate::operation::list_snapshot_blocks::ListSnapshotBlocksError::unhandled)?;
   61     55   
                let output = output.meta(generic);
   62     56   
                output.build()
   63     57   
            };
   64         -
            if tmp.message.is_none() {
   65         -
                tmp.message = _error_message;
   66         -
            }
   67     58   
            tmp
   68     59   
        }),
   69     60   
        "ResourceNotFoundException" => crate::operation::list_snapshot_blocks::ListSnapshotBlocksError::ResourceNotFoundError({
   70     61   
            #[allow(unused_mut)]
   71     62   
            let mut tmp = {
   72     63   
                #[allow(unused_mut)]
   73     64   
                let mut output = crate::types::error::builders::ResourceNotFoundErrorBuilder::default();
   74     65   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   75     66   
                    .map_err(crate::operation::list_snapshot_blocks::ListSnapshotBlocksError::unhandled)?;
   76     67   
                let output = output.meta(generic);
   77     68   
                output.build()
   78     69   
            };
   79         -
            if tmp.message.is_none() {
   80         -
                tmp.message = _error_message;
   81         -
            }
   82     70   
            tmp
   83     71   
        }),
   84     72   
        "ServiceQuotaExceededException" => crate::operation::list_snapshot_blocks::ListSnapshotBlocksError::ServiceQuotaExceededError({
   85     73   
            #[allow(unused_mut)]
   86     74   
            let mut tmp = {
   87     75   
                #[allow(unused_mut)]
   88     76   
                let mut output = crate::types::error::builders::ServiceQuotaExceededErrorBuilder::default();
   89     77   
                output = crate::protocol_serde::shape_service_quota_exceeded_exception::de_service_quota_exceeded_exception_json_err(
   90     78   
                    _response_body,
   91     79   
                    output,
   92     80   
                )
   93     81   
                .map_err(crate::operation::list_snapshot_blocks::ListSnapshotBlocksError::unhandled)?;
   94     82   
                let output = output.meta(generic);
   95     83   
                output.build()
   96     84   
            };
   97         -
            if tmp.message.is_none() {
   98         -
                tmp.message = _error_message;
   99         -
            }
  100     85   
            tmp
  101     86   
        }),
  102     87   
        "ValidationException" => crate::operation::list_snapshot_blocks::ListSnapshotBlocksError::ValidationError({
  103     88   
            #[allow(unused_mut)]
  104     89   
            let mut tmp = {
  105     90   
                #[allow(unused_mut)]
  106     91   
                let mut output = crate::types::error::builders::ValidationErrorBuilder::default();
  107     92   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
  108     93   
                    .map_err(crate::operation::list_snapshot_blocks::ListSnapshotBlocksError::unhandled)?;
  109     94   
                let output = output.meta(generic);
  110     95   
                output.build()
  111     96   
            };
  112         -
            if tmp.message.is_none() {
  113         -
                tmp.message = _error_message;
  114         -
            }
  115     97   
            tmp
  116     98   
        }),
  117     99   
        _ => crate::operation::list_snapshot_blocks::ListSnapshotBlocksError::generic(generic),
  118    100   
    })
  119    101   
}
  120    102   
  121    103   
#[allow(clippy::unnecessary_wraps)]
  122    104   
pub fn de_list_snapshot_blocks_http_response(
  123    105   
    _response_status: u16,
  124    106   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/protocol_serde/shape_put_snapshot_block.rs

@@ -1,1 +141,123 @@
   21     21   
            let mut tmp = {
   22     22   
                #[allow(unused_mut)]
   23     23   
                let mut output = crate::types::error::builders::AccessDeniedErrorBuilder::default();
   24     24   
                output = crate::protocol_serde::shape_access_denied_exception::de_access_denied_exception_json_err(_response_body, output)
   25     25   
                    .map_err(crate::operation::put_snapshot_block::PutSnapshotBlockError::unhandled)?;
   26     26   
                let output = output.meta(generic);
   27     27   
                crate::serde_util::access_denied_exception_correct_errors(output)
   28     28   
                    .build()
   29     29   
                    .map_err(crate::operation::put_snapshot_block::PutSnapshotBlockError::unhandled)?
   30     30   
            };
   31         -
            if tmp.message.is_none() {
   32         -
                tmp.message = _error_message;
   33         -
            }
   34     31   
            tmp
   35     32   
        }),
   36     33   
        "InternalServerException" => crate::operation::put_snapshot_block::PutSnapshotBlockError::InternalServerError({
   37     34   
            #[allow(unused_mut)]
   38     35   
            let mut tmp = {
   39     36   
                #[allow(unused_mut)]
   40     37   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   41     38   
                output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
   42     39   
                    .map_err(crate::operation::put_snapshot_block::PutSnapshotBlockError::unhandled)?;
   43     40   
                let output = output.meta(generic);
   44     41   
                output.build()
   45     42   
            };
   46         -
            if tmp.message.is_none() {
   47         -
                tmp.message = _error_message;
   48         -
            }
   49     43   
            tmp
   50     44   
        }),
   51     45   
        "RequestThrottledException" => crate::operation::put_snapshot_block::PutSnapshotBlockError::RequestThrottledError({
   52     46   
            #[allow(unused_mut)]
   53     47   
            let mut tmp = {
   54     48   
                #[allow(unused_mut)]
   55     49   
                let mut output = crate::types::error::builders::RequestThrottledErrorBuilder::default();
   56     50   
                output = crate::protocol_serde::shape_request_throttled_exception::de_request_throttled_exception_json_err(_response_body, output)
   57     51   
                    .map_err(crate::operation::put_snapshot_block::PutSnapshotBlockError::unhandled)?;
   58     52   
                let output = output.meta(generic);
   59     53   
                output.build()
   60     54   
            };
   61         -
            if tmp.message.is_none() {
   62         -
                tmp.message = _error_message;
   63         -
            }
   64     55   
            tmp
   65     56   
        }),
   66     57   
        "ResourceNotFoundException" => crate::operation::put_snapshot_block::PutSnapshotBlockError::ResourceNotFoundError({
   67     58   
            #[allow(unused_mut)]
   68     59   
            let mut tmp = {
   69     60   
                #[allow(unused_mut)]
   70     61   
                let mut output = crate::types::error::builders::ResourceNotFoundErrorBuilder::default();
   71     62   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   72     63   
                    .map_err(crate::operation::put_snapshot_block::PutSnapshotBlockError::unhandled)?;
   73     64   
                let output = output.meta(generic);
   74     65   
                output.build()
   75     66   
            };
   76         -
            if tmp.message.is_none() {
   77         -
                tmp.message = _error_message;
   78         -
            }
   79     67   
            tmp
   80     68   
        }),
   81     69   
        "ServiceQuotaExceededException" => crate::operation::put_snapshot_block::PutSnapshotBlockError::ServiceQuotaExceededError({
   82     70   
            #[allow(unused_mut)]
   83     71   
            let mut tmp = {
   84     72   
                #[allow(unused_mut)]
   85     73   
                let mut output = crate::types::error::builders::ServiceQuotaExceededErrorBuilder::default();
   86     74   
                output = crate::protocol_serde::shape_service_quota_exceeded_exception::de_service_quota_exceeded_exception_json_err(
   87     75   
                    _response_body,
   88     76   
                    output,
   89     77   
                )
   90     78   
                .map_err(crate::operation::put_snapshot_block::PutSnapshotBlockError::unhandled)?;
   91     79   
                let output = output.meta(generic);
   92     80   
                output.build()
   93     81   
            };
   94         -
            if tmp.message.is_none() {
   95         -
                tmp.message = _error_message;
   96         -
            }
   97     82   
            tmp
   98     83   
        }),
   99     84   
        "ValidationException" => crate::operation::put_snapshot_block::PutSnapshotBlockError::ValidationError({
  100     85   
            #[allow(unused_mut)]
  101     86   
            let mut tmp = {
  102     87   
                #[allow(unused_mut)]
  103     88   
                let mut output = crate::types::error::builders::ValidationErrorBuilder::default();
  104     89   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
  105     90   
                    .map_err(crate::operation::put_snapshot_block::PutSnapshotBlockError::unhandled)?;
  106     91   
                let output = output.meta(generic);
  107     92   
                output.build()
  108     93   
            };
  109         -
            if tmp.message.is_none() {
  110         -
                tmp.message = _error_message;
  111         -
            }
  112     94   
            tmp
  113     95   
        }),
  114     96   
        _ => crate::operation::put_snapshot_block::PutSnapshotBlockError::generic(generic),
  115     97   
    })
  116     98   
}
  117     99   
  118    100   
#[allow(clippy::unnecessary_wraps)]
  119    101   
pub fn de_put_snapshot_block_http_response(
  120    102   
    _response_status: u16,
  121    103   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/protocol_serde/shape_start_snapshot.rs

@@ -1,1 +174,150 @@
   21     21   
            let mut tmp = {
   22     22   
                #[allow(unused_mut)]
   23     23   
                let mut output = crate::types::error::builders::AccessDeniedErrorBuilder::default();
   24     24   
                output = crate::protocol_serde::shape_access_denied_exception::de_access_denied_exception_json_err(_response_body, output)
   25     25   
                    .map_err(crate::operation::start_snapshot::StartSnapshotError::unhandled)?;
   26     26   
                let output = output.meta(generic);
   27     27   
                crate::serde_util::access_denied_exception_correct_errors(output)
   28     28   
                    .build()
   29     29   
                    .map_err(crate::operation::start_snapshot::StartSnapshotError::unhandled)?
   30     30   
            };
   31         -
            if tmp.message.is_none() {
   32         -
                tmp.message = _error_message;
   33         -
            }
   34     31   
            tmp
   35     32   
        }),
   36     33   
        "ConcurrentLimitExceededException" => crate::operation::start_snapshot::StartSnapshotError::ConcurrentLimitExceededError({
   37     34   
            #[allow(unused_mut)]
   38     35   
            let mut tmp = {
   39     36   
                #[allow(unused_mut)]
   40     37   
                let mut output = crate::types::error::builders::ConcurrentLimitExceededErrorBuilder::default();
   41     38   
                output = crate::protocol_serde::shape_concurrent_limit_exceeded_exception::de_concurrent_limit_exceeded_exception_json_err(
   42     39   
                    _response_body,
   43     40   
                    output,
   44     41   
                )
   45     42   
                .map_err(crate::operation::start_snapshot::StartSnapshotError::unhandled)?;
   46     43   
                let output = output.meta(generic);
   47     44   
                output.build()
   48     45   
            };
   49         -
            if tmp.message.is_none() {
   50         -
                tmp.message = _error_message;
   51         -
            }
   52     46   
            tmp
   53     47   
        }),
   54     48   
        "ConflictException" => crate::operation::start_snapshot::StartSnapshotError::ConflictError({
   55     49   
            #[allow(unused_mut)]
   56     50   
            let mut tmp = {
   57     51   
                #[allow(unused_mut)]
   58     52   
                let mut output = crate::types::error::builders::ConflictErrorBuilder::default();
   59     53   
                output = crate::protocol_serde::shape_conflict_exception::de_conflict_exception_json_err(_response_body, output)
   60     54   
                    .map_err(crate::operation::start_snapshot::StartSnapshotError::unhandled)?;
   61     55   
                let output = output.meta(generic);
   62     56   
                output.build()
   63     57   
            };
   64         -
            if tmp.message.is_none() {
   65         -
                tmp.message = _error_message;
   66         -
            }
   67     58   
            tmp
   68     59   
        }),
   69     60   
        "InternalServerException" => crate::operation::start_snapshot::StartSnapshotError::InternalServerError({
   70     61   
            #[allow(unused_mut)]
   71     62   
            let mut tmp = {
   72     63   
                #[allow(unused_mut)]
   73     64   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   74     65   
                output = crate::protocol_serde::shape_internal_server_exception::de_internal_server_exception_json_err(_response_body, output)
   75     66   
                    .map_err(crate::operation::start_snapshot::StartSnapshotError::unhandled)?;
   76     67   
                let output = output.meta(generic);
   77     68   
                output.build()
   78     69   
            };
   79         -
            if tmp.message.is_none() {
   80         -
                tmp.message = _error_message;
   81         -
            }
   82     70   
            tmp
   83     71   
        }),
   84     72   
        "RequestThrottledException" => crate::operation::start_snapshot::StartSnapshotError::RequestThrottledError({
   85     73   
            #[allow(unused_mut)]
   86     74   
            let mut tmp = {
   87     75   
                #[allow(unused_mut)]
   88     76   
                let mut output = crate::types::error::builders::RequestThrottledErrorBuilder::default();
   89     77   
                output = crate::protocol_serde::shape_request_throttled_exception::de_request_throttled_exception_json_err(_response_body, output)
   90     78   
                    .map_err(crate::operation::start_snapshot::StartSnapshotError::unhandled)?;
   91     79   
                let output = output.meta(generic);
   92     80   
                output.build()
   93     81   
            };
   94         -
            if tmp.message.is_none() {
   95         -
                tmp.message = _error_message;
   96         -
            }
   97     82   
            tmp
   98     83   
        }),
   99     84   
        "ResourceNotFoundException" => crate::operation::start_snapshot::StartSnapshotError::ResourceNotFoundError({
  100     85   
            #[allow(unused_mut)]
  101     86   
            let mut tmp = {
  102     87   
                #[allow(unused_mut)]
  103     88   
                let mut output = crate::types::error::builders::ResourceNotFoundErrorBuilder::default();
  104     89   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
  105     90   
                    .map_err(crate::operation::start_snapshot::StartSnapshotError::unhandled)?;
  106     91   
                let output = output.meta(generic);
  107     92   
                output.build()
  108     93   
            };
  109         -
            if tmp.message.is_none() {
  110         -
                tmp.message = _error_message;
  111         -
            }
  112     94   
            tmp
  113     95   
        }),
  114     96   
        "ServiceQuotaExceededException" => crate::operation::start_snapshot::StartSnapshotError::ServiceQuotaExceededError({
  115     97   
            #[allow(unused_mut)]
  116     98   
            let mut tmp = {
  117     99   
                #[allow(unused_mut)]
  118    100   
                let mut output = crate::types::error::builders::ServiceQuotaExceededErrorBuilder::default();
  119    101   
                output = crate::protocol_serde::shape_service_quota_exceeded_exception::de_service_quota_exceeded_exception_json_err(
  120    102   
                    _response_body,
  121    103   
                    output,
  122    104   
                )
  123    105   
                .map_err(crate::operation::start_snapshot::StartSnapshotError::unhandled)?;
  124    106   
                let output = output.meta(generic);
  125    107   
                output.build()
  126    108   
            };
  127         -
            if tmp.message.is_none() {
  128         -
                tmp.message = _error_message;
  129         -
            }
  130    109   
            tmp
  131    110   
        }),
  132    111   
        "ValidationException" => crate::operation::start_snapshot::StartSnapshotError::ValidationError({
  133    112   
            #[allow(unused_mut)]
  134    113   
            let mut tmp = {
  135    114   
                #[allow(unused_mut)]
  136    115   
                let mut output = crate::types::error::builders::ValidationErrorBuilder::default();
  137    116   
                output = crate::protocol_serde::shape_validation_exception::de_validation_exception_json_err(_response_body, output)
  138    117   
                    .map_err(crate::operation::start_snapshot::StartSnapshotError::unhandled)?;
  139    118   
                let output = output.meta(generic);
  140    119   
                output.build()
  141    120   
            };
  142         -
            if tmp.message.is_none() {
  143         -
                tmp.message = _error_message;
  144         -
            }
  145    121   
            tmp
  146    122   
        }),
  147    123   
        _ => crate::operation::start_snapshot::StartSnapshotError::generic(generic),
  148    124   
    })
  149    125   
}
  150    126   
  151    127   
#[allow(clippy::unnecessary_wraps)]
  152    128   
pub fn de_start_snapshot_http_response(
  153    129   
    _response_status: u16,
  154    130   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/protocol_serde/shape_greeting_with_errors.rs

@@ -2,2 +64,61 @@
   22     22   
        "InvalidGreeting" => crate::operation::greeting_with_errors::GreetingWithErrorsError::InvalidGreeting({
   23     23   
            #[allow(unused_mut)]
   24     24   
            let mut tmp = {
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut output = crate::types::error::builders::InvalidGreetingBuilder::default();
   27     27   
                output = crate::protocol_serde::shape_invalid_greeting::de_invalid_greeting_xml_err(_response_body, output)
   28     28   
                    .map_err(crate::operation::greeting_with_errors::GreetingWithErrorsError::unhandled)?;
   29     29   
                let output = output.meta(generic);
   30     30   
                output.build()
   31     31   
            };
   32         -
            if tmp.message.is_none() {
   33         -
                tmp.message = _error_message;
   34         -
            }
   35     32   
            tmp
   36     33   
        }),
   37     34   
        "ComplexError" => crate::operation::greeting_with_errors::GreetingWithErrorsError::ComplexError({
   38     35   
            #[allow(unused_mut)]
   39     36   
            let mut tmp = {
   40     37   
                #[allow(unused_mut)]
   41     38   
                let mut output = crate::types::error::builders::ComplexErrorBuilder::default();
   42     39   
                output = crate::protocol_serde::shape_complex_error::de_complex_error_xml_err(_response_body, output)
   43     40   
                    .map_err(crate::operation::greeting_with_errors::GreetingWithErrorsError::unhandled)?;
   44     41   
                let output = output.meta(generic);

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/types/_complex_nested_error_data.rs

@@ -1,1 +44,55 @@
    5      5   
pub struct ComplexNestedErrorData {
    6      6   
    #[allow(missing_docs)] // documentation missing in model
    7      7   
    pub foo: ::std::option::Option<::std::string::String>,
    8      8   
}
    9      9   
impl ComplexNestedErrorData {
   10     10   
    #[allow(missing_docs)] // documentation missing in model
   11     11   
    pub fn foo(&self) -> ::std::option::Option<&str> {
   12     12   
        self.foo.as_deref()
   13     13   
    }
   14     14   
}
          15  +
impl ::std::fmt::Display for ComplexNestedErrorData {
          16  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
          17  +
        ::std::write!(f, "ComplexNestedErrorData {{")?;
          18  +
        if let ::std::option::Option::Some(inner) = &self.foo {
          19  +
            ::std::write!(f, "foo=Some({})", inner)?;
          20  +
        } else {
          21  +
            ::std::write!(f, "foo=None")?;
          22  +
        }
          23  +
        ::std::write!(f, "}}")
          24  +
    }
          25  +
}
   15     26   
impl ComplexNestedErrorData {
   16     27   
    /// Creates a new builder-style object to manufacture [`ComplexNestedErrorData`](crate::types::ComplexNestedErrorData).
   17     28   
    pub fn builder() -> crate::types::builders::ComplexNestedErrorDataBuilder {
   18     29   
        crate::types::builders::ComplexNestedErrorDataBuilder::default()
   19     30   
    }
   20     31   
}
   21     32   
   22     33   
/// A builder for [`ComplexNestedErrorData`](crate::types::ComplexNestedErrorData).
   23     34   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   24     35   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/protocol_serde/shape_greeting_with_errors.rs

@@ -2,2 +94,85 @@
   22     22   
        "InvalidGreeting" => crate::operation::greeting_with_errors::GreetingWithErrorsError::InvalidGreeting({
   23     23   
            #[allow(unused_mut)]
   24     24   
            let mut tmp = {
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut output = crate::types::error::builders::InvalidGreetingBuilder::default();
   27     27   
                output = crate::protocol_serde::shape_invalid_greeting::de_invalid_greeting_json_err(_response_body, output)
   28     28   
                    .map_err(crate::operation::greeting_with_errors::GreetingWithErrorsError::unhandled)?;
   29     29   
                let output = output.meta(generic);
   30     30   
                output.build()
   31     31   
            };
   32         -
            if tmp.message.is_none() {
   33         -
                tmp.message = _error_message;
   34         -
            }
   35     32   
            tmp
   36     33   
        }),
   37     34   
        "ComplexError" => crate::operation::greeting_with_errors::GreetingWithErrorsError::ComplexError({
   38     35   
            #[allow(unused_mut)]
   39     36   
            let mut tmp = {
   40     37   
                #[allow(unused_mut)]
   41     38   
                let mut output = crate::types::error::builders::ComplexErrorBuilder::default();
   42     39   
                output = crate::protocol_serde::shape_complex_error::de_complex_error_json_err(_response_body, output)
   43     40   
                    .map_err(crate::operation::greeting_with_errors::GreetingWithErrorsError::unhandled)?;
   44     41   
                let output = output.meta(generic);
   45     42   
                output.build()
   46     43   
            };
   47         -
            if tmp.message.is_none() {
   48         -
                tmp.message = _error_message;
   49         -
            }
   50     44   
            tmp
   51     45   
        }),
   52     46   
        "FooError" => crate::operation::greeting_with_errors::GreetingWithErrorsError::FooError({
   53     47   
            #[allow(unused_mut)]
   54     48   
            let mut tmp = {
   55     49   
                #[allow(unused_mut)]
   56     50   
                let mut output = crate::types::error::builders::FooErrorBuilder::default();
   57     51   
                output = crate::protocol_serde::shape_foo_error::de_foo_error_json_err(_response_body, output)
   58     52   
                    .map_err(crate::operation::greeting_with_errors::GreetingWithErrorsError::unhandled)?;
   59     53   
                let output = output.meta(generic);
   60     54   
                output.build()
   61     55   
            };
   62         -
            if tmp.message.is_none() {
   63         -
                tmp.message = _error_message;
   64         -
            }
   65     56   
            tmp
   66     57   
        }),
   67     58   
        _ => crate::operation::greeting_with_errors::GreetingWithErrorsError::generic(generic),
   68     59   
    })
   69     60   
}
   70     61   
   71     62   
#[allow(clippy::unnecessary_wraps)]
   72     63   
pub fn de_greeting_with_errors_http_response(
   73     64   
    _response_status: u16,
   74     65   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/types/_complex_nested_error_data.rs

@@ -1,1 +44,55 @@
    5      5   
pub struct ComplexNestedErrorData {
    6      6   
    #[allow(missing_docs)] // documentation missing in model
    7      7   
    pub foo: ::std::option::Option<::std::string::String>,
    8      8   
}
    9      9   
impl ComplexNestedErrorData {
   10     10   
    #[allow(missing_docs)] // documentation missing in model
   11     11   
    pub fn foo(&self) -> ::std::option::Option<&str> {
   12     12   
        self.foo.as_deref()
   13     13   
    }
   14     14   
}
          15  +
impl ::std::fmt::Display for ComplexNestedErrorData {
          16  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
          17  +
        ::std::write!(f, "ComplexNestedErrorData {{")?;
          18  +
        if let ::std::option::Option::Some(inner) = &self.foo {
          19  +
            ::std::write!(f, "foo=Some({})", inner)?;
          20  +
        } else {
          21  +
            ::std::write!(f, "foo=None")?;
          22  +
        }
          23  +
        ::std::write!(f, "}}")
          24  +
    }
          25  +
}
   15     26   
impl ComplexNestedErrorData {
   16     27   
    /// Creates a new builder-style object to manufacture [`ComplexNestedErrorData`](crate::types::ComplexNestedErrorData).
   17     28   
    pub fn builder() -> crate::types::builders::ComplexNestedErrorDataBuilder {
   18     29   
        crate::types::builders::ComplexNestedErrorDataBuilder::default()
   19     30   
    }
   20     31   
}
   21     32   
   22     33   
/// A builder for [`ComplexNestedErrorData`](crate::types::ComplexNestedErrorData).
   23     34   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   24     35   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/protocol_serde/shape_greeting_with_errors.rs

@@ -2,2 +94,85 @@
   22     22   
        "InvalidGreeting" => crate::operation::greeting_with_errors::GreetingWithErrorsError::InvalidGreeting({
   23     23   
            #[allow(unused_mut)]
   24     24   
            let mut tmp = {
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut output = crate::types::error::builders::InvalidGreetingBuilder::default();
   27     27   
                output = crate::protocol_serde::shape_invalid_greeting::de_invalid_greeting_json_err(_response_body, output)
   28     28   
                    .map_err(crate::operation::greeting_with_errors::GreetingWithErrorsError::unhandled)?;
   29     29   
                let output = output.meta(generic);
   30     30   
                output.build()
   31     31   
            };
   32         -
            if tmp.message.is_none() {
   33         -
                tmp.message = _error_message;
   34         -
            }
   35     32   
            tmp
   36     33   
        }),
   37     34   
        "ComplexError" => crate::operation::greeting_with_errors::GreetingWithErrorsError::ComplexError({
   38     35   
            #[allow(unused_mut)]
   39     36   
            let mut tmp = {
   40     37   
                #[allow(unused_mut)]
   41     38   
                let mut output = crate::types::error::builders::ComplexErrorBuilder::default();
   42     39   
                output = crate::protocol_serde::shape_complex_error::de_complex_error_json_err(_response_body, output)
   43     40   
                    .map_err(crate::operation::greeting_with_errors::GreetingWithErrorsError::unhandled)?;
   44     41   
                let output = output.meta(generic);
   45     42   
                output.build()
   46     43   
            };
   47         -
            if tmp.message.is_none() {
   48         -
                tmp.message = _error_message;
   49         -
            }
   50     44   
            tmp
   51     45   
        }),
   52     46   
        "FooError" => crate::operation::greeting_with_errors::GreetingWithErrorsError::FooError({
   53     47   
            #[allow(unused_mut)]
   54     48   
            let mut tmp = {
   55     49   
                #[allow(unused_mut)]
   56     50   
                let mut output = crate::types::error::builders::FooErrorBuilder::default();
   57     51   
                output = crate::protocol_serde::shape_foo_error::de_foo_error_json_err(_response_body, output)
   58     52   
                    .map_err(crate::operation::greeting_with_errors::GreetingWithErrorsError::unhandled)?;
   59     53   
                let output = output.meta(generic);
   60     54   
                output.build()
   61     55   
            };
   62         -
            if tmp.message.is_none() {
   63         -
                tmp.message = _error_message;
   64         -
            }
   65     56   
            tmp
   66     57   
        }),
   67     58   
        _ => crate::operation::greeting_with_errors::GreetingWithErrorsError::generic(generic),
   68     59   
    })
   69     60   
}
   70     61   
   71     62   
#[allow(clippy::unnecessary_wraps)]
   72     63   
pub fn de_greeting_with_errors_http_response(
   73     64   
    _response_status: u16,
   74     65   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,