AWS SDK

AWS SDK

rev. 03f9d3736bb06bbe282d7bfe7c28721562f20a05 (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_invoke_with_response_stream.rs

@@ -50,50 +585,495 @@
   70     70   
        "EC2AccessDeniedException" => crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::Ec2AccessDeniedException({
   71     71   
            #[allow(unused_mut)]
   72     72   
            let mut tmp = {
   73     73   
                #[allow(unused_mut)]
   74     74   
                let mut output = crate::types::error::builders::Ec2AccessDeniedExceptionBuilder::default();
   75     75   
                output = crate::protocol_serde::shape_ec2_access_denied_exception::de_ec2_access_denied_exception_json_err(_response_body, output)
   76     76   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
   77     77   
                let output = output.meta(generic);
   78     78   
                output.build()
   79     79   
            };
   80         -
            if tmp.message.is_none() {
   81         -
                tmp.message = _error_message;
   82         -
            }
   83     80   
            tmp
   84     81   
        }),
   85     82   
        "EC2ThrottledException" => crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::Ec2ThrottledException({
   86     83   
            #[allow(unused_mut)]
   87     84   
            let mut tmp = {
   88     85   
                #[allow(unused_mut)]
   89     86   
                let mut output = crate::types::error::builders::Ec2ThrottledExceptionBuilder::default();
   90     87   
                output = crate::protocol_serde::shape_ec2_throttled_exception::de_ec2_throttled_exception_json_err(_response_body, output)
   91     88   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
   92     89   
                let output = output.meta(generic);
   93     90   
                output.build()
   94     91   
            };
   95         -
            if tmp.message.is_none() {
   96         -
                tmp.message = _error_message;
   97         -
            }
   98     92   
            tmp
   99     93   
        }),
  100     94   
        "EC2UnexpectedException" => crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::Ec2UnexpectedException({
  101     95   
            #[allow(unused_mut)]
  102     96   
            let mut tmp = {
  103     97   
                #[allow(unused_mut)]
  104     98   
                let mut output = crate::types::error::builders::Ec2UnexpectedExceptionBuilder::default();
  105     99   
                output = crate::protocol_serde::shape_ec2_unexpected_exception::de_ec2_unexpected_exception_json_err(_response_body, output)
  106    100   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  107    101   
                let output = output.meta(generic);
  108    102   
                output.build()
  109    103   
            };
  110         -
            if tmp.message.is_none() {
  111         -
                tmp.message = _error_message;
  112         -
            }
  113    104   
            tmp
  114    105   
        }),
  115    106   
        "EFSIOException" => crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::EfsioException({
  116    107   
            #[allow(unused_mut)]
  117    108   
            let mut tmp = {
  118    109   
                #[allow(unused_mut)]
  119    110   
                let mut output = crate::types::error::builders::EfsioExceptionBuilder::default();
  120    111   
                output = crate::protocol_serde::shape_efsio_exception::de_efsio_exception_json_err(_response_body, output)
  121    112   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  122    113   
                let output = output.meta(generic);
  123    114   
                output.build()
  124    115   
            };
  125         -
            if tmp.message.is_none() {
  126         -
                tmp.message = _error_message;
  127         -
            }
  128    116   
            tmp
  129    117   
        }),
  130    118   
        "EFSMountConnectivityException" => {
  131    119   
            crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::EfsMountConnectivityException({
  132    120   
                #[allow(unused_mut)]
  133    121   
                let mut tmp = {
  134    122   
                    #[allow(unused_mut)]
  135    123   
                    let mut output = crate::types::error::builders::EfsMountConnectivityExceptionBuilder::default();
  136    124   
                    output = crate::protocol_serde::shape_efs_mount_connectivity_exception::de_efs_mount_connectivity_exception_json_err(
  137    125   
                        _response_body,
  138    126   
                        output,
  139    127   
                    )
  140    128   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  141    129   
                    let output = output.meta(generic);
  142    130   
                    output.build()
  143    131   
                };
  144         -
                if tmp.message.is_none() {
  145         -
                    tmp.message = _error_message;
  146         -
                }
  147    132   
                tmp
  148    133   
            })
  149    134   
        }
  150    135   
        "EFSMountFailureException" => crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::EfsMountFailureException({
  151    136   
            #[allow(unused_mut)]
  152    137   
            let mut tmp = {
  153    138   
                #[allow(unused_mut)]
  154    139   
                let mut output = crate::types::error::builders::EfsMountFailureExceptionBuilder::default();
  155    140   
                output = crate::protocol_serde::shape_efs_mount_failure_exception::de_efs_mount_failure_exception_json_err(_response_body, output)
  156    141   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  157    142   
                let output = output.meta(generic);
  158    143   
                output.build()
  159    144   
            };
  160         -
            if tmp.message.is_none() {
  161         -
                tmp.message = _error_message;
  162         -
            }
  163    145   
            tmp
  164    146   
        }),
  165    147   
        "EFSMountTimeoutException" => crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::EfsMountTimeoutException({
  166    148   
            #[allow(unused_mut)]
  167    149   
            let mut tmp = {
  168    150   
                #[allow(unused_mut)]
  169    151   
                let mut output = crate::types::error::builders::EfsMountTimeoutExceptionBuilder::default();
  170    152   
                output = crate::protocol_serde::shape_efs_mount_timeout_exception::de_efs_mount_timeout_exception_json_err(_response_body, output)
  171    153   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  172    154   
                let output = output.meta(generic);
  173    155   
                output.build()
  174    156   
            };
  175         -
            if tmp.message.is_none() {
  176         -
                tmp.message = _error_message;
  177         -
            }
  178    157   
            tmp
  179    158   
        }),
  180    159   
        "ENILimitReachedException" => crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::EniLimitReachedException({
  181    160   
            #[allow(unused_mut)]
  182    161   
            let mut tmp = {
  183    162   
                #[allow(unused_mut)]
  184    163   
                let mut output = crate::types::error::builders::EniLimitReachedExceptionBuilder::default();
  185    164   
                output = crate::protocol_serde::shape_eni_limit_reached_exception::de_eni_limit_reached_exception_json_err(_response_body, output)
  186    165   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  187    166   
                let output = output.meta(generic);
  188    167   
                output.build()
  189    168   
            };
  190         -
            if tmp.message.is_none() {
  191         -
                tmp.message = _error_message;
  192         -
            }
  193    169   
            tmp
  194    170   
        }),
  195    171   
        "InvalidParameterValueException" => {
  196    172   
            crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::InvalidParameterValueException({
  197    173   
                #[allow(unused_mut)]
  198    174   
                let mut tmp = {
  199    175   
                    #[allow(unused_mut)]
  200    176   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
  201    177   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
  202    178   
                        _response_body,
  203    179   
                        output,
  204    180   
                    )
  205    181   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  206    182   
                    let output = output.meta(generic);
  207    183   
                    output.build()
  208    184   
                };
  209         -
                if tmp.message.is_none() {
  210         -
                    tmp.message = _error_message;
  211         -
                }
  212    185   
                tmp
  213    186   
            })
  214    187   
        }
  215    188   
        "InvalidRequestContentException" => {
  216    189   
            crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::InvalidRequestContentException({
  217    190   
                #[allow(unused_mut)]
  218    191   
                let mut tmp = {
  219    192   
                    #[allow(unused_mut)]
  220    193   
                    let mut output = crate::types::error::builders::InvalidRequestContentExceptionBuilder::default();
  221    194   
                    output = crate::protocol_serde::shape_invalid_request_content_exception::de_invalid_request_content_exception_json_err(
  222    195   
                        _response_body,
  223    196   
                        output,
  224    197   
                    )
  225    198   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  226    199   
                    let output = output.meta(generic);
  227    200   
                    output.build()
  228    201   
                };
  229         -
                if tmp.message.is_none() {
  230         -
                    tmp.message = _error_message;
  231         -
                }
  232    202   
                tmp
  233    203   
            })
  234    204   
        }
  235    205   
        "InvalidRuntimeException" => crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::InvalidRuntimeException({
  236    206   
            #[allow(unused_mut)]
  237    207   
            let mut tmp = {
  238    208   
                #[allow(unused_mut)]
  239    209   
                let mut output = crate::types::error::builders::InvalidRuntimeExceptionBuilder::default();
  240    210   
                output = crate::protocol_serde::shape_invalid_runtime_exception::de_invalid_runtime_exception_json_err(_response_body, output)
  241    211   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  242    212   
                let output = output.meta(generic);
  243    213   
                output.build()
  244    214   
            };
  245         -
            if tmp.message.is_none() {
  246         -
                tmp.message = _error_message;
  247         -
            }
  248    215   
            tmp
  249    216   
        }),
  250    217   
        "InvalidSecurityGroupIDException" => {
  251    218   
            crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::InvalidSecurityGroupIdException({
  252    219   
                #[allow(unused_mut)]
  253    220   
                let mut tmp = {
  254    221   
                    #[allow(unused_mut)]
  255    222   
                    let mut output = crate::types::error::builders::InvalidSecurityGroupIdExceptionBuilder::default();
  256    223   
                    output = crate::protocol_serde::shape_invalid_security_group_id_exception::de_invalid_security_group_id_exception_json_err(
  257    224   
                        _response_body,
  258    225   
                        output,
  259    226   
                    )
  260    227   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  261    228   
                    let output = output.meta(generic);
  262    229   
                    output.build()
  263    230   
                };
  264         -
                if tmp.message.is_none() {
  265         -
                    tmp.message = _error_message;
  266         -
                }
  267    231   
                tmp
  268    232   
            })
  269    233   
        }
  270    234   
        "InvalidSubnetIDException" => crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::InvalidSubnetIdException({
  271    235   
            #[allow(unused_mut)]
  272    236   
            let mut tmp = {
  273    237   
                #[allow(unused_mut)]
  274    238   
                let mut output = crate::types::error::builders::InvalidSubnetIdExceptionBuilder::default();
  275    239   
                output = crate::protocol_serde::shape_invalid_subnet_id_exception::de_invalid_subnet_id_exception_json_err(_response_body, output)
  276    240   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  277    241   
                let output = output.meta(generic);
  278    242   
                output.build()
  279    243   
            };
  280         -
            if tmp.message.is_none() {
  281         -
                tmp.message = _error_message;
  282         -
            }
  283    244   
            tmp
  284    245   
        }),
  285    246   
        "InvalidZipFileException" => crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::InvalidZipFileException({
  286    247   
            #[allow(unused_mut)]
  287    248   
            let mut tmp = {
  288    249   
                #[allow(unused_mut)]
  289    250   
                let mut output = crate::types::error::builders::InvalidZipFileExceptionBuilder::default();
  290    251   
                output = crate::protocol_serde::shape_invalid_zip_file_exception::de_invalid_zip_file_exception_json_err(_response_body, output)
  291    252   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  292    253   
                let output = output.meta(generic);
  293    254   
                output.build()
  294    255   
            };
  295         -
            if tmp.message.is_none() {
  296         -
                tmp.message = _error_message;
  297         -
            }
  298    256   
            tmp
  299    257   
        }),
  300    258   
        "KMSAccessDeniedException" => crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::KmsAccessDeniedException({
  301    259   
            #[allow(unused_mut)]
  302    260   
            let mut tmp = {
  303    261   
                #[allow(unused_mut)]
  304    262   
                let mut output = crate::types::error::builders::KmsAccessDeniedExceptionBuilder::default();
  305    263   
                output = crate::protocol_serde::shape_kms_access_denied_exception::de_kms_access_denied_exception_json_err(_response_body, output)
  306    264   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  307    265   
                let output = output.meta(generic);
  308    266   
                output.build()
  309    267   
            };
  310         -
            if tmp.message.is_none() {
  311         -
                tmp.message = _error_message;
  312         -
            }
  313    268   
            tmp
  314    269   
        }),
  315    270   
        "KMSDisabledException" => crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::KmsDisabledException({
  316    271   
            #[allow(unused_mut)]
  317    272   
            let mut tmp = {
  318    273   
                #[allow(unused_mut)]
  319    274   
                let mut output = crate::types::error::builders::KmsDisabledExceptionBuilder::default();
  320    275   
                output = crate::protocol_serde::shape_kms_disabled_exception::de_kms_disabled_exception_json_err(_response_body, output)
  321    276   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  322    277   
                let output = output.meta(generic);
  323    278   
                output.build()
  324    279   
            };
  325         -
            if tmp.message.is_none() {
  326         -
                tmp.message = _error_message;
  327         -
            }
  328    280   
            tmp
  329    281   
        }),
  330    282   
        "KMSInvalidStateException" => crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::KmsInvalidStateException({
  331    283   
            #[allow(unused_mut)]
  332    284   
            let mut tmp = {
  333    285   
                #[allow(unused_mut)]
  334    286   
                let mut output = crate::types::error::builders::KmsInvalidStateExceptionBuilder::default();
  335    287   
                output = crate::protocol_serde::shape_kms_invalid_state_exception::de_kms_invalid_state_exception_json_err(_response_body, output)
  336    288   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  337    289   
                let output = output.meta(generic);
  338    290   
                output.build()
  339    291   
            };
  340         -
            if tmp.message.is_none() {
  341         -
                tmp.message = _error_message;
  342         -
            }
  343    292   
            tmp
  344    293   
        }),
  345    294   
        "KMSNotFoundException" => crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::KmsNotFoundException({
  346    295   
            #[allow(unused_mut)]
  347    296   
            let mut tmp = {
  348    297   
                #[allow(unused_mut)]
  349    298   
                let mut output = crate::types::error::builders::KmsNotFoundExceptionBuilder::default();
  350    299   
                output = crate::protocol_serde::shape_kms_not_found_exception::de_kms_not_found_exception_json_err(_response_body, output)
  351    300   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  352    301   
                let output = output.meta(generic);
  353    302   
                output.build()
  354    303   
            };
  355         -
            if tmp.message.is_none() {
  356         -
                tmp.message = _error_message;
  357         -
            }
  358    304   
            tmp
  359    305   
        }),
  360    306   
        "RecursiveInvocationException" => {
  361    307   
            crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::RecursiveInvocationException({
  362    308   
                #[allow(unused_mut)]
  363    309   
                let mut tmp = {
  364    310   
                    #[allow(unused_mut)]
  365    311   
                    let mut output = crate::types::error::builders::RecursiveInvocationExceptionBuilder::default();
  366    312   
                    output = crate::protocol_serde::shape_recursive_invocation_exception::de_recursive_invocation_exception_json_err(
  367    313   
                        _response_body,
  368    314   
                        output,
  369    315   
                    )
  370    316   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  371    317   
                    let output = output.meta(generic);
  372    318   
                    output.build()
  373    319   
                };
  374         -
                if tmp.message.is_none() {
  375         -
                    tmp.message = _error_message;
  376         -
                }
  377    320   
                tmp
  378    321   
            })
  379    322   
        }
  380    323   
        "RequestTooLargeException" => crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::RequestTooLargeException({
  381    324   
            #[allow(unused_mut)]
  382    325   
            let mut tmp = {
  383    326   
                #[allow(unused_mut)]
  384    327   
                let mut output = crate::types::error::builders::RequestTooLargeExceptionBuilder::default();
  385    328   
                output = crate::protocol_serde::shape_request_too_large_exception::de_request_too_large_exception_json_err(_response_body, output)
  386    329   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  387    330   
                let output = output.meta(generic);
  388    331   
                output.build()
  389    332   
            };
  390         -
            if tmp.message.is_none() {
  391         -
                tmp.message = _error_message;
  392         -
            }
  393    333   
            tmp
  394    334   
        }),
  395    335   
        "ResourceConflictException" => crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::ResourceConflictException({
  396    336   
            #[allow(unused_mut)]
  397    337   
            let mut tmp = {
  398    338   
                #[allow(unused_mut)]
  399    339   
                let mut output = crate::types::error::builders::ResourceConflictExceptionBuilder::default();
  400    340   
                output = crate::protocol_serde::shape_resource_conflict_exception::de_resource_conflict_exception_json_err(_response_body, output)
  401    341   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  402    342   
                let output = output.meta(generic);
  403    343   
                output.build()
  404    344   
            };
  405         -
            if tmp.message.is_none() {
  406         -
                tmp.message = _error_message;
  407         -
            }
  408    345   
            tmp
  409    346   
        }),
  410    347   
        "ResourceNotFoundException" => crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::ResourceNotFoundException({
  411    348   
            #[allow(unused_mut)]
  412    349   
            let mut tmp = {
  413    350   
                #[allow(unused_mut)]
  414    351   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
  415    352   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
  416    353   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  417    354   
                let output = output.meta(generic);
  418    355   
                output.build()
  419    356   
            };
  420         -
            if tmp.message.is_none() {
  421         -
                tmp.message = _error_message;
  422         -
            }
  423    357   
            tmp
  424    358   
        }),
  425    359   
        "ResourceNotReadyException" => crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::ResourceNotReadyException({
  426    360   
            #[allow(unused_mut)]
  427    361   
            let mut tmp = {
  428    362   
                #[allow(unused_mut)]
  429    363   
                let mut output = crate::types::error::builders::ResourceNotReadyExceptionBuilder::default();
  430    364   
                output = crate::protocol_serde::shape_resource_not_ready_exception::de_resource_not_ready_exception_json_err(_response_body, output)
  431    365   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  432    366   
                let output = output.meta(generic);
  433    367   
                output.build()
  434    368   
            };
  435         -
            if tmp.message.is_none() {
  436         -
                tmp.message = _error_message;
  437         -
            }
  438    369   
            tmp
  439    370   
        }),
  440    371   
        "ServiceException" => crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::ServiceException({
  441    372   
            #[allow(unused_mut)]
  442    373   
            let mut tmp = {
  443    374   
                #[allow(unused_mut)]
  444    375   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
  445    376   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
  446    377   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  447    378   
                let output = output.meta(generic);
  448    379   
                output.build()
  449    380   
            };
  450         -
            if tmp.message.is_none() {
  451         -
                tmp.message = _error_message;
  452         -
            }
  453    381   
            tmp
  454    382   
        }),
  455    383   
        "SnapStartException" => crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::SnapStartException({
  456    384   
            #[allow(unused_mut)]
  457    385   
            let mut tmp = {
  458    386   
                #[allow(unused_mut)]
  459    387   
                let mut output = crate::types::error::builders::SnapStartExceptionBuilder::default();
  460    388   
                output = crate::protocol_serde::shape_snap_start_exception::de_snap_start_exception_json_err(_response_body, output)
  461    389   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  462    390   
                let output = output.meta(generic);
  463    391   
                output.build()
  464    392   
            };
  465         -
            if tmp.message.is_none() {
  466         -
                tmp.message = _error_message;
  467         -
            }
  468    393   
            tmp
  469    394   
        }),
  470    395   
        "SnapStartNotReadyException" => crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::SnapStartNotReadyException({
  471    396   
            #[allow(unused_mut)]
  472    397   
            let mut tmp = {
  473    398   
                #[allow(unused_mut)]
  474    399   
                let mut output = crate::types::error::builders::SnapStartNotReadyExceptionBuilder::default();
  475    400   
                output =
  476    401   
                    crate::protocol_serde::shape_snap_start_not_ready_exception::de_snap_start_not_ready_exception_json_err(_response_body, output)
  477    402   
                        .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  478    403   
                let output = output.meta(generic);
  479    404   
                output.build()
  480    405   
            };
  481         -
            if tmp.message.is_none() {
  482         -
                tmp.message = _error_message;
  483         -
            }
  484    406   
            tmp
  485    407   
        }),
  486    408   
        "SnapStartTimeoutException" => crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::SnapStartTimeoutException({
  487    409   
            #[allow(unused_mut)]
  488    410   
            let mut tmp = {
  489    411   
                #[allow(unused_mut)]
  490    412   
                let mut output = crate::types::error::builders::SnapStartTimeoutExceptionBuilder::default();
  491    413   
                output = crate::protocol_serde::shape_snap_start_timeout_exception::de_snap_start_timeout_exception_json_err(_response_body, output)
  492    414   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  493    415   
                let output = output.meta(generic);
  494    416   
                output.build()
  495    417   
            };
  496         -
            if tmp.message.is_none() {
  497         -
                tmp.message = _error_message;
  498         -
            }
  499    418   
            tmp
  500    419   
        }),
  501    420   
        "SubnetIPAddressLimitReachedException" => {
  502    421   
            crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::SubnetIpAddressLimitReachedException({
  503    422   
                #[allow(unused_mut)]
  504    423   
                let mut tmp = {
  505    424   
                    #[allow(unused_mut)]
  506    425   
                    let mut output = crate::types::error::builders::SubnetIpAddressLimitReachedExceptionBuilder::default();
  507    426   
                    output = crate::protocol_serde::shape_subnet_ip_address_limit_reached_exception::de_subnet_ip_address_limit_reached_exception_json_err(_response_body, output).map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  508    427   
                    let output = output.meta(generic);
  509    428   
                    output.build()
  510    429   
                };
  511         -
                if tmp.message.is_none() {
  512         -
                    tmp.message = _error_message;
  513         -
                }
  514    430   
                tmp
  515    431   
            })
  516    432   
        }
  517    433   
        "TooManyRequestsException" => crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::TooManyRequestsException({
  518    434   
            #[allow(unused_mut)]
  519    435   
            let mut tmp = {
  520    436   
                #[allow(unused_mut)]
  521    437   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
  522    438   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
  523    439   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  524    440   
                output = output.set_retry_after_seconds(
  525    441   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
  526    442   
                        crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled(
  527    443   
                            "Failed to parse retryAfterSeconds from header `Retry-After",
  528    444   
                        )
  529    445   
                    })?,
  530    446   
                );
  531    447   
                let output = output.meta(generic);
  532    448   
                output.build()
  533    449   
            };
  534         -
            if tmp.message.is_none() {
  535         -
                tmp.message = _error_message;
  536         -
            }
  537    450   
            tmp
  538    451   
        }),
  539    452   
        "UnsupportedMediaTypeException" => {
  540    453   
            crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::UnsupportedMediaTypeException({
  541    454   
                #[allow(unused_mut)]
  542    455   
                let mut tmp = {
  543    456   
                    #[allow(unused_mut)]
  544    457   
                    let mut output = crate::types::error::builders::UnsupportedMediaTypeExceptionBuilder::default();
  545    458   
                    output = crate::protocol_serde::shape_unsupported_media_type_exception::de_unsupported_media_type_exception_json_err(
  546    459   
                        _response_body,
  547    460   
                        output,
  548    461   
                    )
  549    462   
                    .map_err(crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::unhandled)?;
  550    463   
                    let output = output.meta(generic);
  551    464   
                    output.build()
  552    465   
                };
  553         -
                if tmp.message.is_none() {
  554         -
                    tmp.message = _error_message;
  555         -
                }
  556    466   
                tmp
  557    467   
            })
  558    468   
        }
  559    469   
        _ => crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError::generic(generic),
  560    470   
    })
  561    471   
}
  562    472   
  563    473   
