AWS SDK

AWS SDK

rev. 2915cec5ef64cb1ed4992565a748d76a11505b3b (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/ssm/src/operation/get_parameters/_get_parameters_input.rs

@@ -0,1 +0,215 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
#[allow(missing_docs)] // documentation missing in model
           3  +
#[non_exhaustive]
           4  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
           5  +
pub struct GetParametersInput {
           6  +
    /// <p>The names or Amazon Resource Names (ARNs) of the parameters that you want to query. For parameters shared with you from another account, you must use the full ARNs.</p>
           7  +
    /// <p>To query by parameter label, use <code>"Name": "name:label"</code>. To query by parameter version, use <code>"Name": "name:version"</code>.</p><note>
           8  +
    /// <p>The results for <code>GetParameters</code> requests are listed in alphabetical order in query responses.</p>
           9  +
    /// </note>
          10  +
    /// <p>For information about shared parameters, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-store-shared-parameters.html">Working with shared parameters</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
          11  +
    pub names: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
          12  +
    /// <p>Return decrypted secure string value. Return decrypted values for secure string parameters. This flag is ignored for <code>String</code> and <code>StringList</code> parameter types.</p>
          13  +
    pub with_decryption: ::std::option::Option<bool>,
          14  +
}
          15  +
impl GetParametersInput {
          16  +
    /// <p>The names or Amazon Resource Names (ARNs) of the parameters that you want to query. For parameters shared with you from another account, you must use the full ARNs.</p>
          17  +
    /// <p>To query by parameter label, use <code>"Name": "name:label"</code>. To query by parameter version, use <code>"Name": "name:version"</code>.</p><note>
          18  +
    /// <p>The results for <code>GetParameters</code> requests are listed in alphabetical order in query responses.</p>
          19  +
    /// </note>
          20  +
    /// <p>For information about shared parameters, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-store-shared-parameters.html">Working with shared parameters</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
          21  +
    ///
          22  +
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.names.is_none()`.
          23  +
    pub fn names(&self) -> &[::std::string::String] {
          24  +
        self.names.as_deref().unwrap_or_default()
          25  +
    }
          26  +
    /// <p>Return decrypted secure string value. Return decrypted values for secure string parameters. This flag is ignored for <code>String</code> and <code>StringList</code> parameter types.</p>
          27  +
    pub fn with_decryption(&self) -> ::std::option::Option<bool> {
          28  +
        self.with_decryption
          29  +
    }
          30  +
}
          31  +
static GETPARAMETERSINPUT_MEMBER_NAMES_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          32  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#ParameterNameList$member", "com.amazonaws.ssm", "ParameterNameList"),
          33  +
    ::aws_smithy_schema::ShapeType::String,
          34  +
    "member",
          35  +
    0,
          36  +
);
          37  +
static GETPARAMETERSINPUT_MEMBER_NAMES: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          38  +
    ::aws_smithy_schema::ShapeId::from_parts(
          39  +
        "com.amazonaws.ssm.synthetic#GetParametersInput$Names",
          40  +
        "com.amazonaws.ssm.synthetic",
          41  +
        "GetParametersInput",
          42  +
    ),
          43  +
    ::aws_smithy_schema::ShapeType::List,
          44  +
    "Names",
          45  +
    0,
          46  +
)
          47  +
.with_list_member(&GETPARAMETERSINPUT_MEMBER_NAMES_MEMBER);
          48  +
static GETPARAMETERSINPUT_MEMBER_WITH_DECRYPTION: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          49  +
    ::aws_smithy_schema::ShapeId::from_parts(
          50  +
        "com.amazonaws.ssm.synthetic#GetParametersInput$WithDecryption",
          51  +
        "com.amazonaws.ssm.synthetic",
          52  +
        "GetParametersInput",
          53  +
    ),
          54  +
    ::aws_smithy_schema::ShapeType::Boolean,
          55  +
    "WithDecryption",
          56  +
    1,
          57  +
);
          58  +
static GETPARAMETERSINPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
          59  +
    ::aws_smithy_schema::ShapeId::from_parts(
          60  +
        "com.amazonaws.ssm.synthetic#GetParametersInput",
          61  +
        "com.amazonaws.ssm.synthetic",
          62  +
        "GetParametersInput",
          63  +
    ),
          64  +
    ::aws_smithy_schema::ShapeType::Structure,
          65  +
    &[&GETPARAMETERSINPUT_MEMBER_NAMES, &GETPARAMETERSINPUT_MEMBER_WITH_DECRYPTION],
          66  +
)
          67  +
.with_payload_hint(::aws_smithy_schema::PayloadHint::NoStructPayload)
          68  +
.with_original_name("GetParametersRequest");
          69  +
impl GetParametersInput {
          70  +
    /// The schema for this shape.
          71  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &GETPARAMETERSINPUT_SCHEMA;
          72  +
}
          73  +
impl ::aws_smithy_schema::serde::SerializableStruct for GetParametersInput {
          74  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
          75  +
    fn serialize_members(
          76  +
        &self,
          77  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
          78  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
          79  +
        if let Some(ref val) = self.names {
          80  +
            ser.write_list(
          81  +
                &GETPARAMETERSINPUT_MEMBER_NAMES,
          82  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
          83  +
                    for item in val {
          84  +
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
          85  +
                    }
          86  +
                    Ok(())
          87  +
                },
          88  +
            )?;
          89  +
        }
          90  +
        if let Some(ref val) = self.with_decryption {
          91  +
            ser.write_boolean(&GETPARAMETERSINPUT_MEMBER_WITH_DECRYPTION, *val)?;
          92  +
        }
          93  +
        Ok(())
          94  +
    }
          95  +
}
          96  +
impl GetParametersInput {
          97  +
    /// Deserializes this structure from a [`ShapeDeserializer`].
          98  +
    pub fn deserialize(
          99  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         100  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         101  +
        #[allow(unused_variables, unused_mut)]
         102  +
        let mut builder = Self::builder();
         103  +
        #[allow(
         104  +
            unused_variables,
         105  +
            unreachable_code,
         106  +
            clippy::single_match,
         107  +
            clippy::match_single_binding,
         108  +
            clippy::diverging_sub_expression
         109  +
        )]
         110  +
        deserializer.read_struct(&GETPARAMETERSINPUT_SCHEMA, &mut |member, deser| {
         111  +
            match member.member_index() {
         112  +
                Some(0) => {
         113  +
                    if deser.is_null() {
         114  +
                        deser.read_null()?;
         115  +
                    } else {
         116  +
                        builder.names = Some(deser.read_string_list(member)?);
         117  +
                    }
         118  +
                }
         119  +
                Some(1) => {
         120  +
                    if deser.is_null() {
         121  +
                        deser.read_null()?;
         122  +
                    } else {
         123  +
                        builder.with_decryption = Some(deser.read_boolean(member)?);
         124  +
                    }
         125  +
                }
         126  +
                _ => {}
         127  +
            }
         128  +
            Ok(())
         129  +
        })?;
         130  +
        builder.names = builder.names.or(Some(Vec::new()));
         131  +
        builder.build().map_err(|e| aws_smithy_schema::serde::SerdeError::custom(e.to_string()))
         132  +
    }
         133  +
}
         134  +
impl GetParametersInput {
         135  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         136  +
    pub fn deserialize_with_response(
         137  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         138  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         139  +
        _status: u16,
         140  +
        _body: &[u8],
         141  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         142  +
        Self::deserialize(deserializer)
         143  +
    }
         144  +
}
         145  +
impl GetParametersInput {
         146  +
    /// Creates a new builder-style object to manufacture [`GetParametersInput`](crate::operation::get_parameters::GetParametersInput).
         147  +
    pub fn builder() -> crate::operation::get_parameters::builders::GetParametersInputBuilder {
         148  +
        crate::operation::get_parameters::builders::GetParametersInputBuilder::default()
         149  +
    }
         150  +
}
         151  +
         152  +
/// A builder for [`GetParametersInput`](crate::operation::get_parameters::GetParametersInput).
         153  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
         154  +
#[non_exhaustive]
         155  +
pub struct GetParametersInputBuilder {
         156  +
    pub(crate) names: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
         157  +
    pub(crate) with_decryption: ::std::option::Option<bool>,
         158  +
}
         159  +
impl GetParametersInputBuilder {
         160  +
    /// Appends an item to `names`.
         161  +
    ///
         162  +
    /// To override the contents of this collection use [`set_names`](Self::set_names).
         163  +
    ///
         164  +
    /// <p>The names or Amazon Resource Names (ARNs) of the parameters that you want to query. For parameters shared with you from another account, you must use the full ARNs.</p>
         165  +
    /// <p>To query by parameter label, use <code>"Name": "name:label"</code>. To query by parameter version, use <code>"Name": "name:version"</code>.</p><note>
         166  +
    /// <p>The results for <code>GetParameters</code> requests are listed in alphabetical order in query responses.</p>
         167  +
    /// </note>
         168  +
    /// <p>For information about shared parameters, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-store-shared-parameters.html">Working with shared parameters</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
         169  +
    pub fn names(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         170  +
        let mut v = self.names.unwrap_or_default();
         171  +
        v.push(input.into());
         172  +
        self.names = ::std::option::Option::Some(v);
         173  +
        self
         174  +
    }
         175  +
    /// <p>The names or Amazon Resource Names (ARNs) of the parameters that you want to query. For parameters shared with you from another account, you must use the full ARNs.</p>
         176  +
    /// <p>To query by parameter label, use <code>"Name": "name:label"</code>. To query by parameter version, use <code>"Name": "name:version"</code>.</p><note>
         177  +
    /// <p>The results for <code>GetParameters</code> requests are listed in alphabetical order in query responses.</p>
         178  +
    /// </note>
         179  +
    /// <p>For information about shared parameters, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-store-shared-parameters.html">Working with shared parameters</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
         180  +
    pub fn set_names(mut self, input: ::std::option::Option<::std::vec::Vec<::std::string::String>>) -> Self {
         181  +
        self.names = input;
         182  +
        self
         183  +
    }
         184  +
    /// <p>The names or Amazon Resource Names (ARNs) of the parameters that you want to query. For parameters shared with you from another account, you must use the full ARNs.</p>
         185  +
    /// <p>To query by parameter label, use <code>"Name": "name:label"</code>. To query by parameter version, use <code>"Name": "name:version"</code>.</p><note>
         186  +
    /// <p>The results for <code>GetParameters</code> requests are listed in alphabetical order in query responses.</p>
         187  +
    /// </note>
         188  +
    /// <p>For information about shared parameters, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-store-shared-parameters.html">Working with shared parameters</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
         189  +
    pub fn get_names(&self) -> &::std::option::Option<::std::vec::Vec<::std::string::String>> {
         190  +
        &self.names
         191  +
    }
         192  +
    /// <p>Return decrypted secure string value. Return decrypted values for secure string parameters. This flag is ignored for <code>String</code> and <code>StringList</code> parameter types.</p>
         193  +
    pub fn with_decryption(mut self, input: bool) -> Self {
         194  +
        self.with_decryption = ::std::option::Option::Some(input);
         195  +
        self
         196  +
    }
         197  +
    /// <p>Return decrypted secure string value. Return decrypted values for secure string parameters. This flag is ignored for <code>String</code> and <code>StringList</code> parameter types.</p>
         198  +
    pub fn set_with_decryption(mut self, input: ::std::option::Option<bool>) -> Self {
         199  +
        self.with_decryption = input;
         200  +
        self
         201  +
    }
         202  +
    /// <p>Return decrypted secure string value. Return decrypted values for secure string parameters. This flag is ignored for <code>String</code> and <code>StringList</code> parameter types.</p>
         203  +
    pub fn get_with_decryption(&self) -> &::std::option::Option<bool> {
         204  +
        &self.with_decryption
         205  +
    }
         206  +
    /// Consumes the builder and constructs a [`GetParametersInput`](crate::operation::get_parameters::GetParametersInput).
         207  +
    pub fn build(
         208  +
        self,
         209  +
    ) -> ::std::result::Result<crate::operation::get_parameters::GetParametersInput, ::aws_smithy_types::error::operation::BuildError> {
         210  +
        ::std::result::Result::Ok(crate::operation::get_parameters::GetParametersInput {
         211  +
            names: self.names,
         212  +
            with_decryption: self.with_decryption,
         213  +
        })
         214  +
    }
         215  +
}

tmp-codegen-diff/aws-sdk/sdk/ssm/src/operation/get_parameters/_get_parameters_output.rs

@@ -0,1 +0,292 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
#[allow(missing_docs)] // documentation missing in model
           3  +
#[non_exhaustive]
           4  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
           5  +
pub struct GetParametersOutput {
           6  +
    /// <p>A list of details for a parameter.</p>
           7  +
    pub parameters: ::std::option::Option<::std::vec::Vec<crate::types::Parameter>>,
           8  +
    /// <p>A list of parameters that aren't formatted correctly or don't run during an execution.</p>
           9  +
    pub invalid_parameters: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
          10  +
    _request_id: Option<String>,
          11  +
}
          12  +
impl GetParametersOutput {
          13  +
    /// <p>A list of details for a parameter.</p>
          14  +
    ///
          15  +
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.parameters.is_none()`.
          16  +
    pub fn parameters(&self) -> &[crate::types::Parameter] {
          17  +
        self.parameters.as_deref().unwrap_or_default()
          18  +
    }
          19  +
    /// <p>A list of parameters that aren't formatted correctly or don't run during an execution.</p>
          20  +
    ///
          21  +
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.invalid_parameters.is_none()`.
          22  +
    pub fn invalid_parameters(&self) -> &[::std::string::String] {
          23  +
        self.invalid_parameters.as_deref().unwrap_or_default()
          24  +
    }
          25  +
}
          26  +
static GETPARAMETERSOUTPUT_MEMBER_PARAMETERS_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          27  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#ParameterList$member", "com.amazonaws.ssm", "ParameterList"),
          28  +
    ::aws_smithy_schema::ShapeType::Structure,
          29  +
    "member",
          30  +
    0,
          31  +
);
          32  +
static GETPARAMETERSOUTPUT_MEMBER_PARAMETERS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          33  +
    ::aws_smithy_schema::ShapeId::from_parts(
          34  +
        "com.amazonaws.ssm.synthetic#GetParametersOutput$Parameters",
          35  +
        "com.amazonaws.ssm.synthetic",
          36  +
        "GetParametersOutput",
          37  +
    ),
          38  +
    ::aws_smithy_schema::ShapeType::List,
          39  +
    "Parameters",
          40  +
    0,
          41  +
)
          42  +
.with_list_member(&GETPARAMETERSOUTPUT_MEMBER_PARAMETERS_MEMBER);
          43  +
static GETPARAMETERSOUTPUT_MEMBER_INVALID_PARAMETERS_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          44  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#ParameterNameList$member", "com.amazonaws.ssm", "ParameterNameList"),
          45  +
    ::aws_smithy_schema::ShapeType::String,
          46  +
    "member",
          47  +
    0,
          48  +
);
          49  +
static GETPARAMETERSOUTPUT_MEMBER_INVALID_PARAMETERS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          50  +
    ::aws_smithy_schema::ShapeId::from_parts(
          51  +
        "com.amazonaws.ssm.synthetic#GetParametersOutput$InvalidParameters",
          52  +
        "com.amazonaws.ssm.synthetic",
          53  +
        "GetParametersOutput",
          54  +
    ),
          55  +
    ::aws_smithy_schema::ShapeType::List,
          56  +
    "InvalidParameters",
          57  +
    1,
          58  +
)
          59  +
.with_list_member(&GETPARAMETERSOUTPUT_MEMBER_INVALID_PARAMETERS_MEMBER);
          60  +
static GETPARAMETERSOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          61  +
    ::aws_smithy_schema::ShapeId::from_parts("synthetic#request_id", "synthetic", "request_id"),
          62  +
    ::aws_smithy_schema::ShapeType::String,
          63  +
    "request_id",
          64  +
    2,
          65  +
)
          66  +
.with_http_header("x-amzn-requestid");
          67  +
static GETPARAMETERSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
          68  +
    ::aws_smithy_schema::ShapeId::from_parts(
          69  +
        "com.amazonaws.ssm.synthetic#GetParametersOutput",
          70  +
        "com.amazonaws.ssm.synthetic",
          71  +
        "GetParametersOutput",
          72  +
    ),
          73  +
    ::aws_smithy_schema::ShapeType::Structure,
          74  +
    &[
          75  +
        &GETPARAMETERSOUTPUT_MEMBER_PARAMETERS,
          76  +
        &GETPARAMETERSOUTPUT_MEMBER_INVALID_PARAMETERS,
          77  +
        &GETPARAMETERSOUTPUT_MEMBER__REQUEST_ID,
          78  +
    ],
          79  +
)
          80  +
.with_original_name("GetParametersResult");
          81  +
impl GetParametersOutput {
          82  +
    /// The schema for this shape.
          83  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &GETPARAMETERSOUTPUT_SCHEMA;
          84  +
}
          85  +
impl ::aws_smithy_schema::serde::SerializableStruct for GetParametersOutput {
          86  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
          87  +
    fn serialize_members(
          88  +
        &self,
          89  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
          90  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
          91  +
        if let Some(ref val) = self.parameters {
          92  +
            ser.write_list(
          93  +
                &GETPARAMETERSOUTPUT_MEMBER_PARAMETERS,
          94  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
          95  +
                    for item in val {
          96  +
                        ser.write_struct(crate::types::Parameter::SCHEMA, item)?;
          97  +
                    }
          98  +
                    Ok(())
          99  +
                },
         100  +
            )?;
         101  +
        }
         102  +
        if let Some(ref val) = self.invalid_parameters {
         103  +
            ser.write_list(
         104  +
                &GETPARAMETERSOUTPUT_MEMBER_INVALID_PARAMETERS,
         105  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         106  +
                    for item in val {
         107  +
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
         108  +
                    }
         109  +
                    Ok(())
         110  +
                },
         111  +
            )?;
         112  +
        }
         113  +
        Ok(())
         114  +
    }
         115  +
}
         116  +
impl GetParametersOutput {
         117  +
    /// Deserializes this structure from a [`ShapeDeserializer`].
         118  +
    pub fn deserialize(
         119  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         120  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         121  +
        #[allow(unused_variables, unused_mut)]
         122  +
        let mut builder = Self::builder();
         123  +
        #[allow(
         124  +
            unused_variables,
         125  +
            unreachable_code,
         126  +
            clippy::single_match,
         127  +
            clippy::match_single_binding,
         128  +
            clippy::diverging_sub_expression
         129  +
        )]
         130  +
        deserializer.read_struct(&GETPARAMETERSOUTPUT_SCHEMA, &mut |member, deser| {
         131  +
            match member.member_index() {
         132  +
                Some(0) => {
         133  +
                    if deser.is_null() {
         134  +
                        deser.read_null()?;
         135  +
                    } else {
         136  +
                        builder.parameters = Some({
         137  +
                            let mut container = Vec::new();
         138  +
                            deser.read_list(member, &mut |deser| {
         139  +
                                container.push(crate::types::Parameter::deserialize(deser)?);
         140  +
                                Ok(())
         141  +
                            })?;
         142  +
                            container
         143  +
                        });
         144  +
                    }
         145  +
                }
         146  +
                Some(1) => {
         147  +
                    if deser.is_null() {
         148  +
                        deser.read_null()?;
         149  +
                    } else {
         150  +
                        builder.invalid_parameters = Some(deser.read_string_list(member)?);
         151  +
                    }
         152  +
                }
         153  +
                Some(2) => {
         154  +
                    builder._request_id = Some(deser.read_string(member)?);
         155  +
                }
         156  +
                _ => {}
         157  +
            }
         158  +
            Ok(())
         159  +
        })?;
         160  +
        Ok(builder.build())
         161  +
    }
         162  +
}
         163  +
impl GetParametersOutput {
         164  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         165  +
    /// Header-bound members are read directly from headers, avoiding runtime
         166  +
    /// member iteration overhead. Body members are read via the deserializer.
         167  +
    pub fn deserialize_with_response(
         168  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         169  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         170  +
        _status: u16,
         171  +
        _body: &[u8],
         172  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         173  +
        #[allow(unused_variables, unused_mut)]
         174  +
        let mut builder = Self::builder();
         175  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         176  +
            builder._request_id = Some(val.to_string());
         177  +
        }
         178  +
         179  +
        #[allow(
         180  +
            unused_variables,
         181  +
            unreachable_code,
         182  +
            clippy::single_match,
         183  +
            clippy::match_single_binding,
         184  +
            clippy::diverging_sub_expression
         185  +
        )]
         186  +
        deserializer.read_struct(&GETPARAMETERSOUTPUT_SCHEMA, &mut |member, deser| {
         187  +
            match member.member_index() {
         188  +
                Some(0) => {
         189  +
                    builder.parameters = Some({
         190  +
                        let mut container = Vec::new();
         191  +
                        deser.read_list(member, &mut |deser| {
         192  +
                            container.push(crate::types::Parameter::deserialize(deser)?);
         193  +
                            Ok(())
         194  +
                        })?;
         195  +
                        container
         196  +
                    });
         197  +
                }
         198  +
                Some(1) => {
         199  +
                    builder.invalid_parameters = Some(deser.read_string_list(member)?);
         200  +
                }
         201  +
                _ => {}
         202  +
            }
         203  +
            Ok(())
         204  +
        })?;
         205  +
        Ok(builder.build())
         206  +
    }
         207  +
}
         208  +
impl ::aws_types::request_id::RequestId for GetParametersOutput {
         209  +
    fn request_id(&self) -> Option<&str> {
         210  +
        self._request_id.as_deref()
         211  +
    }
         212  +
}
         213  +
impl GetParametersOutput {
         214  +
    pub(crate) fn _set_request_id(&mut self, request_id: Option<String>) -> &mut Self {
         215  +
        self._request_id = request_id;
         216  +
        self
         217  +
    }
         218  +
}
         219  +
impl GetParametersOutput {
         220  +
    /// Creates a new builder-style object to manufacture [`GetParametersOutput`](crate::operation::get_parameters::GetParametersOutput).
         221  +
    pub fn builder() -> crate::operation::get_parameters::builders::GetParametersOutputBuilder {
         222  +
        crate::operation::get_parameters::builders::GetParametersOutputBuilder::default()
         223  +
    }
         224  +
}
         225  +
         226  +
/// A builder for [`GetParametersOutput`](crate::operation::get_parameters::GetParametersOutput).
         227  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
         228  +
#[non_exhaustive]
         229  +
pub struct GetParametersOutputBuilder {
         230  +
    pub(crate) parameters: ::std::option::Option<::std::vec::Vec<crate::types::Parameter>>,
         231  +
    pub(crate) invalid_parameters: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
         232  +
    _request_id: Option<String>,
         233  +
}
         234  +
impl GetParametersOutputBuilder {
         235  +
    /// Appends an item to `parameters`.
         236  +
    ///
         237  +
    /// To override the contents of this collection use [`set_parameters`](Self::set_parameters).
         238  +
    ///
         239  +
    /// <p>A list of details for a parameter.</p>
         240  +
    pub fn parameters(mut self, input: crate::types::Parameter) -> Self {
         241  +
        let mut v = self.parameters.unwrap_or_default();
         242  +
        v.push(input);
         243  +
        self.parameters = ::std::option::Option::Some(v);
         244  +
        self
         245  +
    }
         246  +
    /// <p>A list of details for a parameter.</p>
         247  +
    pub fn set_parameters(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::Parameter>>) -> Self {
         248  +
        self.parameters = input;
         249  +
        self
         250  +
    }
         251  +
    /// <p>A list of details for a parameter.</p>
         252  +
    pub fn get_parameters(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::Parameter>> {
         253  +
        &self.parameters
         254  +
    }
         255  +
    /// Appends an item to `invalid_parameters`.
         256  +
    ///
         257  +
    /// To override the contents of this collection use [`set_invalid_parameters`](Self::set_invalid_parameters).
         258  +
    ///
         259  +
    /// <p>A list of parameters that aren't formatted correctly or don't run during an execution.</p>
         260  +
    pub fn invalid_parameters(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         261  +
        let mut v = self.invalid_parameters.unwrap_or_default();
         262  +
        v.push(input.into());
         263  +
        self.invalid_parameters = ::std::option::Option::Some(v);
         264  +
        self
         265  +
    }
         266  +
    /// <p>A list of parameters that aren't formatted correctly or don't run during an execution.</p>
         267  +
    pub fn set_invalid_parameters(mut self, input: ::std::option::Option<::std::vec::Vec<::std::string::String>>) -> Self {
         268  +
        self.invalid_parameters = input;
         269  +
        self
         270  +
    }
         271  +
    /// <p>A list of parameters that aren't formatted correctly or don't run during an execution.</p>
         272  +
    pub fn get_invalid_parameters(&self) -> &::std::option::Option<::std::vec::Vec<::std::string::String>> {
         273  +
        &self.invalid_parameters
         274  +
    }
         275  +
    pub(crate) fn _request_id(mut self, request_id: impl Into<String>) -> Self {
         276  +
        self._request_id = Some(request_id.into());
         277  +
        self
         278  +
    }
         279  +
         280  +
    pub(crate) fn _set_request_id(&mut self, request_id: Option<String>) -> &mut Self {
         281  +
        self._request_id = request_id;
         282  +
        self
         283  +
    }
         284  +
    /// Consumes the builder and constructs a [`GetParametersOutput`](crate::operation::get_parameters::GetParametersOutput).
         285  +
    pub fn build(self) -> crate::operation::get_parameters::GetParametersOutput {
         286  +
        crate::operation::get_parameters::GetParametersOutput {
         287  +
            parameters: self.parameters,
         288  +
            invalid_parameters: self.invalid_parameters,
         289  +
            _request_id: self._request_id,
         290  +
        }
         291  +
    }
         292  +
}

tmp-codegen-diff/aws-sdk/sdk/ssm/src/operation/get_parameters/builders.rs

@@ -0,1 +0,162 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
pub use crate::operation::get_parameters::_get_parameters_input::GetParametersInputBuilder;
           3  +
           4  +
pub use crate::operation::get_parameters::_get_parameters_output::GetParametersOutputBuilder;
           5  +
           6  +
impl crate::operation::get_parameters::builders::GetParametersInputBuilder {
           7  +
    /// Sends a request with this input using the given client.
           8  +
    pub async fn send_with(
           9  +
        self,
          10  +
        client: &crate::Client,
          11  +
    ) -> ::std::result::Result<
          12  +
        crate::operation::get_parameters::GetParametersOutput,
          13  +
        ::aws_smithy_runtime_api::client::result::SdkError<
          14  +
            crate::operation::get_parameters::GetParametersError,
          15  +
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
          16  +
        >,
          17  +
    > {
          18  +
        let mut fluent_builder = client.get_parameters();
          19  +
        fluent_builder.inner = self;
          20  +
        fluent_builder.send().await
          21  +
    }
          22  +
}
          23  +
/// Fluent builder constructing a request to `GetParameters`.
          24  +
///
          25  +
/// <p>Get information about one or more parameters by specifying multiple parameter names.</p><note>
          26  +
/// <p>To get information about a single parameter, you can use the <code>GetParameter</code> operation instead.</p>
          27  +
/// </note>
          28  +
/// <p>Parameter names can't contain spaces. The service removes any spaces specified for the beginning or end of a parameter name. If the specified name for a parameter contains spaces between characters, the request fails with a <code>ValidationException</code> error.</p><note>
          29  +
/// <p>Parameter Store throughput defines the number of API transactions per second (TPS) that Systems Manager can process. This applies to <code>GetParameter</code>, <code>GetParameters</code>, and <code>PutParameter</code> API calls for your Amazon Web Services account and Amazon Web Services Region. By default, Parameter Store is configured with a standard throughput quota suitable for low- to moderate-volume workloads. Applications that retrieve configuration data infrequently or operate at smaller scale can use this default setting without additional cost.</p>
          30  +
/// <p>For higher-volume workloads, you can enable higher throughput. This increases the maximum number of supported transactions per second for your account and Region. Increased throughput supports applications and workloads that need concurrent access to multiple parameters. If you experience <code>ThrottlingException: Rate exceeded</code> errors, enable higher throughput. For more information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-store-throughput.html">Changing Parameter Store throughput</a>.</p>
          31  +
/// </note>
          32  +
#[derive(::std::clone::Clone, ::std::fmt::Debug)]
          33  +
pub struct GetParametersFluentBuilder {
          34  +
    handle: ::std::sync::Arc<crate::client::Handle>,
          35  +
    inner: crate::operation::get_parameters::builders::GetParametersInputBuilder,
          36  +
    config_override: ::std::option::Option<crate::config::Builder>,
          37  +
}
          38  +
impl
          39  +
    crate::client::customize::internal::CustomizableSend<
          40  +
        crate::operation::get_parameters::GetParametersOutput,
          41  +
        crate::operation::get_parameters::GetParametersError,
          42  +
    > for GetParametersFluentBuilder
          43  +
{
          44  +
    fn send(
          45  +
        self,
          46  +
        config_override: crate::config::Builder,
          47  +
    ) -> crate::client::customize::internal::BoxFuture<
          48  +
        crate::client::customize::internal::SendResult<
          49  +
            crate::operation::get_parameters::GetParametersOutput,
          50  +
            crate::operation::get_parameters::GetParametersError,
          51  +
        >,
          52  +
    > {
          53  +
        ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
          54  +
    }
          55  +
}
          56  +
impl GetParametersFluentBuilder {
          57  +
    /// Creates a new `GetParametersFluentBuilder`.
          58  +
    pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {
          59  +
        Self {
          60  +
            handle,
          61  +
            inner: ::std::default::Default::default(),
          62  +
            config_override: ::std::option::Option::None,
          63  +
        }
          64  +
    }
          65  +
    /// Access the GetParameters as a reference.
          66  +
    pub fn as_input(&self) -> &crate::operation::get_parameters::builders::GetParametersInputBuilder {
          67  +
        &self.inner
          68  +
    }
          69  +
    /// Sends the request and returns the response.
          70  +
    ///
          71  +
    /// If an error occurs, an `SdkError` will be returned with additional details that
          72  +
    /// can be matched against.
          73  +
    ///
          74  +
    /// By default, any retryable failures will be retried twice. Retry behavior
          75  +
    /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
          76  +
    /// set when configuring the client.
          77  +
    pub async fn send(
          78  +
        self,
          79  +
    ) -> ::std::result::Result<
          80  +
        crate::operation::get_parameters::GetParametersOutput,
          81  +
        ::aws_smithy_runtime_api::client::result::SdkError<
          82  +
            crate::operation::get_parameters::GetParametersError,
          83  +
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
          84  +
        >,
          85  +
    > {
          86  +
        let input = self
          87  +
            .inner
          88  +
            .build()
          89  +
            .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
          90  +
        let runtime_plugins = crate::operation::get_parameters::GetParameters::operation_runtime_plugins(
          91  +
            self.handle.runtime_plugins.clone(),
          92  +
            &self.handle.conf,
          93  +
            self.config_override,
          94  +
        );
          95  +
        crate::operation::get_parameters::GetParameters::orchestrate(&runtime_plugins, input).await
          96  +
    }
          97  +
          98  +
    /// Consumes this builder, creating a customizable operation that can be modified before being sent.
          99  +
    pub fn customize(
         100  +
        self,
         101  +
    ) -> crate::client::customize::CustomizableOperation<
         102  +
        crate::operation::get_parameters::GetParametersOutput,
         103  +
        crate::operation::get_parameters::GetParametersError,
         104  +
        Self,
         105  +
    > {
         106  +
        crate::client::customize::CustomizableOperation::new(self)
         107  +
    }
         108  +
    pub(crate) fn config_override(mut self, config_override: impl ::std::convert::Into<crate::config::Builder>) -> Self {
         109  +
        self.set_config_override(::std::option::Option::Some(config_override.into()));
         110  +
        self
         111  +
    }
         112  +
         113  +
    pub(crate) fn set_config_override(&mut self, config_override: ::std::option::Option<crate::config::Builder>) -> &mut Self {
         114  +
        self.config_override = config_override;
         115  +
        self
         116  +
    }
         117  +
    ///
         118  +
    /// Appends an item to `Names`.
         119  +
    ///
         120  +
    /// To override the contents of this collection use [`set_names`](Self::set_names).
         121  +
    ///
         122  +
    /// <p>The names or Amazon Resource Names (ARNs) of the parameters that you want to query. For parameters shared with you from another account, you must use the full ARNs.</p>
         123  +
    /// <p>To query by parameter label, use <code>"Name": "name:label"</code>. To query by parameter version, use <code>"Name": "name:version"</code>.</p><note>
         124  +
    /// <p>The results for <code>GetParameters</code> requests are listed in alphabetical order in query responses.</p>
         125  +
    /// </note>
         126  +
    /// <p>For information about shared parameters, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-store-shared-parameters.html">Working with shared parameters</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
         127  +
    pub fn names(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         128  +
        self.inner = self.inner.names(input.into());
         129  +
        self
         130  +
    }
         131  +
    /// <p>The names or Amazon Resource Names (ARNs) of the parameters that you want to query. For parameters shared with you from another account, you must use the full ARNs.</p>
         132  +
    /// <p>To query by parameter label, use <code>"Name": "name:label"</code>. To query by parameter version, use <code>"Name": "name:version"</code>.</p><note>
         133  +
    /// <p>The results for <code>GetParameters</code> requests are listed in alphabetical order in query responses.</p>
         134  +
    /// </note>
         135  +
    /// <p>For information about shared parameters, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-store-shared-parameters.html">Working with shared parameters</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
         136  +
    pub fn set_names(mut self, input: ::std::option::Option<::std::vec::Vec<::std::string::String>>) -> Self {
         137  +
        self.inner = self.inner.set_names(input);
         138  +
        self
         139  +
    }
         140  +
    /// <p>The names or Amazon Resource Names (ARNs) of the parameters that you want to query. For parameters shared with you from another account, you must use the full ARNs.</p>
         141  +
    /// <p>To query by parameter label, use <code>"Name": "name:label"</code>. To query by parameter version, use <code>"Name": "name:version"</code>.</p><note>
         142  +
    /// <p>The results for <code>GetParameters</code> requests are listed in alphabetical order in query responses.</p>
         143  +
    /// </note>
         144  +
    /// <p>For information about shared parameters, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-store-shared-parameters.html">Working with shared parameters</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
         145  +
    pub fn get_names(&self) -> &::std::option::Option<::std::vec::Vec<::std::string::String>> {
         146  +
        self.inner.get_names()
         147  +
    }
         148  +
    /// <p>Return decrypted secure string value. Return decrypted values for secure string parameters. This flag is ignored for <code>String</code> and <code>StringList</code> parameter types.</p>
         149  +
    pub fn with_decryption(mut self, input: bool) -> Self {
         150  +
        self.inner = self.inner.with_decryption(input);
         151  +
        self
         152  +
    }
         153  +
    /// <p>Return decrypted secure string value. Return decrypted values for secure string parameters. This flag is ignored for <code>String</code> and <code>StringList</code> parameter types.</p>
         154  +
    pub fn set_with_decryption(mut self, input: ::std::option::Option<bool>) -> Self {
         155  +
        self.inner = self.inner.set_with_decryption(input);
         156  +
        self
         157  +
    }
         158  +
    /// <p>Return decrypted secure string value. Return decrypted values for secure string parameters. This flag is ignored for <code>String</code> and <code>StringList</code> parameter types.</p>
         159  +
    pub fn get_with_decryption(&self) -> &::std::option::Option<bool> {
         160  +
        self.inner.get_with_decryption()
         161  +
    }
         162  +
}

tmp-codegen-diff/aws-sdk/sdk/ssm/src/operation/get_parameters_by_path.rs

@@ -0,1 +0,730 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/// Orchestration and serialization glue logic for `GetParametersByPath`.
           3  +
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
           4  +
#[non_exhaustive]
           5  +
pub struct GetParametersByPath;
           6  +
impl GetParametersByPath {
           7  +
    /// Creates a new `GetParametersByPath`
           8  +
    pub fn new() -> Self {
           9  +
        Self
          10  +
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema<'static> =
          13  +
        crate::operation::get_parameters_by_path::GetParametersByPathInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema<'static> =
          16  +
        crate::operation::get_parameters_by_path::GetParametersByPathOutput::SCHEMA;
          17  +
    pub(crate) async fn orchestrate(
          18  +
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
          19  +
        input: crate::operation::get_parameters_by_path::GetParametersByPathInput,
          20  +
    ) -> ::std::result::Result<
          21  +
        crate::operation::get_parameters_by_path::GetParametersByPathOutput,
          22  +
        ::aws_smithy_runtime_api::client::result::SdkError<
          23  +
            crate::operation::get_parameters_by_path::GetParametersByPathError,
          24  +
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
          25  +
        >,
          26  +
    > {
          27  +
        let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
          28  +
            ::aws_smithy_runtime_api::client::interceptors::context::Error,
          29  +
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
          30  +
        >| {
          31  +
            err.map_service_error(|err| {
          32  +
                err.downcast::<crate::operation::get_parameters_by_path::GetParametersByPathError>()
          33  +
                    .expect("correct error type")
          34  +
            })
          35  +
        };
          36  +
        let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
          37  +
            .await
          38  +
            .map_err(map_err)?;
          39  +
        let output = context.finalize().map_err(map_err)?;
          40  +
        ::std::result::Result::Ok(
          41  +
            output
          42  +
                .downcast::<crate::operation::get_parameters_by_path::GetParametersByPathOutput>()
          43  +
                .expect("correct output type"),
          44  +
        )
          45  +
    }
          46  +
          47  +
    pub(crate) async fn orchestrate_with_stop_point(
          48  +
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
          49  +
        input: crate::operation::get_parameters_by_path::GetParametersByPathInput,
          50  +
        stop_point: ::aws_smithy_runtime::client::orchestrator::StopPoint,
          51  +
    ) -> ::std::result::Result<
          52  +
        ::aws_smithy_runtime_api::client::interceptors::context::InterceptorContext,
          53  +
        ::aws_smithy_runtime_api::client::result::SdkError<
          54  +
            ::aws_smithy_runtime_api::client::interceptors::context::Error,
          55  +
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
          56  +
        >,
          57  +
    > {
          58  +
        let input = ::aws_smithy_runtime_api::client::interceptors::context::Input::erase(input);
          59  +
        use ::tracing::Instrument;
          60  +
        ::aws_smithy_runtime::client::orchestrator::invoke_with_stop_point("SSM", "GetParametersByPath", input, runtime_plugins, stop_point)
          61  +
            // Create a parent span for the entire operation. Includes a random, internal-only,
          62  +
            // seven-digit ID for the operation orchestration so that it can be correlated in the logs.
          63  +
            .instrument(::tracing::debug_span!(
          64  +
                "SSM.GetParametersByPath",
          65  +
                "rpc.service" = "SSM",
          66  +
                "rpc.method" = "GetParametersByPath",
          67  +
                "sdk_invocation_id" = ::fastrand::u32(1_000_000..10_000_000),
          68  +
                "rpc.system" = "aws-api",
          69  +
            ))
          70  +
            .await
          71  +
    }
          72  +
          73  +
    pub(crate) fn operation_runtime_plugins(
          74  +
        client_runtime_plugins: ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
          75  +
        client_config: &crate::config::Config,
          76  +
        config_override: ::std::option::Option<crate::config::Builder>,
          77  +
    ) -> ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins {
          78  +
        let mut runtime_plugins = client_runtime_plugins.with_operation_plugin(Self::new());
          79  +
          80  +
        if let ::std::option::Option::Some(config_override) = config_override {
          81  +
            for plugin in config_override.runtime_plugins.iter().cloned() {
          82  +
                runtime_plugins = runtime_plugins.with_operation_plugin(plugin);
          83  +
            }
          84  +
            runtime_plugins = runtime_plugins.with_operation_plugin(crate::config::ConfigOverrideRuntimePlugin::new(
          85  +
                config_override,
          86  +
                client_config.config.clone(),
          87  +
                &client_config.runtime_components,
          88  +
            ));
          89  +
        }
          90  +
        runtime_plugins
          91  +
    }
          92  +
}
          93  +
/// Per-operation error registry. Contains an entry for every modeled
          94  +
/// error this operation can throw.
          95  +
///
          96  +
/// Used by the schema-serde error path as the operation-scoped lookup
          97  +
/// for registry-backed error reification: an error code that does not
          98  +
/// match one of the operation's modeled errors directly is resolved
          99  +
/// against this registry first, then widened to the service-wide error
         100  +
/// registry.
         101  +
pub(crate) mod error_registry {
         102  +
    pub(crate) static REGISTRY: ::std::sync::LazyLock<::aws_smithy_schema::registry::TypeRegistry> = ::std::sync::LazyLock::new(|| {
         103  +
        ::aws_smithy_schema::registry::TypeRegistry::builder()
         104  +
                            .insert_error_shape(
         105  +
                        crate::types::error::InternalServerError::SCHEMA,
         106  +
                        |d: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer| -> ::std::result::Result<::aws_smithy_types::type_erasure::TypeErasedBox, ::aws_smithy_schema::serde::SerdeError> {
         107  +
                            ::std::result::Result::Ok(::aws_smithy_types::type_erasure::TypeErasedBox::new(crate::types::error::InternalServerError::deserialize(d)?))
         108  +
                        },
         109  +
                        |d: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer| -> ::std::result::Result<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync>, ::aws_smithy_schema::serde::SerdeError> {
         110  +
                            ::std::result::Result::Ok(::std::boxed::Box::new(crate::types::error::InternalServerError::deserialize(d)?))
         111  +
                        },
         112  +
                    )
         113  +
.insert_error_shape(
         114  +
                        crate::types::error::InvalidFilterKey::SCHEMA,
         115  +
                        |d: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer| -> ::std::result::Result<::aws_smithy_types::type_erasure::TypeErasedBox, ::aws_smithy_schema::serde::SerdeError> {
         116  +
                            ::std::result::Result::Ok(::aws_smithy_types::type_erasure::TypeErasedBox::new(crate::types::error::InvalidFilterKey::deserialize(d)?))
         117  +
                        },
         118  +
                        |d: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer| -> ::std::result::Result<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync>, ::aws_smithy_schema::serde::SerdeError> {
         119  +
                            ::std::result::Result::Ok(::std::boxed::Box::new(crate::types::error::InvalidFilterKey::deserialize(d)?))
         120  +
                        },
         121  +
                    )
         122  +
.insert_error_shape(
         123  +
                        crate::types::error::InvalidFilterOption::SCHEMA,
         124  +
                        |d: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer| -> ::std::result::Result<::aws_smithy_types::type_erasure::TypeErasedBox, ::aws_smithy_schema::serde::SerdeError> {
         125  +
                            ::std::result::Result::Ok(::aws_smithy_types::type_erasure::TypeErasedBox::new(crate::types::error::InvalidFilterOption::deserialize(d)?))
         126  +
                        },
         127  +
                        |d: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer| -> ::std::result::Result<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync>, ::aws_smithy_schema::serde::SerdeError> {
         128  +
                            ::std::result::Result::Ok(::std::boxed::Box::new(crate::types::error::InvalidFilterOption::deserialize(d)?))
         129  +
                        },
         130  +
                    )
         131  +
.insert_error_shape(
         132  +
                        crate::types::error::InvalidFilterValue::SCHEMA,
         133  +
                        |d: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer| -> ::std::result::Result<::aws_smithy_types::type_erasure::TypeErasedBox, ::aws_smithy_schema::serde::SerdeError> {
         134  +
                            ::std::result::Result::Ok(::aws_smithy_types::type_erasure::TypeErasedBox::new(crate::types::error::InvalidFilterValue::deserialize(d)?))
         135  +
                        },
         136  +
                        |d: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer| -> ::std::result::Result<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync>, ::aws_smithy_schema::serde::SerdeError> {
         137  +
                            ::std::result::Result::Ok(::std::boxed::Box::new(crate::types::error::InvalidFilterValue::deserialize(d)?))
         138  +
                        },
         139  +
                    )
         140  +
.insert_error_shape(
         141  +
                        crate::types::error::InvalidKeyId::SCHEMA,
         142  +
                        |d: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer| -> ::std::result::Result<::aws_smithy_types::type_erasure::TypeErasedBox, ::aws_smithy_schema::serde::SerdeError> {
         143  +
                            ::std::result::Result::Ok(::aws_smithy_types::type_erasure::TypeErasedBox::new(crate::types::error::InvalidKeyId::deserialize(d)?))
         144  +
                        },
         145  +
                        |d: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer| -> ::std::result::Result<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync>, ::aws_smithy_schema::serde::SerdeError> {
         146  +
                            ::std::result::Result::Ok(::std::boxed::Box::new(crate::types::error::InvalidKeyId::deserialize(d)?))
         147  +
                        },
         148  +
                    )
         149  +
.insert_error_shape(
         150  +
                        crate::types::error::InvalidNextToken::SCHEMA,
         151  +
                        |d: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer| -> ::std::result::Result<::aws_smithy_types::type_erasure::TypeErasedBox, ::aws_smithy_schema::serde::SerdeError> {
         152  +
                            ::std::result::Result::Ok(::aws_smithy_types::type_erasure::TypeErasedBox::new(crate::types::error::InvalidNextToken::deserialize(d)?))
         153  +
                        },
         154  +
                        |d: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer| -> ::std::result::Result<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync>, ::aws_smithy_schema::serde::SerdeError> {
         155  +
                            ::std::result::Result::Ok(::std::boxed::Box::new(crate::types::error::InvalidNextToken::deserialize(d)?))
         156  +
                        },
         157  +
                    )
         158  +
                            .build()
         159  +
    });
         160  +
}
         161  +
impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for GetParametersByPath {
         162  +
    fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
         163  +
        let mut cfg = ::aws_smithy_types::config_bag::Layer::new("GetParametersByPath");
         164  +
         165  +
        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedRequestSerializer::new(
         166  +
            GetParametersByPathRequestSerializer,
         167  +
        ));
         168  +
        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(
         169  +
            GetParametersByPathResponseDeserializer,
         170  +
        ));
         171  +
         172  +
        cfg.store_put(::aws_smithy_runtime_api::client::auth::AuthSchemeOptionResolverParams::new(
         173  +
            crate::config::auth::Params::builder()
         174  +
                .operation_name("GetParametersByPath")
         175  +
                .build()
         176  +
                .expect("required fields set"),
         177  +
        ));
         178  +
         179  +
        cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::SensitiveOutput);
         180  +
        cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
         181  +
            "GetParametersByPath",
         182  +
            "SSM",
         183  +
        ));
         184  +
        let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
         185  +
        signing_options.double_uri_encode = true;
         186  +
        signing_options.content_sha256_header = false;
         187  +
        signing_options.normalize_uri_path = true;
         188  +
        signing_options.payload_override = None;
         189  +
         190  +
        cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
         191  +
            signing_options,
         192  +
            ..::std::default::Default::default()
         193  +
        });
         194  +
         195  +
        ::std::option::Option::Some(cfg.freeze())
         196  +
    }
         197  +
         198  +
    fn runtime_components(
         199  +
        &self,
         200  +
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
         201  +
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         202  +
        #[allow(unused_mut)]
         203  +
        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("GetParametersByPath")
         204  +
            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
         205  +
                GetParametersByPathTelemetryInputCaptureInterceptor,
         206  +
            ))
         207  +
            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
         208  +
                ::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default(),
         209  +
            ))
         210  +
            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
         211  +
                GetParametersByPathEndpointParamsInterceptor,
         212  +
            ))
         213  +
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
         214  +
                crate::operation::get_parameters_by_path::GetParametersByPathError,
         215  +
            >::new())
         216  +
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
         217  +
                crate::operation::get_parameters_by_path::GetParametersByPathError,
         218  +
            >::new())
         219  +
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
         220  +
                crate::operation::get_parameters_by_path::GetParametersByPathError,
         221  +
            >::new())
         222  +
            .with_retry_classifier(::aws_runtime::service_clock_skew::ServiceClockSkewClassifier::<
         223  +
                crate::operation::get_parameters_by_path::GetParametersByPathError,
         224  +
            >::new());
         225  +
         226  +
        ::std::borrow::Cow::Owned(rcb)
         227  +
    }
         228  +
}
         229  +
         230  +
#[derive(Debug)]
         231  +
struct GetParametersByPathTelemetryInputCaptureInterceptor;
         232  +
         233  +
#[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
         234  +
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetParametersByPathTelemetryInputCaptureInterceptor {
         235  +
    fn name(&self) -> &'static str {
         236  +
        "GetParametersByPathTelemetryInputCaptureInterceptor"
         237  +
    }
         238  +
         239  +
    fn read_before_execution(
         240  +
        &self,
         241  +
        context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
         242  +
            '_,
         243  +
            ::aws_smithy_runtime_api::client::interceptors::context::Input,
         244  +
            ::aws_smithy_runtime_api::client::interceptors::context::Output,
         245  +
            ::aws_smithy_runtime_api::client::interceptors::context::Error,
         246  +
        >,
         247  +
        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
         248  +
    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         249  +
        // Nothing to do unless the customer opted in by naming members to record.
         250  +
        let ::std::option::Option::Some(requested) = cfg
         251  +
            .load::<::aws_smithy_types::telemetry::RequestedTelemetryAttributes>()
         252  +
            .filter(|r| !r.is_empty())
         253  +
        else {
         254  +
            return ::std::result::Result::Ok(());
         255  +
        };
         256  +
         257  +
        let ::std::option::Option::Some(input) = context.input().downcast_ref::<GetParametersByPathInput>() else {
         258  +
            // A mismatched input is not this interceptor's concern; skip quietly.
         259  +
            return ::std::result::Result::Ok(());
         260  +
        };
         261  +
         262  +
        let mut captured = ::aws_smithy_types::telemetry::CapturedTelemetryAttributes::default();
         263  +
        if requested.should_capture("Path") {
         264  +
            if let ::std::option::Option::Some(value) = input.path.as_deref() {
         265  +
                captured.insert("Path", value);
         266  +
            }
         267  +
        }
         268  +
        if requested.should_capture("NextToken") {
         269  +
            if let ::std::option::Option::Some(value) = input.next_token.as_deref() {
         270  +
                captured.insert("NextToken", value);
         271  +
            }
         272  +
        }
         273  +
         274  +
        cfg.interceptor_state().store_put(captured);
         275  +
        ::std::result::Result::Ok(())
         276  +
    }
         277  +
}
         278  +
#[derive(Debug)]
         279  +
struct GetParametersByPathResponseDeserializer;
         280  +
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetParametersByPathResponseDeserializer {
         281  +
    fn deserialize_nonstreaming_with_config(
         282  +
        &self,
         283  +
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         284  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
         285  +
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         286  +
        let (success, status) = (response.status().is_success(), response.status().as_u16());
         287  +
        // Load body and headers BEFORE BeforeParseResponse so customizations
         288  +
        // (e.g., S3's `body_is_error` check that detects errors returned with
         289  +
        // HTTP 200) can inspect them. The legacy non-streaming path also
         290  +
        // loads `body` before firing this hook.
         291  +
        let body = response.body().bytes().expect("body loaded");
         292  +
        let headers = response.headers();
         293  +
        #[allow(unused_mut)]
         294  +
        let mut force_error = false;
         295  +
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         296  +
        if !success && status != 200 || force_error {
         297  +
            let protocol = _cfg
         298  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         299  +
                .expect("a SharedClientProtocol is required");
         300  +
            #[allow(unused_mut)]
         301  +
            let mut generic_builder = protocol.parse_error_metadata(response, _cfg).map_err(|e| {
         302  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         303  +
            })?;
         304  +
            generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
         305  +
            let generic = generic_builder.build();
         306  +
            let error_code = match generic.code() {
         307  +
                ::std::option::Option::Some(code) => code,
         308  +
                ::std::option::Option::None => {
         309  +
                    return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         310  +
                        ::aws_smithy_runtime_api::box_error::BoxError::from(
         311  +
                            crate::operation::get_parameters_by_path::GetParametersByPathError::unhandled(generic),
         312  +
                        ),
         313  +
                    ))
         314  +
                }
         315  +
            };
         316  +
            let _error_message = generic.message().map(|msg| msg.to_owned());
         317  +
            let err = match error_code {
         318  +
                "InternalServerError" => crate::operation::get_parameters_by_path::GetParametersByPathError::InternalServerError({
         319  +
                    let mut tmp = match protocol.deserialize_error_response(response, _cfg).and_then(|mut deser| {
         320  +
                        crate::types::error::InternalServerError::deserialize_with_response(
         321  +
                            &mut *deser,
         322  +
                            response.headers(),
         323  +
                            response.status().into(),
         324  +
                            body,
         325  +
                        )
         326  +
                    }) {
         327  +
                        ::std::result::Result::Ok(val) => val,
         328  +
                        ::std::result::Result::Err(e) => {
         329  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         330  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         331  +
                            ))
         332  +
                        }
         333  +
                    };
         334  +
                    tmp.meta = generic;
         335  +
                    if tmp.message.is_none() {
         336  +
                        tmp.message = _error_message;
         337  +
                    }
         338  +
                    tmp
         339  +
                }),
         340  +
                "InvalidFilterKey" => crate::operation::get_parameters_by_path::GetParametersByPathError::InvalidFilterKey({
         341  +
                    let mut tmp = match protocol.deserialize_error_response(response, _cfg).and_then(|mut deser| {
         342  +
                        crate::types::error::InvalidFilterKey::deserialize_with_response(
         343  +
                            &mut *deser,
         344  +
                            response.headers(),
         345  +
                            response.status().into(),
         346  +
                            body,
         347  +
                        )
         348  +
                    }) {
         349  +
                        ::std::result::Result::Ok(val) => val,
         350  +
                        ::std::result::Result::Err(e) => {
         351  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         352  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         353  +
                            ))
         354  +
                        }
         355  +
                    };
         356  +
                    tmp.meta = generic;
         357  +
                    if tmp.message.is_none() {
         358  +
                        tmp.message = _error_message;
         359  +
                    }
         360  +
                    tmp
         361  +
                }),
         362  +
                "InvalidFilterOption" => crate::operation::get_parameters_by_path::GetParametersByPathError::InvalidFilterOption({
         363  +
                    let mut tmp = match protocol.deserialize_error_response(response, _cfg).and_then(|mut deser| {
         364  +
                        crate::types::error::InvalidFilterOption::deserialize_with_response(
         365  +
                            &mut *deser,
         366  +
                            response.headers(),
         367  +
                            response.status().into(),
         368  +
                            body,
         369  +
                        )
         370  +
                    }) {
         371  +
                        ::std::result::Result::Ok(val) => val,
         372  +
                        ::std::result::Result::Err(e) => {
         373  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         374  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         375  +
                            ))
         376  +
                        }
         377  +
                    };
         378  +
                    tmp.meta = generic;
         379  +
                    if tmp.message.is_none() {
         380  +
                        tmp.message = _error_message;
         381  +
                    }
         382  +
                    tmp
         383  +
                }),
         384  +
                "InvalidFilterValue" => crate::operation::get_parameters_by_path::GetParametersByPathError::InvalidFilterValue({
         385  +
                    let mut tmp = match protocol.deserialize_error_response(response, _cfg).and_then(|mut deser| {
         386  +
                        crate::types::error::InvalidFilterValue::deserialize_with_response(
         387  +
                            &mut *deser,
         388  +
                            response.headers(),
         389  +
                            response.status().into(),
         390  +
                            body,
         391  +
                        )
         392  +
                    }) {
         393  +
                        ::std::result::Result::Ok(val) => val,
         394  +
                        ::std::result::Result::Err(e) => {
         395  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         396  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         397  +
                            ))
         398  +
                        }
         399  +
                    };
         400  +
                    tmp.meta = generic;
         401  +
                    if tmp.message.is_none() {
         402  +
                        tmp.message = _error_message;
         403  +
                    }
         404  +
                    tmp
         405  +
                }),
         406  +
                "InvalidKeyId" => crate::operation::get_parameters_by_path::GetParametersByPathError::InvalidKeyId({
         407  +
                    let mut tmp = match protocol.deserialize_error_response(response, _cfg).and_then(|mut deser| {
         408  +
                        crate::types::error::InvalidKeyId::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body)
         409  +
                    }) {
         410  +
                        ::std::result::Result::Ok(val) => val,
         411  +
                        ::std::result::Result::Err(e) => {
         412  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         413  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         414  +
                            ))
         415  +
                        }
         416  +
                    };
         417  +
                    tmp.meta = generic;
         418  +
                    if tmp.message.is_none() {
         419  +
                        tmp.message = _error_message;
         420  +
                    }
         421  +
                    tmp
         422  +
                }),
         423  +
                "InvalidNextToken" => crate::operation::get_parameters_by_path::GetParametersByPathError::InvalidNextToken({
         424  +
                    let mut tmp = match protocol.deserialize_error_response(response, _cfg).and_then(|mut deser| {
         425  +
                        crate::types::error::InvalidNextToken::deserialize_with_response(
         426  +
                            &mut *deser,
         427  +
                            response.headers(),
         428  +
                            response.status().into(),
         429  +
                            body,
         430  +
                        )
         431  +
                    }) {
         432  +
                        ::std::result::Result::Ok(val) => val,
         433  +
                        ::std::result::Result::Err(e) => {
         434  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         435  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         436  +
                            ))
         437  +
                        }
         438  +
                    };
         439  +
                    tmp.meta = generic;
         440  +
                    if tmp.message.is_none() {
         441  +
                        tmp.message = _error_message;
         442  +
                    }
         443  +
                    tmp
         444  +
                }),
         445  +
                _ => {
         446  +
                    // Registry-backed, operation-scoped reification of an error whose
         447  +
                    // code this operation does not model directly: the operation's own
         448  +
                    // error registry is consulted first, then the lookup widens to the
         449  +
                    // service-wide error registry. On a hit, the reified error is attached
         450  +
                    // as the source of the returned unhandled error while its metadata
         451  +
                    // (code, message, request id) is preserved; on a miss the generic
         452  +
                    // error is returned unchanged.
         453  +
                    match protocol
         454  +
                        .deserialize_error_response(response, _cfg)
         455  +
                        .ok()
         456  +
                        .and_then(|mut deser| {
         457  +
                            ::aws_smithy_schema::registry::reify_error(
         458  +
                                crate::operation::get_parameters_by_path::error_registry::REGISTRY
         459  +
                                    .or(&crate::error_type_registry::REGISTRY),
         460  +
                                error_code,
         461  +
                                &mut *deser,
         462  +
                            )
         463  +
                        }) {
         464  +
                        ::std::option::Option::Some(source) => <crate::operation::get_parameters_by_path::GetParametersByPathError as ::aws_smithy_runtime_api::client::result::CreateUnhandledError>::create_unhandled_error(source, ::std::option::Option::Some(generic)),
         465  +
                        ::std::option::Option::None => crate::operation::get_parameters_by_path::GetParametersByPathError::generic(generic),
         466  +
                    }
         467  +
                }
         468  +
            };
         469  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         470  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         471  +
            ))
         472  +
        } else {
         473  +
            let protocol = _cfg
         474  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         475  +
                .expect("a SharedClientProtocol is required");
         476  +
            let mut deser = protocol
         477  +
                .deserialize_response(response, GetParametersByPath::OUTPUT_SCHEMA, _cfg)
         478  +
                .map_err(|e| {
         479  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         480  +
                })?;
         481  +
            // body and headers are already in scope from the top of the function;
         482  +
            // alias `headers` as `_response_headers` so MutateOutput
         483  +
            // customizations have a stable name to read from.
         484  +
            let _response_headers = headers;
         485  +
            #[allow(unused_mut)]
         486  +
            let mut output = crate::operation::get_parameters_by_path::GetParametersByPathOutput::deserialize_with_response(
         487  +
                &mut *deser,
         488  +
                _response_headers,
         489  +
                response.status().into(),
         490  +
                body,
         491  +
            )
         492  +
            .map_err(|e| {
         493  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         494  +
            })?;
         495  +
            output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         496  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         497  +
        }
         498  +
    }
         499  +
}
         500  +
#[derive(Debug)]
         501  +
struct GetParametersByPathRequestSerializer;
         502  +
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetParametersByPathRequestSerializer {
         503  +
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
         504  +
    fn serialize_input(
         505  +
        &self,
         506  +
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         507  +
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
         508  +
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         509  +
        let input = input
         510  +
            .downcast::<crate::operation::get_parameters_by_path::GetParametersByPathInput>()
         511  +
            .expect("correct type");
         512  +
         513  +
        let protocol = _cfg
         514  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         515  +
            .expect("a SharedClientProtocol is required");
         516  +
        let mut request = protocol
         517  +
            .serialize_request(&input, GetParametersByPath::INPUT_SCHEMA, "/", _cfg)
         518  +
            .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         519  +
         520  +
        return ::std::result::Result::Ok(request);
         521  +
    }
         522  +
}
         523  +
#[derive(Debug)]
         524  +
struct GetParametersByPathEndpointParamsInterceptor;
         525  +
         526  +
#[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
         527  +
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetParametersByPathEndpointParamsInterceptor {
         528  +
    fn name(&self) -> &'static str {
         529  +
        "GetParametersByPathEndpointParamsInterceptor"
         530  +
    }
         531  +
         532  +
    fn read_before_execution(
         533  +
        &self,
         534  +
        context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
         535  +
            '_,
         536  +
            ::aws_smithy_runtime_api::client::interceptors::context::Input,
         537  +
            ::aws_smithy_runtime_api::client::interceptors::context::Output,
         538  +
            ::aws_smithy_runtime_api::client::interceptors::context::Error,
         539  +
        >,
         540  +
        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
         541  +
    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         542  +
        let _input = context
         543  +
            .input()
         544  +
            .downcast_ref::<GetParametersByPathInput>()
         545  +
            .ok_or("failed to downcast to GetParametersByPathInput")?;
         546  +
         547  +
        let params = crate::config::endpoint::Params::builder()
         548  +
            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
         549  +
            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
         550  +
            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
         551  +
            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
         552  +
            .build()
         553  +
            .map_err(|err| {
         554  +
                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         555  +
            })?;
         556  +
        cfg.interceptor_state()
         557  +
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         558  +
        ::std::result::Result::Ok(())
         559  +
    }
         560  +
}
         561  +
         562  +
// The get_* functions below are generated from JMESPath expressions in the
         563  +
// operationContextParams trait. They target the operation's input shape.
         564  +
         565  +
/// Error type for the `GetParametersByPathError` operation.
         566  +
#[non_exhaustive]
         567  +
#[derive(::std::fmt::Debug)]
         568  +
pub enum GetParametersByPathError {
         569  +
    /// <p>An error occurred on the server side.</p>
         570  +
    InternalServerError(crate::types::error::InternalServerError),
         571  +
    /// <p>The specified key isn't valid.</p>
         572  +
    InvalidFilterKey(crate::types::error::InvalidFilterKey),
         573  +
    /// <p>The specified filter option isn't valid. Valid options are Equals and BeginsWith. For Path filter, valid options are Recursive and OneLevel.</p>
         574  +
    InvalidFilterOption(crate::types::error::InvalidFilterOption),
         575  +
    /// <p>The filter value isn't valid. Verify the value and try again.</p>
         576  +
    InvalidFilterValue(crate::types::error::InvalidFilterValue),
         577  +
    /// <p>The query key ID isn't valid.</p>
         578  +
    InvalidKeyId(crate::types::error::InvalidKeyId),
         579  +
    /// <p>The specified token isn't valid.</p>
         580  +
    InvalidNextToken(crate::types::error::InvalidNextToken),
         581  +
    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
         582  +
    #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
         583  +
    variable wildcard pattern and check `.code()`:
         584  +
     \
         585  +
    &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
         586  +
     \
         587  +
    See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-GetParametersByPathError) for what information is available for the error.")]
         588  +
    Unhandled(crate::error::sealed_unhandled::Unhandled),
         589  +
}
         590  +
impl GetParametersByPathError {
         591  +
    /// Creates the `GetParametersByPathError::Unhandled` variant from any error type.
         592  +
    pub fn unhandled(
         593  +
        err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
         594  +
    ) -> Self {
         595  +
        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
         596  +
            source: err.into(),
         597  +
            meta: ::std::default::Default::default(),
         598  +
        })
         599  +
    }
         600  +
         601  +
    /// Creates the `GetParametersByPathError::Unhandled` variant from an [`ErrorMetadata`](::aws_smithy_types::error::ErrorMetadata).
         602  +
    pub fn generic(err: ::aws_smithy_types::error::ErrorMetadata) -> Self {
         603  +
        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
         604  +
            source: err.clone().into(),
         605  +
            meta: err,
         606  +
        })
         607  +
    }
         608  +
    ///
         609  +
    /// Returns error metadata, which includes the error code, message,
         610  +
    /// request ID, and potentially additional information.
         611  +
    ///
         612  +
    pub fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
         613  +
        match self {
         614  +
            Self::InternalServerError(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
         615  +
            Self::InvalidFilterKey(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
         616  +
            Self::InvalidFilterOption(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
         617  +
            Self::InvalidFilterValue(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
         618  +
            Self::InvalidKeyId(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
         619  +
            Self::InvalidNextToken(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
         620  +
            Self::Unhandled(e) => &e.meta,
         621  +
        }
         622  +
    }
         623  +
    /// Returns `true` if the error kind is `GetParametersByPathError::InternalServerError`.
         624  +
    pub fn is_internal_server_error(&self) -> bool {
         625  +
        matches!(self, Self::InternalServerError(_))
         626  +
    }
         627  +
    /// Returns `true` if the error kind is `GetParametersByPathError::InvalidFilterKey`.
         628  +
    pub fn is_invalid_filter_key(&self) -> bool {
         629  +
        matches!(self, Self::InvalidFilterKey(_))
         630  +
    }
         631  +
    /// Returns `true` if the error kind is `GetParametersByPathError::InvalidFilterOption`.
         632  +
    pub fn is_invalid_filter_option(&self) -> bool {
         633  +
        matches!(self, Self::InvalidFilterOption(_))
         634  +
    }
         635  +
    /// Returns `true` if the error kind is `GetParametersByPathError::InvalidFilterValue`.
         636  +
    pub fn is_invalid_filter_value(&self) -> bool {
         637  +
        matches!(self, Self::InvalidFilterValue(_))
         638  +
    }
         639  +
    /// Returns `true` if the error kind is `GetParametersByPathError::InvalidKeyId`.
         640  +
    pub fn is_invalid_key_id(&self) -> bool {
         641  +
        matches!(self, Self::InvalidKeyId(_))
         642  +
    }
         643  +
    /// Returns `true` if the error kind is `GetParametersByPathError::InvalidNextToken`.
         644  +
    pub fn is_invalid_next_token(&self) -> bool {
         645  +
        matches!(self, Self::InvalidNextToken(_))
         646  +
    }
         647  +
}
         648  +
impl ::std::error::Error for GetParametersByPathError {
         649  +
    fn source(&self) -> ::std::option::Option<&(dyn ::std::error::Error + 'static)> {
         650  +
        match self {
         651  +
            Self::InternalServerError(_inner) => ::std::option::Option::Some(_inner),
         652  +
            Self::InvalidFilterKey(_inner) => ::std::option::Option::Some(_inner),
         653  +
            Self::InvalidFilterOption(_inner) => ::std::option::Option::Some(_inner),
         654  +
            Self::InvalidFilterValue(_inner) => ::std::option::Option::Some(_inner),
         655  +
            Self::InvalidKeyId(_inner) => ::std::option::Option::Some(_inner),
         656  +
            Self::InvalidNextToken(_inner) => ::std::option::Option::Some(_inner),
         657  +
            Self::Unhandled(_inner) => ::std::option::Option::Some(&*_inner.source),
         658  +
        }
         659  +
    }
         660  +
}
         661  +
impl ::std::fmt::Display for GetParametersByPathError {
         662  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         663  +
        match self {
         664  +
            Self::InternalServerError(_inner) => _inner.fmt(f),
         665  +
            Self::InvalidFilterKey(_inner) => _inner.fmt(f),
         666  +
            Self::InvalidFilterOption(_inner) => _inner.fmt(f),
         667  +
            Self::InvalidFilterValue(_inner) => _inner.fmt(f),
         668  +
            Self::InvalidKeyId(_inner) => _inner.fmt(f),
         669  +
            Self::InvalidNextToken(_inner) => _inner.fmt(f),
         670  +
            Self::Unhandled(_inner) => {
         671  +
                if let ::std::option::Option::Some(code) = ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self) {
         672  +
                    write!(f, "unhandled error ({code})")
         673  +
                } else {
         674  +
                    f.write_str("unhandled error")
         675  +
                }
         676  +
            }
         677  +
        }
         678  +
    }
         679  +
}
         680  +
impl ::aws_smithy_types::retry::ProvideErrorKind for GetParametersByPathError {
         681  +
    fn code(&self) -> ::std::option::Option<&str> {
         682  +
        ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self)
         683  +
    }
         684  +
    fn retryable_error_kind(&self) -> ::std::option::Option<::aws_smithy_types::retry::ErrorKind> {
         685  +
        ::std::option::Option::None
         686  +
    }
         687  +
}
         688  +
impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for GetParametersByPathError {
         689  +
    fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
         690  +
        match self {
         691  +
            Self::InternalServerError(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
         692  +
            Self::InvalidFilterKey(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
         693  +
            Self::InvalidFilterOption(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
         694  +
            Self::InvalidFilterValue(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
         695  +
            Self::InvalidKeyId(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
         696  +
            Self::InvalidNextToken(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
         697  +
            Self::Unhandled(_inner) => &_inner.meta,
         698  +
        }
         699  +
    }
         700  +
}
         701  +
impl ::aws_smithy_runtime_api::client::result::CreateUnhandledError for GetParametersByPathError {
         702  +
    fn create_unhandled_error(
         703  +
        source: ::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>,
         704  +
        meta: ::std::option::Option<::aws_smithy_types::error::ErrorMetadata>,
         705  +
    ) -> Self {
         706  +
        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
         707  +
            source,
         708  +
            meta: meta.unwrap_or_default(),
         709  +
        })
         710  +
    }
         711  +
}
         712  +
impl ::aws_types::request_id::RequestId for crate::operation::get_parameters_by_path::GetParametersByPathError {
         713  +
    fn request_id(&self) -> Option<&str> {
         714  +
        self.meta().request_id()
         715  +
    }
         716  +
}
         717  +
         718  +
pub use crate::operation::get_parameters_by_path::_get_parameters_by_path_input::GetParametersByPathInput;
         719  +
         720  +
pub use crate::operation::get_parameters_by_path::_get_parameters_by_path_output::GetParametersByPathOutput;
         721  +
         722  +
mod _get_parameters_by_path_input;
         723  +
         724  +
mod _get_parameters_by_path_output;
         725  +
         726  +
/// Builders
         727  +
pub mod builders;
         728  +
         729  +
/// Paginator for this operation
         730  +
pub mod paginator;