operation.rs

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
/// Operation shape for `AddClientIDToOpenIDConnectProvider`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`add_client_id_to_open_id_connect_provider`](crate::client::Client::add_client_id_to_open_id_connect_provider).
///
/// See [`crate::client::fluent_builders::AddClientIDToOpenIDConnectProvider`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct AddClientIDToOpenIDConnectProvider {
    _private: (),
}
impl AddClientIDToOpenIDConnectProvider {
    /// Creates a new builder-style object to manufacture [`AddClientIdToOpenIdConnectProviderInput`](crate::input::AddClientIdToOpenIdConnectProviderInput)
    pub fn builder() -> crate::input::add_client_id_to_open_id_connect_provider_input::Builder {
        crate::input::add_client_id_to_open_id_connect_provider_input::Builder::default()
    }
    /// Creates a new `AddClientIDToOpenIDConnectProvider` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for AddClientIDToOpenIDConnectProvider {
    type Output = std::result::Result<
        crate::output::AddClientIdToOpenIdConnectProviderOutput,
        crate::error::AddClientIDToOpenIDConnectProviderError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_add_client_id_to_open_id_connect_provider_error(response)
        } else {
            crate::operation_deser::parse_add_client_id_to_open_id_connect_provider_response(
                response,
            )
        }
    }
}

/// Operation shape for `AddRoleToInstanceProfile`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`add_role_to_instance_profile`](crate::client::Client::add_role_to_instance_profile).
///
/// See [`crate::client::fluent_builders::AddRoleToInstanceProfile`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct AddRoleToInstanceProfile {
    _private: (),
}
impl AddRoleToInstanceProfile {
    /// Creates a new builder-style object to manufacture [`AddRoleToInstanceProfileInput`](crate::input::AddRoleToInstanceProfileInput)
    pub fn builder() -> crate::input::add_role_to_instance_profile_input::Builder {
        crate::input::add_role_to_instance_profile_input::Builder::default()
    }
    /// Creates a new `AddRoleToInstanceProfile` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for AddRoleToInstanceProfile {
    type Output = std::result::Result<
        crate::output::AddRoleToInstanceProfileOutput,
        crate::error::AddRoleToInstanceProfileError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_add_role_to_instance_profile_error(response)
        } else {
            crate::operation_deser::parse_add_role_to_instance_profile_response(response)
        }
    }
}

/// Operation shape for `AddUserToGroup`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`add_user_to_group`](crate::client::Client::add_user_to_group).
///
/// See [`crate::client::fluent_builders::AddUserToGroup`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct AddUserToGroup {
    _private: (),
}
impl AddUserToGroup {
    /// Creates a new builder-style object to manufacture [`AddUserToGroupInput`](crate::input::AddUserToGroupInput)
    pub fn builder() -> crate::input::add_user_to_group_input::Builder {
        crate::input::add_user_to_group_input::Builder::default()
    }
    /// Creates a new `AddUserToGroup` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for AddUserToGroup {
    type Output =
        std::result::Result<crate::output::AddUserToGroupOutput, crate::error::AddUserToGroupError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_add_user_to_group_error(response)
        } else {
            crate::operation_deser::parse_add_user_to_group_response(response)
        }
    }
}

/// Operation shape for `AttachGroupPolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`attach_group_policy`](crate::client::Client::attach_group_policy).
///
/// See [`crate::client::fluent_builders::AttachGroupPolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct AttachGroupPolicy {
    _private: (),
}
impl AttachGroupPolicy {
    /// Creates a new builder-style object to manufacture [`AttachGroupPolicyInput`](crate::input::AttachGroupPolicyInput)
    pub fn builder() -> crate::input::attach_group_policy_input::Builder {
        crate::input::attach_group_policy_input::Builder::default()
    }
    /// Creates a new `AttachGroupPolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for AttachGroupPolicy {
    type Output = std::result::Result<
        crate::output::AttachGroupPolicyOutput,
        crate::error::AttachGroupPolicyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_attach_group_policy_error(response)
        } else {
            crate::operation_deser::parse_attach_group_policy_response(response)
        }
    }
}

/// Operation shape for `AttachRolePolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`attach_role_policy`](crate::client::Client::attach_role_policy).
///
/// See [`crate::client::fluent_builders::AttachRolePolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct AttachRolePolicy {
    _private: (),
}
impl AttachRolePolicy {
    /// Creates a new builder-style object to manufacture [`AttachRolePolicyInput`](crate::input::AttachRolePolicyInput)
    pub fn builder() -> crate::input::attach_role_policy_input::Builder {
        crate::input::attach_role_policy_input::Builder::default()
    }
    /// Creates a new `AttachRolePolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for AttachRolePolicy {
    type Output = std::result::Result<
        crate::output::AttachRolePolicyOutput,
        crate::error::AttachRolePolicyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_attach_role_policy_error(response)
        } else {
            crate::operation_deser::parse_attach_role_policy_response(response)
        }
    }
}

/// Operation shape for `AttachUserPolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`attach_user_policy`](crate::client::Client::attach_user_policy).
///
/// See [`crate::client::fluent_builders::AttachUserPolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct AttachUserPolicy {
    _private: (),
}
impl AttachUserPolicy {
    /// Creates a new builder-style object to manufacture [`AttachUserPolicyInput`](crate::input::AttachUserPolicyInput)
    pub fn builder() -> crate::input::attach_user_policy_input::Builder {
        crate::input::attach_user_policy_input::Builder::default()
    }
    /// Creates a new `AttachUserPolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for AttachUserPolicy {
    type Output = std::result::Result<
        crate::output::AttachUserPolicyOutput,
        crate::error::AttachUserPolicyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_attach_user_policy_error(response)
        } else {
            crate::operation_deser::parse_attach_user_policy_response(response)
        }
    }
}

/// Operation shape for `ChangePassword`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`change_password`](crate::client::Client::change_password).
///
/// See [`crate::client::fluent_builders::ChangePassword`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ChangePassword {
    _private: (),
}
impl ChangePassword {
    /// Creates a new builder-style object to manufacture [`ChangePasswordInput`](crate::input::ChangePasswordInput)
    pub fn builder() -> crate::input::change_password_input::Builder {
        crate::input::change_password_input::Builder::default()
    }
    /// Creates a new `ChangePassword` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ChangePassword {
    type Output =
        std::result::Result<crate::output::ChangePasswordOutput, crate::error::ChangePasswordError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_change_password_error(response)
        } else {
            crate::operation_deser::parse_change_password_response(response)
        }
    }
}

/// Operation shape for `CreateAccessKey`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_access_key`](crate::client::Client::create_access_key).
///
/// See [`crate::client::fluent_builders::CreateAccessKey`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CreateAccessKey {
    _private: (),
}
impl CreateAccessKey {
    /// Creates a new builder-style object to manufacture [`CreateAccessKeyInput`](crate::input::CreateAccessKeyInput)
    pub fn builder() -> crate::input::create_access_key_input::Builder {
        crate::input::create_access_key_input::Builder::default()
    }
    /// Creates a new `CreateAccessKey` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateAccessKey {
    type Output = std::result::Result<
        crate::output::CreateAccessKeyOutput,
        crate::error::CreateAccessKeyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_access_key_error(response)
        } else {
            crate::operation_deser::parse_create_access_key_response(response)
        }
    }
}

/// Operation shape for `CreateAccountAlias`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_account_alias`](crate::client::Client::create_account_alias).
///
/// See [`crate::client::fluent_builders::CreateAccountAlias`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CreateAccountAlias {
    _private: (),
}
impl CreateAccountAlias {
    /// Creates a new builder-style object to manufacture [`CreateAccountAliasInput`](crate::input::CreateAccountAliasInput)
    pub fn builder() -> crate::input::create_account_alias_input::Builder {
        crate::input::create_account_alias_input::Builder::default()
    }
    /// Creates a new `CreateAccountAlias` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateAccountAlias {
    type Output = std::result::Result<
        crate::output::CreateAccountAliasOutput,
        crate::error::CreateAccountAliasError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_account_alias_error(response)
        } else {
            crate::operation_deser::parse_create_account_alias_response(response)
        }
    }
}

/// Operation shape for `CreateGroup`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_group`](crate::client::Client::create_group).
///
/// See [`crate::client::fluent_builders::CreateGroup`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CreateGroup {
    _private: (),
}
impl CreateGroup {
    /// Creates a new builder-style object to manufacture [`CreateGroupInput`](crate::input::CreateGroupInput)
    pub fn builder() -> crate::input::create_group_input::Builder {
        crate::input::create_group_input::Builder::default()
    }
    /// Creates a new `CreateGroup` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateGroup {
    type Output =
        std::result::Result<crate::output::CreateGroupOutput, crate::error::CreateGroupError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_group_error(response)
        } else {
            crate::operation_deser::parse_create_group_response(response)
        }
    }
}

/// Operation shape for `CreateInstanceProfile`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_instance_profile`](crate::client::Client::create_instance_profile).
///
/// See [`crate::client::fluent_builders::CreateInstanceProfile`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CreateInstanceProfile {
    _private: (),
}
impl CreateInstanceProfile {
    /// Creates a new builder-style object to manufacture [`CreateInstanceProfileInput`](crate::input::CreateInstanceProfileInput)
    pub fn builder() -> crate::input::create_instance_profile_input::Builder {
        crate::input::create_instance_profile_input::Builder::default()
    }
    /// Creates a new `CreateInstanceProfile` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateInstanceProfile {
    type Output = std::result::Result<
        crate::output::CreateInstanceProfileOutput,
        crate::error::CreateInstanceProfileError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_instance_profile_error(response)
        } else {
            crate::operation_deser::parse_create_instance_profile_response(response)
        }
    }
}

/// Operation shape for `CreateLoginProfile`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_login_profile`](crate::client::Client::create_login_profile).
///
/// See [`crate::client::fluent_builders::CreateLoginProfile`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CreateLoginProfile {
    _private: (),
}
impl CreateLoginProfile {
    /// Creates a new builder-style object to manufacture [`CreateLoginProfileInput`](crate::input::CreateLoginProfileInput)
    pub fn builder() -> crate::input::create_login_profile_input::Builder {
        crate::input::create_login_profile_input::Builder::default()
    }
    /// Creates a new `CreateLoginProfile` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateLoginProfile {
    type Output = std::result::Result<
        crate::output::CreateLoginProfileOutput,
        crate::error::CreateLoginProfileError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_login_profile_error(response)
        } else {
            crate::operation_deser::parse_create_login_profile_response(response)
        }
    }
}

/// Operation shape for `CreateOpenIDConnectProvider`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_open_id_connect_provider`](crate::client::Client::create_open_id_connect_provider).
///
/// See [`crate::client::fluent_builders::CreateOpenIDConnectProvider`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CreateOpenIDConnectProvider {
    _private: (),
}
impl CreateOpenIDConnectProvider {
    /// Creates a new builder-style object to manufacture [`CreateOpenIdConnectProviderInput`](crate::input::CreateOpenIdConnectProviderInput)
    pub fn builder() -> crate::input::create_open_id_connect_provider_input::Builder {
        crate::input::create_open_id_connect_provider_input::Builder::default()
    }
    /// Creates a new `CreateOpenIDConnectProvider` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateOpenIDConnectProvider {
    type Output = std::result::Result<
        crate::output::CreateOpenIdConnectProviderOutput,
        crate::error::CreateOpenIDConnectProviderError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_open_id_connect_provider_error(response)
        } else {
            crate::operation_deser::parse_create_open_id_connect_provider_response(response)
        }
    }
}

/// Operation shape for `CreatePolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_policy`](crate::client::Client::create_policy).
///
/// See [`crate::client::fluent_builders::CreatePolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CreatePolicy {
    _private: (),
}
impl CreatePolicy {
    /// Creates a new builder-style object to manufacture [`CreatePolicyInput`](crate::input::CreatePolicyInput)
    pub fn builder() -> crate::input::create_policy_input::Builder {
        crate::input::create_policy_input::Builder::default()
    }
    /// Creates a new `CreatePolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreatePolicy {
    type Output =
        std::result::Result<crate::output::CreatePolicyOutput, crate::error::CreatePolicyError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_policy_error(response)
        } else {
            crate::operation_deser::parse_create_policy_response(response)
        }
    }
}

/// Operation shape for `CreatePolicyVersion`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_policy_version`](crate::client::Client::create_policy_version).
///
/// See [`crate::client::fluent_builders::CreatePolicyVersion`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CreatePolicyVersion {
    _private: (),
}
impl CreatePolicyVersion {
    /// Creates a new builder-style object to manufacture [`CreatePolicyVersionInput`](crate::input::CreatePolicyVersionInput)
    pub fn builder() -> crate::input::create_policy_version_input::Builder {
        crate::input::create_policy_version_input::Builder::default()
    }
    /// Creates a new `CreatePolicyVersion` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreatePolicyVersion {
    type Output = std::result::Result<
        crate::output::CreatePolicyVersionOutput,
        crate::error::CreatePolicyVersionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_policy_version_error(response)
        } else {
            crate::operation_deser::parse_create_policy_version_response(response)
        }
    }
}

/// Operation shape for `CreateRole`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_role`](crate::client::Client::create_role).
///
/// See [`crate::client::fluent_builders::CreateRole`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CreateRole {
    _private: (),
}
impl CreateRole {
    /// Creates a new builder-style object to manufacture [`CreateRoleInput`](crate::input::CreateRoleInput)
    pub fn builder() -> crate::input::create_role_input::Builder {
        crate::input::create_role_input::Builder::default()
    }
    /// Creates a new `CreateRole` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateRole {
    type Output =
        std::result::Result<crate::output::CreateRoleOutput, crate::error::CreateRoleError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_role_error(response)
        } else {
            crate::operation_deser::parse_create_role_response(response)
        }
    }
}

/// Operation shape for `CreateSAMLProvider`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_saml_provider`](crate::client::Client::create_saml_provider).
///
/// See [`crate::client::fluent_builders::CreateSAMLProvider`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CreateSAMLProvider {
    _private: (),
}
impl CreateSAMLProvider {
    /// Creates a new builder-style object to manufacture [`CreateSamlProviderInput`](crate::input::CreateSamlProviderInput)
    pub fn builder() -> crate::input::create_saml_provider_input::Builder {
        crate::input::create_saml_provider_input::Builder::default()
    }
    /// Creates a new `CreateSAMLProvider` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateSAMLProvider {
    type Output = std::result::Result<
        crate::output::CreateSamlProviderOutput,
        crate::error::CreateSAMLProviderError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_saml_provider_error(response)
        } else {
            crate::operation_deser::parse_create_saml_provider_response(response)
        }
    }
}

/// Operation shape for `CreateServiceLinkedRole`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_service_linked_role`](crate::client::Client::create_service_linked_role).
///
/// See [`crate::client::fluent_builders::CreateServiceLinkedRole`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CreateServiceLinkedRole {
    _private: (),
}
impl CreateServiceLinkedRole {
    /// Creates a new builder-style object to manufacture [`CreateServiceLinkedRoleInput`](crate::input::CreateServiceLinkedRoleInput)
    pub fn builder() -> crate::input::create_service_linked_role_input::Builder {
        crate::input::create_service_linked_role_input::Builder::default()
    }
    /// Creates a new `CreateServiceLinkedRole` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateServiceLinkedRole {
    type Output = std::result::Result<
        crate::output::CreateServiceLinkedRoleOutput,
        crate::error::CreateServiceLinkedRoleError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_service_linked_role_error(response)
        } else {
            crate::operation_deser::parse_create_service_linked_role_response(response)
        }
    }
}

/// Operation shape for `CreateServiceSpecificCredential`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_service_specific_credential`](crate::client::Client::create_service_specific_credential).
///
/// See [`crate::client::fluent_builders::CreateServiceSpecificCredential`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CreateServiceSpecificCredential {
    _private: (),
}
impl CreateServiceSpecificCredential {
    /// Creates a new builder-style object to manufacture [`CreateServiceSpecificCredentialInput`](crate::input::CreateServiceSpecificCredentialInput)
    pub fn builder() -> crate::input::create_service_specific_credential_input::Builder {
        crate::input::create_service_specific_credential_input::Builder::default()
    }
    /// Creates a new `CreateServiceSpecificCredential` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateServiceSpecificCredential {
    type Output = std::result::Result<
        crate::output::CreateServiceSpecificCredentialOutput,
        crate::error::CreateServiceSpecificCredentialError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_service_specific_credential_error(response)
        } else {
            crate::operation_deser::parse_create_service_specific_credential_response(response)
        }
    }
}

/// Operation shape for `CreateUser`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_user`](crate::client::Client::create_user).
///
/// See [`crate::client::fluent_builders::CreateUser`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CreateUser {
    _private: (),
}
impl CreateUser {
    /// Creates a new builder-style object to manufacture [`CreateUserInput`](crate::input::CreateUserInput)
    pub fn builder() -> crate::input::create_user_input::Builder {
        crate::input::create_user_input::Builder::default()
    }
    /// Creates a new `CreateUser` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateUser {
    type Output =
        std::result::Result<crate::output::CreateUserOutput, crate::error::CreateUserError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_user_error(response)
        } else {
            crate::operation_deser::parse_create_user_response(response)
        }
    }
}

