AWS SDK

AWS SDK

rev. 645b1734ce74ebbc529fecda676baac60fe4d581

Files changed:

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/operation/invoke_model.rs

@@ -227,227 +288,290 @@
  247    247   
  248    248   
        let params = crate::config::endpoint::Params::builder()
  249    249   
            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
  250    250   
            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
  251    251   
            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
  252    252   
            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
  253    253   
            .build()
  254    254   
            .map_err(|err| {
  255    255   
                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  256    256   
            })?;
         257  +
  257    258   
        cfg.interceptor_state()
  258    259   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         260  +
  259    261   
        ::std::result::Result::Ok(())
  260    262   
    }
  261    263   
}
  262    264   
  263    265   
// The get_* functions below are generated from JMESPath expressions in the
  264    266   
// operationContextParams trait. They target the operation's input shape.
  265    267   
  266    268   
/// Error type for the `InvokeModelError` operation.
  267    269   
#[non_exhaustive]
  268    270   
#[derive(::std::fmt::Debug)]

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/operation/invoke_model_with_bidirectional_stream.rs

@@ -255,255 +316,318 @@
  275    275   
  276    276   
        let params = crate::config::endpoint::Params::builder()
  277    277   
            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
  278    278   
            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
  279    279   
            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
  280    280   
            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
  281    281   
            .build()
  282    282   
            .map_err(|err| {
  283    283   
                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  284    284   
            })?;
         285  +
  285    286   
        cfg.interceptor_state()
  286    287   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         288  +
  287    289   
        ::std::result::Result::Ok(())
  288    290   
    }
  289    291   
}
  290    292   
  291    293   
// The get_* functions below are generated from JMESPath expressions in the
  292    294   
// operationContextParams trait. They target the operation's input shape.
  293    295   
  294    296   
/// Error type for the `InvokeModelWithBidirectionalStreamError` operation.
  295    297   
#[non_exhaustive]
  296    298   
#[derive(::std::fmt::Debug)]

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/operation/invoke_model_with_response_stream.rs

@@ -249,249 +310,312 @@
  269    269   
  270    270   
        let params = crate::config::endpoint::Params::builder()
  271    271   
            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
  272    272   
            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
  273    273   
            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
  274    274   
            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
  275    275   
            .build()
  276    276   
            .map_err(|err| {
  277    277   
                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  278    278   
            })?;
         279  +
  279    280   
        cfg.interceptor_state()
  280    281   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         282  +
  281    283   
        ::std::result::Result::Ok(())
  282    284   
    }
  283    285   
}
  284    286   
  285    287   
// The get_* functions below are generated from JMESPath expressions in the
  286    288   
// operationContextParams trait. They target the operation's input shape.
  287    289   
  288    290   
/// Error type for the `InvokeModelWithResponseStreamError` operation.
  289    291   
#[non_exhaustive]
  290    292   
#[derive(::std::fmt::Debug)]

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/operation/list_async_invokes.rs

@@ -260,260 +321,323 @@
  280    280   
  281    281   
        let params = crate::config::endpoint::Params::builder()
  282    282   
            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
  283    283   
            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
  284    284   
            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
  285    285   
            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
  286    286   
            .build()
  287    287   
            .map_err(|err| {
  288    288   
                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  289    289   
            })?;
         290  +
  290    291   
        cfg.interceptor_state()
  291    292   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         293  +
  292    294   
        ::std::result::Result::Ok(())
  293    295   
    }
  294    296   
}
  295    297   
  296    298   
// The get_* functions below are generated from JMESPath expressions in the
  297    299   
// operationContextParams trait. They target the operation's input shape.
  298    300   
  299    301   
/// Error type for the `ListAsyncInvokesError` operation.
  300    302   
#[non_exhaustive]
  301    303   
#[derive(::std::fmt::Debug)]

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/operation/start_async_invoke.rs

@@ -221,221 +282,284 @@
  241    241   
  242    242   
        let params = crate::config::endpoint::Params::builder()
  243    243   
            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
  244    244   
            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
  245    245   
            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
  246    246   
            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
  247    247   
            .build()
  248    248   
            .map_err(|err| {
  249    249   
                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  250    250   
            })?;
         251  +
  251    252   
        cfg.interceptor_state()
  252    253   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         254  +
  253    255   
        ::std::result::Result::Ok(())
  254    256   
    }
  255    257   
}
  256    258   
  257    259   