pub fn ser_invoke_with_response_stream_headers(
  564    474   
    input: &crate::operation::invoke_with_response_stream::InvokeWithResponseStreamInput,
  565    475   
    mut builder: ::http::request::Builder,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_list_aliases.rs

@@ -3,3 +115,103 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::list_aliases::ListAliasesError::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   
        "ResourceNotFoundException" => crate::operation::list_aliases::ListAliasesError::ResourceNotFoundException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::list_aliases::ListAliasesError::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   
        "ServiceException" => crate::operation::list_aliases::ListAliasesError::ServiceException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::list_aliases::ListAliasesError::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   
        "TooManyRequestsException" => crate::operation::list_aliases::ListAliasesError::TooManyRequestsException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::list_aliases::ListAliasesError::unhandled)?;
   75     66   
                output = output.set_retry_after_seconds(
   76     67   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
   77     68   
                        crate::operation::list_aliases::ListAliasesError::unhandled("Failed to parse retryAfterSeconds from header `Retry-After")
   78     69   
                    })?,
   79     70   
                );
   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   
        _ => crate::operation::list_aliases::ListAliasesError::generic(generic),
   89     77   
    })
   90     78   
}
   91     79   
   92     80   
#[allow(clippy::unnecessary_wraps)]
   93     81   
