AWS SDK

AWS SDK

rev. a25ccedd311e7562a03a1cd07d728cef10c9474c (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_get_bucket_request_payment.rs

@@ -18,18 +86,88 @@
   38     38   
        output.build()
   39     39   
    })
   40     40   
}
   41     41   
   42     42   
pub fn ser_get_bucket_request_payment_headers(
   43     43   
    input: &crate::operation::get_bucket_request_payment::GetBucketRequestPaymentInput,
   44     44   
    mut builder: ::http::request::Builder,
   45     45   
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   46     46   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   47     47   
        let formatted_2 = inner_1.as_str();
          48  +
        if !formatted_2.is_empty() {
   48     49   
            let header_value = formatted_2;
   49     50   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
   50     51   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
   51     52   
                    "expected_bucket_owner",
   52     53   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
   53     54   
                )
   54     55   
            })?;
   55     56   
            builder = builder.header("x-amz-expected-bucket-owner", header_value);
   56     57   
        }
          58  +
    }
   57     59   
    Ok(builder)
   58     60   
}
   59     61   
   60     62   
#[allow(unused_mut)]
   61     63   
pub fn de_get_bucket_request_payment(
   62     64   
    inp: &[u8],
   63     65   
    mut builder: crate::operation::get_bucket_request_payment::builders::GetBucketRequestPaymentOutputBuilder,
   64     66   
) -> Result<crate::operation::get_bucket_request_payment::builders::GetBucketRequestPaymentOutputBuilder, ::aws_smithy_xml::decode::XmlDecodeError> {
   65     67   
    let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
   66     68

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_get_bucket_tagging.rs

@@ -12,12 +80,82 @@
   32     32   
            .map_err(crate::operation::get_bucket_tagging::GetBucketTaggingError::unhandled)?
   33     33   
    })
   34     34   
}
   35     35   
   36     36   
pub fn ser_get_bucket_tagging_headers(
   37     37   
    input: &crate::operation::get_bucket_tagging::GetBucketTaggingInput,
   38     38   
    mut builder: ::http::request::Builder,
   39     39   
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   40     40   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   41     41   
        let formatted_2 = inner_1.as_str();
          42  +
        if !formatted_2.is_empty() {
   42     43   
            let header_value = formatted_2;
   43     44   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
   44     45   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
   45     46   
                    "expected_bucket_owner",
   46     47   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
   47     48   
                )
   48     49   
            })?;
   49     50   
            builder = builder.header("x-amz-expected-bucket-owner", header_value);
   50     51   
        }
          52  +
    }
   51     53   
    Ok(builder)
   52     54   
}
   53     55   
   54     56   
#[allow(unused_mut)]
   55     57   
pub fn de_get_bucket_tagging(
   56     58   
    inp: &[u8],
   57     59   
    mut builder: crate::operation::get_bucket_tagging::builders::GetBucketTaggingOutputBuilder,
   58     60   
) -> Result<crate::operation::get_bucket_tagging::builders::GetBucketTaggingOutputBuilder, ::aws_smithy_xml::decode::XmlDecodeError> {
   59     61   
    let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
   60     62

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_get_bucket_versioning.rs

@@ -16,16 +84,86 @@
   36     36   
        output.build()
   37     37   
    })
   38     38   
}
   39     39   
   40     40   
pub fn ser_get_bucket_versioning_headers(
   41     41   
    input: &crate::operation::get_bucket_versioning::GetBucketVersioningInput,
   42     42   
    mut builder: ::http::request::Builder,
   43     43   
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   44     44   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   45     45   
        let formatted_2 = inner_1.as_str();
          46  +
        if !formatted_2.is_empty() {
   46     47   
            let header_value = formatted_2;
   47     48   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
   48     49   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
   49     50   
                    "expected_bucket_owner",
   50     51   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
   51     52   
                )
   52     53   
            })?;
   53     54   
            builder = builder.header("x-amz-expected-bucket-owner", header_value);
   54     55   
        }
          56  +
    }
   55     57   
    Ok(builder)
   56     58   
}
   57     59   
   58     60   
#[allow(unused_mut)]
   59     61   
pub fn de_get_bucket_versioning(
   60     62   
    inp: &[u8],
   61     63   
    mut builder: crate::operation::get_bucket_versioning::builders::GetBucketVersioningOutputBuilder,
   62     64   
) -> Result<crate::operation::get_bucket_versioning::builders::GetBucketVersioningOutputBuilder, ::aws_smithy_xml::decode::XmlDecodeError> {
   63     65   
    let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
   64     66

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_get_bucket_website.rs

@@ -10,10 +78,80 @@
   30     30   
        output.build()
   31     31   
    })
   32     32   
}
   33     33   
   34     34   