// The get_* functions below are generated from JMESPath expressions in the
  258    260   
// operationContextParams trait. They target the operation's input shape.
  259    261   
  260    262   
/// Error type for the `StartAsyncInvokeError` operation.
  261    263   
#[non_exhaustive]
  262    264   
#[derive(::std::fmt::Debug)]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/Cargo.toml

@@ -1,1 +117,117 @@
    9      9   
repository = "https://github.com/awslabs/aws-sdk-rust"
   10     10   
rust-version = "1.86.0"
   11     11   
readme = "README.md"
   12     12   
[package.metadata.smithy]
   13     13   
codegen-version = "ci"
   14     14   
[package.metadata.docs.rs]
   15     15   
all-features = true
   16     16   
targets = ["x86_64-unknown-linux-gnu"]
   17     17   
[dependencies.aws-credential-types]
   18     18   
path = "../aws-credential-types"
   19         -
version = "1.2.6"
          19  +
version = "1.2.7"
   20     20   
   21     21   
[dependencies.aws-runtime]
   22     22   
path = "../aws-runtime"
   23     23   
features = ["event-stream"]
   24         -
version = "1.5.10"
          24  +
version = "1.5.11"
   25     25   
   26     26   
[dependencies.aws-smithy-async]
   27     27   
path = "../aws-smithy-async"
   28     28   
version = "1.2.5"
   29     29   
   30     30   
[dependencies.aws-smithy-eventstream]
   31     31   
path = "../aws-smithy-eventstream"
   32     32   
version = "0.60.11"
   33     33   
   34     34   
[dependencies.aws-smithy-http]
   35     35   
path = "../aws-smithy-http"
   36     36   
features = ["event-stream"]
   37     37   
version = "0.62.3"
   38     38   
   39     39   
[dependencies.aws-smithy-json]
   40     40   
path = "../aws-smithy-json"
   41     41   
version = "0.61.5"
   42     42   
   43     43   
[dependencies.aws-smithy-runtime]
   44     44   
path = "../aws-smithy-runtime"
   45     45   
features = ["client"]
   46     46   
version = "1.9.2"
   47     47   
   48     48   
[dependencies.aws-smithy-runtime-api]
   49     49   
path = "../aws-smithy-runtime-api"
   50     50   
features = ["client", "http-02x"]
   51     51   
version = "1.9.0"
   52     52   
   53     53   
[dependencies.aws-smithy-types]
   54     54   
path = "../aws-smithy-types"
   55     55   
version = "1.3.2"
   56     56   
   57     57   
[dependencies.aws-types]
   58     58   
path = "../aws-types"
   59     59   
version = "1.3.8"
   60     60   
   61     61   
[dependencies.bytes]
   62     62   
version = "1.4.0"
   63     63   
   64     64   
[dependencies.fastrand]
   65     65   
version = "2.0.0"
   66     66   
   67     67   
[dependencies.http]
   68     68   
version = "0.2.9"
   69     69   
   70     70   
[dependencies.regex-lite]
   71     71   
version = "0.1.5"
   72     72   
   73     73   
[dependencies.tracing]
   74     74   
version = "0.1"
   75     75   
[dev-dependencies.aws-config]
   76     76   
path = "../aws-config"
   77     77   
version = "1.8.6"
   78     78   
   79     79   
[dev-dependencies.aws-credential-types]
   80     80   
path = "../aws-credential-types"
   81     81   
features = ["test-util"]
   82         -
version = "1.2.6"
          82  +
version = "1.2.7"
   83     83   
   84     84   
[dev-dependencies.aws-runtime]
   85     85   
path = "../aws-runtime"
   86     86   
features = ["test-util"]
   87         -
version = "1.5.10"
          87  +
version = "1.5.11"
   88     88   
   89     89   
[dev-dependencies.aws-smithy-async]
   90     90   
path = "../aws-smithy-async"
   91     91   
features = ["test-util"]
   92     92   
version = "1.2.5"
   93     93   
   94     94   
[dev-dependencies.aws-smithy-eventstream]
   95     95   
path = "../aws-smithy-eventstream"
   96     96   
features = ["test-util"]
   97     97   
version = "0.60.11"

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/associate_kms_key.rs