/// Operation shape for `CreateVirtualMFADevice`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_virtual_mfa_device`](crate::client::Client::create_virtual_mfa_device).
///
/// See [`crate::client::fluent_builders::CreateVirtualMFADevice`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CreateVirtualMFADevice {
    _private: (),
}
impl CreateVirtualMFADevice {
    /// Creates a new builder-style object to manufacture [`CreateVirtualMfaDeviceInput`](crate::input::CreateVirtualMfaDeviceInput)
    pub fn builder() -> crate::input::create_virtual_mfa_device_input::Builder {
        crate::input::create_virtual_mfa_device_input::Builder::default()
    }
    /// Creates a new `CreateVirtualMFADevice` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateVirtualMFADevice {
    type Output = std::result::Result<
        crate::output::CreateVirtualMfaDeviceOutput,
        crate::error::CreateVirtualMFADeviceError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_virtual_mfa_device_error(response)
        } else {
            crate::operation_deser::parse_create_virtual_mfa_device_response(response)
        }
    }
}

/// Operation shape for `DeactivateMFADevice`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`deactivate_mfa_device`](crate::client::Client::deactivate_mfa_device).
///
/// See [`crate::client::fluent_builders::DeactivateMFADevice`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeactivateMFADevice {
    _private: (),
}
impl DeactivateMFADevice {
    /// Creates a new builder-style object to manufacture [`DeactivateMfaDeviceInput`](crate::input::DeactivateMfaDeviceInput)
    pub fn builder() -> crate::input::deactivate_mfa_device_input::Builder {
        crate::input::deactivate_mfa_device_input::Builder::default()
    }
    /// Creates a new `DeactivateMFADevice` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeactivateMFADevice {
    type Output = std::result::Result<
        crate::output::DeactivateMfaDeviceOutput,
        crate::error::DeactivateMFADeviceError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_deactivate_mfa_device_error(response)
        } else {
            crate::operation_deser::parse_deactivate_mfa_device_response(response)
        }
    }
}

/// Operation shape for `DeleteAccessKey`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_access_key`](crate::client::Client::delete_access_key).
///
/// See [`crate::client::fluent_builders::DeleteAccessKey`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteAccessKey {
    _private: (),
}
impl DeleteAccessKey {
    /// Creates a new builder-style object to manufacture [`DeleteAccessKeyInput`](crate::input::DeleteAccessKeyInput)
    pub fn builder() -> crate::input::delete_access_key_input::Builder {
        crate::input::delete_access_key_input::Builder::default()
    }
    /// Creates a new `DeleteAccessKey` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteAccessKey {
    type Output = std::result::Result<
        crate::output::DeleteAccessKeyOutput,
        crate::error::DeleteAccessKeyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_access_key_error(response)
        } else {
            crate::operation_deser::parse_delete_access_key_response(response)
        }
    }
}

/// Operation shape for `DeleteAccountAlias`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_account_alias`](crate::client::Client::delete_account_alias).
///
/// See [`crate::client::fluent_builders::DeleteAccountAlias`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteAccountAlias {
    _private: (),
}
impl DeleteAccountAlias {
    /// Creates a new builder-style object to manufacture [`DeleteAccountAliasInput`](crate::input::DeleteAccountAliasInput)
    pub fn builder() -> crate::input::delete_account_alias_input::Builder {
        crate::input::delete_account_alias_input::Builder::default()
    }
    /// Creates a new `DeleteAccountAlias` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteAccountAlias {
    type Output = std::result::Result<
        crate::output::DeleteAccountAliasOutput,
        crate::error::DeleteAccountAliasError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_account_alias_error(response)
        } else {
            crate::operation_deser::parse_delete_account_alias_response(response)
        }
    }
}

/// Operation shape for `DeleteAccountPasswordPolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_account_password_policy`](crate::client::Client::delete_account_password_policy).
///
/// See [`crate::client::fluent_builders::DeleteAccountPasswordPolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteAccountPasswordPolicy {
    _private: (),
}
impl DeleteAccountPasswordPolicy {
    /// Creates a new builder-style object to manufacture [`DeleteAccountPasswordPolicyInput`](crate::input::DeleteAccountPasswordPolicyInput)
    pub fn builder() -> crate::input::delete_account_password_policy_input::Builder {
        crate::input::delete_account_password_policy_input::Builder::default()
    }
    /// Creates a new `DeleteAccountPasswordPolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteAccountPasswordPolicy {
    type Output = std::result::Result<
        crate::output::DeleteAccountPasswordPolicyOutput,
        crate::error::DeleteAccountPasswordPolicyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_account_password_policy_error(response)
        } else {
            crate::operation_deser::parse_delete_account_password_policy_response(response)
        }
    }
}

/// Operation shape for `DeleteGroup`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_group`](crate::client::Client::delete_group).
///
/// See [`crate::client::fluent_builders::DeleteGroup`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteGroup {
    _private: (),
}
impl DeleteGroup {
    /// Creates a new builder-style object to manufacture [`DeleteGroupInput`](crate::input::DeleteGroupInput)
    pub fn builder() -> crate::input::delete_group_input::Builder {
        crate::input::delete_group_input::Builder::default()
    }
    /// Creates a new `DeleteGroup` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteGroup {
    type Output =
        std::result::Result<crate::output::DeleteGroupOutput, crate::error::DeleteGroupError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_group_error(response)
        } else {
            crate::operation_deser::parse_delete_group_response(response)
        }
    }
}

/// Operation shape for `DeleteGroupPolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_group_policy`](crate::client::Client::delete_group_policy).
///
/// See [`crate::client::fluent_builders::DeleteGroupPolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteGroupPolicy {
    _private: (),
}
impl DeleteGroupPolicy {
    /// Creates a new builder-style object to manufacture [`DeleteGroupPolicyInput`](crate::input::DeleteGroupPolicyInput)
    pub fn builder() -> crate::input::delete_group_policy_input::Builder {
        crate::input::delete_group_policy_input::Builder::default()
    }
    /// Creates a new `DeleteGroupPolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteGroupPolicy {
    type Output = std::result::Result<
        crate::output::DeleteGroupPolicyOutput,
        crate::error::DeleteGroupPolicyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_group_policy_error(response)
        } else {
            crate::operation_deser::parse_delete_group_policy_response(response)
        }
    }
}

/// Operation shape for `DeleteInstanceProfile`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_instance_profile`](crate::client::Client::delete_instance_profile).
///
/// See [`crate::client::fluent_builders::DeleteInstanceProfile`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteInstanceProfile {
    _private: (),
}
impl DeleteInstanceProfile {
    /// Creates a new builder-style object to manufacture [`DeleteInstanceProfileInput`](crate::input::DeleteInstanceProfileInput)
    pub fn builder() -> crate::input::delete_instance_profile_input::Builder {
        crate::input::delete_instance_profile_input::Builder::default()
    }
    /// Creates a new `DeleteInstanceProfile` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteInstanceProfile {
    type Output = std::result::Result<
        crate::output::DeleteInstanceProfileOutput,
        crate::error::DeleteInstanceProfileError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_instance_profile_error(response)
        } else {
            crate::operation_deser::parse_delete_instance_profile_response(response)
        }
    }
}

/// Operation shape for `DeleteLoginProfile`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_login_profile`](crate::client::Client::delete_login_profile).
///
/// See [`crate::client::fluent_builders::DeleteLoginProfile`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteLoginProfile {
    _private: (),
}
impl DeleteLoginProfile {
    /// Creates a new builder-style object to manufacture [`DeleteLoginProfileInput`](crate::input::DeleteLoginProfileInput)
    pub fn builder() -> crate::input::delete_login_profile_input::Builder {
        crate::input::delete_login_profile_input::Builder::default()
    }
    /// Creates a new `DeleteLoginProfile` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteLoginProfile {
    type Output = std::result::Result<
        crate::output::DeleteLoginProfileOutput,
        crate::error::DeleteLoginProfileError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_login_profile_error(response)
        } else {
            crate::operation_deser::parse_delete_login_profile_response(response)
        }
    }
}

/// Operation shape for `DeleteOpenIDConnectProvider`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_open_id_connect_provider`](crate::client::Client::delete_open_id_connect_provider).
///
/// See [`crate::client::fluent_builders::DeleteOpenIDConnectProvider`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteOpenIDConnectProvider {
    _private: (),
}
impl DeleteOpenIDConnectProvider {
    /// Creates a new builder-style object to manufacture [`DeleteOpenIdConnectProviderInput`](crate::input::DeleteOpenIdConnectProviderInput)
    pub fn builder() -> crate::input::delete_open_id_connect_provider_input::Builder {
        crate::input::delete_open_id_connect_provider_input::Builder::default()
    }
    /// Creates a new `DeleteOpenIDConnectProvider` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteOpenIDConnectProvider {
    type Output = std::result::Result<
        crate::output::DeleteOpenIdConnectProviderOutput,
        crate::error::DeleteOpenIDConnectProviderError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_open_id_connect_provider_error(response)
        } else {
            crate::operation_deser::parse_delete_open_id_connect_provider_response(response)
        }
    }
}

/// Operation shape for `DeletePolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_policy`](crate::client::Client::delete_policy).
///
/// See [`crate::client::fluent_builders::DeletePolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeletePolicy {
    _private: (),
}
impl DeletePolicy {
    /// Creates a new builder-style object to manufacture [`DeletePolicyInput`](crate::input::DeletePolicyInput)
    pub fn builder() -> crate::input::delete_policy_input::Builder {
        crate::input::delete_policy_input::Builder::default()
    }
    /// Creates a new `DeletePolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeletePolicy {
    type Output =
        std::result::Result<crate::output::DeletePolicyOutput, crate::error::DeletePolicyError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_policy_error(response)
        } else {
            crate::operation_deser::parse_delete_policy_response(response)
        }
    }
}

/// Operation shape for `DeletePolicyVersion`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_policy_version`](crate::client::Client::delete_policy_version).
///
/// See [`crate::client::fluent_builders::DeletePolicyVersion`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeletePolicyVersion {
    _private: (),
}
impl DeletePolicyVersion {
    /// Creates a new builder-style object to manufacture [`DeletePolicyVersionInput`](crate::input::DeletePolicyVersionInput)
    pub fn builder() -> crate::input::delete_policy_version_input::Builder {
        crate::input::delete_policy_version_input::Builder::default()
    }
    /// Creates a new `DeletePolicyVersion` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeletePolicyVersion {
    type Output = std::result::Result<
        crate::output::DeletePolicyVersionOutput,
        crate::error::DeletePolicyVersionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_policy_version_error(response)
        } else {
            crate::operation_deser::parse_delete_policy_version_response(response)
        }
    }
}

/// Operation shape for `DeleteRole`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_role`](crate::client::Client::delete_role).
///
/// See [`crate::client::fluent_builders::DeleteRole`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteRole {
    _private: (),
}
impl DeleteRole {
    /// Creates a new builder-style object to manufacture [`DeleteRoleInput`](crate::input::DeleteRoleInput)
    pub fn builder() -> crate::input::delete_role_input::Builder {
        crate::input::delete_role_input::Builder::default()
    }
    /// Creates a new `DeleteRole` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteRole {
    type Output =
        std::result::Result<crate::output::DeleteRoleOutput, crate::error::DeleteRoleError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_role_error(response)
        } else {
            crate::operation_deser::parse_delete_role_response(response)
        }
    }
}

/// Operation shape for `DeleteRolePermissionsBoundary`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_role_permissions_boundary`](crate::client::Client::delete_role_permissions_boundary).
///
/// See [`crate::client::fluent_builders::DeleteRolePermissionsBoundary`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteRolePermissionsBoundary {
    _private: (),
}
impl DeleteRolePermissionsBoundary {
    /// Creates a new builder-style object to manufacture [`DeleteRolePermissionsBoundaryInput`](crate::input::DeleteRolePermissionsBoundaryInput)
    pub fn builder() -> crate::input::delete_role_permissions_boundary_input::Builder {
        crate::input::delete_role_permissions_boundary_input::Builder::default()
    }
    /// Creates a new `DeleteRolePermissionsBoundary` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteRolePermissionsBoundary {
    type Output = std::result::Result<
        crate::output::DeleteRolePermissionsBoundaryOutput,
        crate::error::DeleteRolePermissionsBoundaryError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_role_permissions_boundary_error(response)
        } else {
            crate::operation_deser::parse_delete_role_permissions_boundary_response(response)
        }
    }
}

/// Operation shape for `DeleteRolePolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_role_policy`](crate::client::Client::delete_role_policy).
///
/// See [`crate::client::fluent_builders::DeleteRolePolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteRolePolicy {
    _private: (),
}
impl DeleteRolePolicy {
    /// Creates a new builder-style object to manufacture [`DeleteRolePolicyInput`](crate::input::DeleteRolePolicyInput)
    pub fn builder() -> crate::input::delete_role_policy_input::Builder {
        crate::input::delete_role_policy_input::Builder::default()
    }
    /// Creates a new `DeleteRolePolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteRolePolicy {
    type Output = std::result::Result<
        crate::output::DeleteRolePolicyOutput,
        crate::error::DeleteRolePolicyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_role_policy_error(response)
        } else {
            crate::operation_deser::parse_delete_role_policy_response(response)
        }
    }
}

/// Operation shape for `DeleteSAMLProvider`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_saml_provider`](crate::client::Client::delete_saml_provider).
///
/// See [`crate::client::fluent_builders::DeleteSAMLProvider`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteSAMLProvider {
    _private: (),
}
impl DeleteSAMLProvider {
    /// Creates a new builder-style object to manufacture [`DeleteSamlProviderInput`](crate::input::DeleteSamlProviderInput)
    pub fn builder() -> crate::input::delete_saml_provider_input::Builder {
        crate::input::delete_saml_provider_input::Builder::default()
    }
    /// Creates a new `DeleteSAMLProvider` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteSAMLProvider {
    type Output = std::result::Result<
        crate::output::DeleteSamlProviderOutput,
        crate::error::DeleteSAMLProviderError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_saml_provider_error(response)
        } else {
            crate::operation_deser::parse_delete_saml_provider_response(response)
        }
    }
}

/// Operation shape for `DeleteServerCertificate`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_server_certificate`](crate::client::Client::delete_server_certificate).
///
/// See [`crate::client::fluent_builders::DeleteServerCertificate`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteServerCertificate {
    _private: (),
}
impl DeleteServerCertificate {
    /// Creates a new builder-style object to manufacture [`DeleteServerCertificateInput`](crate::input::DeleteServerCertificateInput)
    pub fn builder() -> crate::input::delete_server_certificate_input::Builder {
        crate::input::delete_server_certificate_input::Builder::default()
    }
    /// Creates a new `DeleteServerCertificate` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteServerCertificate {
    type Output = std::result::Result<
        crate::output::DeleteServerCertificateOutput,
        crate::error::DeleteServerCertificateError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_server_certificate_error(response)
        } else {
            crate::operation_deser::parse_delete_server_certificate_response(response)
        }
    }
}

/// Operation shape for `DeleteServiceLinkedRole`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_service_linked_role`](crate::client::Client::delete_service_linked_role).
///
/// See [`crate::client::fluent_builders::DeleteServiceLinkedRole`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteServiceLinkedRole {
    _private: (),
}
impl DeleteServiceLinkedRole {
    /// Creates a new builder-style object to manufacture [`DeleteServiceLinkedRoleInput`](crate::input::DeleteServiceLinkedRoleInput)
    pub fn builder() -> crate::input::delete_service_linked_role_input::Builder {
        crate::input::delete_service_linked_role_input::Builder::default()
    }
    /// Creates a new `DeleteServiceLinkedRole` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteServiceLinkedRole {
    type Output = std::result::Result<
        crate::output::DeleteServiceLinkedRoleOutput,
        crate::error::DeleteServiceLinkedRoleError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_service_linked_role_error(response)
        } else {
            crate::operation_deser::parse_delete_service_linked_role_response(response)
        }
    }
}

/// Operation shape for `DeleteServiceSpecificCredential`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_service_specific_credential`](crate::client::Client::delete_service_specific_credential).
///
/// See [`crate::client::fluent_builders::DeleteServiceSpecificCredential`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteServiceSpecificCredential {
    _private: (),
}
impl DeleteServiceSpecificCredential {
    /// Creates a new builder-style object to manufacture [`DeleteServiceSpecificCredentialInput`](crate::input::DeleteServiceSpecificCredentialInput)
    pub fn builder() -> crate::input::delete_service_specific_credential_input::Builder {
        crate::input::delete_service_specific_credential_input::Builder::default()
    }
    /// Creates a new `DeleteServiceSpecificCredential` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteServiceSpecificCredential {
    type Output = std::result::Result<
        crate::output::DeleteServiceSpecificCredentialOutput,
        crate::error::DeleteServiceSpecificCredentialError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_service_specific_credential_error(response)
        } else {
            crate::operation_deser::parse_delete_service_specific_credential_response(response)
        }
    }
}

/// Operation shape for `DeleteSigningCertificate`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_signing_certificate`](crate::client::Client::delete_signing_certificate).
///
/// See [`crate::client::fluent_builders::DeleteSigningCertificate`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteSigningCertificate {
    _private: (),
}
impl DeleteSigningCertificate {
    /// Creates a new builder-style object to manufacture [`DeleteSigningCertificateInput`](crate::input::DeleteSigningCertificateInput)
    pub fn builder() -> crate::input::delete_signing_certificate_input::Builder {
        crate::input::delete_signing_certificate_input::Builder::default()
    }
    /// Creates a new `DeleteSigningCertificate` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteSigningCertificate {
    type Output = std::result::Result<
        crate::output::DeleteSigningCertificateOutput,
        crate::error::DeleteSigningCertificateError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_signing_certificate_error(response)
        } else {
            crate::operation_deser::parse_delete_signing_certificate_response(response)
        }
    }
}

