AWS SDK

AWS SDK

rev. 03f9d3736bb06bbe282d7bfe7c28721562f20a05

Files changed:

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_create_hosted_zone.rs

@@ -1,1 +182,155 @@
   20     20   
        "ConflictingDomainExists" => crate::operation::create_hosted_zone::CreateHostedZoneError::ConflictingDomainExists({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::ConflictingDomainExistsBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_conflicting_domain_exists::de_conflicting_domain_exists_xml_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::create_hosted_zone::CreateHostedZoneError::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   
        "DelegationSetNotAvailable" => crate::operation::create_hosted_zone::CreateHostedZoneError::DelegationSetNotAvailable({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::DelegationSetNotAvailableBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_delegation_set_not_available::de_delegation_set_not_available_xml_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::create_hosted_zone::CreateHostedZoneError::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   
        "DelegationSetNotReusable" => crate::operation::create_hosted_zone::CreateHostedZoneError::DelegationSetNotReusable({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::DelegationSetNotReusableBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_delegation_set_not_reusable::de_delegation_set_not_reusable_xml_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::create_hosted_zone::CreateHostedZoneError::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   
        "HostedZoneAlreadyExists" => crate::operation::create_hosted_zone::CreateHostedZoneError::HostedZoneAlreadyExists({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::HostedZoneAlreadyExistsBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_hosted_zone_already_exists::de_hosted_zone_already_exists_xml_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::create_hosted_zone::CreateHostedZoneError::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   
        "InvalidDomainName" => crate::operation::create_hosted_zone::CreateHostedZoneError::InvalidDomainName({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::InvalidDomainNameBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_invalid_domain_name::de_invalid_domain_name_xml_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::create_hosted_zone::CreateHostedZoneError::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   
        "InvalidInput" => crate::operation::create_hosted_zone::CreateHostedZoneError::InvalidInput({
   96     81   
            #[allow(unused_mut)]
   97     82   
            let mut tmp = {
   98     83   
                #[allow(unused_mut)]
   99     84   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
  100     85   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
  101     86   
                    .map_err(crate::operation::create_hosted_zone::CreateHostedZoneError::unhandled)?;
  102     87   
                let output = output.meta(generic);
  103     88   
                output.build()
  104     89   
            };
  105         -
            if tmp.message.is_none() {
  106         -
                tmp.message = _error_message;
  107         -
            }
  108     90   
            tmp
  109     91   
        }),
  110     92   
        "InvalidVPCId" => crate::operation::create_hosted_zone::CreateHostedZoneError::InvalidVpcId({
  111     93   
            #[allow(unused_mut)]
  112     94   
            let mut tmp = {
  113     95   
                #[allow(unused_mut)]
  114     96   
                let mut output = crate::types::error::builders::InvalidVpcIdBuilder::default();
  115     97   
                output = crate::protocol_serde::shape_invalid_vpc_id::de_invalid_vpc_id_xml_err(_response_body, output)
  116     98   
                    .map_err(crate::operation::create_hosted_zone::CreateHostedZoneError::unhandled)?;
  117     99   
                let output = output.meta(generic);
  118    100   
                output.build()
  119    101   
            };
  120         -
            if tmp.message.is_none() {
  121         -
                tmp.message = _error_message;
  122         -
            }
  123    102   
            tmp
  124    103   
        }),
  125    104   
        "NoSuchDelegationSet" => crate::operation::create_hosted_zone::CreateHostedZoneError::NoSuchDelegationSet({
  126    105   
            #[allow(unused_mut)]
  127    106   
            let mut tmp = {
  128    107   
                #[allow(unused_mut)]
  129    108   
                let mut output = crate::types::error::builders::NoSuchDelegationSetBuilder::default();
  130    109   
                output = crate::protocol_serde::shape_no_such_delegation_set::de_no_such_delegation_set_xml_err(_response_body, output)
  131    110   
                    .map_err(crate::operation::create_hosted_zone::CreateHostedZoneError::unhandled)?;
  132    111   
                let output = output.meta(generic);
  133    112   
                output.build()
  134    113   
            };
  135         -
            if tmp.message.is_none() {
  136         -
                tmp.message = _error_message;
  137         -
            }
  138    114   
            tmp
  139    115   
        }),
  140    116   
        "TooManyHostedZones" => crate::operation::create_hosted_zone::CreateHostedZoneError::TooManyHostedZones({
  141    117   
            #[allow(unused_mut)]
  142    118   
            let mut tmp = {
  143    119   
                #[allow(unused_mut)]
  144    120   
                let mut output = crate::types::error::builders::TooManyHostedZonesBuilder::default();
  145    121   
                output = crate::protocol_serde::shape_too_many_hosted_zones::de_too_many_hosted_zones_xml_err(_response_body, output)
  146    122   
                    .map_err(crate::operation::create_hosted_zone::CreateHostedZoneError::unhandled)?;
  147    123   
                let output = output.meta(generic);
  148    124   
                output.build()
  149    125   
            };
  150         -
            if tmp.message.is_none() {
  151         -
                tmp.message = _error_message;
  152         -
            }
  153    126   
            tmp
  154    127   
        }),
  155    128   
        _ => crate::operation::create_hosted_zone::CreateHostedZoneError::generic(generic),
  156    129   
    })
  157    130   
}
  158    131   
  159    132   
#[allow(clippy::unnecessary_wraps)]
  160    133   
pub fn de_create_hosted_zone_http_response(
  161    134   
    _response_status: u16,
  162    135   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_create_key_signing_key.rs

@@ -3,3 +202,172 @@
   23     23   
        "ConcurrentModification" => crate::operation::create_key_signing_key::CreateKeySigningKeyError::ConcurrentModification({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::ConcurrentModificationBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_concurrent_modification::de_concurrent_modification_xml_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::create_key_signing_key::CreateKeySigningKeyError::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   
        "InvalidArgument" => crate::operation::create_key_signing_key::CreateKeySigningKeyError::InvalidArgument({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InvalidArgumentBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_invalid_argument::de_invalid_argument_xml_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::create_key_signing_key::CreateKeySigningKeyError::unhandled)?;
   45     42   
                let output = output.meta(generic);
   46     43   
                output.build()
   47     44   
            };
   48         -
            if tmp.message.is_none() {
   49         -
                tmp.message = _error_message;
   50         -
            }
   51     45   
            tmp
   52     46   
        }),
   53     47   
        "InvalidInput" => crate::operation::create_key_signing_key::CreateKeySigningKeyError::InvalidInput({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::create_key_signing_key::CreateKeySigningKeyError::unhandled)?;
   60     54   
                let output = output.meta(generic);
   61     55   
                output.build()
   62     56   
            };
   63         -
            if tmp.message.is_none() {
   64         -
                tmp.message = _error_message;
   65         -
            }
   66     57   
            tmp
   67     58   
        }),
   68     59   
        "InvalidKeySigningKeyName" => crate::operation::create_key_signing_key::CreateKeySigningKeyError::InvalidKeySigningKeyName({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::InvalidKeySigningKeyNameBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_invalid_key_signing_key_name::de_invalid_key_signing_key_name_xml_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::create_key_signing_key::CreateKeySigningKeyError::unhandled)?;
   75     66   
                let output = output.meta(generic);
   76     67   
                output.build()
   77     68   
            };
   78         -
            if tmp.message.is_none() {
   79         -
                tmp.message = _error_message;
   80         -
            }
   81     69   
            tmp
   82     70   
        }),
   83     71   
        "InvalidKeySigningKeyStatus" => crate::operation::create_key_signing_key::CreateKeySigningKeyError::InvalidKeySigningKeyStatus({
   84     72   
            #[allow(unused_mut)]
   85     73   
            let mut tmp = {
   86     74   
                #[allow(unused_mut)]
   87     75   
                let mut output = crate::types::error::builders::InvalidKeySigningKeyStatusBuilder::default();
   88     76   
                output =
   89     77   
                    crate::protocol_serde::shape_invalid_key_signing_key_status::de_invalid_key_signing_key_status_xml_err(_response_body, output)
   90     78   
                        .map_err(crate::operation::create_key_signing_key::CreateKeySigningKeyError::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   
        "InvalidKMSArn" => crate::operation::create_key_signing_key::CreateKeySigningKeyError::InvalidKmsArn({
  100     85   
            #[allow(unused_mut)]
  101     86   
            let mut tmp = {
  102     87   
                #[allow(unused_mut)]
  103     88   
                let mut output = crate::types::error::builders::InvalidKmsArnBuilder::default();
  104     89   
                output = crate::protocol_serde::shape_invalid_kms_arn::de_invalid_kms_arn_xml_err(_response_body, output)
  105     90   
                    .map_err(crate::operation::create_key_signing_key::CreateKeySigningKeyError::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   
        "InvalidSigningStatus" => crate::operation::create_key_signing_key::CreateKeySigningKeyError::InvalidSigningStatus({
  115     97   
            #[allow(unused_mut)]
  116     98   
            let mut tmp = {
  117     99   
                #[allow(unused_mut)]
  118    100   
                let mut output = crate::types::error::builders::InvalidSigningStatusBuilder::default();
  119    101   
                output = crate::protocol_serde::shape_invalid_signing_status::de_invalid_signing_status_xml_err(_response_body, output)
  120    102   
                    .map_err(crate::operation::create_key_signing_key::CreateKeySigningKeyError::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   
        "KeySigningKeyAlreadyExists" => crate::operation::create_key_signing_key::CreateKeySigningKeyError::KeySigningKeyAlreadyExists({
  130    109   
            #[allow(unused_mut)]
  131    110   
            let mut tmp = {
  132    111   
                #[allow(unused_mut)]
  133    112   
                let mut output = crate::types::error::builders::KeySigningKeyAlreadyExistsBuilder::default();
  134    113   
                output =
  135    114   
                    crate::protocol_serde::shape_key_signing_key_already_exists::de_key_signing_key_already_exists_xml_err(_response_body, output)
  136    115   
                        .map_err(crate::operation::create_key_signing_key::CreateKeySigningKeyError::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   
        "NoSuchHostedZone" => crate::operation::create_key_signing_key::CreateKeySigningKeyError::NoSuchHostedZone({
  146    122   
            #[allow(unused_mut)]
  147    123   
            let mut tmp = {
  148    124   
                #[allow(unused_mut)]
  149    125   
                let mut output = crate::types::error::builders::NoSuchHostedZoneBuilder::default();
  150    126   
                output = crate::protocol_serde::shape_no_such_hosted_zone::de_no_such_hosted_zone_xml_err(_response_body, output)
  151    127   
                    .map_err(crate::operation::create_key_signing_key::CreateKeySigningKeyError::unhandled)?;
  152    128   
                let output = output.meta(generic);
  153    129   
                output.build()
  154    130   
            };
  155         -
            if tmp.message.is_none() {
  156         -
                tmp.message = _error_message;
  157         -
            }
  158    131   
            tmp
  159    132   
        }),
  160    133   
        "TooManyKeySigningKeys" => crate::operation::create_key_signing_key::CreateKeySigningKeyError::TooManyKeySigningKeys({
  161    134   
            #[allow(unused_mut)]
  162    135   
            let mut tmp = {
  163    136   
                #[allow(unused_mut)]
  164    137   
                let mut output = crate::types::error::builders::TooManyKeySigningKeysBuilder::default();
  165    138   
                output = crate::protocol_serde::shape_too_many_key_signing_keys::de_too_many_key_signing_keys_xml_err(_response_body, output)
  166    139   
                    .map_err(crate::operation::create_key_signing_key::CreateKeySigningKeyError::unhandled)?;
  167    140   
                let output = output.meta(generic);
  168    141   
                output.build()
  169    142   
            };
  170         -
            if tmp.message.is_none() {
  171         -
                tmp.message = _error_message;
  172         -
            }
  173    143   
            tmp
  174    144   
        }),
  175    145   
        _ => crate::operation::create_key_signing_key::CreateKeySigningKeyError::generic(generic),
  176    146   
    })
  177    147   
}
  178    148   
  179    149   
#[allow(clippy::unnecessary_wraps)]
  180    150   
pub fn de_create_key_signing_key_http_response(
  181    151   
    _response_status: u16,
  182    152   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_create_query_logging_config.rs

@@ -7,7 +154,136 @@
   27     27   
        "ConcurrentModification" => crate::operation::create_query_logging_config::CreateQueryLoggingConfigError::ConcurrentModification({
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::ConcurrentModificationBuilder::default();
   32     32   
                output = crate::protocol_serde::shape_concurrent_modification::de_concurrent_modification_xml_err(_response_body, output)
   33     33   
                    .map_err(crate::operation::create_query_logging_config::CreateQueryLoggingConfigError::unhandled)?;
   34     34   
                let output = output.meta(generic);
   35     35   
                output.build()
   36     36   
            };
   37         -
            if tmp.message.is_none() {
   38         -
                tmp.message = _error_message;
   39         -
            }
   40     37   
            tmp
   41     38   
        }),
   42     39   
        "InsufficientCloudWatchLogsResourcePolicy" => {
   43     40   
            crate::operation::create_query_logging_config::CreateQueryLoggingConfigError::InsufficientCloudWatchLogsResourcePolicy({
   44     41   
                #[allow(unused_mut)]
   45     42   
                let mut tmp = {
   46     43   
                    #[allow(unused_mut)]
   47     44   
                    let mut output = crate::types::error::builders::InsufficientCloudWatchLogsResourcePolicyBuilder::default();
   48     45   
                    output = crate::protocol_serde::shape_insufficient_cloud_watch_logs_resource_policy::de_insufficient_cloud_watch_logs_resource_policy_xml_err(_response_body, output).map_err(crate::operation::create_query_logging_config::CreateQueryLoggingConfigError::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   
        }
   58     52   
        "InvalidInput" => crate::operation::create_query_logging_config::CreateQueryLoggingConfigError::InvalidInput({
   59     53   
            #[allow(unused_mut)]
   60     54   
            let mut tmp = {
   61     55   
                #[allow(unused_mut)]
   62     56   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   63     57   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   64     58   
                    .map_err(crate::operation::create_query_logging_config::CreateQueryLoggingConfigError::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   
        "NoSuchCloudWatchLogsLogGroup" => {
   74     65   
            crate::operation::create_query_logging_config::CreateQueryLoggingConfigError::NoSuchCloudWatchLogsLogGroup({
   75     66   
                #[allow(unused_mut)]
   76     67   
                let mut tmp = {
   77     68   
                    #[allow(unused_mut)]
   78     69   
                    let mut output = crate::types::error::builders::NoSuchCloudWatchLogsLogGroupBuilder::default();
   79     70   
                    output = crate::protocol_serde::shape_no_such_cloud_watch_logs_log_group::de_no_such_cloud_watch_logs_log_group_xml_err(
   80     71   
                        _response_body,
   81     72   
                        output,
   82     73   
                    )
   83     74   
                    .map_err(crate::operation::create_query_logging_config::CreateQueryLoggingConfigError::unhandled)?;
   84     75   
                    let output = output.meta(generic);
   85     76   
                    output.build()
   86     77   
                };
   87         -
                if tmp.message.is_none() {
   88         -
                    tmp.message = _error_message;
   89         -
                }
   90     78   
                tmp
   91     79   
            })
   92     80   
        }
   93     81   
        "NoSuchHostedZone" => crate::operation::create_query_logging_config::CreateQueryLoggingConfigError::NoSuchHostedZone({
   94     82   
            #[allow(unused_mut)]
   95     83   
            let mut tmp = {
   96     84   
                #[allow(unused_mut)]
   97     85   
                let mut output = crate::types::error::builders::NoSuchHostedZoneBuilder::default();
   98     86   
                output = crate::protocol_serde::shape_no_such_hosted_zone::de_no_such_hosted_zone_xml_err(_response_body, output)
   99     87   
                    .map_err(crate::operation::create_query_logging_config::CreateQueryLoggingConfigError::unhandled)?;
  100     88   
                let output = output.meta(generic);
  101     89   
                output.build()
  102     90   
            };
  103         -
            if tmp.message.is_none() {
  104         -
                tmp.message = _error_message;
  105         -
            }
  106     91   
            tmp
  107     92   
        }),
  108     93   
        "QueryLoggingConfigAlreadyExists" => {
  109     94   
            crate::operation::create_query_logging_config::CreateQueryLoggingConfigError::QueryLoggingConfigAlreadyExists({
  110     95   
                #[allow(unused_mut)]
  111     96   
                let mut tmp = {
  112     97   
                    #[allow(unused_mut)]
  113     98   
                    let mut output = crate::types::error::builders::QueryLoggingConfigAlreadyExistsBuilder::default();
  114     99   
                    output = crate::protocol_serde::shape_query_logging_config_already_exists::de_query_logging_config_already_exists_xml_err(
  115    100   
                        _response_body,
  116    101   
                        output,
  117    102   
                    )
  118    103   
                    .map_err(crate::operation::create_query_logging_config::CreateQueryLoggingConfigError::unhandled)?;
  119    104   
                    let output = output.meta(generic);
  120    105   
                    output.build()
  121    106   
                };
  122         -
                if tmp.message.is_none() {
  123         -
                    tmp.message = _error_message;
  124         -
                }
  125    107   
                tmp
  126    108   
            })
  127    109   
        }
  128    110   
        _ => crate::operation::create_query_logging_config::CreateQueryLoggingConfigError::generic(generic),
  129    111   
    })
  130    112   
}
  131    113   
  132    114   
#[allow(clippy::unnecessary_wraps)]
  133    115   
pub fn de_create_query_logging_config_http_response(
  134    116   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_create_reusable_delegation_set.rs

@@ -7,7 +168,147 @@
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::DelegationSetAlreadyCreatedBuilder::default();
   29     29   
                    output = crate::protocol_serde::shape_delegation_set_already_created::de_delegation_set_already_created_xml_err(
   30     30   
                        _response_body,
   31     31   
                        output,
   32     32   
                    )
   33     33   
                    .map_err(crate::operation::create_reusable_delegation_set::CreateReusableDelegationSetError::unhandled)?;
   34     34   
                    let output = output.meta(generic);
   35     35   
                    output.build()
   36     36   
                };
   37         -
                if tmp.message.is_none() {
   38         -
                    tmp.message = _error_message;
   39         -
                }
   40     37   
                tmp
   41     38   
            })
   42     39   
        }
   43     40   
        "DelegationSetAlreadyReusable" => {
   44     41   
            crate::operation::create_reusable_delegation_set::CreateReusableDelegationSetError::DelegationSetAlreadyReusable({
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut tmp = {
   47     44   
                    #[allow(unused_mut)]
   48     45   
                    let mut output = crate::types::error::builders::DelegationSetAlreadyReusableBuilder::default();
   49     46   
                    output = crate::protocol_serde::shape_delegation_set_already_reusable::de_delegation_set_already_reusable_xml_err(
   50     47   
                        _response_body,
   51     48   
                        output,
   52     49   
                    )
   53     50   
                    .map_err(crate::operation::create_reusable_delegation_set::CreateReusableDelegationSetError::unhandled)?;
   54     51   
                    let output = output.meta(generic);
   55     52   
                    output.build()
   56     53   
                };
   57         -
                if tmp.message.is_none() {
   58         -
                    tmp.message = _error_message;
   59         -
                }
   60     54   
                tmp
   61     55   
            })
   62     56   
        }
   63     57   
        "DelegationSetNotAvailable" => {
   64     58   
            crate::operation::create_reusable_delegation_set::CreateReusableDelegationSetError::DelegationSetNotAvailable({
   65     59   
                #[allow(unused_mut)]
   66     60   
                let mut tmp = {
   67     61   
                    #[allow(unused_mut)]
   68     62   
                    let mut output = crate::types::error::builders::DelegationSetNotAvailableBuilder::default();
   69     63   
                    output =
   70     64   
                        crate::protocol_serde::shape_delegation_set_not_available::de_delegation_set_not_available_xml_err(_response_body, output)
   71     65   
                            .map_err(crate::operation::create_reusable_delegation_set::CreateReusableDelegationSetError::unhandled)?;
   72     66   
                    let output = output.meta(generic);
   73     67   
                    output.build()
   74     68   
                };
   75         -
                if tmp.message.is_none() {
   76         -
                    tmp.message = _error_message;
   77         -
                }
   78     69   
                tmp
   79     70   
            })
   80     71   
        }
   81     72   
        "HostedZoneNotFound" => crate::operation::create_reusable_delegation_set::CreateReusableDelegationSetError::HostedZoneNotFound({
   82     73   
            #[allow(unused_mut)]
   83     74   
            let mut tmp = {
   84     75   
                #[allow(unused_mut)]
   85     76   
                let mut output = crate::types::error::builders::HostedZoneNotFoundBuilder::default();
   86     77   
                output = crate::protocol_serde::shape_hosted_zone_not_found::de_hosted_zone_not_found_xml_err(_response_body, output)
   87     78   
                    .map_err(crate::operation::create_reusable_delegation_set::CreateReusableDelegationSetError::unhandled)?;
   88     79   
                let output = output.meta(generic);
   89     80   
                output.build()
   90     81   
            };
   91         -
            if tmp.message.is_none() {
   92         -
                tmp.message = _error_message;
   93         -
            }
   94     82   
            tmp
   95     83   
        }),
   96     84   
        "InvalidArgument" => crate::operation::create_reusable_delegation_set::CreateReusableDelegationSetError::InvalidArgument({
   97     85   
            #[allow(unused_mut)]
   98     86   
            let mut tmp = {
   99     87   
                #[allow(unused_mut)]
  100     88   
                let mut output = crate::types::error::builders::InvalidArgumentBuilder::default();
  101     89   
                output = crate::protocol_serde::shape_invalid_argument::de_invalid_argument_xml_err(_response_body, output)
  102     90   
                    .map_err(crate::operation::create_reusable_delegation_set::CreateReusableDelegationSetError::unhandled)?;
  103     91   
                let output = output.meta(generic);
  104     92   
                output.build()
  105     93   
            };
  106         -
            if tmp.message.is_none() {
  107         -
                tmp.message = _error_message;
  108         -
            }
  109     94   
            tmp
  110     95   
        }),
  111     96   
        "InvalidInput" => crate::operation::create_reusable_delegation_set::CreateReusableDelegationSetError::InvalidInput({
  112     97   
            #[allow(unused_mut)]
  113     98   
            let mut tmp = {
  114     99   
                #[allow(unused_mut)]
  115    100   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
  116    101   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
  117    102   
                    .map_err(crate::operation::create_reusable_delegation_set::CreateReusableDelegationSetError::unhandled)?;
  118    103   
                let output = output.meta(generic);
  119    104   
                output.build()
  120    105   
            };
  121         -
            if tmp.message.is_none() {
  122         -
                tmp.message = _error_message;
  123         -
            }
  124    106   
            tmp
  125    107   
        }),
  126    108   
        "LimitsExceeded" => crate::operation::create_reusable_delegation_set::CreateReusableDelegationSetError::LimitsExceeded({
  127    109   
            #[allow(unused_mut)]
  128    110   
            let mut tmp = {
  129    111   
                #[allow(unused_mut)]
  130    112   
                let mut output = crate::types::error::builders::LimitsExceededBuilder::default();
  131    113   
                output = crate::protocol_serde::shape_limits_exceeded::de_limits_exceeded_xml_err(_response_body, output)
  132    114   
                    .map_err(crate::operation::create_reusable_delegation_set::CreateReusableDelegationSetError::unhandled)?;
  133    115   
                let output = output.meta(generic);
  134    116   
                output.build()
  135    117   
            };
  136         -
            if tmp.message.is_none() {
  137         -
                tmp.message = _error_message;
  138         -
            }
  139    118   
            tmp
  140    119   
        }),
  141    120   
        _ => crate::operation::create_reusable_delegation_set::CreateReusableDelegationSetError::generic(generic),
  142    121   
    })
  143    122   
}
  144    123   
  145    124   
#[allow(clippy::unnecessary_wraps)]
  146    125   
pub fn de_create_reusable_delegation_set_http_response(
  147    126   
    _response_status: u16,
  148    127   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_create_traffic_policy.rs

@@ -3,3 +111,99 @@
   23     23   
        "InvalidInput" => crate::operation::create_traffic_policy::CreateTrafficPolicyError::InvalidInput({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::create_traffic_policy::CreateTrafficPolicyError::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   
        "InvalidTrafficPolicyDocument" => crate::operation::create_traffic_policy::CreateTrafficPolicyError::InvalidTrafficPolicyDocument({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InvalidTrafficPolicyDocumentBuilder::default();
   43     40   
                output =
   44     41   
                    crate::protocol_serde::shape_invalid_traffic_policy_document::de_invalid_traffic_policy_document_xml_err(_response_body, output)
   45     42   
                        .map_err(crate::operation::create_traffic_policy::CreateTrafficPolicyError::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   
        "TooManyTrafficPolicies" => crate::operation::create_traffic_policy::CreateTrafficPolicyError::TooManyTrafficPolicies({
   55     49   
            #[allow(unused_mut)]
   56     50   
            let mut tmp = {
   57     51   
                #[allow(unused_mut)]
   58     52   
                let mut output = crate::types::error::builders::TooManyTrafficPoliciesBuilder::default();
   59     53   
                output = crate::protocol_serde::shape_too_many_traffic_policies::de_too_many_traffic_policies_xml_err(_response_body, output)
   60     54   
                    .map_err(crate::operation::create_traffic_policy::CreateTrafficPolicyError::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   
        "TrafficPolicyAlreadyExists" => crate::operation::create_traffic_policy::CreateTrafficPolicyError::TrafficPolicyAlreadyExists({
   70     61   
            #[allow(unused_mut)]
   71     62   
            let mut tmp = {
   72     63   
                #[allow(unused_mut)]
   73     64   
                let mut output = crate::types::error::builders::TrafficPolicyAlreadyExistsBuilder::default();
   74     65   
                output = crate::protocol_serde::shape_traffic_policy_already_exists::de_traffic_policy_already_exists_xml_err(_response_body, output)
   75     66   
                    .map_err(crate::operation::create_traffic_policy::CreateTrafficPolicyError::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   
        _ => crate::operation::create_traffic_policy::CreateTrafficPolicyError::generic(generic),
   85     73   
    })
   86     74   
}
   87     75   
   88     76   
#[allow(clippy::unnecessary_wraps)]
   89     77   
pub fn de_create_traffic_policy_http_response(
   90     78   
    _response_status: u16,
   91     79   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_create_traffic_policy_instance.rs

@@ -3,3 +134,119 @@
   23     23   
        "InvalidInput" => crate::operation::create_traffic_policy_instance::CreateTrafficPolicyInstanceError::InvalidInput({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::create_traffic_policy_instance::CreateTrafficPolicyInstanceError::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   
        "NoSuchHostedZone" => crate::operation::create_traffic_policy_instance::CreateTrafficPolicyInstanceError::NoSuchHostedZone({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::NoSuchHostedZoneBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_no_such_hosted_zone::de_no_such_hosted_zone_xml_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::create_traffic_policy_instance::CreateTrafficPolicyInstanceError::unhandled)?;
   45     42   
                let output = output.meta(generic);
   46     43   
                output.build()
   47     44   
            };
   48         -
            if tmp.message.is_none() {
   49         -
                tmp.message = _error_message;
   50         -
            }
   51     45   
            tmp
   52     46   
        }),
   53     47   
        "NoSuchTrafficPolicy" => crate::operation::create_traffic_policy_instance::CreateTrafficPolicyInstanceError::NoSuchTrafficPolicy({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::NoSuchTrafficPolicyBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_no_such_traffic_policy::de_no_such_traffic_policy_xml_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::create_traffic_policy_instance::CreateTrafficPolicyInstanceError::unhandled)?;
   60     54   
                let output = output.meta(generic);
   61     55   
                output.build()
   62     56   
            };
   63         -
            if tmp.message.is_none() {
   64         -
                tmp.message = _error_message;
   65         -
            }
   66     57   
            tmp
   67     58   
        }),
   68     59   
        "TooManyTrafficPolicyInstances" => {
   69     60   
            crate::operation::create_traffic_policy_instance::CreateTrafficPolicyInstanceError::TooManyTrafficPolicyInstances({
   70     61   
                #[allow(unused_mut)]
   71     62   
                let mut tmp = {
   72     63   
                    #[allow(unused_mut)]
   73     64   
                    let mut output = crate::types::error::builders::TooManyTrafficPolicyInstancesBuilder::default();
   74     65   
                    output = crate::protocol_serde::shape_too_many_traffic_policy_instances::de_too_many_traffic_policy_instances_xml_err(
   75     66   
                        _response_body,
   76     67   
                        output,
   77     68   
                    )
   78     69   
                    .map_err(crate::operation::create_traffic_policy_instance::CreateTrafficPolicyInstanceError::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   
        }
   88     76   
        "TrafficPolicyInstanceAlreadyExists" => {
   89     77   
            crate::operation::create_traffic_policy_instance::CreateTrafficPolicyInstanceError::TrafficPolicyInstanceAlreadyExists({
   90     78   
                #[allow(unused_mut)]
   91     79   
                let mut tmp = {
   92     80   
                    #[allow(unused_mut)]
   93     81   
                    let mut output = crate::types::error::builders::TrafficPolicyInstanceAlreadyExistsBuilder::default();
   94     82   
                    output = crate::protocol_serde::shape_traffic_policy_instance_already_exists::de_traffic_policy_instance_already_exists_xml_err(
   95     83   
                        _response_body,
   96     84   
                        output,
   97     85   
                    )
   98     86   
                    .map_err(crate::operation::create_traffic_policy_instance::CreateTrafficPolicyInstanceError::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::create_traffic_policy_instance::CreateTrafficPolicyInstanceError::generic(generic),
  109     94   
    })
  110     95   
}
  111     96   
  112     97   
#[allow(clippy::unnecessary_wraps)]
  113     98   
pub fn de_create_traffic_policy_instance_http_response(
  114     99   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_create_traffic_policy_version.rs

@@ -3,3 +130,115 @@
   23     23   
        "ConcurrentModification" => crate::operation::create_traffic_policy_version::CreateTrafficPolicyVersionError::ConcurrentModification({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::ConcurrentModificationBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_concurrent_modification::de_concurrent_modification_xml_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::create_traffic_policy_version::CreateTrafficPolicyVersionError::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   
        "InvalidInput" => crate::operation::create_traffic_policy_version::CreateTrafficPolicyVersionError::InvalidInput({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::create_traffic_policy_version::CreateTrafficPolicyVersionError::unhandled)?;
   45     42   
                let output = output.meta(generic);
   46     43   
                output.build()
   47     44   
            };
   48         -
            if tmp.message.is_none() {
   49         -
                tmp.message = _error_message;
   50         -
            }
   51     45   
            tmp
   52     46   
        }),
   53     47   
        "InvalidTrafficPolicyDocument" => {
   54     48   
            crate::operation::create_traffic_policy_version::CreateTrafficPolicyVersionError::InvalidTrafficPolicyDocument({
   55     49   
                #[allow(unused_mut)]
   56     50   
                let mut tmp = {
   57     51   
                    #[allow(unused_mut)]
   58     52   
                    let mut output = crate::types::error::builders::InvalidTrafficPolicyDocumentBuilder::default();
   59     53   
                    output = crate::protocol_serde::shape_invalid_traffic_policy_document::de_invalid_traffic_policy_document_xml_err(
   60     54   
                        _response_body,
   61     55   
                        output,
   62     56   
                    )
   63     57   
                    .map_err(crate::operation::create_traffic_policy_version::CreateTrafficPolicyVersionError::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   
        "NoSuchTrafficPolicy" => crate::operation::create_traffic_policy_version::CreateTrafficPolicyVersionError::NoSuchTrafficPolicy({
   74     65   
            #[allow(unused_mut)]
   75     66   
            let mut tmp = {
   76     67   
                #[allow(unused_mut)]
   77     68   
                let mut output = crate::types::error::builders::NoSuchTrafficPolicyBuilder::default();
   78     69   
                output = crate::protocol_serde::shape_no_such_traffic_policy::de_no_such_traffic_policy_xml_err(_response_body, output)
   79     70   
                    .map_err(crate::operation::create_traffic_policy_version::CreateTrafficPolicyVersionError::unhandled)?;
   80     71   
                let output = output.meta(generic);
   81     72   
                output.build()
   82     73   
            };
   83         -
            if tmp.message.is_none() {
   84         -
                tmp.message = _error_message;
   85         -
            }
   86     74   
            tmp
   87     75   
        }),
   88     76   
        "TooManyTrafficPolicyVersionsForCurrentPolicy" => {
   89     77   
            crate::operation::create_traffic_policy_version::CreateTrafficPolicyVersionError::TooManyTrafficPolicyVersionsForCurrentPolicy({
   90     78   
                #[allow(unused_mut)]
   91     79   
                let mut tmp = {
   92     80   
                    #[allow(unused_mut)]
   93     81   
                    let mut output = crate::types::error::builders::TooManyTrafficPolicyVersionsForCurrentPolicyBuilder::default();
   94     82   
                    output = crate::protocol_serde::shape_too_many_traffic_policy_versions_for_current_policy::de_too_many_traffic_policy_versions_for_current_policy_xml_err(_response_body, output).map_err(crate::operation::create_traffic_policy_version::CreateTrafficPolicyVersionError::unhandled)?;
   95     83   
                    let output = output.meta(generic);
   96     84   
                    output.build()
   97     85   
                };
   98         -
                if tmp.message.is_none() {
   99         -
                    tmp.message = _error_message;
  100         -
                }
  101     86   
                tmp
  102     87   
            })
  103     88   
        }
  104     89   
        _ => crate::operation::create_traffic_policy_version::CreateTrafficPolicyVersionError::generic(generic),
  105     90   
    })
  106     91   
}
  107     92   
  108     93   
#[allow(clippy::unnecessary_wraps)]
  109     94   
pub fn de_create_traffic_policy_version_http_response(
  110     95   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_create_vpc_association_authorization.rs

@@ -4,4 +132,117 @@
   24     24   
            crate::operation::create_vpc_association_authorization::CreateVPCAssociationAuthorizationError::ConcurrentModification({
   25     25   
                #[allow(unused_mut)]
   26     26   
                let mut tmp = {
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::ConcurrentModificationBuilder::default();
   29     29   
                    output = crate::protocol_serde::shape_concurrent_modification::de_concurrent_modification_xml_err(_response_body, output)
   30     30   
                        .map_err(crate::operation::create_vpc_association_authorization::CreateVPCAssociationAuthorizationError::unhandled)?;
   31     31   
                    let output = output.meta(generic);
   32     32   
                    output.build()
   33     33   
                };
   34         -
                if tmp.message.is_none() {
   35         -
                    tmp.message = _error_message;
   36         -
                }
   37     34   
                tmp
   38     35   
            })
   39     36   
        }
   40     37   
        "InvalidInput" => crate::operation::create_vpc_association_authorization::CreateVPCAssociationAuthorizationError::InvalidInput({
   41     38   
            #[allow(unused_mut)]
   42     39   
            let mut tmp = {
   43     40   
                #[allow(unused_mut)]
   44     41   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   45     42   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   46     43   
                    .map_err(crate::operation::create_vpc_association_authorization::CreateVPCAssociationAuthorizationError::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   
        "InvalidVPCId" => crate::operation::create_vpc_association_authorization::CreateVPCAssociationAuthorizationError::InvalidVpcId({
   56     50   
            #[allow(unused_mut)]
   57     51   
            let mut tmp = {
   58     52   
                #[allow(unused_mut)]
   59     53   
                let mut output = crate::types::error::builders::InvalidVpcIdBuilder::default();
   60     54   
                output = crate::protocol_serde::shape_invalid_vpc_id::de_invalid_vpc_id_xml_err(_response_body, output)
   61     55   
                    .map_err(crate::operation::create_vpc_association_authorization::CreateVPCAssociationAuthorizationError::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   
        "NoSuchHostedZone" => crate::operation::create_vpc_association_authorization::CreateVPCAssociationAuthorizationError::NoSuchHostedZone({
   71     62   
            #[allow(unused_mut)]
   72     63   
            let mut tmp = {
   73     64   
                #[allow(unused_mut)]
   74     65   
                let mut output = crate::types::error::builders::NoSuchHostedZoneBuilder::default();
   75     66   
                output = crate::protocol_serde::shape_no_such_hosted_zone::de_no_such_hosted_zone_xml_err(_response_body, output)
   76     67   
                    .map_err(crate::operation::create_vpc_association_authorization::CreateVPCAssociationAuthorizationError::unhandled)?;
   77     68   
                let output = output.meta(generic);
   78     69   
                output.build()
   79     70   
            };
   80         -
            if tmp.message.is_none() {
   81         -
                tmp.message = _error_message;
   82         -
            }
   83     71   
            tmp
   84     72   
        }),
   85     73   
        "TooManyVPCAssociationAuthorizations" => {
   86     74   
            crate::operation::create_vpc_association_authorization::CreateVPCAssociationAuthorizationError::TooManyVpcAssociationAuthorizations({
   87     75   
                #[allow(unused_mut)]
   88     76   
                let mut tmp = {
   89     77   
                    #[allow(unused_mut)]
   90     78   
                    let mut output = crate::types::error::builders::TooManyVpcAssociationAuthorizationsBuilder::default();
   91     79   
                    output =
   92     80   
                        crate::protocol_serde::shape_too_many_vpc_association_authorizations::de_too_many_vpc_association_authorizations_xml_err(
   93     81   
                            _response_body,
   94     82   
                            output,
   95     83   
                        )
   96     84   
                        .map_err(crate::operation::create_vpc_association_authorization::CreateVPCAssociationAuthorizationError::unhandled)?;
   97     85   
                    let output = output.meta(generic);
   98     86   
                    output.build()
   99     87   
                };
  100         -
                if tmp.message.is_none() {
  101         -
                    tmp.message = _error_message;
  102         -
                }
  103     88   
                tmp
  104     89   
            })
  105     90   
        }
  106     91   
        _ => crate::operation::create_vpc_association_authorization::CreateVPCAssociationAuthorizationError::generic(generic),
  107     92   
    })
  108     93   
}
  109     94   
  110     95   
#[allow(clippy::unnecessary_wraps)]
  111     96   
pub fn de_create_vpc_association_authorization_http_response(
  112     97   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_deactivate_key_signing_key.rs

@@ -7,7 +165,144 @@
   27     27   
        "ConcurrentModification" => crate::operation::deactivate_key_signing_key::DeactivateKeySigningKeyError::ConcurrentModification({
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::ConcurrentModificationBuilder::default();
   32     32   
                output = crate::protocol_serde::shape_concurrent_modification::de_concurrent_modification_xml_err(_response_body, output)
   33     33   
                    .map_err(crate::operation::deactivate_key_signing_key::DeactivateKeySigningKeyError::unhandled)?;
   34     34   
                let output = output.meta(generic);
   35     35   
                output.build()
   36     36   
            };
   37         -
            if tmp.message.is_none() {
   38         -
                tmp.message = _error_message;
   39         -
            }
   40     37   
            tmp
   41     38   
        }),
   42     39   
        "InvalidInput" => crate::operation::deactivate_key_signing_key::DeactivateKeySigningKeyError::InvalidInput({
   43     40   
            #[allow(unused_mut)]
   44     41   
            let mut tmp = {
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   47     44   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   48     45   
                    .map_err(crate::operation::deactivate_key_signing_key::DeactivateKeySigningKeyError::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   
        "InvalidKeySigningKeyStatus" => crate::operation::deactivate_key_signing_key::DeactivateKeySigningKeyError::InvalidKeySigningKeyStatus({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp = {
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut output = crate::types::error::builders::InvalidKeySigningKeyStatusBuilder::default();
   62     56   
                output =
   63     57   
                    crate::protocol_serde::shape_invalid_key_signing_key_status::de_invalid_key_signing_key_status_xml_err(_response_body, output)
   64     58   
                        .map_err(crate::operation::deactivate_key_signing_key::DeactivateKeySigningKeyError::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   
        "InvalidSigningStatus" => crate::operation::deactivate_key_signing_key::DeactivateKeySigningKeyError::InvalidSigningStatus({
   74     65   
            #[allow(unused_mut)]
   75     66   
            let mut tmp = {
   76     67   
                #[allow(unused_mut)]
   77     68   
                let mut output = crate::types::error::builders::InvalidSigningStatusBuilder::default();
   78     69   
                output = crate::protocol_serde::shape_invalid_signing_status::de_invalid_signing_status_xml_err(_response_body, output)
   79     70   
                    .map_err(crate::operation::deactivate_key_signing_key::DeactivateKeySigningKeyError::unhandled)?;
   80     71   
                let output = output.meta(generic);
   81     72   
                output.build()
   82     73   
            };
   83         -
            if tmp.message.is_none() {
   84         -
                tmp.message = _error_message;
   85         -
            }
   86     74   
            tmp
   87     75   
        }),
   88     76   
        "KeySigningKeyInParentDSRecord" => {
   89     77   
            crate::operation::deactivate_key_signing_key::DeactivateKeySigningKeyError::KeySigningKeyInParentDsRecord({
   90     78   
                #[allow(unused_mut)]
   91     79   
                let mut tmp = {
   92     80   
                    #[allow(unused_mut)]
   93     81   
                    let mut output = crate::types::error::builders::KeySigningKeyInParentDsRecordBuilder::default();
   94     82   
                    output = crate::protocol_serde::shape_key_signing_key_in_parent_ds_record::de_key_signing_key_in_parent_ds_record_xml_err(
   95     83   
                        _response_body,
   96     84   
                        output,
   97     85   
                    )
   98     86   
                    .map_err(crate::operation::deactivate_key_signing_key::DeactivateKeySigningKeyError::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   
        "KeySigningKeyInUse" => crate::operation::deactivate_key_signing_key::DeactivateKeySigningKeyError::KeySigningKeyInUse({
  109     94   
            #[allow(unused_mut)]
  110     95   
            let mut tmp = {
  111     96   
                #[allow(unused_mut)]
  112     97   
                let mut output = crate::types::error::builders::KeySigningKeyInUseBuilder::default();
  113     98   
                output = crate::protocol_serde::shape_key_signing_key_in_use::de_key_signing_key_in_use_xml_err(_response_body, output)
  114     99   
                    .map_err(crate::operation::deactivate_key_signing_key::DeactivateKeySigningKeyError::unhandled)?;
  115    100   
                let output = output.meta(generic);
  116    101   
                output.build()
  117    102   
            };
  118         -
            if tmp.message.is_none() {
  119         -
                tmp.message = _error_message;
  120         -
            }
  121    103   
            tmp
  122    104   
        }),
  123    105   
        "NoSuchKeySigningKey" => crate::operation::deactivate_key_signing_key::DeactivateKeySigningKeyError::NoSuchKeySigningKey({
  124    106   
            #[allow(unused_mut)]
  125    107   
            let mut tmp = {
  126    108   
                #[allow(unused_mut)]
  127    109   
                let mut output = crate::types::error::builders::NoSuchKeySigningKeyBuilder::default();
  128    110   
                output = crate::protocol_serde::shape_no_such_key_signing_key::de_no_such_key_signing_key_xml_err(_response_body, output)
  129    111   
                    .map_err(crate::operation::deactivate_key_signing_key::DeactivateKeySigningKeyError::unhandled)?;
  130    112   
                let output = output.meta(generic);
  131    113   
                output.build()
  132    114   
            };
  133         -
            if tmp.message.is_none() {
  134         -
                tmp.message = _error_message;
  135         -
            }
  136    115   
            tmp
  137    116   
        }),
  138    117   
        _ => crate::operation::deactivate_key_signing_key::DeactivateKeySigningKeyError::generic(generic),
  139    118   
    })
  140    119   
}
  141    120   
  142    121   
#[allow(clippy::unnecessary_wraps)]
  143    122   
pub fn de_deactivate_key_signing_key_http_response(
  144    123   
    _response_status: u16,
  145    124   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_delete_cidr_collection.rs

@@ -6,6 +108,96 @@
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::CidrCollectionInUseExceptionBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_cidr_collection_in_use_exception::de_cidr_collection_in_use_exception_xml_err(
   29     29   
                    _response_body,
   30     30   
                    output,
   31     31   
                )
   32     32   
                .map_err(crate::operation::delete_cidr_collection::DeleteCidrCollectionError::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   
        "ConcurrentModification" => crate::operation::delete_cidr_collection::DeleteCidrCollectionError::ConcurrentModification({
   42     39   
            #[allow(unused_mut)]
   43     40   
            let mut tmp = {
   44     41   
                #[allow(unused_mut)]
   45     42   
                let mut output = crate::types::error::builders::ConcurrentModificationBuilder::default();
   46     43   
                output = crate::protocol_serde::shape_concurrent_modification::de_concurrent_modification_xml_err(_response_body, output)
   47     44   
                    .map_err(crate::operation::delete_cidr_collection::DeleteCidrCollectionError::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   
        "InvalidInput" => crate::operation::delete_cidr_collection::DeleteCidrCollectionError::InvalidInput({
   57     51   
            #[allow(unused_mut)]
   58     52   
            let mut tmp = {
   59     53   
                #[allow(unused_mut)]
   60     54   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   61     55   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   62     56   
                    .map_err(crate::operation::delete_cidr_collection::DeleteCidrCollectionError::unhandled)?;
   63     57   
                let output = output.meta(generic);
   64     58   
                output.build()
   65     59   
            };
   66         -
            if tmp.message.is_none() {
   67         -
                tmp.message = _error_message;
   68         -
            }
   69     60   
            tmp
   70     61   
        }),
   71     62   
        "NoSuchCidrCollectionException" => crate::operation::delete_cidr_collection::DeleteCidrCollectionError::NoSuchCidrCollectionException({
   72     63   
            #[allow(unused_mut)]
   73     64   
            let mut tmp = {
   74     65   
                #[allow(unused_mut)]
   75     66   
                let mut output = crate::types::error::builders::NoSuchCidrCollectionExceptionBuilder::default();
   76     67   
                output = crate::protocol_serde::shape_no_such_cidr_collection_exception::de_no_such_cidr_collection_exception_xml_err(
   77     68   
                    _response_body,
   78     69   
                    output,
   79     70   
                )
   80     71   
                .map_err(crate::operation::delete_cidr_collection::DeleteCidrCollectionError::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   
        _ => crate::operation::delete_cidr_collection::DeleteCidrCollectionError::generic(generic),
   90     78   
    })
   91     79   
}
   92     80   
   93     81   
#[allow(clippy::unnecessary_wraps)]
   94     82   
pub fn de_delete_cidr_collection_http_response(
   95     83   
    _response_status: u16,
   96     84   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_delete_health_check.rs

@@ -1,1 +83,74 @@
   21     21   
        "HealthCheckInUse" => crate::operation::delete_health_check::DeleteHealthCheckError::HealthCheckInUse({
   22     22   
            #[allow(unused_mut)]
   23     23   
            let mut tmp = {
   24     24   
                #[allow(unused_mut)]
   25     25   
                let mut output = crate::types::error::builders::HealthCheckInUseBuilder::default();
   26     26   
                output = crate::protocol_serde::shape_health_check_in_use::de_health_check_in_use_xml_err(_response_body, output)
   27     27   
                    .map_err(crate::operation::delete_health_check::DeleteHealthCheckError::unhandled)?;
   28     28   
                let output = output.meta(generic);
   29     29   
                output.build()
   30     30   
            };
   31         -
            if tmp.message.is_none() {
   32         -
                tmp.message = _error_message;
   33         -
            }
   34     31   
            tmp
   35     32   
        }),
   36     33   
        "InvalidInput" => crate::operation::delete_health_check::DeleteHealthCheckError::InvalidInput({
   37     34   
            #[allow(unused_mut)]
   38     35   
            let mut tmp = {
   39     36   
                #[allow(unused_mut)]
   40     37   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   41     38   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   42     39   
                    .map_err(crate::operation::delete_health_check::DeleteHealthCheckError::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   
        "NoSuchHealthCheck" => crate::operation::delete_health_check::DeleteHealthCheckError::NoSuchHealthCheck({
   52     46   
            #[allow(unused_mut)]
   53     47   
            let mut tmp = {
   54     48   
                #[allow(unused_mut)]
   55     49   
                let mut output = crate::types::error::builders::NoSuchHealthCheckBuilder::default();
   56     50   
                output = crate::protocol_serde::shape_no_such_health_check::de_no_such_health_check_xml_err(_response_body, output)
   57     51   
                    .map_err(crate::operation::delete_health_check::DeleteHealthCheckError::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   
        _ => crate::operation::delete_health_check::DeleteHealthCheckError::generic(generic),
   67     58   
    })
   68     59   
}
   69     60   
   70     61   
#[allow(clippy::unnecessary_wraps)]
   71     62   
pub fn de_delete_health_check_http_response(
   72     63   
    _response_status: u16,
   73     64   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_delete_hosted_zone.rs

@@ -1,1 +122,107 @@
   20     20   
        "HostedZoneNotEmpty" => crate::operation::delete_hosted_zone::DeleteHostedZoneError::HostedZoneNotEmpty({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::HostedZoneNotEmptyBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_hosted_zone_not_empty::de_hosted_zone_not_empty_xml_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::delete_hosted_zone::DeleteHostedZoneError::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   
        "InvalidDomainName" => crate::operation::delete_hosted_zone::DeleteHostedZoneError::InvalidDomainName({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InvalidDomainNameBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_invalid_domain_name::de_invalid_domain_name_xml_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::delete_hosted_zone::DeleteHostedZoneError::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   
        "InvalidInput" => crate::operation::delete_hosted_zone::DeleteHostedZoneError::InvalidInput({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::delete_hosted_zone::DeleteHostedZoneError::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   
        "NoSuchHostedZone" => crate::operation::delete_hosted_zone::DeleteHostedZoneError::NoSuchHostedZone({
   66     57   
            #[allow(unused_mut)]
   67     58   
            let mut tmp = {
   68     59   
                #[allow(unused_mut)]
   69     60   
                let mut output = crate::types::error::builders::NoSuchHostedZoneBuilder::default();
   70     61   
                output = crate::protocol_serde::shape_no_such_hosted_zone::de_no_such_hosted_zone_xml_err(_response_body, output)
   71     62   
                    .map_err(crate::operation::delete_hosted_zone::DeleteHostedZoneError::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   
        "PriorRequestNotComplete" => crate::operation::delete_hosted_zone::DeleteHostedZoneError::PriorRequestNotComplete({
   81     69   
            #[allow(unused_mut)]
   82     70   
            let mut tmp = {
   83     71   
                #[allow(unused_mut)]
   84     72   
                let mut output = crate::types::error::builders::PriorRequestNotCompleteBuilder::default();
   85     73   
                output = crate::protocol_serde::shape_prior_request_not_complete::de_prior_request_not_complete_xml_err(_response_body, output)
   86     74   
                    .map_err(crate::operation::delete_hosted_zone::DeleteHostedZoneError::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::delete_hosted_zone::DeleteHostedZoneError::generic(generic),
   96     81   
    })
   97     82   
}
   98     83   
   99     84   
#[allow(clippy::unnecessary_wraps)]
  100     85   
pub fn de_delete_hosted_zone_http_response(
  101     86   
    _response_status: u16,
  102     87   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_delete_key_signing_key.rs

@@ -3,3 +141,123 @@
   23     23   
        "ConcurrentModification" => crate::operation::delete_key_signing_key::DeleteKeySigningKeyError::ConcurrentModification({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::ConcurrentModificationBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_concurrent_modification::de_concurrent_modification_xml_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::delete_key_signing_key::DeleteKeySigningKeyError::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   
        "InvalidInput" => crate::operation::delete_key_signing_key::DeleteKeySigningKeyError::InvalidInput({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::delete_key_signing_key::DeleteKeySigningKeyError::unhandled)?;
   45     42   
                let output = output.meta(generic);
   46     43   
                output.build()
   47     44   
            };
   48         -
            if tmp.message.is_none() {
   49         -
                tmp.message = _error_message;
   50         -
            }
   51     45   
            tmp
   52     46   
        }),
   53     47   
        "InvalidKeySigningKeyStatus" => crate::operation::delete_key_signing_key::DeleteKeySigningKeyError::InvalidKeySigningKeyStatus({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::InvalidKeySigningKeyStatusBuilder::default();
   58     52   
                output =
   59     53   
                    crate::protocol_serde::shape_invalid_key_signing_key_status::de_invalid_key_signing_key_status_xml_err(_response_body, output)
   60     54   
                        .map_err(crate::operation::delete_key_signing_key::DeleteKeySigningKeyError::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   
        "InvalidKMSArn" => crate::operation::delete_key_signing_key::DeleteKeySigningKeyError::InvalidKmsArn({
   70     61   
            #[allow(unused_mut)]
   71     62   
            let mut tmp = {
   72     63   
                #[allow(unused_mut)]
   73     64   
                let mut output = crate::types::error::builders::InvalidKmsArnBuilder::default();
   74     65   
                output = crate::protocol_serde::shape_invalid_kms_arn::de_invalid_kms_arn_xml_err(_response_body, output)
   75     66   
                    .map_err(crate::operation::delete_key_signing_key::DeleteKeySigningKeyError::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   
        "InvalidSigningStatus" => crate::operation::delete_key_signing_key::DeleteKeySigningKeyError::InvalidSigningStatus({
   85     73   
            #[allow(unused_mut)]
   86     74   
            let mut tmp = {
   87     75   
                #[allow(unused_mut)]
   88     76   
                let mut output = crate::types::error::builders::InvalidSigningStatusBuilder::default();
   89     77   
                output = crate::protocol_serde::shape_invalid_signing_status::de_invalid_signing_status_xml_err(_response_body, output)
   90     78   
                    .map_err(crate::operation::delete_key_signing_key::DeleteKeySigningKeyError::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   
        "NoSuchKeySigningKey" => crate::operation::delete_key_signing_key::DeleteKeySigningKeyError::NoSuchKeySigningKey({
  100     85   
            #[allow(unused_mut)]
  101     86   
            let mut tmp = {
  102     87   
                #[allow(unused_mut)]
  103     88   
                let mut output = crate::types::error::builders::NoSuchKeySigningKeyBuilder::default();
  104     89   
                output = crate::protocol_serde::shape_no_such_key_signing_key::de_no_such_key_signing_key_xml_err(_response_body, output)
  105     90   
                    .map_err(crate::operation::delete_key_signing_key::DeleteKeySigningKeyError::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::delete_key_signing_key::DeleteKeySigningKeyError::generic(generic),
  115     97   
    })
  116     98   
}
  117     99   
  118    100   
#[allow(clippy::unnecessary_wraps)]
  119    101   
pub fn de_delete_key_signing_key_http_response(
  120    102   
    _response_status: u16,
  121    103   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_delete_query_logging_config.rs

@@ -7,7 +91,82 @@
   27     27   
        "ConcurrentModification" => crate::operation::delete_query_logging_config::DeleteQueryLoggingConfigError::ConcurrentModification({
   28     28   
            #[allow(unused_mut)]
   29     29   
            let mut tmp = {
   30     30   
                #[allow(unused_mut)]
   31     31   
                let mut output = crate::types::error::builders::ConcurrentModificationBuilder::default();
   32     32   
                output = crate::protocol_serde::shape_concurrent_modification::de_concurrent_modification_xml_err(_response_body, output)
   33     33   
                    .map_err(crate::operation::delete_query_logging_config::DeleteQueryLoggingConfigError::unhandled)?;
   34     34   
                let output = output.meta(generic);
   35     35   
                output.build()
   36     36   
            };
   37         -
            if tmp.message.is_none() {
   38         -
                tmp.message = _error_message;
   39         -
            }
   40     37   
            tmp
   41     38   
        }),
   42     39   
        "InvalidInput" => crate::operation::delete_query_logging_config::DeleteQueryLoggingConfigError::InvalidInput({
   43     40   
            #[allow(unused_mut)]
   44     41   
            let mut tmp = {
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   47     44   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   48     45   
                    .map_err(crate::operation::delete_query_logging_config::DeleteQueryLoggingConfigError::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   
        "NoSuchQueryLoggingConfig" => crate::operation::delete_query_logging_config::DeleteQueryLoggingConfigError::NoSuchQueryLoggingConfig({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp = {
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut output = crate::types::error::builders::NoSuchQueryLoggingConfigBuilder::default();
   62     56   
                output = crate::protocol_serde::shape_no_such_query_logging_config::de_no_such_query_logging_config_xml_err(_response_body, output)
   63     57   
                    .map_err(crate::operation::delete_query_logging_config::DeleteQueryLoggingConfigError::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::delete_query_logging_config::DeleteQueryLoggingConfigError::generic(generic),
   73     64   
    })
   74     65   
}
   75     66   
   76     67   
#[allow(clippy::unnecessary_wraps)]
   77     68   
pub fn de_delete_query_logging_config_http_response(
   78     69   
    _response_status: u16,
   79     70   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_delete_reusable_delegation_set.rs

@@ -3,3 +102,90 @@
   23     23   
        "DelegationSetInUse" => crate::operation::delete_reusable_delegation_set::DeleteReusableDelegationSetError::DelegationSetInUse({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::DelegationSetInUseBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_delegation_set_in_use::de_delegation_set_in_use_xml_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::delete_reusable_delegation_set::DeleteReusableDelegationSetError::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   
        "DelegationSetNotReusable" => crate::operation::delete_reusable_delegation_set::DeleteReusableDelegationSetError::DelegationSetNotReusable({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::DelegationSetNotReusableBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_delegation_set_not_reusable::de_delegation_set_not_reusable_xml_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::delete_reusable_delegation_set::DeleteReusableDelegationSetError::unhandled)?;
   45     42   
                let output = output.meta(generic);
   46     43   
                output.build()
   47     44   
            };
   48         -
            if tmp.message.is_none() {
   49         -
                tmp.message = _error_message;
   50         -
            }
   51     45   
            tmp
   52     46   
        }),
   53     47   
        "InvalidInput" => crate::operation::delete_reusable_delegation_set::DeleteReusableDelegationSetError::InvalidInput({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::delete_reusable_delegation_set::DeleteReusableDelegationSetError::unhandled)?;
   60     54   
                let output = output.meta(generic);
   61     55   
                output.build()
   62     56   
            };
   63         -
            if tmp.message.is_none() {
   64         -
                tmp.message = _error_message;
   65         -
            }
   66     57   
            tmp
   67     58   
        }),
   68     59   
        "NoSuchDelegationSet" => crate::operation::delete_reusable_delegation_set::DeleteReusableDelegationSetError::NoSuchDelegationSet({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::NoSuchDelegationSetBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_no_such_delegation_set::de_no_such_delegation_set_xml_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::delete_reusable_delegation_set::DeleteReusableDelegationSetError::unhandled)?;
   75     66   
                let output = output.meta(generic);
   76     67   
                output.build()
   77     68   
            };
   78         -
            if tmp.message.is_none() {
   79         -
                tmp.message = _error_message;
   80         -
            }
   81     69   
            tmp
   82     70   
        }),
   83     71   
        _ => crate::operation::delete_reusable_delegation_set::DeleteReusableDelegationSetError::generic(generic),
   84     72   
    })
   85     73   
}
   86     74   
   87     75   
#[allow(clippy::unnecessary_wraps)]
   88     76   
pub fn de_delete_reusable_delegation_set_http_response(
   89     77   
    _response_status: u16,
   90     78   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/route53/src/protocol_serde/shape_delete_traffic_policy.rs

@@ -3,3 +102,90 @@
   23     23   
        "ConcurrentModification" => crate::operation::delete_traffic_policy::DeleteTrafficPolicyError::ConcurrentModification({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::ConcurrentModificationBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_concurrent_modification::de_concurrent_modification_xml_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::delete_traffic_policy::DeleteTrafficPolicyError::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   
        "InvalidInput" => crate::operation::delete_traffic_policy::DeleteTrafficPolicyError::InvalidInput({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::delete_traffic_policy::DeleteTrafficPolicyError::unhandled)?;
   45     42   
                let output = output.meta(generic);
   46     43   
                output.build()
   47     44   
            };
   48         -
            if tmp.message.is_none() {
   49         -
                tmp.message = _error_message;
   50         -
            }
   51     45   
            tmp
   52     46   
        }),
   53     47   
        "NoSuchTrafficPolicy" => crate::operation::delete_traffic_policy::DeleteTrafficPolicyError::NoSuchTrafficPolicy({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::NoSuchTrafficPolicyBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_no_such_traffic_policy::de_no_such_traffic_policy_xml_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::delete_traffic_policy::DeleteTrafficPolicyError::unhandled)?;
   60     54   
                let output = output.meta(generic);
   61     55   
                output.build()
   62     56   
            };
   63         -
            if tmp.message.is_none() {
   64         -
                tmp.message = _error_message;
   65         -
            }
   66     57   
            tmp
   67     58   
        }),
   68     59   
        "TrafficPolicyInUse" => crate::operation::delete_traffic_policy::DeleteTrafficPolicyError::TrafficPolicyInUse({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::TrafficPolicyInUseBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_traffic_policy_in_use::de_traffic_policy_in_use_xml_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::delete_traffic_policy::DeleteTrafficPolicyError::unhandled)?;
   75     66   
                let output = output.meta(generic);
   76     67   
                output.build()
   77     68   
            };
   78         -
            if tmp.message.is_none() {
   79         -
                tmp.message = _error_message;
   80         -
            }
   81     69   
            tmp
   82     70   
        }),
   83     71   
        _ => crate::operation::delete_traffic_policy::DeleteTrafficPolicyError::generic(generic),
   84     72   
    })
   85     73   
}
   86     74   
   87     75   
#[allow(clippy::unnecessary_wraps)]
   88     76   
pub fn de_delete_traffic_policy_http_response(
   89     77   
    _response_status: u16,
   90     78   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,