pub fn de_list_aliases_http_response(
   94     82   
    _response_status: u16,
   95     83   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_list_code_signing_configs.rs

@@ -11,11 +89,83 @@
   31     31   
                    #[allow(unused_mut)]
   32     32   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   33     33   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   34     34   
                        _response_body,
   35     35   
                        output,
   36     36   
                    )
   37     37   
                    .map_err(crate::operation::list_code_signing_configs::ListCodeSigningConfigsError::unhandled)?;
   38     38   
                    let output = output.meta(generic);
   39     39   
                    output.build()
   40     40   
                };
   41         -
                if tmp.message.is_none() {
   42         -
                    tmp.message = _error_message;
   43         -
                }
   44     41   
                tmp
   45     42   
            })
   46     43   
        }
   47     44   
        "ServiceException" => crate::operation::list_code_signing_configs::ListCodeSigningConfigsError::ServiceException({
   48     45   
            #[allow(unused_mut)]
   49     46   
            let mut tmp = {
   50     47   
                #[allow(unused_mut)]
   51     48   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   52     49   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   53     50   
                    .map_err(crate::operation::list_code_signing_configs::ListCodeSigningConfigsError::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   
        _ => crate::operation::list_code_signing_configs::ListCodeSigningConfigsError::generic(generic),
   63     57   
    })
   64     58   
}
   65     59   
   66     60   
#[allow(clippy::unnecessary_wraps)]
   67     61   
pub fn de_list_code_signing_configs_http_response(
   68     62   
    _response_status: u16,
   69     63   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_list_event_source_mappings.rs

@@ -11,11 +126,114 @@
   31     31   
                    #[allow(unused_mut)]
   32     32   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   33     33   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   34     34   
                        _response_body,
   35     35   
                        output,
   36     36   
                    )
   37     37   
                    .map_err(crate::operation::list_event_source_mappings::ListEventSourceMappingsError::unhandled)?;
   38     38   
                    let output = output.meta(generic);
   39     39   
                    output.build()
   40     40   
                };
   41         -
                if tmp.message.is_none() {
   42         -
                    tmp.message = _error_message;
   43         -
                }
   44     41   
                tmp
   45     42   
            })
   46     43   
        }
   47     44   
        "ResourceNotFoundException" => crate::operation::list_event_source_mappings::ListEventSourceMappingsError::ResourceNotFoundException({
   48     45   
            #[allow(unused_mut)]
   49     46   
            let mut tmp = {
   50     47   
                #[allow(unused_mut)]
   51     48   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   52     49   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   53     50   
                    .map_err(crate::operation::list_event_source_mappings::ListEventSourceMappingsError::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   
        "ServiceException" => crate::operation::list_event_source_mappings::ListEventSourceMappingsError::ServiceException({
   63     57   
            #[allow(unused_mut)]
   64     58   
            let mut tmp = {
   65     59   
                #[allow(unused_mut)]
   66     60   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   67     61   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   68     62   
                    .map_err(crate::operation::list_event_source_mappings::ListEventSourceMappingsError::unhandled)?;
   69     63   
                let output = output.meta(generic);
   70     64   
                output.build()
   71     65   
            };
   72         -
            if tmp.message.is_none() {
   73         -
                tmp.message = _error_message;
   74         -
            }
   75     66   
            tmp
   76     67   
        }),
   77     68   
        "TooManyRequestsException" => crate::operation::list_event_source_mappings::ListEventSourceMappingsError::TooManyRequestsException({
   78     69   
            #[allow(unused_mut)]
   79     70   
            let mut tmp = {
   80     71   
                #[allow(unused_mut)]
   81     72   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   82     73   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   83     74   
                    .map_err(crate::operation::list_event_source_mappings::ListEventSourceMappingsError::unhandled)?;
   84     75   
                output = output.set_retry_after_seconds(
   85     76   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
   86     77   
                        crate::operation::list_event_source_mappings::ListEventSourceMappingsError::unhandled(
   87     78   
                            "Failed to parse retryAfterSeconds from header `Retry-After",
   88     79   
                        )
   89     80   
                    })?,
   90     81   
                );
   91     82   
                let output = output.meta(generic);
   92     83   
                output.build()
   93     84   
            };
   94         -
            if tmp.message.is_none() {
   95         -
                tmp.message = _error_message;
   96         -
            }
   97     85   
            tmp
   98     86   
        }),
   99     87   
        _ => crate::operation::list_event_source_mappings::ListEventSourceMappingsError::generic(generic),
  100     88   
    })
  101     89   
}
  102     90   
  103     91   