/// Operation shape for `DeleteSSHPublicKey`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_ssh_public_key`](crate::client::Client::delete_ssh_public_key).
///
/// See [`crate::client::fluent_builders::DeleteSSHPublicKey`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteSSHPublicKey {
    _private: (),
}
impl DeleteSSHPublicKey {
    /// Creates a new builder-style object to manufacture [`DeleteSshPublicKeyInput`](crate::input::DeleteSshPublicKeyInput)
    pub fn builder() -> crate::input::delete_ssh_public_key_input::Builder {
        crate::input::delete_ssh_public_key_input::Builder::default()
    }
    /// Creates a new `DeleteSSHPublicKey` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteSSHPublicKey {
    type Output = std::result::Result<
        crate::output::DeleteSshPublicKeyOutput,
        crate::error::DeleteSSHPublicKeyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_ssh_public_key_error(response)
        } else {
            crate::operation_deser::parse_delete_ssh_public_key_response(response)
        }
    }
}

/// Operation shape for `DeleteUser`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_user`](crate::client::Client::delete_user).
///
/// See [`crate::client::fluent_builders::DeleteUser`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteUser {
    _private: (),
}
impl DeleteUser {
    /// Creates a new builder-style object to manufacture [`DeleteUserInput`](crate::input::DeleteUserInput)
    pub fn builder() -> crate::input::delete_user_input::Builder {
        crate::input::delete_user_input::Builder::default()
    }
    /// Creates a new `DeleteUser` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteUser {
    type Output =
        std::result::Result<crate::output::DeleteUserOutput, crate::error::DeleteUserError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_user_error(response)
        } else {
            crate::operation_deser::parse_delete_user_response(response)
        }
    }
}

/// Operation shape for `DeleteUserPermissionsBoundary`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_user_permissions_boundary`](crate::client::Client::delete_user_permissions_boundary).
///
/// See [`crate::client::fluent_builders::DeleteUserPermissionsBoundary`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteUserPermissionsBoundary {
    _private: (),
}
impl DeleteUserPermissionsBoundary {
    /// Creates a new builder-style object to manufacture [`DeleteUserPermissionsBoundaryInput`](crate::input::DeleteUserPermissionsBoundaryInput)
    pub fn builder() -> crate::input::delete_user_permissions_boundary_input::Builder {
        crate::input::delete_user_permissions_boundary_input::Builder::default()
    }
    /// Creates a new `DeleteUserPermissionsBoundary` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteUserPermissionsBoundary {
    type Output = std::result::Result<
        crate::output::DeleteUserPermissionsBoundaryOutput,
        crate::error::DeleteUserPermissionsBoundaryError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_user_permissions_boundary_error(response)
        } else {
            crate::operation_deser::parse_delete_user_permissions_boundary_response(response)
        }
    }
}

/// Operation shape for `DeleteUserPolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_user_policy`](crate::client::Client::delete_user_policy).
///
/// See [`crate::client::fluent_builders::DeleteUserPolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteUserPolicy {
    _private: (),
}
impl DeleteUserPolicy {
    /// Creates a new builder-style object to manufacture [`DeleteUserPolicyInput`](crate::input::DeleteUserPolicyInput)
    pub fn builder() -> crate::input::delete_user_policy_input::Builder {
        crate::input::delete_user_policy_input::Builder::default()
    }
    /// Creates a new `DeleteUserPolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteUserPolicy {
    type Output = std::result::Result<
        crate::output::DeleteUserPolicyOutput,
        crate::error::DeleteUserPolicyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_user_policy_error(response)
        } else {
            crate::operation_deser::parse_delete_user_policy_response(response)
        }
    }
}

/// Operation shape for `DeleteVirtualMFADevice`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_virtual_mfa_device`](crate::client::Client::delete_virtual_mfa_device).
///
/// See [`crate::client::fluent_builders::DeleteVirtualMFADevice`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteVirtualMFADevice {
    _private: (),
}
impl DeleteVirtualMFADevice {
    /// Creates a new builder-style object to manufacture [`DeleteVirtualMfaDeviceInput`](crate::input::DeleteVirtualMfaDeviceInput)
    pub fn builder() -> crate::input::delete_virtual_mfa_device_input::Builder {
        crate::input::delete_virtual_mfa_device_input::Builder::default()
    }
    /// Creates a new `DeleteVirtualMFADevice` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteVirtualMFADevice {
    type Output = std::result::Result<
        crate::output::DeleteVirtualMfaDeviceOutput,
        crate::error::DeleteVirtualMFADeviceError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_virtual_mfa_device_error(response)
        } else {
            crate::operation_deser::parse_delete_virtual_mfa_device_response(response)
        }
    }
}

/// Operation shape for `DetachGroupPolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`detach_group_policy`](crate::client::Client::detach_group_policy).
///
/// See [`crate::client::fluent_builders::DetachGroupPolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DetachGroupPolicy {
    _private: (),
}
impl DetachGroupPolicy {
    /// Creates a new builder-style object to manufacture [`DetachGroupPolicyInput`](crate::input::DetachGroupPolicyInput)
    pub fn builder() -> crate::input::detach_group_policy_input::Builder {
        crate::input::detach_group_policy_input::Builder::default()
    }
    /// Creates a new `DetachGroupPolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DetachGroupPolicy {
    type Output = std::result::Result<
        crate::output::DetachGroupPolicyOutput,
        crate::error::DetachGroupPolicyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_detach_group_policy_error(response)
        } else {
            crate::operation_deser::parse_detach_group_policy_response(response)
        }
    }
}

/// Operation shape for `DetachRolePolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`detach_role_policy`](crate::client::Client::detach_role_policy).
///
/// See [`crate::client::fluent_builders::DetachRolePolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DetachRolePolicy {
    _private: (),
}
impl DetachRolePolicy {
    /// Creates a new builder-style object to manufacture [`DetachRolePolicyInput`](crate::input::DetachRolePolicyInput)
    pub fn builder() -> crate::input::detach_role_policy_input::Builder {
        crate::input::detach_role_policy_input::Builder::default()
    }
    /// Creates a new `DetachRolePolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DetachRolePolicy {
    type Output = std::result::Result<
        crate::output::DetachRolePolicyOutput,
        crate::error::DetachRolePolicyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_detach_role_policy_error(response)
        } else {
            crate::operation_deser::parse_detach_role_policy_response(response)
        }
    }
}

/// Operation shape for `DetachUserPolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`detach_user_policy`](crate::client::Client::detach_user_policy).
///
/// See [`crate::client::fluent_builders::DetachUserPolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DetachUserPolicy {
    _private: (),
}
impl DetachUserPolicy {
    /// Creates a new builder-style object to manufacture [`DetachUserPolicyInput`](crate::input::DetachUserPolicyInput)
    pub fn builder() -> crate::input::detach_user_policy_input::Builder {
        crate::input::detach_user_policy_input::Builder::default()
    }
    /// Creates a new `DetachUserPolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DetachUserPolicy {
    type Output = std::result::Result<
        crate::output::DetachUserPolicyOutput,
        crate::error::DetachUserPolicyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_detach_user_policy_error(response)
        } else {
            crate::operation_deser::parse_detach_user_policy_response(response)
        }
    }
}

/// Operation shape for `EnableMFADevice`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`enable_mfa_device`](crate::client::Client::enable_mfa_device).
///
/// See [`crate::client::fluent_builders::EnableMFADevice`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct EnableMFADevice {
    _private: (),
}
impl EnableMFADevice {
    /// Creates a new builder-style object to manufacture [`EnableMfaDeviceInput`](crate::input::EnableMfaDeviceInput)
    pub fn builder() -> crate::input::enable_mfa_device_input::Builder {
        crate::input::enable_mfa_device_input::Builder::default()
    }
    /// Creates a new `EnableMFADevice` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for EnableMFADevice {
    type Output = std::result::Result<
        crate::output::EnableMfaDeviceOutput,
        crate::error::EnableMFADeviceError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_enable_mfa_device_error(response)
        } else {
            crate::operation_deser::parse_enable_mfa_device_response(response)
        }
    }
}

/// Operation shape for `GenerateCredentialReport`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`generate_credential_report`](crate::client::Client::generate_credential_report).
///
/// See [`crate::client::fluent_builders::GenerateCredentialReport`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GenerateCredentialReport {
    _private: (),
}
impl GenerateCredentialReport {
    /// Creates a new builder-style object to manufacture [`GenerateCredentialReportInput`](crate::input::GenerateCredentialReportInput)
    pub fn builder() -> crate::input::generate_credential_report_input::Builder {
        crate::input::generate_credential_report_input::Builder::default()
    }
    /// Creates a new `GenerateCredentialReport` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GenerateCredentialReport {
    type Output = std::result::Result<
        crate::output::GenerateCredentialReportOutput,
        crate::error::GenerateCredentialReportError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_generate_credential_report_error(response)
        } else {
            crate::operation_deser::parse_generate_credential_report_response(response)
        }
    }
}

/// Operation shape for `GenerateOrganizationsAccessReport`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`generate_organizations_access_report`](crate::client::Client::generate_organizations_access_report).
///
/// See [`crate::client::fluent_builders::GenerateOrganizationsAccessReport`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GenerateOrganizationsAccessReport {
    _private: (),
}
impl GenerateOrganizationsAccessReport {
    /// Creates a new builder-style object to manufacture [`GenerateOrganizationsAccessReportInput`](crate::input::GenerateOrganizationsAccessReportInput)
    pub fn builder() -> crate::input::generate_organizations_access_report_input::Builder {
        crate::input::generate_organizations_access_report_input::Builder::default()
    }
    /// Creates a new `GenerateOrganizationsAccessReport` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GenerateOrganizationsAccessReport {
    type Output = std::result::Result<
        crate::output::GenerateOrganizationsAccessReportOutput,
        crate::error::GenerateOrganizationsAccessReportError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_generate_organizations_access_report_error(response)
        } else {
            crate::operation_deser::parse_generate_organizations_access_report_response(response)
        }
    }
}

/// Operation shape for `GenerateServiceLastAccessedDetails`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`generate_service_last_accessed_details`](crate::client::Client::generate_service_last_accessed_details).
///
/// See [`crate::client::fluent_builders::GenerateServiceLastAccessedDetails`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GenerateServiceLastAccessedDetails {
    _private: (),
}
impl GenerateServiceLastAccessedDetails {
    /// Creates a new builder-style object to manufacture [`GenerateServiceLastAccessedDetailsInput`](crate::input::GenerateServiceLastAccessedDetailsInput)
    pub fn builder() -> crate::input::generate_service_last_accessed_details_input::Builder {
        crate::input::generate_service_last_accessed_details_input::Builder::default()
    }
    /// Creates a new `GenerateServiceLastAccessedDetails` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GenerateServiceLastAccessedDetails {
    type Output = std::result::Result<
        crate::output::GenerateServiceLastAccessedDetailsOutput,
        crate::error::GenerateServiceLastAccessedDetailsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_generate_service_last_accessed_details_error(response)
        } else {
            crate::operation_deser::parse_generate_service_last_accessed_details_response(response)
        }
    }
}

/// Operation shape for `GetAccessKeyLastUsed`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_access_key_last_used`](crate::client::Client::get_access_key_last_used).
///
/// See [`crate::client::fluent_builders::GetAccessKeyLastUsed`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetAccessKeyLastUsed {
    _private: (),
}
impl GetAccessKeyLastUsed {
    /// Creates a new builder-style object to manufacture [`GetAccessKeyLastUsedInput`](crate::input::GetAccessKeyLastUsedInput)
    pub fn builder() -> crate::input::get_access_key_last_used_input::Builder {
        crate::input::get_access_key_last_used_input::Builder::default()
    }
    /// Creates a new `GetAccessKeyLastUsed` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetAccessKeyLastUsed {
    type Output = std::result::Result<
        crate::output::GetAccessKeyLastUsedOutput,
        crate::error::GetAccessKeyLastUsedError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_access_key_last_used_error(response)
        } else {
            crate::operation_deser::parse_get_access_key_last_used_response(response)
        }
    }
}

/// Operation shape for `GetAccountAuthorizationDetails`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_account_authorization_details`](crate::client::Client::get_account_authorization_details).
///
/// See [`crate::client::fluent_builders::GetAccountAuthorizationDetails`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetAccountAuthorizationDetails {
    _private: (),
}
impl GetAccountAuthorizationDetails {
    /// Creates a new builder-style object to manufacture [`GetAccountAuthorizationDetailsInput`](crate::input::GetAccountAuthorizationDetailsInput)
    pub fn builder() -> crate::input::get_account_authorization_details_input::Builder {
        crate::input::get_account_authorization_details_input::Builder::default()
    }
    /// Creates a new `GetAccountAuthorizationDetails` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetAccountAuthorizationDetails {
    type Output = std::result::Result<
        crate::output::GetAccountAuthorizationDetailsOutput,
        crate::error::GetAccountAuthorizationDetailsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_account_authorization_details_error(response)
        } else {
            crate::operation_deser::parse_get_account_authorization_details_response(response)
        }
    }
}

/// Operation shape for `GetAccountPasswordPolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_account_password_policy`](crate::client::Client::get_account_password_policy).
///
/// See [`crate::client::fluent_builders::GetAccountPasswordPolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetAccountPasswordPolicy {
    _private: (),
}
impl GetAccountPasswordPolicy {
    /// Creates a new builder-style object to manufacture [`GetAccountPasswordPolicyInput`](crate::input::GetAccountPasswordPolicyInput)
    pub fn builder() -> crate::input::get_account_password_policy_input::Builder {
        crate::input::get_account_password_policy_input::Builder::default()
    }
    /// Creates a new `GetAccountPasswordPolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetAccountPasswordPolicy {
    type Output = std::result::Result<
        crate::output::GetAccountPasswordPolicyOutput,
        crate::error::GetAccountPasswordPolicyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_account_password_policy_error(response)
        } else {
            crate::operation_deser::parse_get_account_password_policy_response(response)
        }
    }
}

/// Operation shape for `GetAccountSummary`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_account_summary`](crate::client::Client::get_account_summary).
///
/// See [`crate::client::fluent_builders::GetAccountSummary`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetAccountSummary {
    _private: (),
}
impl GetAccountSummary {
    /// Creates a new builder-style object to manufacture [`GetAccountSummaryInput`](crate::input::GetAccountSummaryInput)
    pub fn builder() -> crate::input::get_account_summary_input::Builder {
        crate::input::get_account_summary_input::Builder::default()
    }
    /// Creates a new `GetAccountSummary` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetAccountSummary {
    type Output = std::result::Result<
        crate::output::GetAccountSummaryOutput,
        crate::error::GetAccountSummaryError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_account_summary_error(response)
        } else {
            crate::operation_deser::parse_get_account_summary_response(response)
        }
    }
}

/// Operation shape for `GetContextKeysForCustomPolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_context_keys_for_custom_policy`](crate::client::Client::get_context_keys_for_custom_policy).
///
/// See [`crate::client::fluent_builders::GetContextKeysForCustomPolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetContextKeysForCustomPolicy {
    _private: (),
}
impl GetContextKeysForCustomPolicy {
    /// Creates a new builder-style object to manufacture [`GetContextKeysForCustomPolicyInput`](crate::input::GetContextKeysForCustomPolicyInput)
    pub fn builder() -> crate::input::get_context_keys_for_custom_policy_input::Builder {
        crate::input::get_context_keys_for_custom_policy_input::Builder::default()
    }
    /// Creates a new `GetContextKeysForCustomPolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetContextKeysForCustomPolicy {
    type Output = std::result::Result<
        crate::output::GetContextKeysForCustomPolicyOutput,
        crate::error::GetContextKeysForCustomPolicyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_context_keys_for_custom_policy_error(response)
        } else {
            crate::operation_deser::parse_get_context_keys_for_custom_policy_response(response)
        }
    }
}

/// Operation shape for `GetContextKeysForPrincipalPolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_context_keys_for_principal_policy`](crate::client::Client::get_context_keys_for_principal_policy).
///
/// See [`crate::client::fluent_builders::GetContextKeysForPrincipalPolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetContextKeysForPrincipalPolicy {
    _private: (),
}
impl GetContextKeysForPrincipalPolicy {
    /// Creates a new builder-style object to manufacture [`GetContextKeysForPrincipalPolicyInput`](crate::input::GetContextKeysForPrincipalPolicyInput)
    pub fn builder() -> crate::input::get_context_keys_for_principal_policy_input::Builder {
        crate::input::get_context_keys_for_principal_policy_input::Builder::default()
    }
    /// Creates a new `GetContextKeysForPrincipalPolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetContextKeysForPrincipalPolicy {
    type Output = std::result::Result<
        crate::output::GetContextKeysForPrincipalPolicyOutput,
        crate::error::GetContextKeysForPrincipalPolicyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_context_keys_for_principal_policy_error(response)
        } else {
            crate::operation_deser::parse_get_context_keys_for_principal_policy_response(response)
        }
    }
}

/// Operation shape for `GetCredentialReport`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_credential_report`](crate::client::Client::get_credential_report).
///
/// See [`crate::client::fluent_builders::GetCredentialReport`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetCredentialReport {
    _private: (),
}
impl GetCredentialReport {
    /// Creates a new builder-style object to manufacture [`GetCredentialReportInput`](crate::input::GetCredentialReportInput)
    pub fn builder() -> crate::input::get_credential_report_input::Builder {
        crate::input::get_credential_report_input::Builder::default()
    }
    /// Creates a new `GetCredentialReport` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetCredentialReport {
    type Output = std::result::Result<
        crate::output::GetCredentialReportOutput,
        crate::error::GetCredentialReportError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_credential_report_error(response)
        } else {
            crate::operation_deser::parse_get_credential_report_response(response)
        }
    }
}