pub fn ser_get_bucket_website_headers(
   35     35   
    input: &crate::operation::get_bucket_website::GetBucketWebsiteInput,
   36     36   
    mut builder: ::http::request::Builder,
   37     37   
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   38     38   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   39     39   
        let formatted_2 = inner_1.as_str();
          40  +
        if !formatted_2.is_empty() {
   40     41   
            let header_value = formatted_2;
   41     42   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
   42     43   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
   43     44   
                    "expected_bucket_owner",
   44     45   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
   45     46   
                )
   46     47   
            })?;
   47     48   
            builder = builder.header("x-amz-expected-bucket-owner", header_value);
   48     49   
        }
          50  +
    }
   49     51   
    Ok(builder)
   50     52   
}
   51     53   
   52     54   
#[allow(unused_mut)]
   53     55   
pub fn de_get_bucket_website(
   54     56   
    inp: &[u8],
   55     57   
    mut builder: crate::operation::get_bucket_website::builders::GetBucketWebsiteOutputBuilder,
   56     58   
) -> Result<crate::operation::get_bucket_website::builders::GetBucketWebsiteOutputBuilder, ::aws_smithy_xml::decode::XmlDecodeError> {
   57     59   
    let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
   58     60

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_get_object.rs

@@ -233,233 +383,405 @@
  253    253   
        _ => crate::operation::get_object::GetObjectError::generic(generic),
  254    254   
    })
  255    255   
}
  256    256   
  257    257   