#[allow(clippy::unnecessary_wraps)]
  104     92   
pub fn de_list_event_source_mappings_http_response(
  105     93   
    _response_status: u16,
  106     94   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_list_function_event_invoke_configs.rs

@@ -7,7 +127,115 @@
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   29     29   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   30     30   
                        _response_body,
   31     31   
                        output,
   32     32   
                    )
   33     33   
                    .map_err(crate::operation::list_function_event_invoke_configs::ListFunctionEventInvokeConfigsError::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   
        "ResourceNotFoundException" => {
   44     41   
            crate::operation::list_function_event_invoke_configs::ListFunctionEventInvokeConfigsError::ResourceNotFoundException({
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut tmp = {
   47     44   
                    #[allow(unused_mut)]
   48     45   
                    let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   49     46   
                    output =
   50     47   
                        crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   51     48   
                            .map_err(crate::operation::list_function_event_invoke_configs::ListFunctionEventInvokeConfigsError::unhandled)?;
   52     49   
                    let output = output.meta(generic);
   53     50   
                    output.build()
   54     51   
                };
   55         -
                if tmp.message.is_none() {
   56         -
                    tmp.message = _error_message;
   57         -
                }
   58     52   
                tmp
   59     53   
            })
   60     54   
        }
   61     55   
        "ServiceException" => crate::operation::list_function_event_invoke_configs::ListFunctionEventInvokeConfigsError::ServiceException({
   62     56   
            #[allow(unused_mut)]
   63     57   
            let mut tmp = {
   64     58   
                #[allow(unused_mut)]
   65     59   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   66     60   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   67     61   
                    .map_err(crate::operation::list_function_event_invoke_configs::ListFunctionEventInvokeConfigsError::unhandled)?;
   68     62   
                let output = output.meta(generic);
   69     63   
                output.build()
   70     64   
            };
   71         -
            if tmp.message.is_none() {
   72         -
                tmp.message = _error_message;
   73         -
            }
   74     65   
            tmp
   75     66   
        }),
   76     67   
        "TooManyRequestsException" => {
   77     68   
            crate::operation::list_function_event_invoke_configs::ListFunctionEventInvokeConfigsError::TooManyRequestsException({
   78     69   
                #[allow(unused_mut)]
   79     70   
                let mut tmp = {
   80     71   
                    #[allow(unused_mut)]
   81     72   
                    let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   82     73   
                    output =
   83     74   
                        crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   84     75   
                            .map_err(crate::operation::list_function_event_invoke_configs::ListFunctionEventInvokeConfigsError::unhandled)?;
   85     76   
                    output = output.set_retry_after_seconds(
   86     77   
                        crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
   87     78   
                            crate::operation::list_function_event_invoke_configs::ListFunctionEventInvokeConfigsError::unhandled(
   88     79   
                                "Failed to parse retryAfterSeconds from header `Retry-After",
   89     80   
                            )
   90     81   
                        })?,
   91     82   
                    );
   92     83   
                    let output = output.meta(generic);
   93     84   
                    output.build()
   94     85   
                };
   95         -
                if tmp.message.is_none() {
   96         -
                    tmp.message = _error_message;
   97         -
                }
   98     86   
                tmp
   99     87   
            })
  100     88   
        }
  101     89   
        _ => crate::operation::list_function_event_invoke_configs::ListFunctionEventInvokeConfigsError::generic(generic),
  102     90   
    })
  103     91   
}
  104     92   
  105     93   
#[allow(clippy::unnecessary_wraps)]
  106     94   