/// Operation shape for `GetGroup`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_group`](crate::client::Client::get_group).
///
/// See [`crate::client::fluent_builders::GetGroup`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetGroup {
    _private: (),
}
impl GetGroup {
    /// Creates a new builder-style object to manufacture [`GetGroupInput`](crate::input::GetGroupInput)
    pub fn builder() -> crate::input::get_group_input::Builder {
        crate::input::get_group_input::Builder::default()
    }
    /// Creates a new `GetGroup` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetGroup {
    type Output = std::result::Result<crate::output::GetGroupOutput, crate::error::GetGroupError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_group_error(response)
        } else {
            crate::operation_deser::parse_get_group_response(response)
        }
    }
}

/// Operation shape for `GetGroupPolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_group_policy`](crate::client::Client::get_group_policy).
///
/// See [`crate::client::fluent_builders::GetGroupPolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetGroupPolicy {
    _private: (),
}
impl GetGroupPolicy {
    /// Creates a new builder-style object to manufacture [`GetGroupPolicyInput`](crate::input::GetGroupPolicyInput)
    pub fn builder() -> crate::input::get_group_policy_input::Builder {
        crate::input::get_group_policy_input::Builder::default()
    }
    /// Creates a new `GetGroupPolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetGroupPolicy {
    type Output =
        std::result::Result<crate::output::GetGroupPolicyOutput, crate::error::GetGroupPolicyError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_group_policy_error(response)
        } else {
            crate::operation_deser::parse_get_group_policy_response(response)
        }
    }
}

/// Operation shape for `GetInstanceProfile`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_instance_profile`](crate::client::Client::get_instance_profile).
///
/// See [`crate::client::fluent_builders::GetInstanceProfile`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetInstanceProfile {
    _private: (),
}
impl GetInstanceProfile {
    /// Creates a new builder-style object to manufacture [`GetInstanceProfileInput`](crate::input::GetInstanceProfileInput)
    pub fn builder() -> crate::input::get_instance_profile_input::Builder {
        crate::input::get_instance_profile_input::Builder::default()
    }
    /// Creates a new `GetInstanceProfile` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetInstanceProfile {
    type Output = std::result::Result<
        crate::output::GetInstanceProfileOutput,
        crate::error::GetInstanceProfileError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_instance_profile_error(response)
        } else {
            crate::operation_deser::parse_get_instance_profile_response(response)
        }
    }
}

/// Operation shape for `GetLoginProfile`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_login_profile`](crate::client::Client::get_login_profile).
///
/// See [`crate::client::fluent_builders::GetLoginProfile`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetLoginProfile {
    _private: (),
}
impl GetLoginProfile {
    /// Creates a new builder-style object to manufacture [`GetLoginProfileInput`](crate::input::GetLoginProfileInput)
    pub fn builder() -> crate::input::get_login_profile_input::Builder {
        crate::input::get_login_profile_input::Builder::default()
    }
    /// Creates a new `GetLoginProfile` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetLoginProfile {
    type Output = std::result::Result<
        crate::output::GetLoginProfileOutput,
        crate::error::GetLoginProfileError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_login_profile_error(response)
        } else {
            crate::operation_deser::parse_get_login_profile_response(response)
        }
    }
}

/// Operation shape for `GetOpenIDConnectProvider`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_open_id_connect_provider`](crate::client::Client::get_open_id_connect_provider).
///
/// See [`crate::client::fluent_builders::GetOpenIDConnectProvider`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetOpenIDConnectProvider {
    _private: (),
}
impl GetOpenIDConnectProvider {
    /// Creates a new builder-style object to manufacture [`GetOpenIdConnectProviderInput`](crate::input::GetOpenIdConnectProviderInput)
    pub fn builder() -> crate::input::get_open_id_connect_provider_input::Builder {
        crate::input::get_open_id_connect_provider_input::Builder::default()
    }
    /// Creates a new `GetOpenIDConnectProvider` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetOpenIDConnectProvider {
    type Output = std::result::Result<
        crate::output::GetOpenIdConnectProviderOutput,
        crate::error::GetOpenIDConnectProviderError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_open_id_connect_provider_error(response)
        } else {
            crate::operation_deser::parse_get_open_id_connect_provider_response(response)
        }
    }
}

/// Operation shape for `GetOrganizationsAccessReport`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_organizations_access_report`](crate::client::Client::get_organizations_access_report).
///
/// See [`crate::client::fluent_builders::GetOrganizationsAccessReport`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetOrganizationsAccessReport {
    _private: (),
}
impl GetOrganizationsAccessReport {
    /// Creates a new builder-style object to manufacture [`GetOrganizationsAccessReportInput`](crate::input::GetOrganizationsAccessReportInput)
    pub fn builder() -> crate::input::get_organizations_access_report_input::Builder {
        crate::input::get_organizations_access_report_input::Builder::default()
    }
    /// Creates a new `GetOrganizationsAccessReport` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetOrganizationsAccessReport {
    type Output = std::result::Result<
        crate::output::GetOrganizationsAccessReportOutput,
        crate::error::GetOrganizationsAccessReportError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_organizations_access_report_error(response)
        } else {
            crate::operation_deser::parse_get_organizations_access_report_response(response)
        }
    }
}

/// Operation shape for `GetPolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_policy`](crate::client::Client::get_policy).
///
/// See [`crate::client::fluent_builders::GetPolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetPolicy {
    _private: (),
}
impl GetPolicy {
    /// Creates a new builder-style object to manufacture [`GetPolicyInput`](crate::input::GetPolicyInput)
    pub fn builder() -> crate::input::get_policy_input::Builder {
        crate::input::get_policy_input::Builder::default()
    }
    /// Creates a new `GetPolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetPolicy {
    type Output = std::result::Result<crate::output::GetPolicyOutput, crate::error::GetPolicyError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_policy_error(response)
        } else {
            crate::operation_deser::parse_get_policy_response(response)
        }
    }
}

/// Operation shape for `GetPolicyVersion`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_policy_version`](crate::client::Client::get_policy_version).
///
/// See [`crate::client::fluent_builders::GetPolicyVersion`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetPolicyVersion {
    _private: (),
}
impl GetPolicyVersion {
    /// Creates a new builder-style object to manufacture [`GetPolicyVersionInput`](crate::input::GetPolicyVersionInput)
    pub fn builder() -> crate::input::get_policy_version_input::Builder {
        crate::input::get_policy_version_input::Builder::default()
    }
    /// Creates a new `GetPolicyVersion` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetPolicyVersion {
    type Output = std::result::Result<
        crate::output::GetPolicyVersionOutput,
        crate::error::GetPolicyVersionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_policy_version_error(response)
        } else {
            crate::operation_deser::parse_get_policy_version_response(response)
        }
    }
}

/// Operation shape for `GetRole`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_role`](crate::client::Client::get_role).
///
/// See [`crate::client::fluent_builders::GetRole`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetRole {
    _private: (),
}
impl GetRole {
    /// Creates a new builder-style object to manufacture [`GetRoleInput`](crate::input::GetRoleInput)
    pub fn builder() -> crate::input::get_role_input::Builder {
        crate::input::get_role_input::Builder::default()
    }
    /// Creates a new `GetRole` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetRole {
    type Output = std::result::Result<crate::output::GetRoleOutput, crate::error::GetRoleError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_role_error(response)
        } else {
            crate::operation_deser::parse_get_role_response(response)
        }
    }
}

/// Operation shape for `GetRolePolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_role_policy`](crate::client::Client::get_role_policy).
///
/// See [`crate::client::fluent_builders::GetRolePolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetRolePolicy {
    _private: (),
}
impl GetRolePolicy {
    /// Creates a new builder-style object to manufacture [`GetRolePolicyInput`](crate::input::GetRolePolicyInput)
    pub fn builder() -> crate::input::get_role_policy_input::Builder {
        crate::input::get_role_policy_input::Builder::default()
    }
    /// Creates a new `GetRolePolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetRolePolicy {
    type Output =
        std::result::Result<crate::output::GetRolePolicyOutput, crate::error::GetRolePolicyError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_role_policy_error(response)
        } else {
            crate::operation_deser::parse_get_role_policy_response(response)
        }
    }
}

/// Operation shape for `GetSAMLProvider`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_saml_provider`](crate::client::Client::get_saml_provider).
///
/// See [`crate::client::fluent_builders::GetSAMLProvider`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetSAMLProvider {
    _private: (),
}
impl GetSAMLProvider {
    /// Creates a new builder-style object to manufacture [`GetSamlProviderInput`](crate::input::GetSamlProviderInput)
    pub fn builder() -> crate::input::get_saml_provider_input::Builder {
        crate::input::get_saml_provider_input::Builder::default()
    }
    /// Creates a new `GetSAMLProvider` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetSAMLProvider {
    type Output = std::result::Result<
        crate::output::GetSamlProviderOutput,
        crate::error::GetSAMLProviderError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_saml_provider_error(response)
        } else {
            crate::operation_deser::parse_get_saml_provider_response(response)
        }
    }
}

/// Operation shape for `GetServerCertificate`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_server_certificate`](crate::client::Client::get_server_certificate).
///
/// See [`crate::client::fluent_builders::GetServerCertificate`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetServerCertificate {
    _private: (),
}
impl GetServerCertificate {
    /// Creates a new builder-style object to manufacture [`GetServerCertificateInput`](crate::input::GetServerCertificateInput)
    pub fn builder() -> crate::input::get_server_certificate_input::Builder {
        crate::input::get_server_certificate_input::Builder::default()
    }
    /// Creates a new `GetServerCertificate` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetServerCertificate {
    type Output = std::result::Result<
        crate::output::GetServerCertificateOutput,
        crate::error::GetServerCertificateError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_server_certificate_error(response)
        } else {
            crate::operation_deser::parse_get_server_certificate_response(response)
        }
    }
}

/// Operation shape for `GetServiceLastAccessedDetails`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_service_last_accessed_details`](crate::client::Client::get_service_last_accessed_details).
///
/// See [`crate::client::fluent_builders::GetServiceLastAccessedDetails`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetServiceLastAccessedDetails {
    _private: (),
}
impl GetServiceLastAccessedDetails {
    /// Creates a new builder-style object to manufacture [`GetServiceLastAccessedDetailsInput`](crate::input::GetServiceLastAccessedDetailsInput)
    pub fn builder() -> crate::input::get_service_last_accessed_details_input::Builder {
        crate::input::get_service_last_accessed_details_input::Builder::default()
    }
    /// Creates a new `GetServiceLastAccessedDetails` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetServiceLastAccessedDetails {
    type Output = std::result::Result<
        crate::output::GetServiceLastAccessedDetailsOutput,
        crate::error::GetServiceLastAccessedDetailsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_service_last_accessed_details_error(response)
        } else {
            crate::operation_deser::parse_get_service_last_accessed_details_response(response)
        }
    }
}

/// Operation shape for `GetServiceLastAccessedDetailsWithEntities`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_service_last_accessed_details_with_entities`](crate::client::Client::get_service_last_accessed_details_with_entities).
///
/// See [`crate::client::fluent_builders::GetServiceLastAccessedDetailsWithEntities`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetServiceLastAccessedDetailsWithEntities {
    _private: (),
}
impl GetServiceLastAccessedDetailsWithEntities {
    /// Creates a new builder-style object to manufacture [`GetServiceLastAccessedDetailsWithEntitiesInput`](crate::input::GetServiceLastAccessedDetailsWithEntitiesInput)
    pub fn builder() -> crate::input::get_service_last_accessed_details_with_entities_input::Builder
    {
        crate::input::get_service_last_accessed_details_with_entities_input::Builder::default()
    }
    /// Creates a new `GetServiceLastAccessedDetailsWithEntities` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetServiceLastAccessedDetailsWithEntities {
    type Output = std::result::Result<
        crate::output::GetServiceLastAccessedDetailsWithEntitiesOutput,
        crate::error::GetServiceLastAccessedDetailsWithEntitiesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_service_last_accessed_details_with_entities_error(
                response,
            )
        } else {
            crate::operation_deser::parse_get_service_last_accessed_details_with_entities_response(
                response,
            )
        }
    }
}

/// Operation shape for `GetServiceLinkedRoleDeletionStatus`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_service_linked_role_deletion_status`](crate::client::Client::get_service_linked_role_deletion_status).
///
/// See [`crate::client::fluent_builders::GetServiceLinkedRoleDeletionStatus`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetServiceLinkedRoleDeletionStatus {
    _private: (),
}
impl GetServiceLinkedRoleDeletionStatus {
    /// Creates a new builder-style object to manufacture [`GetServiceLinkedRoleDeletionStatusInput`](crate::input::GetServiceLinkedRoleDeletionStatusInput)
    pub fn builder() -> crate::input::get_service_linked_role_deletion_status_input::Builder {
        crate::input::get_service_linked_role_deletion_status_input::Builder::default()
    }
    /// Creates a new `GetServiceLinkedRoleDeletionStatus` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetServiceLinkedRoleDeletionStatus {
    type Output = std::result::Result<
        crate::output::GetServiceLinkedRoleDeletionStatusOutput,
        crate::error::GetServiceLinkedRoleDeletionStatusError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_service_linked_role_deletion_status_error(response)
        } else {
            crate::operation_deser::parse_get_service_linked_role_deletion_status_response(response)
        }
    }
}

/// Operation shape for `GetSSHPublicKey`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_ssh_public_key`](crate::client::Client::get_ssh_public_key).
///
/// See [`crate::client::fluent_builders::GetSSHPublicKey`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetSSHPublicKey {
    _private: (),
}
impl GetSSHPublicKey {
    /// Creates a new builder-style object to manufacture [`GetSshPublicKeyInput`](crate::input::GetSshPublicKeyInput)
    pub fn builder() -> crate::input::get_ssh_public_key_input::Builder {
        crate::input::get_ssh_public_key_input::Builder::default()
    }
    /// Creates a new `GetSSHPublicKey` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetSSHPublicKey {
    type Output = std::result::Result<
        crate::output::GetSshPublicKeyOutput,
        crate::error::GetSSHPublicKeyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_ssh_public_key_error(response)
        } else {
            crate::operation_deser::parse_get_ssh_public_key_response(response)
        }
    }
}

/// Operation shape for `GetUser`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_user`](crate::client::Client::get_user).
///
/// See [`crate::client::fluent_builders::GetUser`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetUser {
    _private: (),
}
impl GetUser {
    /// Creates a new builder-style object to manufacture [`GetUserInput`](crate::input::GetUserInput)
    pub fn builder() -> crate::input::get_user_input::Builder {
        crate::input::get_user_input::Builder::default()
    }
    /// Creates a new `GetUser` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetUser {
    type Output = std::result::Result<crate::output::GetUserOutput, crate::error::GetUserError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_user_error(response)
        } else {
            crate::operation_deser::parse_get_user_response(response)
        }
    }
}

/// Operation shape for `GetUserPolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_user_policy`](crate::client::Client::get_user_policy).
///
/// See [`crate::client::fluent_builders::GetUserPolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetUserPolicy {
    _private: (),
}
impl GetUserPolicy {
    /// Creates a new builder-style object to manufacture [`GetUserPolicyInput`](crate::input::GetUserPolicyInput)
    pub fn builder() -> crate::input::get_user_policy_input::Builder {
        crate::input::get_user_policy_input::Builder::default()
    }
    /// Creates a new `GetUserPolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetUserPolicy {
    type Output =
        std::result::Result<crate::output::GetUserPolicyOutput, crate::error::GetUserPolicyError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_user_policy_error(response)
        } else {
            crate::operation_deser::parse_get_user_policy_response(response)
        }
    }
}

/// Operation shape for `ListAccessKeys`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_access_keys`](crate::client::Client::list_access_keys).
///
/// See [`crate::client::fluent_builders::ListAccessKeys`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListAccessKeys {
    _private: (),
}
impl ListAccessKeys {
    /// Creates a new builder-style object to manufacture [`ListAccessKeysInput`](crate::input::ListAccessKeysInput)
    pub fn builder() -> crate::input::list_access_keys_input::Builder {
        crate::input::list_access_keys_input::Builder::default()
    }
    /// Creates a new `ListAccessKeys` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListAccessKeys {
    type Output =
        std::result::Result<crate::output::ListAccessKeysOutput, crate::error::ListAccessKeysError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_access_keys_error(response)
        } else {
            crate::operation_deser::parse_list_access_keys_response(response)
        }
    }
}

/// Operation shape for `ListAccountAliases`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_account_aliases`](crate::client::Client::list_account_aliases).
///
/// See [`crate::client::fluent_builders::ListAccountAliases`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListAccountAliases {
    _private: (),
}
impl ListAccountAliases {
    /// Creates a new builder-style object to manufacture [`ListAccountAliasesInput`](crate::input::ListAccountAliasesInput)
    pub fn builder() -> crate::input::list_account_aliases_input::Builder {
        crate::input::list_account_aliases_input::Builder::default()
    }
    /// Creates a new `ListAccountAliases` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListAccountAliases {
    type Output = std::result::Result<
        crate::output::ListAccountAliasesOutput,
        crate::error::ListAccountAliasesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_account_aliases_error(response)
        } else {
            crate::operation_deser::parse_list_account_aliases_response(response)
        }
    }
}