pub fn ser_get_object_headers(
  258    258   
    input: &crate::operation::get_object::GetObjectInput,
  259    259   
    mut builder: ::http::request::Builder,
  260    260   
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  261    261   
    if let ::std::option::Option::Some(inner_1) = &input.if_match {
  262    262   
        let formatted_2 = inner_1.as_str();
         263  +
        if !formatted_2.is_empty() {
  263    264   
            let header_value = formatted_2;
  264    265   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  265    266   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  266    267   
                    "if_match",
  267    268   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
  268    269   
                )
  269    270   
            })?;
  270    271   
            builder = builder.header("If-Match", header_value);
  271    272   
        }
         273  +
    }
  272    274   
    if let ::std::option::Option::Some(inner_3) = &input.if_modified_since {
  273    275   
        let formatted_4 = inner_3.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
         276  +
        if !formatted_4.is_empty() {
  274    277   
            let header_value = formatted_4;
  275    278   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  276    279   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  277    280   
                    "if_modified_since",
  278    281   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
  279    282   
                )
  280    283   
            })?;
  281    284   
            builder = builder.header("If-Modified-Since", header_value);
  282    285   
        }
         286  +
    }
  283    287   
    if let ::std::option::Option::Some(inner_5) = &input.if_none_match {
  284    288   
        let formatted_6 = inner_5.as_str();
         289  +
        if !formatted_6.is_empty() {
  285    290   
            let header_value = formatted_6;
  286    291   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  287    292   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  288    293   
                    "if_none_match",
  289    294   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
  290    295   
                )
  291    296   
            })?;
  292    297   
            builder = builder.header("If-None-Match", header_value);
  293    298   
        }
         299  +
    }
  294    300   
    if let ::std::option::Option::Some(inner_7) = &input.if_unmodified_since {
  295    301   
        let formatted_8 = inner_7.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
         302  +
        if !formatted_8.is_empty() {
  296    303   
            let header_value = formatted_8;
  297    304   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  298    305   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  299    306   
                    "if_unmodified_since",
  300    307   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
  301    308   
                )
  302    309   
            })?;
  303    310   
            builder = builder.header("If-Unmodified-Since", header_value);
  304    311   
        }
         312  +
    }
  305    313   
    if let ::std::option::Option::Some(inner_9) = &input.range {
  306    314   
        let formatted_10 = inner_9.as_str();
         315  +
        if !formatted_10.is_empty() {
  307    316   
            let header_value = formatted_10;
  308    317   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  309    318   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  310    319   
                    "range",
  311    320   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
  312    321   
                )
  313    322   
            })?;
  314    323   
            builder = builder.header("Range", header_value);
  315    324   
        }
         325  +
    }
  316    326   
    if let ::std::option::Option::Some(inner_11) = &input.sse_customer_algorithm {
  317    327   
        let formatted_12 = inner_11.as_str();
         328  +
        if !formatted_12.is_empty() {
  318    329   
            let header_value = formatted_12;
  319    330   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  320    331   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  321    332   
                    "sse_customer_algorithm",
  322    333   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
  323    334   
                )
  324    335   
            })?;
  325    336   
            builder = builder.header("x-amz-server-side-encryption-customer-algorithm", header_value);
  326    337   
        }
         338  +
    }
  327    339   
    if let ::std::option::Option::Some(inner_13) = &input.sse_customer_key {
  328    340   
        let formatted_14 = inner_13.as_str();
         341  +
        if !formatted_14.is_empty() {
  329    342   
            let header_value = formatted_14;
  330    343   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  331    344   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  332    345   
                    "sse_customer_key",
  333    346   
                    format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
  334    347   
                )
  335    348   
            })?;
  336    349   
            builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
  337    350   
        }
         351  +
    }
  338    352   
    if let ::std::option::Option::Some(inner_15) = &input.sse_customer_key_md5 {
  339    353   
        let formatted_16 = inner_15.as_str();
         354  +
        if !formatted_16.is_empty() {
  340    355   
            let header_value = formatted_16;
  341    356   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  342    357   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  343    358   
                    "sse_customer_key_md5",
  344    359   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
  345    360   
                )
  346    361   
            })?;
  347    362   
            builder = builder.header("x-amz-server-side-encryption-customer-key-MD5", header_value);
  348    363   
        }
         364  +
    }
  349    365   
    if let ::std::option::Option::Some(inner_17) = &input.request_payer {
  350    366   
        let formatted_18 = inner_17.as_str();
         367  +
        if !formatted_18.is_empty() {
  351    368   
            let header_value = formatted_18;
  352    369   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  353    370   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  354    371   
                    "request_payer",
  355    372   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
  356    373   
                )
  357    374   
            })?;
  358    375   
            builder = builder.header("x-amz-request-payer", header_value);
  359    376   
        }
         377  +
    }
  360    378   
    if let ::std::option::Option::Some(inner_19) = &input.expected_bucket_owner {
  361    379   
        let formatted_20 = inner_19.as_str();
         380  +
        if !formatted_20.is_empty() {
  362    381   
            let header_value = formatted_20;
  363    382   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  364    383   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  365    384   
                    "expected_bucket_owner",
  366    385   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
  367    386   
                )
  368    387   
            })?;
  369    388   
            builder = builder.header("x-amz-expected-bucket-owner", header_value);
  370    389   
        }
         390  +
    }
  371    391   
    if let ::std::option::Option::Some(inner_21) = &input.checksum_mode {
  372    392   
        let formatted_22 = inner_21.as_str();
         393  +
        if !formatted_22.is_empty() {
  373    394   
            let header_value = formatted_22;
  374    395   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  375    396   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  376    397   
                    "checksum_mode",
  377    398   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
  378    399   
                )
  379    400   
            })?;
  380    401   
            builder = builder.header("x-amz-checksum-mode", header_value);
  381    402   
        }
         403  +
    }
  382    404   
    Ok(builder)
  383    405   
}

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_get_object_acl.rs

@@ -38,38 +117,121 @@
   58     58   
        output.build()
   59     59   
    })
   60     60   
}
   61     61   
   62     62   
pub fn ser_get_object_acl_headers(
   63     63   
    input: &crate::operation::get_object_acl::GetObjectAclInput,
   64     64   
    mut builder: ::http::request::Builder,
   65     65   
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   66     66   
    if let ::std::option::Option::Some(inner_1) = &input.request_payer {
   67     67   
        let formatted_2 = inner_1.as_str();
          68  +
        if !formatted_2.is_empty() {
   68     69   
            let header_value = formatted_2;
   69     70   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
   70     71   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
   71     72   
                    "request_payer",
   72     73   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
   73     74   
                )
   74     75   
            })?;
   75     76   
            builder = builder.header("x-amz-request-payer", header_value);
   76     77   
        }
          78  +
    }
   77     79   
    if let ::std::option::Option::Some(inner_3) = &input.expected_bucket_owner {
   78     80   
        let formatted_4 = inner_3.as_str();
          81  +
        if !formatted_4.is_empty() {
   79     82   
            let header_value = formatted_4;
   80     83   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
   81     84   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
   82     85   
                    "expected_bucket_owner",
   83     86   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
   84     87   
                )
   85     88   
            })?;
   86     89   
            builder = builder.header("x-amz-expected-bucket-owner", header_value);
   87     90   
        }
          91  +
    }
   88     92   
    Ok(builder)
   89     93   
}
   90     94   
   91     95   