@@ -219,219 +280,282 @@
  239    239   
  240    240   
        let params = crate::config::endpoint::Params::builder()
  241    241   
            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
  242    242   
            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
  243    243   
            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
  244    244   
            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
  245    245   
            .build()
  246    246   
            .map_err(|err| {
  247    247   
                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  248    248   
            })?;
         249  +
  249    250   
        cfg.interceptor_state()
  250    251   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         252  +
  251    253   
        ::std::result::Result::Ok(())
  252    254   
    }
  253    255   
}
  254    256   
  255    257   
// The get_* functions below are generated from JMESPath expressions in the
  256    258   
// operationContextParams trait. They target the operation's input shape.
  257    259   
  258    260   
/// Error type for the `AssociateKmsKeyError` operation.
  259    261   
#[non_exhaustive]
  260    262   
#[derive(::std::fmt::Debug)]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/cancel_export_task.rs

@@ -219,219 +280,282 @@
  239    239   
  240    240   
        let params = crate::config::endpoint::Params::builder()
  241    241   
            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
  242    242   
            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
  243    243   
            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
  244    244   
            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
  245    245   
            .build()
  246    246   
            .map_err(|err| {
  247    247   
                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  248    248   
            })?;
         249  +
  249    250   
        cfg.interceptor_state()
  250    251   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         252  +
  251    253   
        ::std::result::Result::Ok(())
  252    254   
    }
  253    255   
}
  254    256   
  255    257   
// The get_* functions below are generated from JMESPath expressions in the
  256    258   
// operationContextParams trait. They target the operation's input shape.
  257    259   
  258    260   
/// Error type for the `CancelExportTaskError` operation.
  259    261   
#[non_exhaustive]
  260    262   
#[derive(::std::fmt::Debug)]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/create_delivery.rs

@@ -219,219 +280,282 @@
  239    239   
  240    240   
        let params = crate::config::endpoint::Params::builder()
  241    241   
            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
  242    242   
            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
  243    243   
            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
  244    244   
            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
  245    245   
            .build()
  246    246   
            .map_err(|err| {
  247    247   
                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  248    248   
            })?;
         249  +
  249    250   
        cfg.interceptor_state()
  250    251   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         252  +
  251    253   
        ::std::result::Result::Ok(())
  252    254   
    }
  253    255   
}
  254    256   
  255    257   
// The get_* functions below are generated from JMESPath expressions in the
  256    258   
// operationContextParams trait. They target the operation's input shape.
  257    259   
  258    260   
/// Error type for the `CreateDeliveryError` operation.
  259    261   
#[non_exhaustive]
  260    262   
#[derive(::std::fmt::Debug)]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/create_export_task.rs

@@ -219,219 +280,282 @@
  239    239   
  240    240   
        let params = crate::config::endpoint::Params::builder()
  241    241   
            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
  242    242   
            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
  243    243   
            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
  244    244   
            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
  245    245   
            .build()
  246    246   
            .map_err(|err| {
  247    247   
                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  248    248   
            })?;
         249  +
  249    250   
        cfg.interceptor_state()
  250    251   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         252  +
  251    253   
        ::std::result::Result::Ok(())
  252    254   
    }
  253    255   
}
  254    256   
  255    257   
// The get_* functions below are generated from JMESPath expressions in the
  256    258   
// operationContextParams trait. They target the operation's input shape.
  257    259   
  258    260   
/// Error type for the `CreateExportTaskError` operation.
  259    261   
#[non_exhaustive]
  260    262   
#[derive(::std::fmt::Debug)]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/create_log_anomaly_detector.rs

@@ -227,227 +288,290 @@
  247    247   
  248    248   
        let params = crate::config::endpoint::Params::builder()
  249    249   
            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
  250    250   
            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
  251    251   
            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
  252    252   
            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
  253    253   
            .build()
  254    254   
            .map_err(|err| {
  255    255   
                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  256    256   
            })?;
         257  +
  257    258   
        cfg.interceptor_state()
  258    259   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         260  +
  259    261   
        ::std::result::Result::Ok(())
  260    262   
    }
  261    263   
}
  262    264   
  263    265   
// The get_* functions below are generated from JMESPath expressions in the
  264    266   
// operationContextParams trait. They target the operation's input shape.
  265    267   
  266    268   
/// Error type for the `CreateLogAnomalyDetectorError` operation.
  267    269   
#[non_exhaustive]
  268    270   
#[derive(::std::fmt::Debug)]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/create_log_group.rs