/// Operation shape for `ListAttachedGroupPolicies`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_attached_group_policies`](crate::client::Client::list_attached_group_policies).
///
/// See [`crate::client::fluent_builders::ListAttachedGroupPolicies`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListAttachedGroupPolicies {
    _private: (),
}
impl ListAttachedGroupPolicies {
    /// Creates a new builder-style object to manufacture [`ListAttachedGroupPoliciesInput`](crate::input::ListAttachedGroupPoliciesInput)
    pub fn builder() -> crate::input::list_attached_group_policies_input::Builder {
        crate::input::list_attached_group_policies_input::Builder::default()
    }
    /// Creates a new `ListAttachedGroupPolicies` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListAttachedGroupPolicies {
    type Output = std::result::Result<
        crate::output::ListAttachedGroupPoliciesOutput,
        crate::error::ListAttachedGroupPoliciesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_attached_group_policies_error(response)
        } else {
            crate::operation_deser::parse_list_attached_group_policies_response(response)
        }
    }
}

/// Operation shape for `ListAttachedRolePolicies`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_attached_role_policies`](crate::client::Client::list_attached_role_policies).
///
/// See [`crate::client::fluent_builders::ListAttachedRolePolicies`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListAttachedRolePolicies {
    _private: (),
}
impl ListAttachedRolePolicies {
    /// Creates a new builder-style object to manufacture [`ListAttachedRolePoliciesInput`](crate::input::ListAttachedRolePoliciesInput)
    pub fn builder() -> crate::input::list_attached_role_policies_input::Builder {
        crate::input::list_attached_role_policies_input::Builder::default()
    }
    /// Creates a new `ListAttachedRolePolicies` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListAttachedRolePolicies {
    type Output = std::result::Result<
        crate::output::ListAttachedRolePoliciesOutput,
        crate::error::ListAttachedRolePoliciesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_attached_role_policies_error(response)
        } else {
            crate::operation_deser::parse_list_attached_role_policies_response(response)
        }
    }
}

/// Operation shape for `ListAttachedUserPolicies`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_attached_user_policies`](crate::client::Client::list_attached_user_policies).
///
/// See [`crate::client::fluent_builders::ListAttachedUserPolicies`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListAttachedUserPolicies {
    _private: (),
}
impl ListAttachedUserPolicies {
    /// Creates a new builder-style object to manufacture [`ListAttachedUserPoliciesInput`](crate::input::ListAttachedUserPoliciesInput)
    pub fn builder() -> crate::input::list_attached_user_policies_input::Builder {
        crate::input::list_attached_user_policies_input::Builder::default()
    }
    /// Creates a new `ListAttachedUserPolicies` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListAttachedUserPolicies {
    type Output = std::result::Result<
        crate::output::ListAttachedUserPoliciesOutput,
        crate::error::ListAttachedUserPoliciesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_attached_user_policies_error(response)
        } else {
            crate::operation_deser::parse_list_attached_user_policies_response(response)
        }
    }
}

/// Operation shape for `ListEntitiesForPolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_entities_for_policy`](crate::client::Client::list_entities_for_policy).
///
/// See [`crate::client::fluent_builders::ListEntitiesForPolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListEntitiesForPolicy {
    _private: (),
}
impl ListEntitiesForPolicy {
    /// Creates a new builder-style object to manufacture [`ListEntitiesForPolicyInput`](crate::input::ListEntitiesForPolicyInput)
    pub fn builder() -> crate::input::list_entities_for_policy_input::Builder {
        crate::input::list_entities_for_policy_input::Builder::default()
    }
    /// Creates a new `ListEntitiesForPolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListEntitiesForPolicy {
    type Output = std::result::Result<
        crate::output::ListEntitiesForPolicyOutput,
        crate::error::ListEntitiesForPolicyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_entities_for_policy_error(response)
        } else {
            crate::operation_deser::parse_list_entities_for_policy_response(response)
        }
    }
}

/// Operation shape for `ListGroupPolicies`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_group_policies`](crate::client::Client::list_group_policies).
///
/// See [`crate::client::fluent_builders::ListGroupPolicies`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListGroupPolicies {
    _private: (),
}
impl ListGroupPolicies {
    /// Creates a new builder-style object to manufacture [`ListGroupPoliciesInput`](crate::input::ListGroupPoliciesInput)
    pub fn builder() -> crate::input::list_group_policies_input::Builder {
        crate::input::list_group_policies_input::Builder::default()
    }
    /// Creates a new `ListGroupPolicies` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListGroupPolicies {
    type Output = std::result::Result<
        crate::output::ListGroupPoliciesOutput,
        crate::error::ListGroupPoliciesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_group_policies_error(response)
        } else {
            crate::operation_deser::parse_list_group_policies_response(response)
        }
    }
}

/// Operation shape for `ListGroups`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_groups`](crate::client::Client::list_groups).
///
/// See [`crate::client::fluent_builders::ListGroups`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListGroups {
    _private: (),
}
impl ListGroups {
    /// Creates a new builder-style object to manufacture [`ListGroupsInput`](crate::input::ListGroupsInput)
    pub fn builder() -> crate::input::list_groups_input::Builder {
        crate::input::list_groups_input::Builder::default()
    }
    /// Creates a new `ListGroups` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListGroups {
    type Output =
        std::result::Result<crate::output::ListGroupsOutput, crate::error::ListGroupsError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_groups_error(response)
        } else {
            crate::operation_deser::parse_list_groups_response(response)
        }
    }
}

/// Operation shape for `ListGroupsForUser`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_groups_for_user`](crate::client::Client::list_groups_for_user).
///
/// See [`crate::client::fluent_builders::ListGroupsForUser`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListGroupsForUser {
    _private: (),
}
impl ListGroupsForUser {
    /// Creates a new builder-style object to manufacture [`ListGroupsForUserInput`](crate::input::ListGroupsForUserInput)
    pub fn builder() -> crate::input::list_groups_for_user_input::Builder {
        crate::input::list_groups_for_user_input::Builder::default()
    }
    /// Creates a new `ListGroupsForUser` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListGroupsForUser {
    type Output = std::result::Result<
        crate::output::ListGroupsForUserOutput,
        crate::error::ListGroupsForUserError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_groups_for_user_error(response)
        } else {
            crate::operation_deser::parse_list_groups_for_user_response(response)
        }
    }
}

/// Operation shape for `ListInstanceProfiles`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_instance_profiles`](crate::client::Client::list_instance_profiles).
///
/// See [`crate::client::fluent_builders::ListInstanceProfiles`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListInstanceProfiles {
    _private: (),
}
impl ListInstanceProfiles {
    /// Creates a new builder-style object to manufacture [`ListInstanceProfilesInput`](crate::input::ListInstanceProfilesInput)
    pub fn builder() -> crate::input::list_instance_profiles_input::Builder {
        crate::input::list_instance_profiles_input::Builder::default()
    }
    /// Creates a new `ListInstanceProfiles` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListInstanceProfiles {
    type Output = std::result::Result<
        crate::output::ListInstanceProfilesOutput,
        crate::error::ListInstanceProfilesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_instance_profiles_error(response)
        } else {
            crate::operation_deser::parse_list_instance_profiles_response(response)
        }
    }
}

/// Operation shape for `ListInstanceProfilesForRole`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_instance_profiles_for_role`](crate::client::Client::list_instance_profiles_for_role).
///
/// See [`crate::client::fluent_builders::ListInstanceProfilesForRole`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListInstanceProfilesForRole {
    _private: (),
}
impl ListInstanceProfilesForRole {
    /// Creates a new builder-style object to manufacture [`ListInstanceProfilesForRoleInput`](crate::input::ListInstanceProfilesForRoleInput)
    pub fn builder() -> crate::input::list_instance_profiles_for_role_input::Builder {
        crate::input::list_instance_profiles_for_role_input::Builder::default()
    }
    /// Creates a new `ListInstanceProfilesForRole` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListInstanceProfilesForRole {
    type Output = std::result::Result<
        crate::output::ListInstanceProfilesForRoleOutput,
        crate::error::ListInstanceProfilesForRoleError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_instance_profiles_for_role_error(response)
        } else {
            crate::operation_deser::parse_list_instance_profiles_for_role_response(response)
        }
    }
}

/// Operation shape for `ListInstanceProfileTags`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_instance_profile_tags`](crate::client::Client::list_instance_profile_tags).
///
/// See [`crate::client::fluent_builders::ListInstanceProfileTags`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListInstanceProfileTags {
    _private: (),
}
impl ListInstanceProfileTags {
    /// Creates a new builder-style object to manufacture [`ListInstanceProfileTagsInput`](crate::input::ListInstanceProfileTagsInput)
    pub fn builder() -> crate::input::list_instance_profile_tags_input::Builder {
        crate::input::list_instance_profile_tags_input::Builder::default()
    }
    /// Creates a new `ListInstanceProfileTags` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListInstanceProfileTags {
    type Output = std::result::Result<
        crate::output::ListInstanceProfileTagsOutput,
        crate::error::ListInstanceProfileTagsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_instance_profile_tags_error(response)
        } else {
            crate::operation_deser::parse_list_instance_profile_tags_response(response)
        }
    }
}

/// Operation shape for `ListMFADevices`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_mfa_devices`](crate::client::Client::list_mfa_devices).
///
/// See [`crate::client::fluent_builders::ListMFADevices`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListMFADevices {
    _private: (),
}
impl ListMFADevices {
    /// Creates a new builder-style object to manufacture [`ListMfaDevicesInput`](crate::input::ListMfaDevicesInput)
    pub fn builder() -> crate::input::list_mfa_devices_input::Builder {
        crate::input::list_mfa_devices_input::Builder::default()
    }
    /// Creates a new `ListMFADevices` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListMFADevices {
    type Output =
        std::result::Result<crate::output::ListMfaDevicesOutput, crate::error::ListMFADevicesError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_mfa_devices_error(response)
        } else {
            crate::operation_deser::parse_list_mfa_devices_response(response)
        }
    }
}

/// Operation shape for `ListMFADeviceTags`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_mfa_device_tags`](crate::client::Client::list_mfa_device_tags).
///
/// See [`crate::client::fluent_builders::ListMFADeviceTags`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListMFADeviceTags {
    _private: (),
}
impl ListMFADeviceTags {
    /// Creates a new builder-style object to manufacture [`ListMfaDeviceTagsInput`](crate::input::ListMfaDeviceTagsInput)
    pub fn builder() -> crate::input::list_mfa_device_tags_input::Builder {
        crate::input::list_mfa_device_tags_input::Builder::default()
    }
    /// Creates a new `ListMFADeviceTags` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListMFADeviceTags {
    type Output = std::result::Result<
        crate::output::ListMfaDeviceTagsOutput,
        crate::error::ListMFADeviceTagsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_mfa_device_tags_error(response)
        } else {
            crate::operation_deser::parse_list_mfa_device_tags_response(response)
        }
    }
}

/// Operation shape for `ListOpenIDConnectProviders`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_open_id_connect_providers`](crate::client::Client::list_open_id_connect_providers).
///
/// See [`crate::client::fluent_builders::ListOpenIDConnectProviders`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListOpenIDConnectProviders {
    _private: (),
}
impl ListOpenIDConnectProviders {
    /// Creates a new builder-style object to manufacture [`ListOpenIdConnectProvidersInput`](crate::input::ListOpenIdConnectProvidersInput)
    pub fn builder() -> crate::input::list_open_id_connect_providers_input::Builder {
        crate::input::list_open_id_connect_providers_input::Builder::default()
    }
    /// Creates a new `ListOpenIDConnectProviders` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListOpenIDConnectProviders {
    type Output = std::result::Result<
        crate::output::ListOpenIdConnectProvidersOutput,
        crate::error::ListOpenIDConnectProvidersError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_open_id_connect_providers_error(response)
        } else {
            crate::operation_deser::parse_list_open_id_connect_providers_response(response)
        }
    }
}

/// Operation shape for `ListOpenIDConnectProviderTags`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_open_id_connect_provider_tags`](crate::client::Client::list_open_id_connect_provider_tags).
///
/// See [`crate::client::fluent_builders::ListOpenIDConnectProviderTags`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListOpenIDConnectProviderTags {
    _private: (),
}
impl ListOpenIDConnectProviderTags {
    /// Creates a new builder-style object to manufacture [`ListOpenIdConnectProviderTagsInput`](crate::input::ListOpenIdConnectProviderTagsInput)
    pub fn builder() -> crate::input::list_open_id_connect_provider_tags_input::Builder {
        crate::input::list_open_id_connect_provider_tags_input::Builder::default()
    }
    /// Creates a new `ListOpenIDConnectProviderTags` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListOpenIDConnectProviderTags {
    type Output = std::result::Result<
        crate::output::ListOpenIdConnectProviderTagsOutput,
        crate::error::ListOpenIDConnectProviderTagsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_open_id_connect_provider_tags_error(response)
        } else {
            crate::operation_deser::parse_list_open_id_connect_provider_tags_response(response)
        }
    }
}

/// Operation shape for `ListPolicies`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_policies`](crate::client::Client::list_policies).
///
/// See [`crate::client::fluent_builders::ListPolicies`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListPolicies {
    _private: (),
}
impl ListPolicies {
    /// Creates a new builder-style object to manufacture [`ListPoliciesInput`](crate::input::ListPoliciesInput)
    pub fn builder() -> crate::input::list_policies_input::Builder {
        crate::input::list_policies_input::Builder::default()
    }
    /// Creates a new `ListPolicies` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListPolicies {
    type Output =
        std::result::Result<crate::output::ListPoliciesOutput, crate::error::ListPoliciesError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_policies_error(response)
        } else {
            crate::operation_deser::parse_list_policies_response(response)
        }
    }
}

/// Operation shape for `ListPoliciesGrantingServiceAccess`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_policies_granting_service_access`](crate::client::Client::list_policies_granting_service_access).
///
/// See [`crate::client::fluent_builders::ListPoliciesGrantingServiceAccess`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListPoliciesGrantingServiceAccess {
    _private: (),
}
impl ListPoliciesGrantingServiceAccess {
    /// Creates a new builder-style object to manufacture [`ListPoliciesGrantingServiceAccessInput`](crate::input::ListPoliciesGrantingServiceAccessInput)
    pub fn builder() -> crate::input::list_policies_granting_service_access_input::Builder {
        crate::input::list_policies_granting_service_access_input::Builder::default()
    }
    /// Creates a new `ListPoliciesGrantingServiceAccess` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListPoliciesGrantingServiceAccess {
    type Output = std::result::Result<
        crate::output::ListPoliciesGrantingServiceAccessOutput,
        crate::error::ListPoliciesGrantingServiceAccessError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_policies_granting_service_access_error(response)
        } else {
            crate::operation_deser::parse_list_policies_granting_service_access_response(response)
        }
    }
}

/// Operation shape for `ListPolicyTags`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_policy_tags`](crate::client::Client::list_policy_tags).
///
/// See [`crate::client::fluent_builders::ListPolicyTags`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListPolicyTags {
    _private: (),
}
impl ListPolicyTags {
    /// Creates a new builder-style object to manufacture [`ListPolicyTagsInput`](crate::input::ListPolicyTagsInput)
    pub fn builder() -> crate::input::list_policy_tags_input::Builder {
        crate::input::list_policy_tags_input::Builder::default()
    }
    /// Creates a new `ListPolicyTags` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListPolicyTags {
    type Output =
        std::result::Result<crate::output::ListPolicyTagsOutput, crate::error::ListPolicyTagsError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_policy_tags_error(response)
        } else {
            crate::operation_deser::parse_list_policy_tags_response(response)
        }
    }
}

/// Operation shape for `ListPolicyVersions`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_policy_versions`](crate::client::Client::list_policy_versions).
///
/// See [`crate::client::fluent_builders::ListPolicyVersions`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListPolicyVersions {
    _private: (),
}
impl ListPolicyVersions {
    /// Creates a new builder-style object to manufacture [`ListPolicyVersionsInput`](crate::input::ListPolicyVersionsInput)
    pub fn builder() -> crate::input::list_policy_versions_input::Builder {
        crate::input::list_policy_versions_input::Builder::default()
    }
    /// Creates a new `ListPolicyVersions` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListPolicyVersions {
    type Output = std::result::Result<
        crate::output::ListPolicyVersionsOutput,
        crate::error::ListPolicyVersionsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_policy_versions_error(response)
        } else {
            crate::operation_deser::parse_list_policy_versions_response(response)
        }
    }
}

/// Operation shape for `ListRolePolicies`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_role_policies`](crate::client::Client::list_role_policies).
///
/// See [`crate::client::fluent_builders::ListRolePolicies`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListRolePolicies {
    _private: (),
}
impl ListRolePolicies {
    /// Creates a new builder-style object to manufacture [`ListRolePoliciesInput`](crate::input::ListRolePoliciesInput)
    pub fn builder() -> crate::input::list_role_policies_input::Builder {
        crate::input::list_role_policies_input::Builder::default()
    }
    /// Creates a new `ListRolePolicies` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListRolePolicies {
    type Output = std::result::Result<
        crate::output::ListRolePoliciesOutput,
        crate::error::ListRolePoliciesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_role_policies_error(response)
        } else {
            crate::operation_deser::parse_list_role_policies_response(response)
        }
    }
}

/// Operation shape for `ListRoles`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_roles`](crate::client::Client::list_roles).
///
/// See [`crate::client::fluent_builders::ListRoles`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListRoles {
    _private: (),
}
impl ListRoles {
    /// Creates a new builder-style object to manufacture [`ListRolesInput`](crate::input::ListRolesInput)
    pub fn builder() -> crate::input::list_roles_input::Builder {
        crate::input::list_roles_input::Builder::default()
    }
    /// Creates a new `ListRoles` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListRoles {
    type Output = std::result::Result<crate::output::ListRolesOutput, crate::error::ListRolesError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_roles_error(response)
        } else {
            crate::operation_deser::parse_list_roles_response(response)
        }
    }
}