#[allow(unused_mut)]
   92     96   
pub fn de_get_object_acl(
   93     97   
    inp: &[u8],
   94     98   
    mut builder: crate::operation::get_object_acl::builders::GetObjectAclOutputBuilder,
   95     99   
) -> Result<crate::operation::get_object_acl::builders::GetObjectAclOutputBuilder, ::aws_smithy_xml::decode::XmlDecodeError> {
   96    100   
    let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
   97    101

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_get_object_attributes.rs

@@ -68,68 +209,220 @@
   88     88   
    })
   89     89   
}
   90     90   
   91     91   
pub fn ser_get_object_attributes_headers(
   92     92   
    input: &crate::operation::get_object_attributes::GetObjectAttributesInput,
   93     93   
    mut builder: ::http::request::Builder,
   94     94   
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   95     95   
    if let ::std::option::Option::Some(inner_1) = &input.max_parts {
   96     96   
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_1);
   97     97   
        let formatted_2 = encoder.encode();
          98  +
        if !formatted_2.is_empty() {
   98     99   
            let header_value = formatted_2;
   99    100   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  100    101   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  101    102   
                    "max_parts",
  102    103   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
  103    104   
                )
  104    105   
            })?;
  105    106   
            builder = builder.header("x-amz-max-parts", header_value);
  106    107   
        }
         108  +
    }
  107    109   
    if let ::std::option::Option::Some(inner_3) = &input.part_number_marker {
  108    110   
        let formatted_4 = inner_3.as_str();
         111  +
        if !formatted_4.is_empty() {
  109    112   
            let header_value = formatted_4;
  110    113   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  111    114   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  112    115   
                    "part_number_marker",
  113    116   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
  114    117   
                )
  115    118   
            })?;
  116    119   
            builder = builder.header("x-amz-part-number-marker", header_value);
  117    120   
        }
         121  +
    }
  118    122   
    if let ::std::option::Option::Some(inner_5) = &input.sse_customer_algorithm {
  119    123   
        let formatted_6 = inner_5.as_str();
         124  +
        if !formatted_6.is_empty() {
  120    125   
            let header_value = formatted_6;
  121    126   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  122    127   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  123    128   
                    "sse_customer_algorithm",
  124    129   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
  125    130   
                )
  126    131   
            })?;
  127    132   
            builder = builder.header("x-amz-server-side-encryption-customer-algorithm", header_value);
  128    133   
        }
         134  +
    }
  129    135   
    if let ::std::option::Option::Some(inner_7) = &input.sse_customer_key {
  130    136   
        let formatted_8 = inner_7.as_str();
         137  +
        if !formatted_8.is_empty() {
  131    138   
            let header_value = formatted_8;
  132    139   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  133    140   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  134    141   
                    "sse_customer_key",
  135    142   
                    format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
  136    143   
                )
  137    144   
            })?;
  138    145   
            builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
  139    146   
        }
         147  +
    }
  140    148   
    if let ::std::option::Option::Some(inner_9) = &input.sse_customer_key_md5 {
  141    149   
        let formatted_10 = inner_9.as_str();
         150  +
        if !formatted_10.is_empty() {
  142    151   
            let header_value = formatted_10;
  143    152   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  144    153   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  145    154   
                    "sse_customer_key_md5",
  146    155   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
  147    156   
                )
  148    157   
            })?;
  149    158   
            builder = builder.header("x-amz-server-side-encryption-customer-key-MD5", header_value);
  150    159   
        }
         160  +
    }
  151    161   
    if let ::std::option::Option::Some(inner_11) = &input.request_payer {
  152    162   
        let formatted_12 = inner_11.as_str();
         163  +
        if !formatted_12.is_empty() {
  153    164   
            let header_value = formatted_12;
  154    165   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  155    166   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  156    167   
                    "request_payer",
  157    168   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
  158    169   
                )
  159    170   
            })?;
  160    171   
            builder = builder.header("x-amz-request-payer", header_value);
  161    172   
        }
         173  +
    }
  162    174   
    if let ::std::option::Option::Some(inner_13) = &input.expected_bucket_owner {
  163    175   
        let formatted_14 = inner_13.as_str();
         176  +
        if !formatted_14.is_empty() {
  164    177   
            let header_value = formatted_14;
  165    178   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  166    179   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  167    180   
                    "expected_bucket_owner",
  168    181   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
  169    182   
                )
  170    183   
            })?;
  171    184   
            builder = builder.header("x-amz-expected-bucket-owner", header_value);
  172    185   
        }
         186  +
    }
  173    187   
    if let ::std::option::Option::Some(inner_15) = &input.object_attributes {
  174         -
        // Empty vec in header is serialized as an empty string
  175         -
        if inner_15.is_empty() {
  176         -
            builder = builder.header("x-amz-object-attributes", "");
  177         -
        } else {
  178    188   
        for inner_16 in inner_15 {
  179    189   
            let formatted_17 = ::aws_smithy_http::header::quote_header_value(inner_16.as_str());
         190  +
            if !formatted_17.is_empty() {
  180    191   
                let header_value = formatted_17;
  181    192   
                let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  182    193   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
  183    194   
                        "object_attributes",
  184    195   
                        format!("`{}` cannot be used as a header value: {}", &header_value, err),
  185    196   
                    )
  186    197   
                })?;
  187    198   
                builder = builder.header("x-amz-object-attributes", header_value);
  188    199   
            }
  189    200   
        }

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_get_object_legal_hold.rs