@@ -219,219 +280,282 @@
  239    239   
  240    240   
        let params = crate::config::endpoint::Params::builder()
  241    241   
            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
  242    242   
            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
  243    243   
            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
  244    244   
            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
  245    245   
            .build()
  246    246   
            .map_err(|err| {
  247    247   
                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  248    248   
            })?;
         249  +
  249    250   
        cfg.interceptor_state()
  250    251   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         252  +
  251    253   
        ::std::result::Result::Ok(())
  252    254   
    }
  253    255   
}
  254    256   
  255    257   
// The get_* functions below are generated from JMESPath expressions in the
  256    258   
// operationContextParams trait. They target the operation's input shape.
  257    259   
  258    260   
/// Error type for the `CreateLogGroupError` operation.
  259    261   
#[non_exhaustive]
  260    262   
#[derive(::std::fmt::Debug)]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/create_log_stream.rs

@@ -219,219 +280,282 @@
  239    239   
  240    240   
        let params = crate::config::endpoint::Params::builder()
  241    241   
            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
  242    242   
            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
  243    243   
            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
  244    244   
            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
  245    245   
            .build()
  246    246   
            .map_err(|err| {
  247    247   
                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  248    248   
            })?;
         249  +
  249    250   
        cfg.interceptor_state()
  250    251   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         252  +
  251    253   
        ::std::result::Result::Ok(())
  252    254   
    }
  253    255   
}
  254    256   
  255    257   
// The get_* functions below are generated from JMESPath expressions in the
  256    258   
// operationContextParams trait. They target the operation's input shape.
  257    259   
  258    260   
/// Error type for the `CreateLogStreamError` operation.
  259    261   
#[non_exhaustive]
  260    262   
#[derive(::std::fmt::Debug)]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/delete_account_policy.rs

@@ -227,227 +288,290 @@
  247    247   
  248    248   
        let params = crate::config::endpoint::Params::builder()
  249    249   
            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
  250    250   
            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
  251    251   
            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
  252    252   
            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
  253    253   
            .build()
  254    254   
            .map_err(|err| {
  255    255   
                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  256    256   
            })?;
         257  +
  257    258   
        cfg.interceptor_state()
  258    259   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         260  +
  259    261   
        ::std::result::Result::Ok(())
  260    262   
    }
  261    263   
}
  262    264   
  263    265   
// The get_* functions below are generated from JMESPath expressions in the
  264    266   
// operationContextParams trait. They target the operation's input shape.
  265    267   
  266    268   
/// Error type for the `DeleteAccountPolicyError` operation.
  267    269   
#[non_exhaustive]
  268    270   
#[derive(::std::fmt::Debug)]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/delete_data_protection_policy.rs

@@ -227,227 +288,290 @@
  247    247   
  248    248   
        let params = crate::config::endpoint::Params::builder()
  249    249   
            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
  250    250   
            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
  251    251   
            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
  252    252   
            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
  253    253   
            .build()
  254    254   
            .map_err(|err| {
  255    255   
                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  256    256   
            })?;
         257  +
  257    258   
        cfg.interceptor_state()
  258    259   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         260  +
  259    261   
        ::std::result::Result::Ok(())
  260    262   
    }
  261    263   
}
  262    264   
  263    265   
// The get_* functions below are generated from JMESPath expressions in the
  264    266   
// operationContextParams trait. They target the operation's input shape.
  265    267   
  266    268   
/// Error type for the `DeleteDataProtectionPolicyError` operation.
  267    269   
#[non_exhaustive]
  268    270   
#[derive(::std::fmt::Debug)]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/delete_delivery.rs

@@ -219,219 +280,282 @@
  239    239   
  240    240   
        let params = crate::config::endpoint::Params::builder()
  241    241   
            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
  242    242   
            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
  243    243   
            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
  244    244   
            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
  245    245   
            .build()
  246    246   
            .map_err(|err| {
  247    247   
                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  248    248   
            })?;
         249  +
  249    250   
        cfg.interceptor_state()
  250    251   
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         252  +
  251    253   
        ::std::result::Result::Ok(())
  252    254   
    }
  253    255   
}
  254    256   
  255    257   
// The get_* functions below are generated from JMESPath expressions in the
  256    258   
// operationContextParams trait. They target the operation's input shape.
  257    259   
  258    260   
/// Error type for the `DeleteDeliveryError` operation.
  259    261   
#[non_exhaustive]
  260    262   
#[derive(::std::fmt::Debug)]