/// Operation shape for `ListRoleTags`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_role_tags`](crate::client::Client::list_role_tags).
///
/// See [`crate::client::fluent_builders::ListRoleTags`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListRoleTags {
    _private: (),
}
impl ListRoleTags {
    /// Creates a new builder-style object to manufacture [`ListRoleTagsInput`](crate::input::ListRoleTagsInput)
    pub fn builder() -> crate::input::list_role_tags_input::Builder {
        crate::input::list_role_tags_input::Builder::default()
    }
    /// Creates a new `ListRoleTags` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListRoleTags {
    type Output =
        std::result::Result<crate::output::ListRoleTagsOutput, crate::error::ListRoleTagsError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_role_tags_error(response)
        } else {
            crate::operation_deser::parse_list_role_tags_response(response)
        }
    }
}

/// Operation shape for `ListSAMLProviders`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_saml_providers`](crate::client::Client::list_saml_providers).
///
/// See [`crate::client::fluent_builders::ListSAMLProviders`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListSAMLProviders {
    _private: (),
}
impl ListSAMLProviders {
    /// Creates a new builder-style object to manufacture [`ListSamlProvidersInput`](crate::input::ListSamlProvidersInput)
    pub fn builder() -> crate::input::list_saml_providers_input::Builder {
        crate::input::list_saml_providers_input::Builder::default()
    }
    /// Creates a new `ListSAMLProviders` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListSAMLProviders {
    type Output = std::result::Result<
        crate::output::ListSamlProvidersOutput,
        crate::error::ListSAMLProvidersError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_saml_providers_error(response)
        } else {
            crate::operation_deser::parse_list_saml_providers_response(response)
        }
    }
}

/// Operation shape for `ListSAMLProviderTags`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_saml_provider_tags`](crate::client::Client::list_saml_provider_tags).
///
/// See [`crate::client::fluent_builders::ListSAMLProviderTags`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListSAMLProviderTags {
    _private: (),
}
impl ListSAMLProviderTags {
    /// Creates a new builder-style object to manufacture [`ListSamlProviderTagsInput`](crate::input::ListSamlProviderTagsInput)
    pub fn builder() -> crate::input::list_saml_provider_tags_input::Builder {
        crate::input::list_saml_provider_tags_input::Builder::default()
    }
    /// Creates a new `ListSAMLProviderTags` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListSAMLProviderTags {
    type Output = std::result::Result<
        crate::output::ListSamlProviderTagsOutput,
        crate::error::ListSAMLProviderTagsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_saml_provider_tags_error(response)
        } else {
            crate::operation_deser::parse_list_saml_provider_tags_response(response)
        }
    }
}

/// Operation shape for `ListServerCertificates`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_server_certificates`](crate::client::Client::list_server_certificates).
///
/// See [`crate::client::fluent_builders::ListServerCertificates`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListServerCertificates {
    _private: (),
}
impl ListServerCertificates {
    /// Creates a new builder-style object to manufacture [`ListServerCertificatesInput`](crate::input::ListServerCertificatesInput)
    pub fn builder() -> crate::input::list_server_certificates_input::Builder {
        crate::input::list_server_certificates_input::Builder::default()
    }
    /// Creates a new `ListServerCertificates` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListServerCertificates {
    type Output = std::result::Result<
        crate::output::ListServerCertificatesOutput,
        crate::error::ListServerCertificatesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_server_certificates_error(response)
        } else {
            crate::operation_deser::parse_list_server_certificates_response(response)
        }
    }
}

/// Operation shape for `ListServerCertificateTags`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_server_certificate_tags`](crate::client::Client::list_server_certificate_tags).
///
/// See [`crate::client::fluent_builders::ListServerCertificateTags`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListServerCertificateTags {
    _private: (),
}
impl ListServerCertificateTags {
    /// Creates a new builder-style object to manufacture [`ListServerCertificateTagsInput`](crate::input::ListServerCertificateTagsInput)
    pub fn builder() -> crate::input::list_server_certificate_tags_input::Builder {
        crate::input::list_server_certificate_tags_input::Builder::default()
    }
    /// Creates a new `ListServerCertificateTags` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListServerCertificateTags {
    type Output = std::result::Result<
        crate::output::ListServerCertificateTagsOutput,
        crate::error::ListServerCertificateTagsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_server_certificate_tags_error(response)
        } else {
            crate::operation_deser::parse_list_server_certificate_tags_response(response)
        }
    }
}

/// Operation shape for `ListServiceSpecificCredentials`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_service_specific_credentials`](crate::client::Client::list_service_specific_credentials).
///
/// See [`crate::client::fluent_builders::ListServiceSpecificCredentials`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListServiceSpecificCredentials {
    _private: (),
}
impl ListServiceSpecificCredentials {
    /// Creates a new builder-style object to manufacture [`ListServiceSpecificCredentialsInput`](crate::input::ListServiceSpecificCredentialsInput)
    pub fn builder() -> crate::input::list_service_specific_credentials_input::Builder {
        crate::input::list_service_specific_credentials_input::Builder::default()
    }
    /// Creates a new `ListServiceSpecificCredentials` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListServiceSpecificCredentials {
    type Output = std::result::Result<
        crate::output::ListServiceSpecificCredentialsOutput,
        crate::error::ListServiceSpecificCredentialsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_service_specific_credentials_error(response)
        } else {
            crate::operation_deser::parse_list_service_specific_credentials_response(response)
        }
    }
}

/// Operation shape for `ListSigningCertificates`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_signing_certificates`](crate::client::Client::list_signing_certificates).
///
/// See [`crate::client::fluent_builders::ListSigningCertificates`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListSigningCertificates {
    _private: (),
}
impl ListSigningCertificates {
    /// Creates a new builder-style object to manufacture [`ListSigningCertificatesInput`](crate::input::ListSigningCertificatesInput)
    pub fn builder() -> crate::input::list_signing_certificates_input::Builder {
        crate::input::list_signing_certificates_input::Builder::default()
    }
    /// Creates a new `ListSigningCertificates` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListSigningCertificates {
    type Output = std::result::Result<
        crate::output::ListSigningCertificatesOutput,
        crate::error::ListSigningCertificatesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_signing_certificates_error(response)
        } else {
            crate::operation_deser::parse_list_signing_certificates_response(response)
        }
    }
}

/// Operation shape for `ListSSHPublicKeys`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_ssh_public_keys`](crate::client::Client::list_ssh_public_keys).
///
/// See [`crate::client::fluent_builders::ListSSHPublicKeys`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListSSHPublicKeys {
    _private: (),
}
impl ListSSHPublicKeys {
    /// Creates a new builder-style object to manufacture [`ListSshPublicKeysInput`](crate::input::ListSshPublicKeysInput)
    pub fn builder() -> crate::input::list_ssh_public_keys_input::Builder {
        crate::input::list_ssh_public_keys_input::Builder::default()
    }
    /// Creates a new `ListSSHPublicKeys` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListSSHPublicKeys {
    type Output = std::result::Result<
        crate::output::ListSshPublicKeysOutput,
        crate::error::ListSSHPublicKeysError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_ssh_public_keys_error(response)
        } else {
            crate::operation_deser::parse_list_ssh_public_keys_response(response)
        }
    }
}

/// Operation shape for `ListUserPolicies`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_user_policies`](crate::client::Client::list_user_policies).
///
/// See [`crate::client::fluent_builders::ListUserPolicies`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListUserPolicies {
    _private: (),
}
impl ListUserPolicies {
    /// Creates a new builder-style object to manufacture [`ListUserPoliciesInput`](crate::input::ListUserPoliciesInput)
    pub fn builder() -> crate::input::list_user_policies_input::Builder {
        crate::input::list_user_policies_input::Builder::default()
    }
    /// Creates a new `ListUserPolicies` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListUserPolicies {
    type Output = std::result::Result<
        crate::output::ListUserPoliciesOutput,
        crate::error::ListUserPoliciesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_user_policies_error(response)
        } else {
            crate::operation_deser::parse_list_user_policies_response(response)
        }
    }
}

/// Operation shape for `ListUsers`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_users`](crate::client::Client::list_users).
///
/// See [`crate::client::fluent_builders::ListUsers`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListUsers {
    _private: (),
}
impl ListUsers {
    /// Creates a new builder-style object to manufacture [`ListUsersInput`](crate::input::ListUsersInput)
    pub fn builder() -> crate::input::list_users_input::Builder {
        crate::input::list_users_input::Builder::default()
    }
    /// Creates a new `ListUsers` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListUsers {
    type Output = std::result::Result<crate::output::ListUsersOutput, crate::error::ListUsersError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_users_error(response)
        } else {
            crate::operation_deser::parse_list_users_response(response)
        }
    }
}

/// Operation shape for `ListUserTags`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_user_tags`](crate::client::Client::list_user_tags).
///
/// See [`crate::client::fluent_builders::ListUserTags`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListUserTags {
    _private: (),
}
impl ListUserTags {
    /// Creates a new builder-style object to manufacture [`ListUserTagsInput`](crate::input::ListUserTagsInput)
    pub fn builder() -> crate::input::list_user_tags_input::Builder {
        crate::input::list_user_tags_input::Builder::default()
    }
    /// Creates a new `ListUserTags` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListUserTags {
    type Output =
        std::result::Result<crate::output::ListUserTagsOutput, crate::error::ListUserTagsError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_user_tags_error(response)
        } else {
            crate::operation_deser::parse_list_user_tags_response(response)
        }
    }
}

/// Operation shape for `ListVirtualMFADevices`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_virtual_mfa_devices`](crate::client::Client::list_virtual_mfa_devices).
///
/// See [`crate::client::fluent_builders::ListVirtualMFADevices`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListVirtualMFADevices {
    _private: (),
}
impl ListVirtualMFADevices {
    /// Creates a new builder-style object to manufacture [`ListVirtualMfaDevicesInput`](crate::input::ListVirtualMfaDevicesInput)
    pub fn builder() -> crate::input::list_virtual_mfa_devices_input::Builder {
        crate::input::list_virtual_mfa_devices_input::Builder::default()
    }
    /// Creates a new `ListVirtualMFADevices` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListVirtualMFADevices {
    type Output = std::result::Result<
        crate::output::ListVirtualMfaDevicesOutput,
        crate::error::ListVirtualMFADevicesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_virtual_mfa_devices_error(response)
        } else {
            crate::operation_deser::parse_list_virtual_mfa_devices_response(response)
        }
    }
}

/// Operation shape for `PutGroupPolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`put_group_policy`](crate::client::Client::put_group_policy).
///
/// See [`crate::client::fluent_builders::PutGroupPolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct PutGroupPolicy {
    _private: (),
}
impl PutGroupPolicy {
    /// Creates a new builder-style object to manufacture [`PutGroupPolicyInput`](crate::input::PutGroupPolicyInput)
    pub fn builder() -> crate::input::put_group_policy_input::Builder {
        crate::input::put_group_policy_input::Builder::default()
    }
    /// Creates a new `PutGroupPolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for PutGroupPolicy {
    type Output =
        std::result::Result<crate::output::PutGroupPolicyOutput, crate::error::PutGroupPolicyError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_put_group_policy_error(response)
        } else {
            crate::operation_deser::parse_put_group_policy_response(response)
        }
    }
}

/// Operation shape for `PutRolePermissionsBoundary`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`put_role_permissions_boundary`](crate::client::Client::put_role_permissions_boundary).
///
/// See [`crate::client::fluent_builders::PutRolePermissionsBoundary`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct PutRolePermissionsBoundary {
    _private: (),
}
impl PutRolePermissionsBoundary {
    /// Creates a new builder-style object to manufacture [`PutRolePermissionsBoundaryInput`](crate::input::PutRolePermissionsBoundaryInput)
    pub fn builder() -> crate::input::put_role_permissions_boundary_input::Builder {
        crate::input::put_role_permissions_boundary_input::Builder::default()
    }
    /// Creates a new `PutRolePermissionsBoundary` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for PutRolePermissionsBoundary {
    type Output = std::result::Result<
        crate::output::PutRolePermissionsBoundaryOutput,
        crate::error::PutRolePermissionsBoundaryError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_put_role_permissions_boundary_error(response)
        } else {
            crate::operation_deser::parse_put_role_permissions_boundary_response(response)
        }
    }
}

/// Operation shape for `PutRolePolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`put_role_policy`](crate::client::Client::put_role_policy).
///
/// See [`crate::client::fluent_builders::PutRolePolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct PutRolePolicy {
    _private: (),
}
impl PutRolePolicy {
    /// Creates a new builder-style object to manufacture [`PutRolePolicyInput`](crate::input::PutRolePolicyInput)
    pub fn builder() -> crate::input::put_role_policy_input::Builder {
        crate::input::put_role_policy_input::Builder::default()
    }
    /// Creates a new `PutRolePolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for PutRolePolicy {
    type Output =
        std::result::Result<crate::output::PutRolePolicyOutput, crate::error::PutRolePolicyError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_put_role_policy_error(response)
        } else {
            crate::operation_deser::parse_put_role_policy_response(response)
        }
    }
}

/// Operation shape for `PutUserPermissionsBoundary`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`put_user_permissions_boundary`](crate::client::Client::put_user_permissions_boundary).
///
/// See [`crate::client::fluent_builders::PutUserPermissionsBoundary`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct PutUserPermissionsBoundary {
    _private: (),
}
impl PutUserPermissionsBoundary {
    /// Creates a new builder-style object to manufacture [`PutUserPermissionsBoundaryInput`](crate::input::PutUserPermissionsBoundaryInput)
    pub fn builder() -> crate::input::put_user_permissions_boundary_input::Builder {
        crate::input::put_user_permissions_boundary_input::Builder::default()
    }
    /// Creates a new `PutUserPermissionsBoundary` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for PutUserPermissionsBoundary {
    type Output = std::result::Result<
        crate::output::PutUserPermissionsBoundaryOutput,
        crate::error::PutUserPermissionsBoundaryError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_put_user_permissions_boundary_error(response)
        } else {
            crate::operation_deser::parse_put_user_permissions_boundary_response(response)
        }
    }
}

/// Operation shape for `PutUserPolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`put_user_policy`](crate::client::Client::put_user_policy).
///
/// See [`crate::client::fluent_builders::PutUserPolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct PutUserPolicy {
    _private: (),
}
impl PutUserPolicy {
    /// Creates a new builder-style object to manufacture [`PutUserPolicyInput`](crate::input::PutUserPolicyInput)
    pub fn builder() -> crate::input::put_user_policy_input::Builder {
        crate::input::put_user_policy_input::Builder::default()
    }
    /// Creates a new `PutUserPolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for PutUserPolicy {
    type Output =
        std::result::Result<crate::output::PutUserPolicyOutput, crate::error::PutUserPolicyError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_put_user_policy_error(response)
        } else {
            crate::operation_deser::parse_put_user_policy_response(response)
        }
    }
}

/// Operation shape for `RemoveClientIDFromOpenIDConnectProvider`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`remove_client_id_from_open_id_connect_provider`](crate::client::Client::remove_client_id_from_open_id_connect_provider).
///
/// See [`crate::client::fluent_builders::RemoveClientIDFromOpenIDConnectProvider`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct RemoveClientIDFromOpenIDConnectProvider {
    _private: (),
}
impl RemoveClientIDFromOpenIDConnectProvider {
    /// Creates a new builder-style object to manufacture [`RemoveClientIdFromOpenIdConnectProviderInput`](crate::input::RemoveClientIdFromOpenIdConnectProviderInput)
    pub fn builder() -> crate::input::remove_client_id_from_open_id_connect_provider_input::Builder
    {
        crate::input::remove_client_id_from_open_id_connect_provider_input::Builder::default()
    }
    /// Creates a new `RemoveClientIDFromOpenIDConnectProvider` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for RemoveClientIDFromOpenIDConnectProvider {
    type Output = std::result::Result<
        crate::output::RemoveClientIdFromOpenIdConnectProviderOutput,
        crate::error::RemoveClientIDFromOpenIDConnectProviderError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_remove_client_id_from_open_id_connect_provider_error(
                response,
            )
        } else {
            crate::operation_deser::parse_remove_client_id_from_open_id_connect_provider_response(
                response,
            )
        }
    }
}

/// Operation shape for `RemoveRoleFromInstanceProfile`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`remove_role_from_instance_profile`](crate::client::Client::remove_role_from_instance_profile).
///
/// See [`crate::client::fluent_builders::RemoveRoleFromInstanceProfile`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct RemoveRoleFromInstanceProfile {
    _private: (),
}
impl RemoveRoleFromInstanceProfile {
    /// Creates a new builder-style object to manufacture [`RemoveRoleFromInstanceProfileInput`](crate::input::RemoveRoleFromInstanceProfileInput)
    pub fn builder() -> crate::input::remove_role_from_instance_profile_input::Builder {
        crate::input::remove_role_from_instance_profile_input::Builder::default()
    }
    /// Creates a new `RemoveRoleFromInstanceProfile` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for RemoveRoleFromInstanceProfile {
    type Output = std::result::Result<
        crate::output::RemoveRoleFromInstanceProfileOutput,
        crate::error::RemoveRoleFromInstanceProfileError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_remove_role_from_instance_profile_error(response)
        } else {
            crate::operation_deser::parse_remove_role_from_instance_profile_response(response)
        }
    }
}

