Client Test

Client Test

rev. 024d02a2e8f38a611999fe239a68eb14068662df

Files changed:

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

@@ -5,5 +97,88 @@
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut output = crate::types::error::builders::GlobalTableNotFoundErrorBuilder::default();
   27     27   
                output = crate::protocol_serde::shape_global_table_not_found_exception::de_global_table_not_found_exception_json_err(
   28     28   
                    _response_body,
   29     29   
                    output,
   30     30   
                )
   31     31   
                .map_err(crate::operation::describe_global_table::DescribeGlobalTableError::unhandled)?;
   32     32   
                let output = output.meta(generic);
   33     33   
                output.build()
   34     34   
            };
   35         -
            if tmp.message.is_none() {
   36         -
                tmp.message = _error_message;
   37         -
            }
   38     35   
            tmp
   39     36   
        }),
   40     37   
        "InternalServerError" => crate::operation::describe_global_table::DescribeGlobalTableError::InternalServerError({
   41     38   
            #[allow(unused_mut)]
   42     39   
            let mut tmp = {
   43     40   
                #[allow(unused_mut)]
   44     41   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   45     42   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   46     43   
                    .map_err(crate::operation::describe_global_table::DescribeGlobalTableError::unhandled)?;
   47     44   
                let output = output.meta(generic);
   48     45   
                output.build()
   49     46   
            };
   50         -
            if tmp.message.is_none() {
   51         -
                tmp.message = _error_message;
   52         -
            }
   53     47   
            tmp
   54     48   
        }),
   55     49   
        "InvalidEndpointException" => crate::operation::describe_global_table::DescribeGlobalTableError::InvalidEndpointError({
   56     50   
            #[allow(unused_mut)]
   57     51   
            let mut tmp = {
   58     52   
                #[allow(unused_mut)]
   59     53   
                let mut output = crate::types::error::builders::InvalidEndpointErrorBuilder::default();
   60     54   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   61     55   
                    .map_err(crate::operation::describe_global_table::DescribeGlobalTableError::unhandled)?;
   62     56   
                let output = output.meta(generic);
   63     57   
                output.build()
   64     58   
            };
   65         -
            if tmp.message.is_none() {
   66         -
                tmp.message = _error_message;
   67         -
            }
   68     59   
            tmp
   69     60   
        }),
   70     61   
        _ => crate::operation::describe_global_table::DescribeGlobalTableError::generic(generic),
   71     62   
    })
   72     63   
}
   73     64   
   74     65   
#[allow(clippy::unnecessary_wraps)]
   75     66   
pub fn de_describe_global_table_http_response(
   76     67   
    _response_status: u16,
   77     68   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -6,6 +99,90 @@
   26     26   
                    #[allow(unused_mut)]
   27     27   
                    let mut output = crate::types::error::builders::GlobalTableNotFoundErrorBuilder::default();
   28     28   
                    output = crate::protocol_serde::shape_global_table_not_found_exception::de_global_table_not_found_exception_json_err(
   29     29   
                        _response_body,
   30     30   
                        output,
   31     31   
                    )
   32     32   
                    .map_err(crate::operation::describe_global_table_settings::DescribeGlobalTableSettingsError::unhandled)?;
   33     33   
                    let output = output.meta(generic);
   34     34   
                    output.build()
   35     35   
                };
   36         -
                if tmp.message.is_none() {
   37         -
                    tmp.message = _error_message;
   38         -
                }
   39     36   
                tmp
   40     37   
            })
   41     38   
        }
   42     39   
        "InternalServerError" => crate::operation::describe_global_table_settings::DescribeGlobalTableSettingsError::InternalServerError({
   43     40   
            #[allow(unused_mut)]
   44     41   
            let mut tmp = {
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   47     44   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   48     45   
                    .map_err(crate::operation::describe_global_table_settings::DescribeGlobalTableSettingsError::unhandled)?;
   49     46   
                let output = output.meta(generic);
   50     47   
                output.build()
   51     48   
            };
   52         -
            if tmp.message.is_none() {
   53         -
                tmp.message = _error_message;
   54         -
            }
   55     49   
            tmp
   56     50   
        }),
   57     51   
        "InvalidEndpointException" => crate::operation::describe_global_table_settings::DescribeGlobalTableSettingsError::InvalidEndpointError({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp = {
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut output = crate::types::error::builders::InvalidEndpointErrorBuilder::default();
   62     56   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   63     57   
                    .map_err(crate::operation::describe_global_table_settings::DescribeGlobalTableSettingsError::unhandled)?;
   64     58   
                let output = output.meta(generic);
   65     59   
                output.build()
   66     60   
            };
   67         -
            if tmp.message.is_none() {
   68         -
                tmp.message = _error_message;
   69         -
            }
   70     61   
            tmp
   71     62   
        }),
   72     63   
        _ => crate::operation::describe_global_table_settings::DescribeGlobalTableSettingsError::generic(generic),
   73     64   
    })
   74     65   
}
   75     66   
   76     67   