pub fn de_list_function_event_invoke_configs_http_response(
  107     95   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_list_function_url_configs.rs

@@ -11,11 +126,114 @@
   31     31   
                    #[allow(unused_mut)]
   32     32   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   33     33   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   34     34   
                        _response_body,
   35     35   
                        output,
   36     36   
                    )
   37     37   
                    .map_err(crate::operation::list_function_url_configs::ListFunctionUrlConfigsError::unhandled)?;
   38     38   
                    let output = output.meta(generic);
   39     39   
                    output.build()
   40     40   
                };
   41         -
                if tmp.message.is_none() {
   42         -
                    tmp.message = _error_message;
   43         -
                }
   44     41   
                tmp
   45     42   
            })
   46     43   
        }
   47     44   
        "ResourceNotFoundException" => crate::operation::list_function_url_configs::ListFunctionUrlConfigsError::ResourceNotFoundException({
   48     45   
            #[allow(unused_mut)]
   49     46   
            let mut tmp = {
   50     47   
                #[allow(unused_mut)]
   51     48   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   52     49   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   53     50   
                    .map_err(crate::operation::list_function_url_configs::ListFunctionUrlConfigsError::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   
        "ServiceException" => crate::operation::list_function_url_configs::ListFunctionUrlConfigsError::ServiceException({
   63     57   
            #[allow(unused_mut)]
   64     58   
            let mut tmp = {
   65     59   
                #[allow(unused_mut)]
   66     60   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   67     61   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   68     62   
                    .map_err(crate::operation::list_function_url_configs::ListFunctionUrlConfigsError::unhandled)?;
   69     63   
                let output = output.meta(generic);
   70     64   
                output.build()
   71     65   
            };
   72         -
            if tmp.message.is_none() {
   73         -
                tmp.message = _error_message;
   74         -
            }
   75     66   
            tmp
   76     67   
        }),
   77     68   
        "TooManyRequestsException" => crate::operation::list_function_url_configs::ListFunctionUrlConfigsError::TooManyRequestsException({
   78     69   
            #[allow(unused_mut)]
   79     70   
            let mut tmp = {
   80     71   
                #[allow(unused_mut)]
   81     72   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   82     73   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   83     74   
                    .map_err(crate::operation::list_function_url_configs::ListFunctionUrlConfigsError::unhandled)?;
   84     75   
                output = output.set_retry_after_seconds(
   85     76   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
   86     77   
                        crate::operation::list_function_url_configs::ListFunctionUrlConfigsError::unhandled(
   87     78   
                            "Failed to parse retryAfterSeconds from header `Retry-After",
   88     79   
                        )
   89     80   
                    })?,
   90     81   
                );
   91     82   
                let output = output.meta(generic);
   92     83   
                output.build()
   93     84   
            };
   94         -
            if tmp.message.is_none() {
   95         -
                tmp.message = _error_message;
   96         -
            }
   97     85   
            tmp
   98     86   
        }),
   99     87   
        _ => crate::operation::list_function_url_configs::ListFunctionUrlConfigsError::generic(generic),
  100     88   
    })
  101     89   
}
  102     90   
  103     91   
#[allow(clippy::unnecessary_wraps)]
  104     92   
pub fn de_list_function_url_configs_http_response(
  105     93   
    _response_status: u16,
  106     94   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_list_functions.rs

@@ -3,3 +100,91 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::list_functions::ListFunctionsError::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   
        "ServiceException" => crate::operation::list_functions::ListFunctionsError::ServiceException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::list_functions::ListFunctionsError::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   
        "TooManyRequestsException" => crate::operation::list_functions::ListFunctionsError::TooManyRequestsException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::list_functions::ListFunctionsError::unhandled)?;
   60     54   
                output = output.set_retry_after_seconds(
   61     55   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
   62     56   
                        crate::operation::list_functions::ListFunctionsError::unhandled("Failed to parse retryAfterSeconds from header `Retry-After")
   63     57   
                    })?,
   64     58   
                );
   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::list_functions::ListFunctionsError::generic(generic),
   74     65   
    })
   75     66   
}
   76     67   
   77     68   
#[allow(clippy::unnecessary_wraps)]
   78     69   
pub fn de_list_functions_http_response(
   79     70   
    _response_status: u16,
   80     71   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_list_functions_by_code_signing_config.rs

@@ -7,7 +103,94 @@
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   29     29   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   30     30   
                        _response_body,
   31     31   
                        output,
   32     32   
                    )
   33     33   
                    .map_err(crate::operation::list_functions_by_code_signing_config::ListFunctionsByCodeSigningConfigError::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   
        "ResourceNotFoundException" => {
   44     41   
            crate::operation::list_functions_by_code_signing_config::ListFunctionsByCodeSigningConfigError::ResourceNotFoundException({
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut tmp = {
   47     44   
                    #[allow(unused_mut)]
   48     45   
                    let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   49     46   
                    output =
   50     47   
                        crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   51     48   
                            .map_err(crate::operation::list_functions_by_code_signing_config::ListFunctionsByCodeSigningConfigError::unhandled)?;
   52     49   
                    let output = output.meta(generic);
   53     50   
                    output.build()
   54     51   
                };
   55         -
                if tmp.message.is_none() {
   56         -
                    tmp.message = _error_message;
   57         -
                }
   58     52   
                tmp
   59     53   
            })
   60     54   
        }
   61     55   
        "ServiceException" => crate::operation::list_functions_by_code_signing_config::ListFunctionsByCodeSigningConfigError::ServiceException({
   62     56   
            #[allow(unused_mut)]
   63     57   
            let mut tmp = {
   64     58   
                #[allow(unused_mut)]
   65     59   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   66     60   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   67     61   
                    .map_err(crate::operation::list_functions_by_code_signing_config::ListFunctionsByCodeSigningConfigError::unhandled)?;
   68     62   
                let output = output.meta(generic);
   69     63   
                output.build()
   70     64   
            };
   71         -
            if tmp.message.is_none() {
   72         -
                tmp.message = _error_message;
   73         -
            }
   74     65   
            tmp
   75     66   
        }),
   76     67   
        _ => crate::operation::list_functions_by_code_signing_config::ListFunctionsByCodeSigningConfigError::generic(generic),
   77     68   
    })
   78     69   
}
   79     70   
   80     71   
#[allow(clippy::unnecessary_wraps)]
   81     72   
pub fn de_list_functions_by_code_signing_config_http_response(
   82     73   
    _response_status: u16,
   83     74   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_list_layer_versions.rs

@@ -4,4 +118,106 @@
   24     24   
                #[allow(unused_mut)]
   25     25   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   26     26   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   27     27   
                    _response_body,
   28     28   
                    output,
   29     29   
                )
   30     30   
                .map_err(crate::operation::list_layer_versions::ListLayerVersionsError::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   
        "ResourceNotFoundException" => crate::operation::list_layer_versions::ListLayerVersionsError::ResourceNotFoundException({
   40     37   
            #[allow(unused_mut)]
   41     38   
            let mut tmp = {
   42     39   
                #[allow(unused_mut)]
   43     40   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   44     41   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   45     42   
                    .map_err(crate::operation::list_layer_versions::ListLayerVersionsError::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   
        "ServiceException" => crate::operation::list_layer_versions::ListLayerVersionsError::ServiceException({
   55     49   
            #[allow(unused_mut)]
   56     50   
            let mut tmp = {
   57     51   
                #[allow(unused_mut)]
   58     52   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   59     53   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   60     54   
                    .map_err(crate::operation::list_layer_versions::ListLayerVersionsError::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   
        "TooManyRequestsException" => crate::operation::list_layer_versions::ListLayerVersionsError::TooManyRequestsException({
   70     61   
            #[allow(unused_mut)]
   71     62   
            let mut tmp = {
   72     63   
                #[allow(unused_mut)]
   73     64   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   74     65   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   75     66   
                    .map_err(crate::operation::list_layer_versions::ListLayerVersionsError::unhandled)?;
   76     67   
                output = output.set_retry_after_seconds(
   77     68   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
   78     69   
                        crate::operation::list_layer_versions::ListLayerVersionsError::unhandled(
   79     70   
                            "Failed to parse retryAfterSeconds from header `Retry-After",
   80     71   
                        )
   81     72   
                    })?,
   82     73   
                );
   83     74   
                let output = output.meta(generic);
   84     75   
                output.build()
   85     76   
            };
   86         -
            if tmp.message.is_none() {
   87         -
                tmp.message = _error_message;
   88         -
            }
   89     77   
            tmp
   90     78   
        }),
   91     79   
        _ => crate::operation::list_layer_versions::ListLayerVersionsError::generic(generic),
   92     80   
    })
   93     81   
}
   94     82   
   95     83   
#[allow(clippy::unnecessary_wraps)]
   96     84   
pub fn de_list_layer_versions_http_response(
   97     85   
    _response_status: u16,
   98     86   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_list_layers.rs

@@ -3,3 +100,91 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::list_layers::ListLayersError::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   
        "ServiceException" => crate::operation::list_layers::ListLayersError::ServiceException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::list_layers::ListLayersError::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   
        "TooManyRequestsException" => crate::operation::list_layers::ListLayersError::TooManyRequestsException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::list_layers::ListLayersError::unhandled)?;
   60     54   
                output = output.set_retry_after_seconds(
   61     55   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
   62     56   
                        crate::operation::list_layers::ListLayersError::unhandled("Failed to parse retryAfterSeconds from header `Retry-After")
   63     57   
                    })?,
   64     58   
                );
   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::list_layers::ListLayersError::generic(generic),
   74     65   
    })
   75     66   
}
   76     67   
   77     68   