/// Operation shape for `RemoveUserFromGroup`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`remove_user_from_group`](crate::client::Client::remove_user_from_group).
///
/// See [`crate::client::fluent_builders::RemoveUserFromGroup`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct RemoveUserFromGroup {
    _private: (),
}
impl RemoveUserFromGroup {
    /// Creates a new builder-style object to manufacture [`RemoveUserFromGroupInput`](crate::input::RemoveUserFromGroupInput)
    pub fn builder() -> crate::input::remove_user_from_group_input::Builder {
        crate::input::remove_user_from_group_input::Builder::default()
    }
    /// Creates a new `RemoveUserFromGroup` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for RemoveUserFromGroup {
    type Output = std::result::Result<
        crate::output::RemoveUserFromGroupOutput,
        crate::error::RemoveUserFromGroupError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_remove_user_from_group_error(response)
        } else {
            crate::operation_deser::parse_remove_user_from_group_response(response)
        }
    }
}

/// Operation shape for `ResetServiceSpecificCredential`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`reset_service_specific_credential`](crate::client::Client::reset_service_specific_credential).
///
/// See [`crate::client::fluent_builders::ResetServiceSpecificCredential`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ResetServiceSpecificCredential {
    _private: (),
}
impl ResetServiceSpecificCredential {
    /// Creates a new builder-style object to manufacture [`ResetServiceSpecificCredentialInput`](crate::input::ResetServiceSpecificCredentialInput)
    pub fn builder() -> crate::input::reset_service_specific_credential_input::Builder {
        crate::input::reset_service_specific_credential_input::Builder::default()
    }
    /// Creates a new `ResetServiceSpecificCredential` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ResetServiceSpecificCredential {
    type Output = std::result::Result<
        crate::output::ResetServiceSpecificCredentialOutput,
        crate::error::ResetServiceSpecificCredentialError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_reset_service_specific_credential_error(response)
        } else {
            crate::operation_deser::parse_reset_service_specific_credential_response(response)
        }
    }
}

/// Operation shape for `ResyncMFADevice`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`resync_mfa_device`](crate::client::Client::resync_mfa_device).
///
/// See [`crate::client::fluent_builders::ResyncMFADevice`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ResyncMFADevice {
    _private: (),
}
impl ResyncMFADevice {
    /// Creates a new builder-style object to manufacture [`ResyncMfaDeviceInput`](crate::input::ResyncMfaDeviceInput)
    pub fn builder() -> crate::input::resync_mfa_device_input::Builder {
        crate::input::resync_mfa_device_input::Builder::default()
    }
    /// Creates a new `ResyncMFADevice` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ResyncMFADevice {
    type Output = std::result::Result<
        crate::output::ResyncMfaDeviceOutput,
        crate::error::ResyncMFADeviceError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_resync_mfa_device_error(response)
        } else {
            crate::operation_deser::parse_resync_mfa_device_response(response)
        }
    }
}

/// Operation shape for `SetDefaultPolicyVersion`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`set_default_policy_version`](crate::client::Client::set_default_policy_version).
///
/// See [`crate::client::fluent_builders::SetDefaultPolicyVersion`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct SetDefaultPolicyVersion {
    _private: (),
}
impl SetDefaultPolicyVersion {
    /// Creates a new builder-style object to manufacture [`SetDefaultPolicyVersionInput`](crate::input::SetDefaultPolicyVersionInput)
    pub fn builder() -> crate::input::set_default_policy_version_input::Builder {
        crate::input::set_default_policy_version_input::Builder::default()
    }
    /// Creates a new `SetDefaultPolicyVersion` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for SetDefaultPolicyVersion {
    type Output = std::result::Result<
        crate::output::SetDefaultPolicyVersionOutput,
        crate::error::SetDefaultPolicyVersionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_set_default_policy_version_error(response)
        } else {
            crate::operation_deser::parse_set_default_policy_version_response(response)
        }
    }
}

/// Operation shape for `SetSecurityTokenServicePreferences`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`set_security_token_service_preferences`](crate::client::Client::set_security_token_service_preferences).
///
/// See [`crate::client::fluent_builders::SetSecurityTokenServicePreferences`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct SetSecurityTokenServicePreferences {
    _private: (),
}
impl SetSecurityTokenServicePreferences {
    /// Creates a new builder-style object to manufacture [`SetSecurityTokenServicePreferencesInput`](crate::input::SetSecurityTokenServicePreferencesInput)
    pub fn builder() -> crate::input::set_security_token_service_preferences_input::Builder {
        crate::input::set_security_token_service_preferences_input::Builder::default()
    }
    /// Creates a new `SetSecurityTokenServicePreferences` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for SetSecurityTokenServicePreferences {
    type Output = std::result::Result<
        crate::output::SetSecurityTokenServicePreferencesOutput,
        crate::error::SetSecurityTokenServicePreferencesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_set_security_token_service_preferences_error(response)
        } else {
            crate::operation_deser::parse_set_security_token_service_preferences_response(response)
        }
    }
}

/// Operation shape for `SimulateCustomPolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`simulate_custom_policy`](crate::client::Client::simulate_custom_policy).
///
/// See [`crate::client::fluent_builders::SimulateCustomPolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct SimulateCustomPolicy {
    _private: (),
}
impl SimulateCustomPolicy {
    /// Creates a new builder-style object to manufacture [`SimulateCustomPolicyInput`](crate::input::SimulateCustomPolicyInput)
    pub fn builder() -> crate::input::simulate_custom_policy_input::Builder {
        crate::input::simulate_custom_policy_input::Builder::default()
    }
    /// Creates a new `SimulateCustomPolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for SimulateCustomPolicy {
    type Output = std::result::Result<
        crate::output::SimulateCustomPolicyOutput,
        crate::error::SimulateCustomPolicyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_simulate_custom_policy_error(response)
        } else {
            crate::operation_deser::parse_simulate_custom_policy_response(response)
        }
    }
}

/// Operation shape for `SimulatePrincipalPolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`simulate_principal_policy`](crate::client::Client::simulate_principal_policy).
///
/// See [`crate::client::fluent_builders::SimulatePrincipalPolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct SimulatePrincipalPolicy {
    _private: (),
}
impl SimulatePrincipalPolicy {
    /// Creates a new builder-style object to manufacture [`SimulatePrincipalPolicyInput`](crate::input::SimulatePrincipalPolicyInput)
    pub fn builder() -> crate::input::simulate_principal_policy_input::Builder {
        crate::input::simulate_principal_policy_input::Builder::default()
    }
    /// Creates a new `SimulatePrincipalPolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for SimulatePrincipalPolicy {
    type Output = std::result::Result<
        crate::output::SimulatePrincipalPolicyOutput,
        crate::error::SimulatePrincipalPolicyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_simulate_principal_policy_error(response)
        } else {
            crate::operation_deser::parse_simulate_principal_policy_response(response)
        }
    }
}

/// Operation shape for `TagInstanceProfile`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`tag_instance_profile`](crate::client::Client::tag_instance_profile).
///
/// See [`crate::client::fluent_builders::TagInstanceProfile`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct TagInstanceProfile {
    _private: (),
}
impl TagInstanceProfile {
    /// Creates a new builder-style object to manufacture [`TagInstanceProfileInput`](crate::input::TagInstanceProfileInput)
    pub fn builder() -> crate::input::tag_instance_profile_input::Builder {
        crate::input::tag_instance_profile_input::Builder::default()
    }
    /// Creates a new `TagInstanceProfile` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for TagInstanceProfile {
    type Output = std::result::Result<
        crate::output::TagInstanceProfileOutput,
        crate::error::TagInstanceProfileError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_tag_instance_profile_error(response)
        } else {
            crate::operation_deser::parse_tag_instance_profile_response(response)
        }
    }
}

/// Operation shape for `TagMFADevice`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`tag_mfa_device`](crate::client::Client::tag_mfa_device).
///
/// See [`crate::client::fluent_builders::TagMFADevice`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct TagMFADevice {
    _private: (),
}
impl TagMFADevice {
    /// Creates a new builder-style object to manufacture [`TagMfaDeviceInput`](crate::input::TagMfaDeviceInput)
    pub fn builder() -> crate::input::tag_mfa_device_input::Builder {
        crate::input::tag_mfa_device_input::Builder::default()
    }
    /// Creates a new `TagMFADevice` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for TagMFADevice {
    type Output =
        std::result::Result<crate::output::TagMfaDeviceOutput, crate::error::TagMFADeviceError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_tag_mfa_device_error(response)
        } else {
            crate::operation_deser::parse_tag_mfa_device_response(response)
        }
    }
}

/// Operation shape for `TagOpenIDConnectProvider`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`tag_open_id_connect_provider`](crate::client::Client::tag_open_id_connect_provider).
///
/// See [`crate::client::fluent_builders::TagOpenIDConnectProvider`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct TagOpenIDConnectProvider {
    _private: (),
}
impl TagOpenIDConnectProvider {
    /// Creates a new builder-style object to manufacture [`TagOpenIdConnectProviderInput`](crate::input::TagOpenIdConnectProviderInput)
    pub fn builder() -> crate::input::tag_open_id_connect_provider_input::Builder {
        crate::input::tag_open_id_connect_provider_input::Builder::default()
    }
    /// Creates a new `TagOpenIDConnectProvider` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for TagOpenIDConnectProvider {
    type Output = std::result::Result<
        crate::output::TagOpenIdConnectProviderOutput,
        crate::error::TagOpenIDConnectProviderError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_tag_open_id_connect_provider_error(response)
        } else {
            crate::operation_deser::parse_tag_open_id_connect_provider_response(response)
        }
    }
}

/// Operation shape for `TagPolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`tag_policy`](crate::client::Client::tag_policy).
///
/// See [`crate::client::fluent_builders::TagPolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct TagPolicy {
    _private: (),
}
impl TagPolicy {
    /// Creates a new builder-style object to manufacture [`TagPolicyInput`](crate::input::TagPolicyInput)
    pub fn builder() -> crate::input::tag_policy_input::Builder {
        crate::input::tag_policy_input::Builder::default()
    }
    /// Creates a new `TagPolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for TagPolicy {
    type Output = std::result::Result<crate::output::TagPolicyOutput, crate::error::TagPolicyError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_tag_policy_error(response)
        } else {
            crate::operation_deser::parse_tag_policy_response(response)
        }
    }
}

/// Operation shape for `TagRole`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`tag_role`](crate::client::Client::tag_role).
///
/// See [`crate::client::fluent_builders::TagRole`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct TagRole {
    _private: (),
}
impl TagRole {
    /// Creates a new builder-style object to manufacture [`TagRoleInput`](crate::input::TagRoleInput)
    pub fn builder() -> crate::input::tag_role_input::Builder {
        crate::input::tag_role_input::Builder::default()
    }
    /// Creates a new `TagRole` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for TagRole {
    type Output = std::result::Result<crate::output::TagRoleOutput, crate::error::TagRoleError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_tag_role_error(response)
        } else {
            crate::operation_deser::parse_tag_role_response(response)
        }
    }
}

/// Operation shape for `TagSAMLProvider`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`tag_saml_provider`](crate::client::Client::tag_saml_provider).
///
/// See [`crate::client::fluent_builders::TagSAMLProvider`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct TagSAMLProvider {
    _private: (),
}
impl TagSAMLProvider {
    /// Creates a new builder-style object to manufacture [`TagSamlProviderInput`](crate::input::TagSamlProviderInput)
    pub fn builder() -> crate::input::tag_saml_provider_input::Builder {
        crate::input::tag_saml_provider_input::Builder::default()
    }
    /// Creates a new `TagSAMLProvider` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for TagSAMLProvider {
    type Output = std::result::Result<
        crate::output::TagSamlProviderOutput,
        crate::error::TagSAMLProviderError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_tag_saml_provider_error(response)
        } else {
            crate::operation_deser::parse_tag_saml_provider_response(response)
        }
    }
}

/// Operation shape for `TagServerCertificate`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`tag_server_certificate`](crate::client::Client::tag_server_certificate).
///
/// See [`crate::client::fluent_builders::TagServerCertificate`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct TagServerCertificate {
    _private: (),
}
impl TagServerCertificate {
    /// Creates a new builder-style object to manufacture [`TagServerCertificateInput`](crate::input::TagServerCertificateInput)
    pub fn builder() -> crate::input::tag_server_certificate_input::Builder {
        crate::input::tag_server_certificate_input::Builder::default()
    }
    /// Creates a new `TagServerCertificate` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for TagServerCertificate {
    type Output = std::result::Result<
        crate::output::TagServerCertificateOutput,
        crate::error::TagServerCertificateError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_tag_server_certificate_error(response)
        } else {
            crate::operation_deser::parse_tag_server_certificate_response(response)
        }
    }
}

/// Operation shape for `TagUser`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`tag_user`](crate::client::Client::tag_user).
///
/// See [`crate::client::fluent_builders::TagUser`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct TagUser {
    _private: (),
}
impl TagUser {
    /// Creates a new builder-style object to manufacture [`TagUserInput`](crate::input::TagUserInput)
    pub fn builder() -> crate::input::tag_user_input::Builder {
        crate::input::tag_user_input::Builder::default()
    }
    /// Creates a new `TagUser` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for TagUser {
    type Output = std::result::Result<crate::output::TagUserOutput, crate::error::TagUserError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_tag_user_error(response)
        } else {
            crate::operation_deser::parse_tag_user_response(response)
        }
    }
}

/// Operation shape for `UntagInstanceProfile`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`untag_instance_profile`](crate::client::Client::untag_instance_profile).
///
/// See [`crate::client::fluent_builders::UntagInstanceProfile`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UntagInstanceProfile {
    _private: (),
}
impl UntagInstanceProfile {
    /// Creates a new builder-style object to manufacture [`UntagInstanceProfileInput`](crate::input::UntagInstanceProfileInput)
    pub fn builder() -> crate::input::untag_instance_profile_input::Builder {
        crate::input::untag_instance_profile_input::Builder::default()
    }
    /// Creates a new `UntagInstanceProfile` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UntagInstanceProfile {
    type Output = std::result::Result<
        crate::output::UntagInstanceProfileOutput,
        crate::error::UntagInstanceProfileError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_untag_instance_profile_error(response)
        } else {
            crate::operation_deser::parse_untag_instance_profile_response(response)
        }
    }
}

/// Operation shape for `UntagMFADevice`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`untag_mfa_device`](crate::client::Client::untag_mfa_device).
///
/// See [`crate::client::fluent_builders::UntagMFADevice`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UntagMFADevice {
    _private: (),
}
impl UntagMFADevice {
    /// Creates a new builder-style object to manufacture [`UntagMfaDeviceInput`](crate::input::UntagMfaDeviceInput)
    pub fn builder() -> crate::input::untag_mfa_device_input::Builder {
        crate::input::untag_mfa_device_input::Builder::default()
    }
    /// Creates a new `UntagMFADevice` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UntagMFADevice {
    type Output =
        std::result::Result<crate::output::UntagMfaDeviceOutput, crate::error::UntagMFADeviceError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_untag_mfa_device_error(response)
        } else {
            crate::operation_deser::parse_untag_mfa_device_response(response)
        }
    }
}

/// Operation shape for `UntagOpenIDConnectProvider`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`untag_open_id_connect_provider`](crate::client::Client::untag_open_id_connect_provider).
///
/// See [`crate::client::fluent_builders::UntagOpenIDConnectProvider`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UntagOpenIDConnectProvider {
    _private: (),
}
impl UntagOpenIDConnectProvider {
    /// Creates a new builder-style object to manufacture [`UntagOpenIdConnectProviderInput`](crate::input::UntagOpenIdConnectProviderInput)
    pub fn builder() -> crate::input::untag_open_id_connect_provider_input::Builder {
        crate::input::untag_open_id_connect_provider_input::Builder::default()
    }
    /// Creates a new `UntagOpenIDConnectProvider` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UntagOpenIDConnectProvider {
    type Output = std::result::Result<
        crate::output::UntagOpenIdConnectProviderOutput,
        crate::error::UntagOpenIDConnectProviderError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_untag_open_id_connect_provider_error(response)
        } else {
            crate::operation_deser::parse_untag_open_id_connect_provider_response(response)
        }
    }
}

/// Operation shape for `UntagPolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`untag_policy`](crate::client::Client::untag_policy).
///
/// See [`crate::client::fluent_builders::UntagPolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UntagPolicy {
    _private: (),
}
impl UntagPolicy {
    /// Creates a new builder-style object to manufacture [`UntagPolicyInput`](crate::input::UntagPolicyInput)
    pub fn builder() -> crate::input::untag_policy_input::Builder {
        crate::input::untag_policy_input::Builder::default()
    }
    /// Creates a new `UntagPolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UntagPolicy {
    type Output =
        std::result::Result<crate::output::UntagPolicyOutput, crate::error::UntagPolicyError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_untag_policy_error(response)
        } else {
            crate::operation_deser::parse_untag_policy_response(response)
        }
    }
}

/// Operation shape for `UntagRole`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`untag_role`](crate::client::Client::untag_role).
///
/// See [`crate::client::fluent_builders::UntagRole`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UntagRole {
    _private: (),
}
impl UntagRole {
    /// Creates a new builder-style object to manufacture [`UntagRoleInput`](crate::input::UntagRoleInput)
    pub fn builder() -> crate::input::untag_role_input::Builder {
        crate::input::untag_role_input::Builder::default()
    }
    /// Creates a new `UntagRole` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UntagRole {
    type Output = std::result::Result<crate::output::UntagRoleOutput, crate::error::UntagRoleError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_untag_role_error(response)
        } else {
            crate::operation_deser::parse_untag_role_response(response)
        }
    }
}

