AWS SDK

AWS SDK

rev. 03f9d3736bb06bbe282d7bfe7c28721562f20a05

Files changed:

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

@@ -3,3 +92,83 @@
   23     23   
        "InvalidInput" => crate::operation::delete_traffic_policy_instance::DeleteTrafficPolicyInstanceError::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::delete_traffic_policy_instance::DeleteTrafficPolicyInstanceError::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   
        "NoSuchTrafficPolicyInstance" => {
   39     36   
            crate::operation::delete_traffic_policy_instance::DeleteTrafficPolicyInstanceError::NoSuchTrafficPolicyInstance({
   40     37   
                #[allow(unused_mut)]
   41     38   
                let mut tmp = {
   42     39   
                    #[allow(unused_mut)]
   43     40   
                    let mut output = crate::types::error::builders::NoSuchTrafficPolicyInstanceBuilder::default();
   44     41   
                    output = crate::protocol_serde::shape_no_such_traffic_policy_instance::de_no_such_traffic_policy_instance_xml_err(
   45     42   
                        _response_body,
   46     43   
                        output,
   47     44   
                    )
   48     45   
                    .map_err(crate::operation::delete_traffic_policy_instance::DeleteTrafficPolicyInstanceError::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   
        "PriorRequestNotComplete" => crate::operation::delete_traffic_policy_instance::DeleteTrafficPolicyInstanceError::PriorRequestNotComplete({
   59     53   
            #[allow(unused_mut)]
   60     54   
            let mut tmp = {
   61     55   
                #[allow(unused_mut)]
   62     56   
                let mut output = crate::types::error::builders::PriorRequestNotCompleteBuilder::default();
   63     57   
                output = crate::protocol_serde::shape_prior_request_not_complete::de_prior_request_not_complete_xml_err(_response_body, output)
   64     58   
                    .map_err(crate::operation::delete_traffic_policy_instance::DeleteTrafficPolicyInstanceError::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   
        _ => crate::operation::delete_traffic_policy_instance::DeleteTrafficPolicyInstanceError::generic(generic),
   74     65   
    })
   75     66   
}
   76     67   
   77     68   
#[allow(clippy::unnecessary_wraps)]
   78     69   
pub fn de_delete_traffic_policy_instance_http_response(
   79     70   
    _response_status: u16,
   80     71   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -4,4 +132,117 @@
   24     24   
            crate::operation::delete_vpc_association_authorization::DeleteVPCAssociationAuthorizationError::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::delete_vpc_association_authorization::DeleteVPCAssociationAuthorizationError::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::delete_vpc_association_authorization::DeleteVPCAssociationAuthorizationError::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::delete_vpc_association_authorization::DeleteVPCAssociationAuthorizationError::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::delete_vpc_association_authorization::DeleteVPCAssociationAuthorizationError::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::delete_vpc_association_authorization::DeleteVPCAssociationAuthorizationError::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::delete_vpc_association_authorization::DeleteVPCAssociationAuthorizationError::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::delete_vpc_association_authorization::DeleteVPCAssociationAuthorizationError::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   
        "VPCAssociationAuthorizationNotFound" => {
   86     74   
            crate::operation::delete_vpc_association_authorization::DeleteVPCAssociationAuthorizationError::VpcAssociationAuthorizationNotFound({
   87     75   
                #[allow(unused_mut)]
   88     76   
                let mut tmp = {
   89     77   
                    #[allow(unused_mut)]
   90     78   
                    let mut output = crate::types::error::builders::VpcAssociationAuthorizationNotFoundBuilder::default();
   91     79   
                    output =
   92     80   
                        crate::protocol_serde::shape_vpc_association_authorization_not_found::de_vpc_association_authorization_not_found_xml_err(
   93     81   
                            _response_body,
   94     82   
                            output,
   95     83   
                        )
   96     84   
                        .map_err(crate::operation::delete_vpc_association_authorization::DeleteVPCAssociationAuthorizationError::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::delete_vpc_association_authorization::DeleteVPCAssociationAuthorizationError::generic(generic),
  107     92   
    })
  108     93   
}
  109     94   
  110     95   
#[allow(clippy::unnecessary_wraps)]
  111     96   
pub fn de_delete_vpc_association_authorization_http_response(
  112     97   
    _response_status: u16,

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

@@ -7,7 +180,156 @@
   27     27   
        "ConcurrentModification" => crate::operation::disable_hosted_zone_dnssec::DisableHostedZoneDNSSECError::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::disable_hosted_zone_dnssec::DisableHostedZoneDNSSECError::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   
        "DNSSECNotFound" => crate::operation::disable_hosted_zone_dnssec::DisableHostedZoneDNSSECError::DnssecNotFound({
   43     40   
            #[allow(unused_mut)]
   44     41   
            let mut tmp = {
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut output = crate::types::error::builders::DnssecNotFoundBuilder::default();
   47     44   
                output = crate::protocol_serde::shape_dnssec_not_found::de_dnssec_not_found_xml_err(_response_body, output)
   48     45   
                    .map_err(crate::operation::disable_hosted_zone_dnssec::DisableHostedZoneDNSSECError::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   
        "InvalidArgument" => crate::operation::disable_hosted_zone_dnssec::DisableHostedZoneDNSSECError::InvalidArgument({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp = {
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut output = crate::types::error::builders::InvalidArgumentBuilder::default();
   62     56   
                output = crate::protocol_serde::shape_invalid_argument::de_invalid_argument_xml_err(_response_body, output)
   63     57   
                    .map_err(crate::operation::disable_hosted_zone_dnssec::DisableHostedZoneDNSSECError::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   
        "InvalidInput" => crate::operation::disable_hosted_zone_dnssec::DisableHostedZoneDNSSECError::InvalidInput({
   73     64   
            #[allow(unused_mut)]
   74     65   
            let mut tmp = {
   75     66   
                #[allow(unused_mut)]
   76     67   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   77     68   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   78     69   
                    .map_err(crate::operation::disable_hosted_zone_dnssec::DisableHostedZoneDNSSECError::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   
        "InvalidKeySigningKeyStatus" => crate::operation::disable_hosted_zone_dnssec::DisableHostedZoneDNSSECError::InvalidKeySigningKeyStatus({
   88     76   
            #[allow(unused_mut)]
   89     77   
            let mut tmp = {
   90     78   
                #[allow(unused_mut)]
   91     79   
                let mut output = crate::types::error::builders::InvalidKeySigningKeyStatusBuilder::default();
   92     80   
                output =
   93     81   
                    crate::protocol_serde::shape_invalid_key_signing_key_status::de_invalid_key_signing_key_status_xml_err(_response_body, output)
   94     82   
                        .map_err(crate::operation::disable_hosted_zone_dnssec::DisableHostedZoneDNSSECError::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   
        "InvalidKMSArn" => crate::operation::disable_hosted_zone_dnssec::DisableHostedZoneDNSSECError::InvalidKmsArn({
  104     89   
            #[allow(unused_mut)]
  105     90   
            let mut tmp = {
  106     91   
                #[allow(unused_mut)]
  107     92   
                let mut output = crate::types::error::builders::InvalidKmsArnBuilder::default();
  108     93   
                output = crate::protocol_serde::shape_invalid_kms_arn::de_invalid_kms_arn_xml_err(_response_body, output)
  109     94   
                    .map_err(crate::operation::disable_hosted_zone_dnssec::DisableHostedZoneDNSSECError::unhandled)?;
  110     95   
                let output = output.meta(generic);
  111     96   
                output.build()
  112     97   
            };
  113         -
            if tmp.message.is_none() {
  114         -
                tmp.message = _error_message;
  115         -
            }
  116     98   
            tmp
  117     99   
        }),
  118    100   
        "KeySigningKeyInParentDSRecord" => {
  119    101   
            crate::operation::disable_hosted_zone_dnssec::DisableHostedZoneDNSSECError::KeySigningKeyInParentDsRecord({
  120    102   
                #[allow(unused_mut)]
  121    103   
                let mut tmp = {
  122    104   
                    #[allow(unused_mut)]
  123    105   
                    let mut output = crate::types::error::builders::KeySigningKeyInParentDsRecordBuilder::default();
  124    106   
                    output = crate::protocol_serde::shape_key_signing_key_in_parent_ds_record::de_key_signing_key_in_parent_ds_record_xml_err(
  125    107   
                        _response_body,
  126    108   
                        output,
  127    109   
                    )
  128    110   
                    .map_err(crate::operation::disable_hosted_zone_dnssec::DisableHostedZoneDNSSECError::unhandled)?;
  129    111   
                    let output = output.meta(generic);
  130    112   
                    output.build()
  131    113   
                };
  132         -
                if tmp.message.is_none() {
  133         -
                    tmp.message = _error_message;
  134         -
                }
  135    114   
                tmp
  136    115   
            })
  137    116   
        }
  138    117   
        "NoSuchHostedZone" => crate::operation::disable_hosted_zone_dnssec::DisableHostedZoneDNSSECError::NoSuchHostedZone({
  139    118   
            #[allow(unused_mut)]
  140    119   
            let mut tmp = {
  141    120   
                #[allow(unused_mut)]
  142    121   
                let mut output = crate::types::error::builders::NoSuchHostedZoneBuilder::default();
  143    122   
                output = crate::protocol_serde::shape_no_such_hosted_zone::de_no_such_hosted_zone_xml_err(_response_body, output)
  144    123   
                    .map_err(crate::operation::disable_hosted_zone_dnssec::DisableHostedZoneDNSSECError::unhandled)?;
  145    124   
                let output = output.meta(generic);
  146    125   
                output.build()
  147    126   
            };
  148         -
            if tmp.message.is_none() {
  149         -
                tmp.message = _error_message;
  150         -
            }
  151    127   
            tmp
  152    128   
        }),
  153    129   
        _ => crate::operation::disable_hosted_zone_dnssec::DisableHostedZoneDNSSECError::generic(generic),
  154    130   
    })
  155    131   
}
  156    132   
  157    133   
#[allow(clippy::unnecessary_wraps)]
  158    134   
pub fn de_disable_hosted_zone_dnssec_http_response(
  159    135   
    _response_status: u16,
  160    136   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +126,111 @@
   23     23   
        "InvalidInput" => crate::operation::disassociate_vpc_from_hosted_zone::DisassociateVPCFromHostedZoneError::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::disassociate_vpc_from_hosted_zone::DisassociateVPCFromHostedZoneError::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   
        "InvalidVPCId" => crate::operation::disassociate_vpc_from_hosted_zone::DisassociateVPCFromHostedZoneError::InvalidVpcId({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::InvalidVpcIdBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_invalid_vpc_id::de_invalid_vpc_id_xml_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::disassociate_vpc_from_hosted_zone::DisassociateVPCFromHostedZoneError::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   
        "LastVPCAssociation" => crate::operation::disassociate_vpc_from_hosted_zone::DisassociateVPCFromHostedZoneError::LastVpcAssociation({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::LastVpcAssociationBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_last_vpc_association::de_last_vpc_association_xml_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::disassociate_vpc_from_hosted_zone::DisassociateVPCFromHostedZoneError::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   
        "NoSuchHostedZone" => crate::operation::disassociate_vpc_from_hosted_zone::DisassociateVPCFromHostedZoneError::NoSuchHostedZone({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::NoSuchHostedZoneBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_no_such_hosted_zone::de_no_such_hosted_zone_xml_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::disassociate_vpc_from_hosted_zone::DisassociateVPCFromHostedZoneError::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   
        "VPCAssociationNotFound" => {
   84     72   
            crate::operation::disassociate_vpc_from_hosted_zone::DisassociateVPCFromHostedZoneError::VpcAssociationNotFound({
   85     73   
                #[allow(unused_mut)]
   86     74   
                let mut tmp = {
   87     75   
                    #[allow(unused_mut)]
   88     76   
                    let mut output = crate::types::error::builders::VpcAssociationNotFoundBuilder::default();
   89     77   
                    output = crate::protocol_serde::shape_vpc_association_not_found::de_vpc_association_not_found_xml_err(_response_body, output)
   90     78   
                        .map_err(crate::operation::disassociate_vpc_from_hosted_zone::DisassociateVPCFromHostedZoneError::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   
        }
  100     85   
        _ => crate::operation::disassociate_vpc_from_hosted_zone::DisassociateVPCFromHostedZoneError::generic(generic),
  101     86   
    })
  102     87   
}
  103     88   
  104     89   
#[allow(clippy::unnecessary_wraps)]
  105     90   
pub fn de_disassociate_vpc_from_hosted_zone_http_response(
  106     91   
    _response_status: u16,

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

@@ -7,7 +192,165 @@
   27     27   
        "ConcurrentModification" => crate::operation::enable_hosted_zone_dnssec::EnableHostedZoneDNSSECError::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::enable_hosted_zone_dnssec::EnableHostedZoneDNSSECError::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   
        "DNSSECNotFound" => crate::operation::enable_hosted_zone_dnssec::EnableHostedZoneDNSSECError::DnssecNotFound({
   43     40   
            #[allow(unused_mut)]
   44     41   
            let mut tmp = {
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut output = crate::types::error::builders::DnssecNotFoundBuilder::default();
   47     44   
                output = crate::protocol_serde::shape_dnssec_not_found::de_dnssec_not_found_xml_err(_response_body, output)
   48     45   
                    .map_err(crate::operation::enable_hosted_zone_dnssec::EnableHostedZoneDNSSECError::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   
        "HostedZonePartiallyDelegated" => crate::operation::enable_hosted_zone_dnssec::EnableHostedZoneDNSSECError::HostedZonePartiallyDelegated({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp = {
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut output = crate::types::error::builders::HostedZonePartiallyDelegatedBuilder::default();
   62     56   
                output =
   63     57   
                    crate::protocol_serde::shape_hosted_zone_partially_delegated::de_hosted_zone_partially_delegated_xml_err(_response_body, output)
   64     58   
                        .map_err(crate::operation::enable_hosted_zone_dnssec::EnableHostedZoneDNSSECError::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   
        "InvalidArgument" => crate::operation::enable_hosted_zone_dnssec::EnableHostedZoneDNSSECError::InvalidArgument({
   74     65   
            #[allow(unused_mut)]
   75     66   
            let mut tmp = {
   76     67   
                #[allow(unused_mut)]
   77     68   
                let mut output = crate::types::error::builders::InvalidArgumentBuilder::default();
   78     69   
                output = crate::protocol_serde::shape_invalid_argument::de_invalid_argument_xml_err(_response_body, output)
   79     70   
                    .map_err(crate::operation::enable_hosted_zone_dnssec::EnableHostedZoneDNSSECError::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   
        "InvalidInput" => crate::operation::enable_hosted_zone_dnssec::EnableHostedZoneDNSSECError::InvalidInput({
   89     77   
            #[allow(unused_mut)]
   90     78   
            let mut tmp = {
   91     79   
                #[allow(unused_mut)]
   92     80   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   93     81   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   94     82   
                    .map_err(crate::operation::enable_hosted_zone_dnssec::EnableHostedZoneDNSSECError::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   
        "InvalidKeySigningKeyStatus" => crate::operation::enable_hosted_zone_dnssec::EnableHostedZoneDNSSECError::InvalidKeySigningKeyStatus({
  104     89   
            #[allow(unused_mut)]
  105     90   
            let mut tmp = {
  106     91   
                #[allow(unused_mut)]
  107     92   
                let mut output = crate::types::error::builders::InvalidKeySigningKeyStatusBuilder::default();
  108     93   
                output =
  109     94   
                    crate::protocol_serde::shape_invalid_key_signing_key_status::de_invalid_key_signing_key_status_xml_err(_response_body, output)
  110     95   
                        .map_err(crate::operation::enable_hosted_zone_dnssec::EnableHostedZoneDNSSECError::unhandled)?;
  111     96   
                let output = output.meta(generic);
  112     97   
                output.build()
  113     98   
            };
  114         -
            if tmp.message.is_none() {
  115         -
                tmp.message = _error_message;
  116         -
            }
  117     99   
            tmp
  118    100   
        }),
  119    101   
        "InvalidKMSArn" => crate::operation::enable_hosted_zone_dnssec::EnableHostedZoneDNSSECError::InvalidKmsArn({
  120    102   
            #[allow(unused_mut)]
  121    103   
            let mut tmp = {
  122    104   
                #[allow(unused_mut)]
  123    105   
                let mut output = crate::types::error::builders::InvalidKmsArnBuilder::default();
  124    106   
                output = crate::protocol_serde::shape_invalid_kms_arn::de_invalid_kms_arn_xml_err(_response_body, output)
  125    107   
                    .map_err(crate::operation::enable_hosted_zone_dnssec::EnableHostedZoneDNSSECError::unhandled)?;
  126    108   
                let output = output.meta(generic);
  127    109   
                output.build()
  128    110   
            };
  129         -
            if tmp.message.is_none() {
  130         -
                tmp.message = _error_message;
  131         -
            }
  132    111   
            tmp
  133    112   
        }),
  134    113   
        "KeySigningKeyWithActiveStatusNotFound" => {
  135    114   
            crate::operation::enable_hosted_zone_dnssec::EnableHostedZoneDNSSECError::KeySigningKeyWithActiveStatusNotFound({
  136    115   
                #[allow(unused_mut)]
  137    116   
                let mut tmp = {
  138    117   
                    #[allow(unused_mut)]
  139    118   
                    let mut output = crate::types::error::builders::KeySigningKeyWithActiveStatusNotFoundBuilder::default();
  140    119   
                    output = crate::protocol_serde::shape_key_signing_key_with_active_status_not_found::de_key_signing_key_with_active_status_not_found_xml_err(_response_body, output).map_err(crate::operation::enable_hosted_zone_dnssec::EnableHostedZoneDNSSECError::unhandled)?;
  141    120   
                    let output = output.meta(generic);
  142    121   
                    output.build()
  143    122   
                };
  144         -
                if tmp.message.is_none() {
  145         -
                    tmp.message = _error_message;
  146         -
                }
  147    123   
                tmp
  148    124   
            })
  149    125   
        }
  150    126   
        "NoSuchHostedZone" => crate::operation::enable_hosted_zone_dnssec::EnableHostedZoneDNSSECError::NoSuchHostedZone({
  151    127   
            #[allow(unused_mut)]
  152    128   
            let mut tmp = {
  153    129   
                #[allow(unused_mut)]
  154    130   
                let mut output = crate::types::error::builders::NoSuchHostedZoneBuilder::default();
  155    131   
                output = crate::protocol_serde::shape_no_such_hosted_zone::de_no_such_hosted_zone_xml_err(_response_body, output)
  156    132   
                    .map_err(crate::operation::enable_hosted_zone_dnssec::EnableHostedZoneDNSSECError::unhandled)?;
  157    133   
                let output = output.meta(generic);
  158    134   
                output.build()
  159    135   
            };
  160         -
            if tmp.message.is_none() {
  161         -
                tmp.message = _error_message;
  162         -
            }
  163    136   
            tmp
  164    137   
        }),
  165    138   
        _ => crate::operation::enable_hosted_zone_dnssec::EnableHostedZoneDNSSECError::generic(generic),
  166    139   
    })
  167    140   
}
  168    141   
  169    142   
#[allow(clippy::unnecessary_wraps)]
  170    143   
pub fn de_enable_hosted_zone_dnssec_http_response(
  171    144   
    _response_status: u16,
  172    145   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +62,59 @@
   20     20   
        "InvalidInput" => crate::operation::get_account_limit::GetAccountLimitError::InvalidInput({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::get_account_limit::GetAccountLimitError::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   
        _ => crate::operation::get_account_limit::GetAccountLimitError::generic(generic),
   36     33   
    })
   37     34   
}
   38     35   
   39     36   
#[allow(clippy::unnecessary_wraps)]
   40     37   
pub fn de_get_account_limit_http_response(
   41     38   
    _response_status: u16,
   42     39   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +77,71 @@
   20     20   
        "InvalidInput" => crate::operation::get_change::GetChangeError::InvalidInput({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::get_change::GetChangeError::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   
        "NoSuchChange" => crate::operation::get_change::GetChangeError::NoSuchChange({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::NoSuchChangeBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_no_such_change::de_no_such_change_xml_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::get_change::GetChangeError::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   
        _ => crate::operation::get_change::GetChangeError::generic(generic),
   51     45   
    })
   52     46   
}
   53     47   
   54     48   
#[allow(clippy::unnecessary_wraps)]
   55     49   
pub fn de_get_change_http_response(
   56     50   
    _response_status: u16,
   57     51   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +92,83 @@
   20     20   
        "InvalidArgument" => crate::operation::get_dnssec::GetDNSSECError::InvalidArgument({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidArgumentBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_argument::de_invalid_argument_xml_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::get_dnssec::GetDNSSECError::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   
        "InvalidInput" => crate::operation::get_dnssec::GetDNSSECError::InvalidInput({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::get_dnssec::GetDNSSECError::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   
        "NoSuchHostedZone" => crate::operation::get_dnssec::GetDNSSECError::NoSuchHostedZone({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::NoSuchHostedZoneBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_no_such_hosted_zone::de_no_such_hosted_zone_xml_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::get_dnssec::GetDNSSECError::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   
        _ => crate::operation::get_dnssec::GetDNSSECError::generic(generic),
   66     57   
    })
   67     58   
}
   68     59   
   69     60   
#[allow(clippy::unnecessary_wraps)]
   70     61   
pub fn de_get_dnssec_http_response(
   71     62   
    _response_status: u16,
   72     63   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +77,71 @@
   20     20   
        "InvalidInput" => crate::operation::get_geo_location::GetGeoLocationError::InvalidInput({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::get_geo_location::GetGeoLocationError::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   
        "NoSuchGeoLocation" => crate::operation::get_geo_location::GetGeoLocationError::NoSuchGeoLocation({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::NoSuchGeoLocationBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_no_such_geo_location::de_no_such_geo_location_xml_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::get_geo_location::GetGeoLocationError::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   
        _ => crate::operation::get_geo_location::GetGeoLocationError::generic(generic),
   51     45   
    })
   52     46   
}
   53     47   
   54     48   
#[allow(clippy::unnecessary_wraps)]
   55     49   
pub fn de_get_geo_location_http_response(
   56     50   
    _response_status: u16,
   57     51   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +92,83 @@
   20     20   
        "IncompatibleVersion" => crate::operation::get_health_check::GetHealthCheckError::IncompatibleVersion({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::IncompatibleVersionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_incompatible_version::de_incompatible_version_xml_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::get_health_check::GetHealthCheckError::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   
        "InvalidInput" => crate::operation::get_health_check::GetHealthCheckError::InvalidInput({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::get_health_check::GetHealthCheckError::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   
        "NoSuchHealthCheck" => crate::operation::get_health_check::GetHealthCheckError::NoSuchHealthCheck({
   51     45   
            #[allow(unused_mut)]
   52     46   
            let mut tmp = {
   53     47   
                #[allow(unused_mut)]
   54     48   
                let mut output = crate::types::error::builders::NoSuchHealthCheckBuilder::default();
   55     49   
                output = crate::protocol_serde::shape_no_such_health_check::de_no_such_health_check_xml_err(_response_body, output)
   56     50   
                    .map_err(crate::operation::get_health_check::GetHealthCheckError::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   
        _ => crate::operation::get_health_check::GetHealthCheckError::generic(generic),
   66     57   
    })
   67     58   
}
   68     59   
   69     60   
#[allow(clippy::unnecessary_wraps)]
   70     61   
pub fn de_get_health_check_http_response(
   71     62   
    _response_status: u16,
   72     63   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +80,74 @@
   23     23   
        "InvalidInput" => crate::operation::get_health_check_last_failure_reason::GetHealthCheckLastFailureReasonError::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::get_health_check_last_failure_reason::GetHealthCheckLastFailureReasonError::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   
        "NoSuchHealthCheck" => crate::operation::get_health_check_last_failure_reason::GetHealthCheckLastFailureReasonError::NoSuchHealthCheck({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::NoSuchHealthCheckBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_no_such_health_check::de_no_such_health_check_xml_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::get_health_check_last_failure_reason::GetHealthCheckLastFailureReasonError::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   
        _ => crate::operation::get_health_check_last_failure_reason::GetHealthCheckLastFailureReasonError::generic(generic),
   54     48   
    })
   55     49   
}
   56     50   
   57     51   
#[allow(clippy::unnecessary_wraps)]
   58     52   
pub fn de_get_health_check_last_failure_reason_http_response(
   59     53   
    _response_status: u16,
   60     54   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +80,74 @@
   23     23   
        "InvalidInput" => crate::operation::get_health_check_status::GetHealthCheckStatusError::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::get_health_check_status::GetHealthCheckStatusError::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   
        "NoSuchHealthCheck" => crate::operation::get_health_check_status::GetHealthCheckStatusError::NoSuchHealthCheck({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::NoSuchHealthCheckBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_no_such_health_check::de_no_such_health_check_xml_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::get_health_check_status::GetHealthCheckStatusError::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   
        _ => crate::operation::get_health_check_status::GetHealthCheckStatusError::generic(generic),
   54     48   
    })
   55     49   
}
   56     50   
   57     51   
#[allow(clippy::unnecessary_wraps)]
   58     52   
pub fn de_get_health_check_status_http_response(
   59     53   
    _response_status: u16,
   60     54   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -1,1 +77,71 @@
   20     20   
        "InvalidInput" => crate::operation::get_hosted_zone::GetHostedZoneError::InvalidInput({
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidInputBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_input::de_invalid_input_xml_err(_response_body, output)
   26     26   
                    .map_err(crate::operation::get_hosted_zone::GetHostedZoneError::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   
        "NoSuchHostedZone" => crate::operation::get_hosted_zone::GetHostedZoneError::NoSuchHostedZone({
   36     33   
            #[allow(unused_mut)]
   37     34   
            let mut tmp = {
   38     35   
                #[allow(unused_mut)]
   39     36   
                let mut output = crate::types::error::builders::NoSuchHostedZoneBuilder::default();
   40     37   
                output = crate::protocol_serde::shape_no_such_hosted_zone::de_no_such_hosted_zone_xml_err(_response_body, output)
   41     38   
                    .map_err(crate::operation::get_hosted_zone::GetHostedZoneError::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   
        _ => crate::operation::get_hosted_zone::GetHostedZoneError::generic(generic),
   51     45   
    })
   52     46   
}
   53     47   
   54     48   
#[allow(clippy::unnecessary_wraps)]
   55     49   
pub fn de_get_hosted_zone_http_response(
   56     50   
    _response_status: u16,
   57     51   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +65,62 @@
   23     23   
        "InvalidInput" => crate::operation::get_hosted_zone_count::GetHostedZoneCountError::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::get_hosted_zone_count::GetHostedZoneCountError::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   
        _ => crate::operation::get_hosted_zone_count::GetHostedZoneCountError::generic(generic),
   39     36   
    })
   40     37   
}
   41     38   
   42     39   
#[allow(clippy::unnecessary_wraps)]
   43     40   
pub fn de_get_hosted_zone_count_http_response(
   44     41   
    _response_status: u16,
   45     42   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +95,86 @@
   23     23   
        "HostedZoneNotPrivate" => crate::operation::get_hosted_zone_limit::GetHostedZoneLimitError::HostedZoneNotPrivate({
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::HostedZoneNotPrivateBuilder::default();
   28     28   
                output = crate::protocol_serde::shape_hosted_zone_not_private::de_hosted_zone_not_private_xml_err(_response_body, output)
   29     29   
                    .map_err(crate::operation::get_hosted_zone_limit::GetHostedZoneLimitError::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::get_hosted_zone_limit::GetHostedZoneLimitError::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::get_hosted_zone_limit::GetHostedZoneLimitError::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   
        "NoSuchHostedZone" => crate::operation::get_hosted_zone_limit::GetHostedZoneLimitError::NoSuchHostedZone({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::NoSuchHostedZoneBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_no_such_hosted_zone::de_no_such_hosted_zone_xml_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::get_hosted_zone_limit::GetHostedZoneLimitError::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   
        _ => crate::operation::get_hosted_zone_limit::GetHostedZoneLimitError::generic(generic),
   69     60   
    })
   70     61   
}
   71     62   
   72     63   
#[allow(clippy::unnecessary_wraps)]
   73     64   
pub fn de_get_hosted_zone_limit_http_response(
   74     65   
    _response_status: u16,
   75     66   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

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

@@ -3,3 +80,74 @@
   23     23   
        "InvalidInput" => crate::operation::get_query_logging_config::GetQueryLoggingConfigError::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::get_query_logging_config::GetQueryLoggingConfigError::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   
        "NoSuchQueryLoggingConfig" => crate::operation::get_query_logging_config::GetQueryLoggingConfigError::NoSuchQueryLoggingConfig({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::NoSuchQueryLoggingConfigBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_no_such_query_logging_config::de_no_such_query_logging_config_xml_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::get_query_logging_config::GetQueryLoggingConfigError::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   
        _ => crate::operation::get_query_logging_config::GetQueryLoggingConfigError::generic(generic),
   54     48   
    })
   55     49   
}
   56     50   
   57     51   
#[allow(clippy::unnecessary_wraps)]
   58     52   
pub fn de_get_query_logging_config_http_response(
   59     53   
    _response_status: u16,
   60     54   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,