#[allow(clippy::unnecessary_wraps)]
   78     69   
pub fn de_list_layers_http_response(
   79     70   
    _response_status: u16,
   80     71   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_list_provisioned_concurrency_configs.rs

@@ -7,7 +127,115 @@
   27     27   
                    #[allow(unused_mut)]
   28     28   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   29     29   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   30     30   
                        _response_body,
   31     31   
                        output,
   32     32   
                    )
   33     33   
                    .map_err(crate::operation::list_provisioned_concurrency_configs::ListProvisionedConcurrencyConfigsError::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   
        "ResourceNotFoundException" => {
   44     41   
            crate::operation::list_provisioned_concurrency_configs::ListProvisionedConcurrencyConfigsError::ResourceNotFoundException({
   45     42   
                #[allow(unused_mut)]
   46     43   
                let mut tmp = {
   47     44   
                    #[allow(unused_mut)]
   48     45   
                    let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   49     46   
                    output =
   50     47   
                        crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   51     48   
                            .map_err(crate::operation::list_provisioned_concurrency_configs::ListProvisionedConcurrencyConfigsError::unhandled)?;
   52     49   
                    let output = output.meta(generic);
   53     50   
                    output.build()
   54     51   
                };
   55         -
                if tmp.message.is_none() {
   56         -
                    tmp.message = _error_message;
   57         -
                }
   58     52   
                tmp
   59     53   
            })
   60     54   
        }
   61     55   
        "ServiceException" => crate::operation::list_provisioned_concurrency_configs::ListProvisionedConcurrencyConfigsError::ServiceException({
   62     56   
            #[allow(unused_mut)]
   63     57   
            let mut tmp = {
   64     58   
                #[allow(unused_mut)]
   65     59   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   66     60   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   67     61   
                    .map_err(crate::operation::list_provisioned_concurrency_configs::ListProvisionedConcurrencyConfigsError::unhandled)?;
   68     62   
                let output = output.meta(generic);
   69     63   
                output.build()
   70     64   
            };
   71         -
            if tmp.message.is_none() {
   72         -
                tmp.message = _error_message;
   73         -
            }
   74     65   
            tmp
   75     66   
        }),
   76     67   
        "TooManyRequestsException" => {
   77     68   
            crate::operation::list_provisioned_concurrency_configs::ListProvisionedConcurrencyConfigsError::TooManyRequestsException({
   78     69   
                #[allow(unused_mut)]
   79     70   
                let mut tmp = {
   80     71   
                    #[allow(unused_mut)]
   81     72   
                    let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   82     73   
                    output =
   83     74   
                        crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   84     75   
                            .map_err(crate::operation::list_provisioned_concurrency_configs::ListProvisionedConcurrencyConfigsError::unhandled)?;
   85     76   
                    output = output.set_retry_after_seconds(
   86     77   
                        crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
   87     78   
                            crate::operation::list_provisioned_concurrency_configs::ListProvisionedConcurrencyConfigsError::unhandled(
   88     79   
                                "Failed to parse retryAfterSeconds from header `Retry-After",
   89     80   
                            )
   90     81   
                        })?,
   91     82   
                    );
   92     83   
                    let output = output.meta(generic);
   93     84   
                    output.build()
   94     85   
                };
   95         -
                if tmp.message.is_none() {
   96         -
                    tmp.message = _error_message;
   97         -
                }
   98     86   
                tmp
   99     87   
            })
  100     88   
        }
  101     89   
        _ => crate::operation::list_provisioned_concurrency_configs::ListProvisionedConcurrencyConfigsError::generic(generic),
  102     90   
    })
  103     91   
}
  104     92   
  105     93   
#[allow(clippy::unnecessary_wraps)]
  106     94   