/// Operation shape for `UntagSAMLProvider`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`untag_saml_provider`](crate::client::Client::untag_saml_provider).
///
/// See [`crate::client::fluent_builders::UntagSAMLProvider`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UntagSAMLProvider {
    _private: (),
}
impl UntagSAMLProvider {
    /// Creates a new builder-style object to manufacture [`UntagSamlProviderInput`](crate::input::UntagSamlProviderInput)
    pub fn builder() -> crate::input::untag_saml_provider_input::Builder {
        crate::input::untag_saml_provider_input::Builder::default()
    }
    /// Creates a new `UntagSAMLProvider` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UntagSAMLProvider {
    type Output = std::result::Result<
        crate::output::UntagSamlProviderOutput,
        crate::error::UntagSAMLProviderError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_untag_saml_provider_error(response)
        } else {
            crate::operation_deser::parse_untag_saml_provider_response(response)
        }
    }
}

/// Operation shape for `UntagServerCertificate`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`untag_server_certificate`](crate::client::Client::untag_server_certificate).
///
/// See [`crate::client::fluent_builders::UntagServerCertificate`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UntagServerCertificate {
    _private: (),
}
impl UntagServerCertificate {
    /// Creates a new builder-style object to manufacture [`UntagServerCertificateInput`](crate::input::UntagServerCertificateInput)
    pub fn builder() -> crate::input::untag_server_certificate_input::Builder {
        crate::input::untag_server_certificate_input::Builder::default()
    }
    /// Creates a new `UntagServerCertificate` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UntagServerCertificate {
    type Output = std::result::Result<
        crate::output::UntagServerCertificateOutput,
        crate::error::UntagServerCertificateError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_untag_server_certificate_error(response)
        } else {
            crate::operation_deser::parse_untag_server_certificate_response(response)
        }
    }
}

/// Operation shape for `UntagUser`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`untag_user`](crate::client::Client::untag_user).
///
/// See [`crate::client::fluent_builders::UntagUser`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UntagUser {
    _private: (),
}
impl UntagUser {
    /// Creates a new builder-style object to manufacture [`UntagUserInput`](crate::input::UntagUserInput)
    pub fn builder() -> crate::input::untag_user_input::Builder {
        crate::input::untag_user_input::Builder::default()
    }
    /// Creates a new `UntagUser` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UntagUser {
    type Output = std::result::Result<crate::output::UntagUserOutput, crate::error::UntagUserError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_untag_user_error(response)
        } else {
            crate::operation_deser::parse_untag_user_response(response)
        }
    }
}

/// Operation shape for `UpdateAccessKey`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_access_key`](crate::client::Client::update_access_key).
///
/// See [`crate::client::fluent_builders::UpdateAccessKey`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UpdateAccessKey {
    _private: (),
}
impl UpdateAccessKey {
    /// Creates a new builder-style object to manufacture [`UpdateAccessKeyInput`](crate::input::UpdateAccessKeyInput)
    pub fn builder() -> crate::input::update_access_key_input::Builder {
        crate::input::update_access_key_input::Builder::default()
    }
    /// Creates a new `UpdateAccessKey` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateAccessKey {
    type Output = std::result::Result<
        crate::output::UpdateAccessKeyOutput,
        crate::error::UpdateAccessKeyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_access_key_error(response)
        } else {
            crate::operation_deser::parse_update_access_key_response(response)
        }
    }
}

/// Operation shape for `UpdateAccountPasswordPolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_account_password_policy`](crate::client::Client::update_account_password_policy).
///
/// See [`crate::client::fluent_builders::UpdateAccountPasswordPolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UpdateAccountPasswordPolicy {
    _private: (),
}
impl UpdateAccountPasswordPolicy {
    /// Creates a new builder-style object to manufacture [`UpdateAccountPasswordPolicyInput`](crate::input::UpdateAccountPasswordPolicyInput)
    pub fn builder() -> crate::input::update_account_password_policy_input::Builder {
        crate::input::update_account_password_policy_input::Builder::default()
    }
    /// Creates a new `UpdateAccountPasswordPolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateAccountPasswordPolicy {
    type Output = std::result::Result<
        crate::output::UpdateAccountPasswordPolicyOutput,
        crate::error::UpdateAccountPasswordPolicyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_account_password_policy_error(response)
        } else {
            crate::operation_deser::parse_update_account_password_policy_response(response)
        }
    }
}

/// Operation shape for `UpdateAssumeRolePolicy`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_assume_role_policy`](crate::client::Client::update_assume_role_policy).
///
/// See [`crate::client::fluent_builders::UpdateAssumeRolePolicy`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UpdateAssumeRolePolicy {
    _private: (),
}
impl UpdateAssumeRolePolicy {
    /// Creates a new builder-style object to manufacture [`UpdateAssumeRolePolicyInput`](crate::input::UpdateAssumeRolePolicyInput)
    pub fn builder() -> crate::input::update_assume_role_policy_input::Builder {
        crate::input::update_assume_role_policy_input::Builder::default()
    }
    /// Creates a new `UpdateAssumeRolePolicy` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateAssumeRolePolicy {
    type Output = std::result::Result<
        crate::output::UpdateAssumeRolePolicyOutput,
        crate::error::UpdateAssumeRolePolicyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_assume_role_policy_error(response)
        } else {
            crate::operation_deser::parse_update_assume_role_policy_response(response)
        }
    }
}

/// Operation shape for `UpdateGroup`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_group`](crate::client::Client::update_group).
///
/// See [`crate::client::fluent_builders::UpdateGroup`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UpdateGroup {
    _private: (),
}
impl UpdateGroup {
    /// Creates a new builder-style object to manufacture [`UpdateGroupInput`](crate::input::UpdateGroupInput)
    pub fn builder() -> crate::input::update_group_input::Builder {
        crate::input::update_group_input::Builder::default()
    }
    /// Creates a new `UpdateGroup` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateGroup {
    type Output =
        std::result::Result<crate::output::UpdateGroupOutput, crate::error::UpdateGroupError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_group_error(response)
        } else {
            crate::operation_deser::parse_update_group_response(response)
        }
    }
}

/// Operation shape for `UpdateLoginProfile`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_login_profile`](crate::client::Client::update_login_profile).
///
/// See [`crate::client::fluent_builders::UpdateLoginProfile`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UpdateLoginProfile {
    _private: (),
}
impl UpdateLoginProfile {
    /// Creates a new builder-style object to manufacture [`UpdateLoginProfileInput`](crate::input::UpdateLoginProfileInput)
    pub fn builder() -> crate::input::update_login_profile_input::Builder {
        crate::input::update_login_profile_input::Builder::default()
    }
    /// Creates a new `UpdateLoginProfile` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateLoginProfile {
    type Output = std::result::Result<
        crate::output::UpdateLoginProfileOutput,
        crate::error::UpdateLoginProfileError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_login_profile_error(response)
        } else {
            crate::operation_deser::parse_update_login_profile_response(response)
        }
    }
}

/// Operation shape for `UpdateOpenIDConnectProviderThumbprint`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_open_id_connect_provider_thumbprint`](crate::client::Client::update_open_id_connect_provider_thumbprint).
///
/// See [`crate::client::fluent_builders::UpdateOpenIDConnectProviderThumbprint`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UpdateOpenIDConnectProviderThumbprint {
    _private: (),
}
impl UpdateOpenIDConnectProviderThumbprint {
    /// Creates a new builder-style object to manufacture [`UpdateOpenIdConnectProviderThumbprintInput`](crate::input::UpdateOpenIdConnectProviderThumbprintInput)
    pub fn builder() -> crate::input::update_open_id_connect_provider_thumbprint_input::Builder {
        crate::input::update_open_id_connect_provider_thumbprint_input::Builder::default()
    }
    /// Creates a new `UpdateOpenIDConnectProviderThumbprint` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateOpenIDConnectProviderThumbprint {
    type Output = std::result::Result<
        crate::output::UpdateOpenIdConnectProviderThumbprintOutput,
        crate::error::UpdateOpenIDConnectProviderThumbprintError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_open_id_connect_provider_thumbprint_error(response)
        } else {
            crate::operation_deser::parse_update_open_id_connect_provider_thumbprint_response(
                response,
            )
        }
    }
}

/// Operation shape for `UpdateRole`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_role`](crate::client::Client::update_role).
///
/// See [`crate::client::fluent_builders::UpdateRole`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UpdateRole {
    _private: (),
}
impl UpdateRole {
    /// Creates a new builder-style object to manufacture [`UpdateRoleInput`](crate::input::UpdateRoleInput)
    pub fn builder() -> crate::input::update_role_input::Builder {
        crate::input::update_role_input::Builder::default()
    }
    /// Creates a new `UpdateRole` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateRole {
    type Output =
        std::result::Result<crate::output::UpdateRoleOutput, crate::error::UpdateRoleError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_role_error(response)
        } else {
            crate::operation_deser::parse_update_role_response(response)
        }
    }
}

/// Operation shape for `UpdateRoleDescription`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_role_description`](crate::client::Client::update_role_description).
///
/// See [`crate::client::fluent_builders::UpdateRoleDescription`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UpdateRoleDescription {
    _private: (),
}
impl UpdateRoleDescription {
    /// Creates a new builder-style object to manufacture [`UpdateRoleDescriptionInput`](crate::input::UpdateRoleDescriptionInput)
    pub fn builder() -> crate::input::update_role_description_input::Builder {
        crate::input::update_role_description_input::Builder::default()
    }
    /// Creates a new `UpdateRoleDescription` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateRoleDescription {
    type Output = std::result::Result<
        crate::output::UpdateRoleDescriptionOutput,
        crate::error::UpdateRoleDescriptionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_role_description_error(response)
        } else {
            crate::operation_deser::parse_update_role_description_response(response)
        }
    }
}

/// Operation shape for `UpdateSAMLProvider`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_saml_provider`](crate::client::Client::update_saml_provider).
///
/// See [`crate::client::fluent_builders::UpdateSAMLProvider`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UpdateSAMLProvider {
    _private: (),
}
impl UpdateSAMLProvider {
    /// Creates a new builder-style object to manufacture [`UpdateSamlProviderInput`](crate::input::UpdateSamlProviderInput)
    pub fn builder() -> crate::input::update_saml_provider_input::Builder {
        crate::input::update_saml_provider_input::Builder::default()
    }
    /// Creates a new `UpdateSAMLProvider` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateSAMLProvider {
    type Output = std::result::Result<
        crate::output::UpdateSamlProviderOutput,
        crate::error::UpdateSAMLProviderError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_saml_provider_error(response)
        } else {
            crate::operation_deser::parse_update_saml_provider_response(response)
        }
    }
}

/// Operation shape for `UpdateServerCertificate`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_server_certificate`](crate::client::Client::update_server_certificate).
///
/// See [`crate::client::fluent_builders::UpdateServerCertificate`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UpdateServerCertificate {
    _private: (),
}
impl UpdateServerCertificate {
    /// Creates a new builder-style object to manufacture [`UpdateServerCertificateInput`](crate::input::UpdateServerCertificateInput)
    pub fn builder() -> crate::input::update_server_certificate_input::Builder {
        crate::input::update_server_certificate_input::Builder::default()
    }
    /// Creates a new `UpdateServerCertificate` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateServerCertificate {
    type Output = std::result::Result<
        crate::output::UpdateServerCertificateOutput,
        crate::error::UpdateServerCertificateError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_server_certificate_error(response)
        } else {
            crate::operation_deser::parse_update_server_certificate_response(response)
        }
    }
}

/// Operation shape for `UpdateServiceSpecificCredential`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_service_specific_credential`](crate::client::Client::update_service_specific_credential).
///
/// See [`crate::client::fluent_builders::UpdateServiceSpecificCredential`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UpdateServiceSpecificCredential {
    _private: (),
}
impl UpdateServiceSpecificCredential {
    /// Creates a new builder-style object to manufacture [`UpdateServiceSpecificCredentialInput`](crate::input::UpdateServiceSpecificCredentialInput)
    pub fn builder() -> crate::input::update_service_specific_credential_input::Builder {
        crate::input::update_service_specific_credential_input::Builder::default()
    }
    /// Creates a new `UpdateServiceSpecificCredential` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateServiceSpecificCredential {
    type Output = std::result::Result<
        crate::output::UpdateServiceSpecificCredentialOutput,
        crate::error::UpdateServiceSpecificCredentialError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_service_specific_credential_error(response)
        } else {
            crate::operation_deser::parse_update_service_specific_credential_response(response)
        }
    }
}

/// Operation shape for `UpdateSigningCertificate`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_signing_certificate`](crate::client::Client::update_signing_certificate).
///
/// See [`crate::client::fluent_builders::UpdateSigningCertificate`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UpdateSigningCertificate {
    _private: (),
}
impl UpdateSigningCertificate {
    /// Creates a new builder-style object to manufacture [`UpdateSigningCertificateInput`](crate::input::UpdateSigningCertificateInput)
    pub fn builder() -> crate::input::update_signing_certificate_input::Builder {
        crate::input::update_signing_certificate_input::Builder::default()
    }
    /// Creates a new `UpdateSigningCertificate` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateSigningCertificate {
    type Output = std::result::Result<
        crate::output::UpdateSigningCertificateOutput,
        crate::error::UpdateSigningCertificateError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_signing_certificate_error(response)
        } else {
            crate::operation_deser::parse_update_signing_certificate_response(response)
        }
    }
}

/// Operation shape for `UpdateSSHPublicKey`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_ssh_public_key`](crate::client::Client::update_ssh_public_key).
///
/// See [`crate::client::fluent_builders::UpdateSSHPublicKey`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UpdateSSHPublicKey {
    _private: (),
}
impl UpdateSSHPublicKey {
    /// Creates a new builder-style object to manufacture [`UpdateSshPublicKeyInput`](crate::input::UpdateSshPublicKeyInput)
    pub fn builder() -> crate::input::update_ssh_public_key_input::Builder {
        crate::input::update_ssh_public_key_input::Builder::default()
    }
    /// Creates a new `UpdateSSHPublicKey` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateSSHPublicKey {
    type Output = std::result::Result<
        crate::output::UpdateSshPublicKeyOutput,
        crate::error::UpdateSSHPublicKeyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_ssh_public_key_error(response)
        } else {
            crate::operation_deser::parse_update_ssh_public_key_response(response)
        }
    }
}

/// Operation shape for `UpdateUser`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_user`](crate::client::Client::update_user).
///
/// See [`crate::client::fluent_builders::UpdateUser`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UpdateUser {
    _private: (),
}
impl UpdateUser {
    /// Creates a new builder-style object to manufacture [`UpdateUserInput`](crate::input::UpdateUserInput)
    pub fn builder() -> crate::input::update_user_input::Builder {
        crate::input::update_user_input::Builder::default()
    }
    /// Creates a new `UpdateUser` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateUser {
    type Output =
        std::result::Result<crate::output::UpdateUserOutput, crate::error::UpdateUserError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_user_error(response)
        } else {
            crate::operation_deser::parse_update_user_response(response)
        }
    }
}

/// Operation shape for `UploadServerCertificate`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`upload_server_certificate`](crate::client::Client::upload_server_certificate).
///
/// See [`crate::client::fluent_builders::UploadServerCertificate`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UploadServerCertificate {
    _private: (),
}
impl UploadServerCertificate {
    /// Creates a new builder-style object to manufacture [`UploadServerCertificateInput`](crate::input::UploadServerCertificateInput)
    pub fn builder() -> crate::input::upload_server_certificate_input::Builder {
        crate::input::upload_server_certificate_input::Builder::default()
    }
    /// Creates a new `UploadServerCertificate` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UploadServerCertificate {
    type Output = std::result::Result<
        crate::output::UploadServerCertificateOutput,
        crate::error::UploadServerCertificateError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_upload_server_certificate_error(response)
        } else {
            crate::operation_deser::parse_upload_server_certificate_response(response)
        }
    }
}

/// Operation shape for `UploadSigningCertificate`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`upload_signing_certificate`](crate::client::Client::upload_signing_certificate).
///
/// See [`crate::client::fluent_builders::UploadSigningCertificate`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UploadSigningCertificate {
    _private: (),
}
impl UploadSigningCertificate {
    /// Creates a new builder-style object to manufacture [`UploadSigningCertificateInput`](crate::input::UploadSigningCertificateInput)
    pub fn builder() -> crate::input::upload_signing_certificate_input::Builder {
        crate::input::upload_signing_certificate_input::Builder::default()
    }
    /// Creates a new `UploadSigningCertificate` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UploadSigningCertificate {
    type Output = std::result::Result<
        crate::output::UploadSigningCertificateOutput,
        crate::error::UploadSigningCertificateError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_upload_signing_certificate_error(response)
        } else {
            crate::operation_deser::parse_upload_signing_certificate_response(response)
        }
    }
}

/// Operation shape for `UploadSSHPublicKey`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`upload_ssh_public_key`](crate::client::Client::upload_ssh_public_key).
///
/// See [`crate::client::fluent_builders::UploadSSHPublicKey`] for more details about the operation.
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UploadSSHPublicKey {
    _private: (),
}
impl UploadSSHPublicKey {
    /// Creates a new builder-style object to manufacture [`UploadSshPublicKeyInput`](crate::input::UploadSshPublicKeyInput)
    pub fn builder() -> crate::input::upload_ssh_public_key_input::Builder {
        crate::input::upload_ssh_public_key_input::Builder::default()
    }
    /// Creates a new `UploadSSHPublicKey` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UploadSSHPublicKey {
    type Output = std::result::Result<
        crate::output::UploadSshPublicKeyOutput,
        crate::error::UploadSSHPublicKeyError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_upload_ssh_public_key_error(response)
        } else {
            crate::operation_deser::parse_upload_ssh_public_key_response(response)
        }
    }
}