@@ -17,17 +68,72 @@
   37     37   
        output.build()
   38     38   
    })
   39     39   
}
   40     40   
   41     41   
pub fn ser_get_object_legal_hold_headers(
   42     42   
    input: &crate::operation::get_object_legal_hold::GetObjectLegalHoldInput,
   43     43   
    mut builder: ::http::request::Builder,
   44     44   
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   45     45   
    if let ::std::option::Option::Some(inner_1) = &input.request_payer {
   46     46   
        let formatted_2 = inner_1.as_str();
          47  +
        if !formatted_2.is_empty() {
   47     48   
            let header_value = formatted_2;
   48     49   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
   49     50   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
   50     51   
                    "request_payer",
   51     52   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
   52     53   
                )
   53     54   
            })?;
   54     55   
            builder = builder.header("x-amz-request-payer", header_value);
   55     56   
        }
          57  +
    }
   56     58   
    if let ::std::option::Option::Some(inner_3) = &input.expected_bucket_owner {
   57     59   
        let formatted_4 = inner_3.as_str();
          60  +
        if !formatted_4.is_empty() {
   58     61   
            let header_value = formatted_4;
   59     62   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
   60     63   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
   61     64   
                    "expected_bucket_owner",
   62     65   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
   63     66   
                )
   64     67   
            })?;
   65     68   
            builder = builder.header("x-amz-expected-bucket-owner", header_value);
   66     69   
        }
          70  +
    }
   67     71   
    Ok(builder)
   68     72   
}

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_get_object_lock_configuration.rs

@@ -19,19 +59,61 @@
   39     39   
        output.build()
   40     40   
    })
   41     41   
}
   42     42   
   43     43   
pub fn ser_get_object_lock_configuration_headers(
   44     44   
    input: &crate::operation::get_object_lock_configuration::GetObjectLockConfigurationInput,
   45     45   
    mut builder: ::http::request::Builder,
   46     46   
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   47     47   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   48     48   
        let formatted_2 = inner_1.as_str();
          49  +
        if !formatted_2.is_empty() {
   49     50   
            let header_value = formatted_2;
   50     51   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
   51     52   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
   52     53   
                    "expected_bucket_owner",
   53     54   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
   54     55   
                )
   55     56   
            })?;
   56     57   
            builder = builder.header("x-amz-expected-bucket-owner", header_value);
   57     58   
        }
          59  +
    }
   58     60   
    Ok(builder)
   59     61   
}

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_get_object_retention.rs

@@ -17,17 +68,72 @@
   37     37   
        output.build()
   38     38   
    })
   39     39   
}
   40     40   
   41     41   
pub fn ser_get_object_retention_headers(
   42     42   
    input: &crate::operation::get_object_retention::GetObjectRetentionInput,
   43     43   
    mut builder: ::http::request::Builder,
   44     44   
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   45     45   
    if let ::std::option::Option::Some(inner_1) = &input.request_payer {
   46     46   
        let formatted_2 = inner_1.as_str();
          47  +
        if !formatted_2.is_empty() {
   47     48   
            let header_value = formatted_2;
   48     49   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
   49     50   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
   50     51   
                    "request_payer",
   51     52   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
   52     53   
                )
   53     54   
            })?;
   54     55   
            builder = builder.header("x-amz-request-payer", header_value);
   55     56   
        }
          57  +
    }
   56     58   
    if let ::std::option::Option::Some(inner_3) = &input.expected_bucket_owner {
   57     59   
        let formatted_4 = inner_3.as_str();
          60  +
        if !formatted_4.is_empty() {
   58     61   
            let header_value = formatted_4;
   59     62   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
   60     63   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
   61     64   
                    "expected_bucket_owner",
   62     65   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
   63     66   
                )
   64     67   
            })?;
   65     68   
            builder = builder.header("x-amz-expected-bucket-owner", header_value);
   66     69   
        }
          70  +
    }
   67     71   
    Ok(builder)
   68     72   
}

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_get_object_tagging.rs