pub fn de_list_provisioned_concurrency_configs_http_response(
  107     95   
    _response_status: u16,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_list_tags.rs

@@ -3,3 +115,103 @@
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   25     25   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   26     26   
                    _response_body,
   27     27   
                    output,
   28     28   
                )
   29     29   
                .map_err(crate::operation::list_tags::ListTagsError::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   
        "ResourceNotFoundException" => crate::operation::list_tags::ListTagsError::ResourceNotFoundException({
   39     36   
            #[allow(unused_mut)]
   40     37   
            let mut tmp = {
   41     38   
                #[allow(unused_mut)]
   42     39   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   43     40   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   44     41   
                    .map_err(crate::operation::list_tags::ListTagsError::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   
        "ServiceException" => crate::operation::list_tags::ListTagsError::ServiceException({
   54     48   
            #[allow(unused_mut)]
   55     49   
            let mut tmp = {
   56     50   
                #[allow(unused_mut)]
   57     51   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   58     52   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   59     53   
                    .map_err(crate::operation::list_tags::ListTagsError::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   
        "TooManyRequestsException" => crate::operation::list_tags::ListTagsError::TooManyRequestsException({
   69     60   
            #[allow(unused_mut)]
   70     61   
            let mut tmp = {
   71     62   
                #[allow(unused_mut)]
   72     63   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   73     64   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   74     65   
                    .map_err(crate::operation::list_tags::ListTagsError::unhandled)?;
   75     66   
                output = output.set_retry_after_seconds(
   76     67   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
   77     68   
                        crate::operation::list_tags::ListTagsError::unhandled("Failed to parse retryAfterSeconds from header `Retry-After")
   78     69   
                    })?,
   79     70   
                );
   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   
        _ => crate::operation::list_tags::ListTagsError::generic(generic),
   89     77   
    })
   90     78   
}
   91     79   
   92     80   
#[allow(clippy::unnecessary_wraps)]
   93     81   
pub fn de_list_tags_http_response(
   94     82   
    _response_status: u16,
   95     83   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_list_versions_by_function.rs

@@ -11,11 +126,114 @@
   31     31   
                    #[allow(unused_mut)]
   32     32   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   33     33   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   34     34   
                        _response_body,
   35     35   
                        output,
   36     36   
                    )
   37     37   
                    .map_err(crate::operation::list_versions_by_function::ListVersionsByFunctionError::unhandled)?;
   38     38   
                    let output = output.meta(generic);
   39     39   
                    output.build()
   40     40   
                };
   41         -
                if tmp.message.is_none() {
   42         -
                    tmp.message = _error_message;
   43         -
                }
   44     41   
                tmp
   45     42   
            })
   46     43   
        }
   47     44   
        "ResourceNotFoundException" => crate::operation::list_versions_by_function::ListVersionsByFunctionError::ResourceNotFoundException({
   48     45   
            #[allow(unused_mut)]
   49     46   
            let mut tmp = {
   50     47   
                #[allow(unused_mut)]
   51     48   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   52     49   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   53     50   
                    .map_err(crate::operation::list_versions_by_function::ListVersionsByFunctionError::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   
        "ServiceException" => crate::operation::list_versions_by_function::ListVersionsByFunctionError::ServiceException({
   63     57   
            #[allow(unused_mut)]
   64     58   
            let mut tmp = {
   65     59   
                #[allow(unused_mut)]
   66     60   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   67     61   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   68     62   
                    .map_err(crate::operation::list_versions_by_function::ListVersionsByFunctionError::unhandled)?;
   69     63   
                let output = output.meta(generic);
   70     64   
                output.build()
   71     65   
            };
   72         -
            if tmp.message.is_none() {
   73         -
                tmp.message = _error_message;
   74         -
            }
   75     66   
            tmp
   76     67   
        }),
   77     68   
        "TooManyRequestsException" => crate::operation::list_versions_by_function::ListVersionsByFunctionError::TooManyRequestsException({
   78     69   
            #[allow(unused_mut)]
   79     70   
            let mut tmp = {
   80     71   
                #[allow(unused_mut)]
   81     72   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   82     73   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   83     74   
                    .map_err(crate::operation::list_versions_by_function::ListVersionsByFunctionError::unhandled)?;
   84     75   
                output = output.set_retry_after_seconds(
   85     76   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
   86     77   
                        crate::operation::list_versions_by_function::ListVersionsByFunctionError::unhandled(
   87     78   
                            "Failed to parse retryAfterSeconds from header `Retry-After",
   88     79   
                        )
   89     80   
                    })?,
   90     81   
                );
   91     82   
                let output = output.meta(generic);
   92     83   
                output.build()
   93     84   
            };
   94         -
            if tmp.message.is_none() {
   95         -
                tmp.message = _error_message;
   96         -
            }
   97     85   
            tmp
   98     86   
        }),
   99     87   
        _ => crate::operation::list_versions_by_function::ListVersionsByFunctionError::generic(generic),
  100     88   
    })
  101     89   
}
  102     90   
  103     91   
#[allow(clippy::unnecessary_wraps)]
  104     92   
pub fn de_list_versions_by_function_http_response(
  105     93   
    _response_status: u16,
  106     94   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_publish_layer_version.rs

@@ -4,4 +136,121 @@
   24     24   
            #[allow(unused_mut)]
   25     25   
            let mut tmp = {
   26     26   
                #[allow(unused_mut)]
   27     27   
                let mut output = crate::types::error::builders::CodeStorageExceededExceptionBuilder::default();
   28     28   
                output =
   29     29   
                    crate::protocol_serde::shape_code_storage_exceeded_exception::de_code_storage_exceeded_exception_json_err(_response_body, output)
   30     30   
                        .map_err(crate::operation::publish_layer_version::PublishLayerVersionError::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   
        "InvalidParameterValueException" => crate::operation::publish_layer_version::PublishLayerVersionError::InvalidParameterValueException({
   40     37   
            #[allow(unused_mut)]
   41     38   
            let mut tmp = {
   42     39   
                #[allow(unused_mut)]
   43     40   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   44     41   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   45     42   
                    _response_body,
   46     43   
                    output,
   47     44   
                )
   48     45   
                .map_err(crate::operation::publish_layer_version::PublishLayerVersionError::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   
        "ResourceNotFoundException" => crate::operation::publish_layer_version::PublishLayerVersionError::ResourceNotFoundException({
   58     52   
            #[allow(unused_mut)]
   59     53   
            let mut tmp = {
   60     54   
                #[allow(unused_mut)]
   61     55   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   62     56   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   63     57   
                    .map_err(crate::operation::publish_layer_version::PublishLayerVersionError::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   
        "ServiceException" => crate::operation::publish_layer_version::PublishLayerVersionError::ServiceException({
   73     64   
            #[allow(unused_mut)]
   74     65   
            let mut tmp = {
   75     66   
                #[allow(unused_mut)]
   76     67   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
   77     68   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
   78     69   
                    .map_err(crate::operation::publish_layer_version::PublishLayerVersionError::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   
        "TooManyRequestsException" => crate::operation::publish_layer_version::PublishLayerVersionError::TooManyRequestsException({
   88     76   
            #[allow(unused_mut)]
   89     77   
            let mut tmp = {
   90     78   
                #[allow(unused_mut)]
   91     79   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
   92     80   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
   93     81   
                    .map_err(crate::operation::publish_layer_version::PublishLayerVersionError::unhandled)?;
   94     82   
                output = output.set_retry_after_seconds(
   95     83   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
   96     84   
                        crate::operation::publish_layer_version::PublishLayerVersionError::unhandled(
   97     85   
                            "Failed to parse retryAfterSeconds from header `Retry-After",
   98     86   
                        )
   99     87   
                    })?,
  100     88   
                );
  101     89   
                let output = output.meta(generic);
  102     90   
                output.build()
  103     91   
            };
  104         -
            if tmp.message.is_none() {
  105         -
                tmp.message = _error_message;
  106         -
            }
  107     92   
            tmp
  108     93   
        }),
  109     94   
        _ => crate::operation::publish_layer_version::PublishLayerVersionError::generic(generic),
  110     95   
    })
  111     96   
}
  112     97   
  113     98   
#[allow(clippy::unnecessary_wraps)]
  114     99   
pub fn de_publish_layer_version_http_response(
  115    100   
    _response_status: u16,
  116    101   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_publish_version.rs

@@ -1,1 +164,143 @@
   21     21   
            #[allow(unused_mut)]
   22     22   
            let mut tmp = {
   23     23   
                #[allow(unused_mut)]
   24     24   
                let mut output = crate::types::error::builders::CodeStorageExceededExceptionBuilder::default();
   25     25   
                output =
   26     26   
                    crate::protocol_serde::shape_code_storage_exceeded_exception::de_code_storage_exceeded_exception_json_err(_response_body, output)
   27     27   
                        .map_err(crate::operation::publish_version::PublishVersionError::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   
        "InvalidParameterValueException" => crate::operation::publish_version::PublishVersionError::InvalidParameterValueException({
   37     34   
            #[allow(unused_mut)]
   38     35   
            let mut tmp = {
   39     36   
                #[allow(unused_mut)]
   40     37   
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   41     38   
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   42     39   
                    _response_body,
   43     40   
                    output,
   44     41   
                )
   45     42   
                .map_err(crate::operation::publish_version::PublishVersionError::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   
        "PreconditionFailedException" => crate::operation::publish_version::PublishVersionError::PreconditionFailedException({
   55     49   
            #[allow(unused_mut)]
   56     50   
            let mut tmp = {
   57     51   
                #[allow(unused_mut)]
   58     52   
                let mut output = crate::types::error::builders::PreconditionFailedExceptionBuilder::default();
   59     53   
                output =
   60     54   
                    crate::protocol_serde::shape_precondition_failed_exception::de_precondition_failed_exception_json_err(_response_body, output)
   61     55   
                        .map_err(crate::operation::publish_version::PublishVersionError::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   
        "ResourceConflictException" => crate::operation::publish_version::PublishVersionError::ResourceConflictException({
   71     62   
            #[allow(unused_mut)]
   72     63   
            let mut tmp = {
   73     64   
                #[allow(unused_mut)]
   74     65   
                let mut output = crate::types::error::builders::ResourceConflictExceptionBuilder::default();
   75     66   
                output = crate::protocol_serde::shape_resource_conflict_exception::de_resource_conflict_exception_json_err(_response_body, output)
   76     67   
                    .map_err(crate::operation::publish_version::PublishVersionError::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   
        "ResourceNotFoundException" => crate::operation::publish_version::PublishVersionError::ResourceNotFoundException({
   86     74   
            #[allow(unused_mut)]
   87     75   
            let mut tmp = {
   88     76   
                #[allow(unused_mut)]
   89     77   
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   90     78   
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   91     79   
                    .map_err(crate::operation::publish_version::PublishVersionError::unhandled)?;
   92     80   
                let output = output.meta(generic);
   93     81   
                output.build()
   94     82   
            };
   95         -
            if tmp.message.is_none() {
   96         -
                tmp.message = _error_message;
   97         -
            }
   98     83   
            tmp
   99     84   
        }),
  100     85   
        "ServiceException" => crate::operation::publish_version::PublishVersionError::ServiceException({
  101     86   
            #[allow(unused_mut)]
  102     87   
            let mut tmp = {
  103     88   
                #[allow(unused_mut)]
  104     89   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
  105     90   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
  106     91   
                    .map_err(crate::operation::publish_version::PublishVersionError::unhandled)?;
  107     92   
                let output = output.meta(generic);
  108     93   
                output.build()
  109     94   
            };
  110         -
            if tmp.message.is_none() {
  111         -
                tmp.message = _error_message;
  112         -
            }
  113     95   
            tmp
  114     96   
        }),
  115     97   
        "TooManyRequestsException" => crate::operation::publish_version::PublishVersionError::TooManyRequestsException({
  116     98   
            #[allow(unused_mut)]
  117     99   
            let mut tmp = {
  118    100   
                #[allow(unused_mut)]
  119    101   
                let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
  120    102   
                output = crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
  121    103   
                    .map_err(crate::operation::publish_version::PublishVersionError::unhandled)?;
  122    104   
                output = output.set_retry_after_seconds(
  123    105   
                    crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
  124    106   
                        crate::operation::publish_version::PublishVersionError::unhandled(
  125    107   
                            "Failed to parse retryAfterSeconds from header `Retry-After",
  126    108   
                        )
  127    109   
                    })?,
  128    110   
                );
  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   
        _ => crate::operation::publish_version::PublishVersionError::generic(generic),
  138    117   
    })
  139    118   
}
  140    119   
  141    120   
#[allow(clippy::unnecessary_wraps)]
  142    121   
pub fn de_publish_version_http_response(
  143    122   
    _response_status: u16,
  144    123   
    _response_headers: &::aws_smithy_runtime_api::http::Headers,

tmp-codegen-diff/aws-sdk/sdk/lambda/src/protocol_serde/shape_put_function_code_signing_config.rs

@@ -8,8 +166,148 @@
   28     28   
                    let mut output = crate::types::error::builders::CodeSigningConfigNotFoundExceptionBuilder::default();
   29     29   
                    output =
   30     30   
                        crate::protocol_serde::shape_code_signing_config_not_found_exception::de_code_signing_config_not_found_exception_json_err(
   31     31   
                            _response_body,
   32     32   
                            output,
   33     33   
                        )
   34     34   
                        .map_err(crate::operation::put_function_code_signing_config::PutFunctionCodeSigningConfigError::unhandled)?;
   35     35   
                    let output = output.meta(generic);
   36     36   
                    output.build()
   37     37   
                };
   38         -
                if tmp.message.is_none() {
   39         -
                    tmp.message = _error_message;
   40         -
                }
   41     38   
                tmp
   42     39   
            })
   43     40   
        }
   44     41   
        "InvalidParameterValueException" => {
   45     42   
            crate::operation::put_function_code_signing_config::PutFunctionCodeSigningConfigError::InvalidParameterValueException({
   46     43   
                #[allow(unused_mut)]
   47     44   
                let mut tmp = {
   48     45   
                    #[allow(unused_mut)]
   49     46   
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   50     47   
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   51     48   
                        _response_body,
   52     49   
                        output,
   53     50   
                    )
   54     51   
                    .map_err(crate::operation::put_function_code_signing_config::PutFunctionCodeSigningConfigError::unhandled)?;
   55     52   
                    let output = output.meta(generic);
   56     53   
                    output.build()
   57     54   
                };
   58         -
                if tmp.message.is_none() {
   59         -
                    tmp.message = _error_message;
   60         -
                }
   61     55   
                tmp
   62     56   
            })
   63     57   
        }
   64     58   
        "ResourceConflictException" => {
   65     59   
            crate::operation::put_function_code_signing_config::PutFunctionCodeSigningConfigError::ResourceConflictException({
   66     60   
                #[allow(unused_mut)]
   67     61   
                let mut tmp = {
   68     62   
                    #[allow(unused_mut)]
   69     63   
                    let mut output = crate::types::error::builders::ResourceConflictExceptionBuilder::default();
   70     64   
                    output =
   71     65   
                        crate::protocol_serde::shape_resource_conflict_exception::de_resource_conflict_exception_json_err(_response_body, output)
   72     66   
                            .map_err(crate::operation::put_function_code_signing_config::PutFunctionCodeSigningConfigError::unhandled)?;
   73     67   
                    let output = output.meta(generic);
   74     68   
                    output.build()
   75     69   
                };
   76         -
                if tmp.message.is_none() {
   77         -
                    tmp.message = _error_message;
   78         -
                }
   79     70   
                tmp
   80     71   
            })
   81     72   
        }
   82     73   
        "ResourceNotFoundException" => {
   83     74   
            crate::operation::put_function_code_signing_config::PutFunctionCodeSigningConfigError::ResourceNotFoundException({
   84     75   
                #[allow(unused_mut)]
   85     76   
                let mut tmp = {
   86     77   
                    #[allow(unused_mut)]
   87     78   
                    let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   88     79   
                    output =
   89     80   
                        crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   90     81   
                            .map_err(crate::operation::put_function_code_signing_config::PutFunctionCodeSigningConfigError::unhandled)?;
   91     82   
                    let output = output.meta(generic);
   92     83   
                    output.build()
   93     84   
                };
   94         -
                if tmp.message.is_none() {
   95         -
                    tmp.message = _error_message;
   96         -
                }
   97     85   
                tmp
   98     86   
            })
   99     87   
        }
  100     88   
        "ServiceException" => crate::operation::put_function_code_signing_config::PutFunctionCodeSigningConfigError::ServiceException({
  101     89   
            #[allow(unused_mut)]
  102     90   
            let mut tmp = {
  103     91   
                #[allow(unused_mut)]
  104     92   
                let mut output = crate::types::error::builders::ServiceExceptionBuilder::default();
  105     93   
                output = crate::protocol_serde::shape_service_exception::de_service_exception_json_err(_response_body, output)
  106     94   
                    .map_err(crate::operation::put_function_code_signing_config::PutFunctionCodeSigningConfigError::unhandled)?;
  107     95   
                let output = output.meta(generic);
  108     96   
                output.build()
  109     97   
            };
  110         -
            if tmp.message.is_none() {
  111         -
                tmp.message = _error_message;
  112         -
            }
  113     98   
            tmp
  114     99   
        }),
  115    100   
        "TooManyRequestsException" => {
  116    101   
            crate::operation::put_function_code_signing_config::PutFunctionCodeSigningConfigError::TooManyRequestsException({
  117    102   
                #[allow(unused_mut)]
  118    103   
                let mut tmp = {
  119    104   
                    #[allow(unused_mut)]
  120    105   
                    let mut output = crate::types::error::builders::TooManyRequestsExceptionBuilder::default();
  121    106   
                    output =
  122    107   
                        crate::protocol_serde::shape_too_many_requests_exception::de_too_many_requests_exception_json_err(_response_body, output)
  123    108   
                            .map_err(crate::operation::put_function_code_signing_config::PutFunctionCodeSigningConfigError::unhandled)?;
  124    109   
                    output = output.set_retry_after_seconds(
  125    110   
                        crate::protocol_serde::shape_too_many_requests_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
  126    111   
                            crate::operation::put_function_code_signing_config::PutFunctionCodeSigningConfigError::unhandled(
  127    112   
                                "Failed to parse retryAfterSeconds from header `Retry-After",
  128    113   
                            )
  129    114   
                        })?,
  130    115   
                    );
  131    116   
                    let output = output.meta(generic);
  132    117   
                    output.build()
  133    118   
                };
  134         -
                if tmp.message.is_none() {
  135         -
                    tmp.message = _error_message;
  136         -
                }
  137    119   
                tmp
  138    120   
            })
  139    121   
        }
  140    122   
        _ => crate::operation::put_function_code_signing_config::PutFunctionCodeSigningConfigError::generic(generic),
  141    123   
    })
  142    124   
}
  143    125   
  144    126   
#[allow(clippy::unnecessary_wraps)]
  145    127   
pub fn de_put_function_code_signing_config_http_response(
  146    128   
    _response_status: u16,