#[allow(clippy::unnecessary_wraps)]
   77     68   
pub fn de_describe_global_table_settings_http_response(
   78     69   
    _response_status: u16,
   79     70   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +100,91 @@
   23     23   
            crate::operation::describe_kinesis_streaming_destination::DescribeKinesisStreamingDestinationError::InternalServerError({
   24     24   
                #[allow(unused_mut)]
   25     25   
                let mut tmp = {
   26     26   
                    #[allow(unused_mut)]
   27     27   
                    let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   28     28   
                    output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   29     29   
                        .map_err(crate::operation::describe_kinesis_streaming_destination::DescribeKinesisStreamingDestinationError::unhandled)?;
   30     30   
                    let output = output.meta(generic);
   31     31   
                    output.build()
   32     32   
                };
   33         -
                if tmp.message.is_none() {
   34         -
                    tmp.message = _error_message;
   35         -
                }
   36     33   
                tmp
   37     34   
            })
   38     35   
        }
   39     36   
        "InvalidEndpointException" => {
   40     37   
            crate::operation::describe_kinesis_streaming_destination::DescribeKinesisStreamingDestinationError::InvalidEndpointError({
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut tmp = {
   43     40   
                    #[allow(unused_mut)]
   44     41   
                    let mut output = crate::types::error::builders::InvalidEndpointErrorBuilder::default();
   45     42   
                    output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   46     43   
                        .map_err(crate::operation::describe_kinesis_streaming_destination::DescribeKinesisStreamingDestinationError::unhandled)?;
   47     44   
                    let output = output.meta(generic);
   48     45   
                    output.build()
   49     46   
                };
   50         -
                if tmp.message.is_none() {
   51         -
                    tmp.message = _error_message;
   52         -
                }
   53     47   
                tmp
   54     48   
            })
   55     49   
        }
   56     50   
        "ResourceNotFoundException" => {
   57     51   
            crate::operation::describe_kinesis_streaming_destination::DescribeKinesisStreamingDestinationError::ResourceNotFoundError({
   58     52   
                #[allow(unused_mut)]
   59     53   
                let mut tmp = {
   60     54   
                    #[allow(unused_mut)]
   61     55   
                    let mut output = crate::types::error::builders::ResourceNotFoundErrorBuilder::default();
   62     56   
                    output =
   63     57   
                        crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   64     58   
                            .map_err(crate::operation::describe_kinesis_streaming_destination::DescribeKinesisStreamingDestinationError::unhandled)?;
   65     59   
                    let output = output.meta(generic);
   66     60   
                    output.build()
   67     61   
                };
   68         -
                if tmp.message.is_none() {
   69         -
                    tmp.message = _error_message;
   70         -
                }
   71     62   
                tmp
   72     63   
            })
   73     64   
        }
   74     65   
        _ => crate::operation::describe_kinesis_streaming_destination::DescribeKinesisStreamingDestinationError::generic(generic),
   75     66   
    })
   76     67   
}
   77     68   
   78     69   
#[allow(clippy::unnecessary_wraps)]
   79     70   
pub fn de_describe_kinesis_streaming_destination_http_response(
   80     71   
    _response_status: u16,

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

@@ -1,1 +76,70 @@
   19     19   
        "InternalServerError" => crate::operation::describe_limits::DescribeLimitsError::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::describe_limits::DescribeLimitsError::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::describe_limits::DescribeLimitsError::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::describe_limits::DescribeLimitsError::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   
        _ => crate::operation::describe_limits::DescribeLimitsError::generic(generic),
   50     44   
    })
   51     45   
}
   52     46   
   53     47   