@@ -17,17 +96,100 @@
   37     37   
            .map_err(crate::operation::get_object_tagging::GetObjectTaggingError::unhandled)?
   38     38   
    })
   39     39   
}
   40     40   
   41     41   
pub fn ser_get_object_tagging_headers(
   42     42   
    input: &crate::operation::get_object_tagging::GetObjectTaggingInput,
   43     43   
    mut builder: ::http::request::Builder,
   44     44   
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   45     45   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   46     46   
        let formatted_2 = inner_1.as_str();
          47  +
        if !formatted_2.is_empty() {
   47     48   
            let header_value = formatted_2;
   48     49   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
   49     50   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
   50     51   
                    "expected_bucket_owner",
   51     52   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
   52     53   
                )
   53     54   
            })?;
   54     55   
            builder = builder.header("x-amz-expected-bucket-owner", header_value);
   55     56   
        }
          57  +
    }
   56     58   
    if let ::std::option::Option::Some(inner_3) = &input.request_payer {
   57     59   
        let formatted_4 = inner_3.as_str();
          60  +
        if !formatted_4.is_empty() {
   58     61   
            let header_value = formatted_4;
   59     62   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
   60     63   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
   61     64   
                    "request_payer",
   62     65   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
   63     66   
                )
   64     67   
            })?;
   65     68   
            builder = builder.header("x-amz-request-payer", header_value);
   66     69   
        }
          70  +
    }
   67     71   
    Ok(builder)
   68     72   
}
   69     73   
   70     74   
#[allow(unused_mut)]
   71     75   
pub fn de_get_object_tagging(
   72     76   
    inp: &[u8],
   73     77   
    mut builder: crate::operation::get_object_tagging::builders::GetObjectTaggingOutputBuilder,
   74     78   
) -> Result<crate::operation::get_object_tagging::builders::GetObjectTaggingOutputBuilder, ::aws_smithy_xml::decode::XmlDecodeError> {
   75     79   
    let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
   76     80

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_get_object_torrent.rs

@@ -22,22 +73,77 @@
   42     42   
    let generic = generic_builder.build();
   43     43   
    Err(crate::operation::get_object_torrent::GetObjectTorrentError::generic(generic))
   44     44   
}
   45     45   
   46     46   
pub fn ser_get_object_torrent_headers(
   47     47   
    input: &crate::operation::get_object_torrent::GetObjectTorrentInput,
   48     48   
    mut builder: ::http::request::Builder,
   49     49   
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   50     50   
    if let ::std::option::Option::Some(inner_1) = &input.request_payer {
   51     51   
        let formatted_2 = inner_1.as_str();
          52  +
        if !formatted_2.is_empty() {
   52     53   
            let header_value = formatted_2;
   53     54   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
   54     55   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
   55     56   
                    "request_payer",
   56     57   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
   57     58   
                )
   58     59   
            })?;
   59     60   
            builder = builder.header("x-amz-request-payer", header_value);
   60     61   
        }
          62  +
    }
   61     63   
    if let ::std::option::Option::Some(inner_3) = &input.expected_bucket_owner {
   62     64   
        let formatted_4 = inner_3.as_str();
          65  +
        if !formatted_4.is_empty() {
   63     66   
            let header_value = formatted_4;
   64     67   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
   65     68   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
   66     69   
                    "expected_bucket_owner",
   67     70   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
   68     71   
                )
   69     72   
            })?;
   70     73   
            builder = builder.header("x-amz-expected-bucket-owner", header_value);
   71     74   
        }
          75  +
    }
   72     76   
    Ok(builder)
   73     77   
}

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_get_public_access_block.rs

@@ -17,17 +57,59 @@
   37     37   
        output.build()
   38     38   
    })
   39     39   
}
   40     40   
   41     41   
pub fn ser_get_public_access_block_headers(
   42     42   
    input: &crate::operation::get_public_access_block::GetPublicAccessBlockInput,
   43     43   
    mut builder: ::http::request::Builder,
   44     44   
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   45     45   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   46     46   
        let formatted_2 = inner_1.as_str();
          47  +
        if !formatted_2.is_empty() {
   47     48   
            let header_value = formatted_2;
   48     49   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
   49     50   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
   50     51   
                    "expected_bucket_owner",
   51     52   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
   52     53   
                )
   53     54   
            })?;
   54     55   
            builder = builder.header("x-amz-expected-bucket-owner", header_value);
   55     56   
        }
          57  +
    }
   56     58   
    Ok(builder)
   57     59   
}

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_head_bucket.rs

@@ -55,55 +95,97 @@
   75     75   
        output.build()
   76     76   
    })
   77     77   
}
   78     78   
   79     79   
pub fn ser_head_bucket_headers(
   80     80   
    input: &crate::operation::head_bucket::HeadBucketInput,
   81     81   
    mut builder: ::http::request::Builder,
   82     82   
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   83     83   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   84     84   
        let formatted_2 = inner_1.as_str();
          85  +
        if !formatted_2.is_empty() {
   85     86   
            let header_value = formatted_2;
   86     87   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
   87     88   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
   88     89   
                    "expected_bucket_owner",
   89     90   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
   90     91   
                )
   91     92   
            })?;
   92     93   
            builder = builder.header("x-amz-expected-bucket-owner", header_value);
   93     94   
        }
          95  +
    }
   94     96   
    Ok(builder)
   95     97   
}

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_head_object.rs

@@ -211,211 +361,383 @@
  231    231   
        output.build()
  232    232   
    })
  233    233   
}
  234    234   
  235    235   
pub fn ser_head_object_headers(
  236    236   
    input: &crate::operation::head_object::HeadObjectInput,
  237    237   
    mut builder: ::http::request::Builder,
  238    238   
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  239    239   
    if let ::std::option::Option::Some(inner_1) = &input.if_match {
  240    240   
        let formatted_2 = inner_1.as_str();
         241  +
        if !formatted_2.is_empty() {
  241    242   
            let header_value = formatted_2;
  242    243   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  243    244   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  244    245   
                    "if_match",
  245    246   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
  246    247   
                )
  247    248   
            })?;
  248    249   
            builder = builder.header("If-Match", header_value);
  249    250   
        }
         251  +
    }
  250    252   
    if let ::std::option::Option::Some(inner_3) = &input.if_modified_since {
  251    253   
        let formatted_4 = inner_3.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
         254  +
        if !formatted_4.is_empty() {
  252    255   
            let header_value = formatted_4;
  253    256   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  254    257   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  255    258   
                    "if_modified_since",
  256    259   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
  257    260   
                )
  258    261   
            })?;
  259    262   
            builder = builder.header("If-Modified-Since", header_value);
  260    263   
        }
         264  +
    }
  261    265   
    if let ::std::option::Option::Some(inner_5) = &input.if_none_match {
  262    266   
        let formatted_6 = inner_5.as_str();
         267  +
        if !formatted_6.is_empty() {
  263    268   
            let header_value = formatted_6;
  264    269   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  265    270   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  266    271   
                    "if_none_match",
  267    272   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
  268    273   
                )
  269    274   
            })?;
  270    275   
            builder = builder.header("If-None-Match", header_value);
  271    276   
        }
         277  +
    }
  272    278   
    if let ::std::option::Option::Some(inner_7) = &input.if_unmodified_since {
  273    279   
        let formatted_8 = inner_7.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
         280  +
        if !formatted_8.is_empty() {
  274    281   
            let header_value = formatted_8;
  275    282   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  276    283   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  277    284   
                    "if_unmodified_since",
  278    285   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
  279    286   
                )
  280    287   
            })?;
  281    288   
            builder = builder.header("If-Unmodified-Since", header_value);
  282    289   
        }
         290  +
    }
  283    291   
    if let ::std::option::Option::Some(inner_9) = &input.range {
  284    292   
        let formatted_10 = inner_9.as_str();
         293  +
        if !formatted_10.is_empty() {
  285    294   
            let header_value = formatted_10;
  286    295   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  287    296   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  288    297   
                    "range",
  289    298   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
  290    299   
                )
  291    300   
            })?;
  292    301   
            builder = builder.header("Range", header_value);
  293    302   
        }
         303  +
    }
  294    304   
    if let ::std::option::Option::Some(inner_11) = &input.sse_customer_algorithm {
  295    305   
        let formatted_12 = inner_11.as_str();
         306  +
        if !formatted_12.is_empty() {
  296    307   
            let header_value = formatted_12;
  297    308   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  298    309   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  299    310   
                    "sse_customer_algorithm",
  300    311   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
  301    312   
                )
  302    313   
            })?;
  303    314   
            builder = builder.header("x-amz-server-side-encryption-customer-algorithm", header_value);
  304    315   
        }
         316  +
    }
  305    317   
    if let ::std::option::Option::Some(inner_13) = &input.sse_customer_key {
  306    318   
        let formatted_14 = inner_13.as_str();
         319  +
        if !formatted_14.is_empty() {
  307    320   
            let header_value = formatted_14;
  308    321   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  309    322   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  310    323   
                    "sse_customer_key",
  311    324   
                    format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
  312    325   
                )
  313    326   
            })?;
  314    327   
            builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
  315    328   
        }
         329  +
    }
  316    330   
    if let ::std::option::Option::Some(inner_15) = &input.sse_customer_key_md5 {
  317    331   
        let formatted_16 = inner_15.as_str();
         332  +
        if !formatted_16.is_empty() {
  318    333   
            let header_value = formatted_16;
  319    334   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  320    335   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  321    336   
                    "sse_customer_key_md5",
  322    337   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
  323    338   
                )
  324    339   
            })?;
  325    340   
            builder = builder.header("x-amz-server-side-encryption-customer-key-MD5", header_value);
  326    341   
        }
         342  +
    }
  327    343   
    if let ::std::option::Option::Some(inner_17) = &input.request_payer {
  328    344   
        let formatted_18 = inner_17.as_str();
         345  +
        if !formatted_18.is_empty() {
  329    346   
            let header_value = formatted_18;
  330    347   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  331    348   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  332    349   
                    "request_payer",
  333    350   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
  334    351   
                )
  335    352   
            })?;
  336    353   
            builder = builder.header("x-amz-request-payer", header_value);
  337    354   
        }
         355  +
    }
  338    356   
    if let ::std::option::Option::Some(inner_19) = &input.expected_bucket_owner {
  339    357   
        let formatted_20 = inner_19.as_str();
         358  +
        if !formatted_20.is_empty() {
  340    359   
            let header_value = formatted_20;
  341    360   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  342    361   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  343    362   
                    "expected_bucket_owner",
  344    363   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
  345    364   
                )
  346    365   
            })?;
  347    366   
            builder = builder.header("x-amz-expected-bucket-owner", header_value);
  348    367   
        }
         368  +
    }
  349    369   
    if let ::std::option::Option::Some(inner_21) = &input.checksum_mode {
  350    370   
        let formatted_22 = inner_21.as_str();
         371  +
        if !formatted_22.is_empty() {
  351    372   
            let header_value = formatted_22;
  352    373   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
  353    374   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
  354    375   
                    "checksum_mode",
  355    376   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
  356    377   
                )
  357    378   
            })?;
  358    379   
            builder = builder.header("x-amz-checksum-mode", header_value);
  359    380   
        }
         381  +
    }
  360    382   
    Ok(builder)
  361    383   
}

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_list_bucket_analytics_configurations.rs