#[allow(clippy::unnecessary_wraps)]
   54     48   
pub fn de_describe_limits_http_response(
   55     49   
    _response_status: u16,
   56     50   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +91,82 @@
   19     19   
        "InternalServerError" => crate::operation::describe_table::DescribeTableError::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::describe_table::DescribeTableError::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::describe_table::DescribeTableError::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::describe_table::DescribeTableError::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   
        "ResourceNotFoundException" => crate::operation::describe_table::DescribeTableError::ResourceNotFoundError({
   50     44   
            #[allow(unused_mut)]
   51     45   
            let mut tmp = {
   52     46   
                #[allow(unused_mut)]
   53     47   
                let mut output = crate::types::error::builders::ResourceNotFoundErrorBuilder::default();
   54     48   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   55     49   
                    .map_err(crate::operation::describe_table::DescribeTableError::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   
        _ => crate::operation::describe_table::DescribeTableError::generic(generic),
   65     56   
    })
   66     57   
}
   67     58   
   68     59   
#[allow(clippy::unnecessary_wraps)]
   69     60   
pub fn de_describe_table_http_response(
   70     61   
    _response_status: u16,
   71     62   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -2,2 +81,75 @@
   22     22   
        "InternalServerError" => crate::operation::describe_table_replica_auto_scaling::DescribeTableReplicaAutoScalingError::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::describe_table_replica_auto_scaling::DescribeTableReplicaAutoScalingError::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   
        "ResourceNotFoundException" => {
   38     35   
            crate::operation::describe_table_replica_auto_scaling::DescribeTableReplicaAutoScalingError::ResourceNotFoundError({
   39     36   
                #[allow(unused_mut)]
   40     37   
                let mut tmp = {
   41     38   
                    #[allow(unused_mut)]
   42     39   
                    let mut output = crate::types::error::builders::ResourceNotFoundErrorBuilder::default();
   43     40   
                    output =
   44     41   
                        crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   45     42   
                            .map_err(crate::operation::describe_table_replica_auto_scaling::DescribeTableReplicaAutoScalingError::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   
        }
   55     49   
        _ => crate::operation::describe_table_replica_auto_scaling::DescribeTableReplicaAutoScalingError::generic(generic),
   56     50   
    })
   57     51   
}
   58     52   
   59     53   
#[allow(clippy::unnecessary_wraps)]
   60     54   
pub fn de_describe_table_replica_auto_scaling_http_response(
   61     55   
    _response_status: u16,

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

@@ -2,2 +94,85 @@
   22     22   
        "InternalServerError" => crate::operation::describe_time_to_live::DescribeTimeToLiveError::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::describe_time_to_live::DescribeTimeToLiveError::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   
        "InvalidEndpointException" => crate::operation::describe_time_to_live::DescribeTimeToLiveError::InvalidEndpointError({
   38     35   
            #[allow(unused_mut)]
   39     36   
            let mut tmp = {
   40     37   
                #[allow(unused_mut)]
   41     38   
                let mut output = crate::types::error::builders::InvalidEndpointErrorBuilder::default();
   42     39   
                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)
   43     40   
                    .map_err(crate::operation::describe_time_to_live::DescribeTimeToLiveError::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   
        "ResourceNotFoundException" => crate::operation::describe_time_to_live::DescribeTimeToLiveError::ResourceNotFoundError({
   53     47   
            #[allow(unused_mut)]
   54     48   
            let mut tmp = {
   55     49   
                #[allow(unused_mut)]
   56     50   
                let mut output = crate::types::error::builders::ResourceNotFoundErrorBuilder::default();
   57     51   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   58     52   
                    .map_err(crate::operation::describe_time_to_live::DescribeTimeToLiveError::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::describe_time_to_live::DescribeTimeToLiveError::generic(generic),
   68     59   
    })
   69     60   
}
   70     61   
   71     62   
#[allow(clippy::unnecessary_wraps)]
   72     63   
pub fn de_describe_time_to_live_http_response(
   73     64   
    _response_status: u16,
   74     65   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

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

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

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

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

@@ -2,2 +172,148 @@
   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::execute_statement::ExecuteStatementError::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   
        "DuplicateItemException" => crate::operation::execute_statement::ExecuteStatementError::DuplicateItemError({
   38     35   
            #[allow(unused_mut)]
   39     36   
            let mut tmp = {
   40     37   
                #[allow(unused_mut)]
   41     38   
                let mut output = crate::types::error::builders::DuplicateItemErrorBuilder::default();
   42     39   
                output = crate::protocol_serde::shape_duplicate_item_exception::de_duplicate_item_exception_json_err(_response_body, output)
   43     40   
                    .map_err(crate::operation::execute_statement::ExecuteStatementError::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   
        "InternalServerError" => crate::operation::execute_statement::ExecuteStatementError::InternalServerError({
   53     47   
            #[allow(unused_mut)]
   54     48   
            let mut tmp = {
   55     49   
                #[allow(unused_mut)]
   56     50   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   57     51   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   58     52   
                    .map_err(crate::operation::execute_statement::ExecuteStatementError::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" => {
   68     59   
            crate::operation::execute_statement::ExecuteStatementError::ItemCollectionSizeLimitExceededError({
   69     60   
                #[allow(unused_mut)]
   70     61   
                let mut tmp = {
   71     62   
                    #[allow(unused_mut)]
   72     63   
                    let mut output = crate::types::error::builders::ItemCollectionSizeLimitExceededErrorBuilder::default();
   73     64   
                    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::execute_statement::ExecuteStatementError::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   
        }
   83     71   
        "ProvisionedThroughputExceededException" => {
   84     72   
            crate::operation::execute_statement::ExecuteStatementError::ProvisionedThroughputExceededError({
   85     73   
                #[allow(unused_mut)]
   86     74   
                let mut tmp = {
   87     75   
                    #[allow(unused_mut)]
   88     76   
                    let mut output = crate::types::error::builders::ProvisionedThroughputExceededErrorBuilder::default();
   89     77   
                    output = crate::protocol_serde::shape_provisioned_throughput_exceeded_exception::de_provisioned_throughput_exceeded_exception_json_err(_response_body, output).map_err(crate::operation::execute_statement::ExecuteStatementError::unhandled)?;
   90     78   
                    let output = output.meta(generic);
   91     79   
                    output.build()
   92     80   
                };
   93         -
                if tmp.message.is_none() {
   94         -
                    tmp.message = _error_message;
   95         -
                }
   96     81   
                tmp
   97     82   
            })
   98     83   
        }
   99     84   
        "RequestLimitExceeded" => crate::operation::execute_statement::ExecuteStatementError::RequestLimitExceeded({
  100     85   
            #[allow(unused_mut)]
  101     86   
            let mut tmp = {
  102     87   
                #[allow(unused_mut)]
  103     88   
                let mut output = crate::types::error::builders::RequestLimitExceededBuilder::default();
  104     89   
                output = crate::protocol_serde::shape_request_limit_exceeded::de_request_limit_exceeded_json_err(_response_body, output)
  105     90   
                    .map_err(crate::operation::execute_statement::ExecuteStatementError::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   
        "ResourceNotFoundException" => crate::operation::execute_statement::ExecuteStatementError::ResourceNotFoundError({
  115     97   
            #[allow(unused_mut)]
  116     98   
            let mut tmp = {
  117     99   
                #[allow(unused_mut)]
  118    100   
                let mut output = crate::types::error::builders::ResourceNotFoundErrorBuilder::default();
  119    101   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
  120    102   
                    .map_err(crate::operation::execute_statement::ExecuteStatementError::unhandled)?;
  121    103   
                let output = output.meta(generic);
  122    104   
                output.build()
  123    105   
            };
  124         -
            if tmp.message.is_none() {
  125         -
                tmp.message = _error_message;
  126         -
            }
  127    106   
            tmp
  128    107   
        }),
  129    108   
        "TransactionConflictException" => crate::operation::execute_statement::ExecuteStatementError::TransactionConflictError({
  130    109   
            #[allow(unused_mut)]
  131    110   
            let mut tmp = {
  132    111   
                #[allow(unused_mut)]
  133    112   
                let mut output = crate::types::error::builders::TransactionConflictErrorBuilder::default();
  134    113   
                output =
  135    114   
                    crate::protocol_serde::shape_transaction_conflict_exception::de_transaction_conflict_exception_json_err(_response_body, output)
  136    115   
                        .map_err(crate::operation::execute_statement::ExecuteStatementError::unhandled)?;
  137    116   
                let output = output.meta(generic);
  138    117   
                output.build()
  139    118   
            };
  140         -
            if tmp.message.is_none() {
  141         -
                tmp.message = _error_message;
  142         -
            }
  143    119   
            tmp
  144    120   
        }),
  145    121   
        _ => crate::operation::execute_statement::ExecuteStatementError::generic(generic),
  146    122   
    })
  147    123   
}
  148    124   
  149    125   
#[allow(clippy::unnecessary_wraps)]
  150    126   
pub fn de_execute_statement_http_response(
  151    127   
    _response_status: u16,
  152    128   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -5,5 +162,141 @@
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut output = crate::types::error::builders::IdempotentParameterMismatchErrorBuilder::default();
   27     27   
                output = crate::protocol_serde::shape_idempotent_parameter_mismatch_exception::de_idempotent_parameter_mismatch_exception_json_err(
   28     28   
                    _response_body,
   29     29   
                    output,
   30     30   
                )
   31     31   
                .map_err(crate::operation::execute_transaction::ExecuteTransactionError::unhandled)?;
   32     32   
                let output = output.meta(generic);
   33     33   
                output.build()
   34     34   
            };
   35         -
            if tmp.message.is_none() {
   36         -
                tmp.message = _error_message;
   37         -
            }
   38     35   
            tmp
   39     36   
        }),
   40     37   
        "InternalServerError" => crate::operation::execute_transaction::ExecuteTransactionError::InternalServerError({
   41     38   
            #[allow(unused_mut)]
   42     39   
            let mut tmp = {
   43     40   
                #[allow(unused_mut)]
   44     41   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   45     42   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   46     43   
                    .map_err(crate::operation::execute_transaction::ExecuteTransactionError::unhandled)?;
   47     44   
                let output = output.meta(generic);
   48     45   
                output.build()
   49     46   
            };
   50         -
            if tmp.message.is_none() {
   51         -
                tmp.message = _error_message;
   52         -
            }
   53     47   
            tmp
   54     48   
        }),
   55     49   
        "ProvisionedThroughputExceededException" => {
   56     50   
            crate::operation::execute_transaction::ExecuteTransactionError::ProvisionedThroughputExceededError({
   57     51   
                #[allow(unused_mut)]
   58     52   
                let mut tmp = {
   59     53   
                    #[allow(unused_mut)]
   60     54   
                    let mut output = crate::types::error::builders::ProvisionedThroughputExceededErrorBuilder::default();
   61     55   
                    output = crate::protocol_serde::shape_provisioned_throughput_exceeded_exception::de_provisioned_throughput_exceeded_exception_json_err(_response_body, output).map_err(crate::operation::execute_transaction::ExecuteTransactionError::unhandled)?;
   62     56   
                    let output = output.meta(generic);
   63     57   
                    output.build()
   64     58   
                };
   65         -
                if tmp.message.is_none() {
   66         -
                    tmp.message = _error_message;
   67         -
                }
   68     59   
                tmp
   69     60   
            })
   70     61   
        }
   71     62   
        "RequestLimitExceeded" => crate::operation::execute_transaction::ExecuteTransactionError::RequestLimitExceeded({
   72     63   
            #[allow(unused_mut)]
   73     64   
            let mut tmp = {
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut output = crate::types::error::builders::RequestLimitExceededBuilder::default();
   76     67   
                output = crate::protocol_serde::shape_request_limit_exceeded::de_request_limit_exceeded_json_err(_response_body, output)
   77     68   
                    .map_err(crate::operation::execute_transaction::ExecuteTransactionError::unhandled)?;
   78     69   
                let output = output.meta(generic);
   79     70   
                output.build()
   80     71   
            };
   81         -
            if tmp.message.is_none() {
   82         -
                tmp.message = _error_message;
   83         -
            }
   84     72   
            tmp
   85     73   
        }),
   86     74   
        "ResourceNotFoundException" => crate::operation::execute_transaction::ExecuteTransactionError::ResourceNotFoundError({
   87     75   
            #[allow(unused_mut)]
   88     76   
            let mut tmp = {
   89     77   
                #[allow(unused_mut)]
   90     78   
                let mut output = crate::types::error::builders::ResourceNotFoundErrorBuilder::default();
   91     79   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   92     80   
                    .map_err(crate::operation::execute_transaction::ExecuteTransactionError::unhandled)?;
   93     81   
                let output = output.meta(generic);
   94     82   
                output.build()
   95     83   
            };
   96         -
            if tmp.message.is_none() {
   97         -
                tmp.message = _error_message;
   98         -
            }
   99     84   
            tmp
  100     85   
        }),
  101     86   
        "TransactionCanceledException" => crate::operation::execute_transaction::ExecuteTransactionError::TransactionCanceledError({
  102     87   
            #[allow(unused_mut)]
  103     88   
            let mut tmp = {
  104     89   
                #[allow(unused_mut)]
  105     90   
                let mut output = crate::types::error::builders::TransactionCanceledErrorBuilder::default();
  106     91   
                output =
  107     92   
                    crate::protocol_serde::shape_transaction_canceled_exception::de_transaction_canceled_exception_json_err(_response_body, output)
  108     93   
                        .map_err(crate::operation::execute_transaction::ExecuteTransactionError::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   
        "TransactionInProgressException" => crate::operation::execute_transaction::ExecuteTransactionError::TransactionInProgressError({
  118    100   
            #[allow(unused_mut)]
  119    101   
            let mut tmp = {
  120    102   
                #[allow(unused_mut)]
  121    103   
                let mut output = crate::types::error::builders::TransactionInProgressErrorBuilder::default();
  122    104   
                output = crate::protocol_serde::shape_transaction_in_progress_exception::de_transaction_in_progress_exception_json_err(
  123    105   
                    _response_body,
  124    106   
                    output,
  125    107   
                )
  126    108   
                .map_err(crate::operation::execute_transaction::ExecuteTransactionError::unhandled)?;
  127    109   
                let output = output.meta(generic);
  128    110   
                output.build()
  129    111   
            };
  130         -
            if tmp.message.is_none() {
  131         -
                tmp.message = _error_message;
  132         -
            }
  133    112   
            tmp
  134    113   
        }),
  135    114   
        _ => crate::operation::execute_transaction::ExecuteTransactionError::generic(generic),
  136    115   
    })
  137    116   
}
  138    117   
  139    118   
#[allow(clippy::unnecessary_wraps)]
  140    119   
pub fn de_execute_transaction_http_response(
  141    120   
    _response_status: u16,
  142    121   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -6,6 +145,127 @@
   26     26   
        "ExportConflictException" => crate::operation::export_table_to_point_in_time::ExportTableToPointInTimeError::ExportConflictError({
   27     27   
            #[allow(unused_mut)]
   28     28   
            let mut tmp = {
   29     29   
                #[allow(unused_mut)]
   30     30   
                let mut output = crate::types::error::builders::ExportConflictErrorBuilder::default();
   31     31   
                output = crate::protocol_serde::shape_export_conflict_exception::de_export_conflict_exception_json_err(_response_body, output)
   32     32   
                    .map_err(crate::operation::export_table_to_point_in_time::ExportTableToPointInTimeError::unhandled)?;
   33     33   
                let output = output.meta(generic);
   34     34   
                output.build()
   35     35   
            };
   36         -
            if tmp.message.is_none() {
   37         -
                tmp.message = _error_message;
   38         -
            }
   39     36   
            tmp
   40     37   
        }),
   41     38   
        "InternalServerError" => crate::operation::export_table_to_point_in_time::ExportTableToPointInTimeError::InternalServerError({
   42     39   
            #[allow(unused_mut)]
   43     40   
            let mut tmp = {
   44     41   
                #[allow(unused_mut)]
   45     42   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   46     43   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   47     44   
                    .map_err(crate::operation::export_table_to_point_in_time::ExportTableToPointInTimeError::unhandled)?;
   48     45   
                let output = output.meta(generic);
   49     46   
                output.build()
   50     47   
            };
   51         -
            if tmp.message.is_none() {
   52         -
                tmp.message = _error_message;
   53         -
            }
   54     48   
            tmp
   55     49   
        }),
   56     50   
        "InvalidExportTimeException" => crate::operation::export_table_to_point_in_time::ExportTableToPointInTimeError::InvalidExportTimeError({
   57     51   
            #[allow(unused_mut)]
   58     52   
            let mut tmp = {
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut output = crate::types::error::builders::InvalidExportTimeErrorBuilder::default();
   61     55   
                output =
   62     56   
                    crate::protocol_serde::shape_invalid_export_time_exception::de_invalid_export_time_exception_json_err(_response_body, output)
   63     57   
                        .map_err(crate::operation::export_table_to_point_in_time::ExportTableToPointInTimeError::unhandled)?;
   64     58   
                let output = output.meta(generic);
   65     59   
                output.build()
   66     60   
            };
   67         -
            if tmp.message.is_none() {
   68         -
                tmp.message = _error_message;
   69         -
            }
   70     61   
            tmp
   71     62   
        }),
   72     63   
        "LimitExceededException" => crate::operation::export_table_to_point_in_time::ExportTableToPointInTimeError::LimitExceededError({
   73     64   
            #[allow(unused_mut)]
   74     65   
            let mut tmp = {
   75     66   
                #[allow(unused_mut)]
   76     67   
                let mut output = crate::types::error::builders::LimitExceededErrorBuilder::default();
   77     68   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   78     69   
                    .map_err(crate::operation::export_table_to_point_in_time::ExportTableToPointInTimeError::unhandled)?;
   79     70   
                let output = output.meta(generic);
   80     71   
                output.build()
   81     72   
            };
   82         -
            if tmp.message.is_none() {
   83         -
                tmp.message = _error_message;
   84         -
            }
   85     73   
            tmp
   86     74   
        }),
   87     75   
        "PointInTimeRecoveryUnavailableException" => {
   88     76   
            crate::operation::export_table_to_point_in_time::ExportTableToPointInTimeError::PointInTimeRecoveryUnavailableError({
   89     77   
                #[allow(unused_mut)]
   90     78   
                let mut tmp = {
   91     79   
                    #[allow(unused_mut)]
   92     80   
                    let mut output = crate::types::error::builders::PointInTimeRecoveryUnavailableErrorBuilder::default();
   93     81   
                    output = crate::protocol_serde::shape_point_in_time_recovery_unavailable_exception::de_point_in_time_recovery_unavailable_exception_json_err(_response_body, output).map_err(crate::operation::export_table_to_point_in_time::ExportTableToPointInTimeError::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   
        }
  103     88   
        "TableNotFoundException" => crate::operation::export_table_to_point_in_time::ExportTableToPointInTimeError::TableNotFoundError({
  104     89   
            #[allow(unused_mut)]
  105     90   
            let mut tmp = {
  106     91   
                #[allow(unused_mut)]
  107     92   
                let mut output = crate::types::error::builders::TableNotFoundErrorBuilder::default();
  108     93   
                output = crate::protocol_serde::shape_table_not_found_exception::de_table_not_found_exception_json_err(_response_body, output)
  109     94   
                    .map_err(crate::operation::export_table_to_point_in_time::ExportTableToPointInTimeError::unhandled)?;
  110     95   
                let output = output.meta(generic);
  111     96   
                output.build()
  112     97   
            };
  113         -
            if tmp.message.is_none() {
  114         -
                tmp.message = _error_message;
  115         -
            }
  116     98   
            tmp
  117     99   
        }),
  118    100   
        _ => crate::operation::export_table_to_point_in_time::ExportTableToPointInTimeError::generic(generic),
  119    101   
    })
  120    102   
}
  121    103   
  122    104   
#[allow(clippy::unnecessary_wraps)]
  123    105   
pub fn de_export_table_to_point_in_time_http_response(
  124    106   
    _response_status: u16,
  125    107   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +122,107 @@
   19     19   
        "InternalServerError" => crate::operation::get_item::GetItemError::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::get_item::GetItemError::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::get_item::GetItemError::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::get_item::GetItemError::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   
        "ProvisionedThroughputExceededException" => {
   50     44   
            crate::operation::get_item::GetItemError::ProvisionedThroughputExceededError({
   51     45   
                #[allow(unused_mut)]
   52     46   
                let mut tmp = {
   53     47   
                    #[allow(unused_mut)]
   54     48   
                    let mut output = crate::types::error::builders::ProvisionedThroughputExceededErrorBuilder::default();
   55     49   
                    output = crate::protocol_serde::shape_provisioned_throughput_exceeded_exception::de_provisioned_throughput_exceeded_exception_json_err(_response_body, output).map_err(crate::operation::get_item::GetItemError::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   
        }
   65     56   
        "RequestLimitExceeded" => crate::operation::get_item::GetItemError::RequestLimitExceeded({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::RequestLimitExceededBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_request_limit_exceeded::de_request_limit_exceeded_json_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::get_item::GetItemError::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::get_item::GetItemError::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::get_item::GetItemError::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::get_item::GetItemError::generic(generic),
   96     81   
    })
   97     82   
}
   98     83   
   99     84   
#[allow(clippy::unnecessary_wraps)]
  100     85   
pub fn de_get_item_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/protocol_serde/shape_list_backups.rs

@@ -1,1 +76,70 @@
   19     19   
        "InternalServerError" => crate::operation::list_backups::ListBackupsError::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::list_backups::ListBackupsError::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::list_backups::ListBackupsError::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::list_backups::ListBackupsError::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   
        _ => crate::operation::list_backups::ListBackupsError::generic(generic),
   50     44   
    })
   51     45   
}
   52     46   
   53     47   
#[allow(clippy::unnecessary_wraps)]
   54     48   
pub fn de_list_backups_http_response(
   55     49   
    _response_status: u16,
   56     50   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -6,6 +83,77 @@
   26     26   
        "InternalServerError" => crate::operation::list_contributor_insights::ListContributorInsightsError::InternalServerError({
   27     27   
            #[allow(unused_mut)]
   28     28   
            let mut tmp = {
   29     29   
                #[allow(unused_mut)]
   30     30   
                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();
   31     31   
                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)
   32     32   
                    .map_err(crate::operation::list_contributor_insights::ListContributorInsightsError::unhandled)?;
   33     33   
                let output = output.meta(generic);
   34     34   
                output.build()
   35     35   
            };
   36         -
            if tmp.message.is_none() {
   37         -
                tmp.message = _error_message;
   38         -
            }
   39     36   
            tmp
   40     37   
        }),
   41     38   
        "ResourceNotFoundException" => crate::operation::list_contributor_insights::ListContributorInsightsError::ResourceNotFoundError({
   42     39   
            #[allow(unused_mut)]
   43     40   
            let mut tmp = {
   44     41   
                #[allow(unused_mut)]
   45     42   
                let mut output = crate::types::error::builders::ResourceNotFoundErrorBuilder::default();
   46     43   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   47     44   
                    .map_err(crate::operation::list_contributor_insights::ListContributorInsightsError::unhandled)?;
   48     45   
                let output = output.meta(generic);
   49     46   
                output.build()
   50     47   
            };
   51         -
            if tmp.message.is_none() {
   52         -
                tmp.message = _error_message;
   53         -
            }
   54     48   
            tmp
   55     49   
        }),
   56     50   
        _ => crate::operation::list_contributor_insights::ListContributorInsightsError::generic(generic),
   57     51   
    })
   58     52   
}
   59     53   
   60     54   
#[allow(clippy::unnecessary_wraps)]
   61     55   
pub fn de_list_contributor_insights_http_response(
   62     56   
    _response_status: u16,
   63     57   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +76,70 @@
   19     19   
        "InternalServerError" => crate::operation::list_exports::ListExportsError::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::list_exports::ListExportsError::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   
        "LimitExceededException" => crate::operation::list_exports::ListExportsError::LimitExceededError({
   35     32   
            #[allow(unused_mut)]
   36     33   
            let mut tmp = {
   37     34   
                #[allow(unused_mut)]
   38     35   
                let mut output = crate::types::error::builders::LimitExceededErrorBuilder::default();
   39     36   
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   40     37   
                    .map_err(crate::operation::list_exports::ListExportsError::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   
        _ => crate::operation::list_exports::ListExportsError::generic(generic),
   50     44   
    })
   51     45   
}
   52     46   
   53     47   
#[allow(clippy::unnecessary_wraps)]
   54     48   
pub fn de_list_exports_http_response(
   55     49   
    _response_status: u16,
   56     50   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,