@@ -16,16 +84,86 @@
   36     36   
        output.build()
   37     37   
    })
   38     38   
}
   39     39   
   40     40   
pub fn ser_list_bucket_analytics_configurations_headers(
   41     41   
    input: &crate::operation::list_bucket_analytics_configurations::ListBucketAnalyticsConfigurationsInput,
   42     42   
    mut builder: ::http::request::Builder,
   43     43   
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
   44     44   
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
   45     45   
        let formatted_2 = inner_1.as_str();
          46  +
        if !formatted_2.is_empty() {
   46     47   
            let header_value = formatted_2;
   47     48   
            let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
   48     49   
                ::aws_smithy_types::error::operation::BuildError::invalid_field(
   49     50   
                    "expected_bucket_owner",
   50     51   
                    format!("`{}` cannot be used as a header value: {}", &header_value, err),
   51     52   
                )
   52     53   
            })?;
   53     54   
            builder = builder.header("x-amz-expected-bucket-owner", header_value);
   54     55   
        }
          56  +
    }
   55     57   
    Ok(builder)
   56     58   
}
   57     59   
   58     60   
#[allow(unused_mut)]
   59     61   
pub fn de_list_bucket_analytics_configurations(
   60     62   
    inp: &[u8],
   61     63   
    mut builder: crate::operation::list_bucket_analytics_configurations::builders::ListBucketAnalyticsConfigurationsOutputBuilder,
   62     64   
) -> Result<
   63     65   
    crate::operation::list_bucket_analytics_configurations::builders::ListBucketAnalyticsConfigurationsOutputBuilder,
   64     66   
    ::aws_smithy_xml::decode::XmlDecodeError,