#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct AddClientIDToOpenIDConnectProvider {
_private: (),
}
impl AddClientIDToOpenIDConnectProvider {
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()
}
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,
)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct AddRoleToInstanceProfile {
_private: (),
}
impl AddRoleToInstanceProfile {
pub fn builder() -> crate::input::add_role_to_instance_profile_input::Builder {
crate::input::add_role_to_instance_profile_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct AddUserToGroup {
_private: (),
}
impl AddUserToGroup {
pub fn builder() -> crate::input::add_user_to_group_input::Builder {
crate::input::add_user_to_group_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct AttachGroupPolicy {
_private: (),
}
impl AttachGroupPolicy {
pub fn builder() -> crate::input::attach_group_policy_input::Builder {
crate::input::attach_group_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct AttachRolePolicy {
_private: (),
}
impl AttachRolePolicy {
pub fn builder() -> crate::input::attach_role_policy_input::Builder {
crate::input::attach_role_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct AttachUserPolicy {
_private: (),
}
impl AttachUserPolicy {
pub fn builder() -> crate::input::attach_user_policy_input::Builder {
crate::input::attach_user_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ChangePassword {
_private: (),
}
impl ChangePassword {
pub fn builder() -> crate::input::change_password_input::Builder {
crate::input::change_password_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateAccessKey {
_private: (),
}
impl CreateAccessKey {
pub fn builder() -> crate::input::create_access_key_input::Builder {
crate::input::create_access_key_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateAccountAlias {
_private: (),
}
impl CreateAccountAlias {
pub fn builder() -> crate::input::create_account_alias_input::Builder {
crate::input::create_account_alias_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateGroup {
_private: (),
}
impl CreateGroup {
pub fn builder() -> crate::input::create_group_input::Builder {
crate::input::create_group_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateInstanceProfile {
_private: (),
}
impl CreateInstanceProfile {
pub fn builder() -> crate::input::create_instance_profile_input::Builder {
crate::input::create_instance_profile_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateLoginProfile {
_private: (),
}
impl CreateLoginProfile {
pub fn builder() -> crate::input::create_login_profile_input::Builder {
crate::input::create_login_profile_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateOpenIDConnectProvider {
_private: (),
}
impl CreateOpenIDConnectProvider {
pub fn builder() -> crate::input::create_open_id_connect_provider_input::Builder {
crate::input::create_open_id_connect_provider_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreatePolicy {
_private: (),
}
impl CreatePolicy {
pub fn builder() -> crate::input::create_policy_input::Builder {
crate::input::create_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreatePolicyVersion {
_private: (),
}
impl CreatePolicyVersion {
pub fn builder() -> crate::input::create_policy_version_input::Builder {
crate::input::create_policy_version_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateRole {
_private: (),
}
impl CreateRole {
pub fn builder() -> crate::input::create_role_input::Builder {
crate::input::create_role_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateSAMLProvider {
_private: (),
}
impl CreateSAMLProvider {
pub fn builder() -> crate::input::create_saml_provider_input::Builder {
crate::input::create_saml_provider_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateServiceLinkedRole {
_private: (),
}
impl CreateServiceLinkedRole {
pub fn builder() -> crate::input::create_service_linked_role_input::Builder {
crate::input::create_service_linked_role_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateServiceSpecificCredential {
_private: (),
}
impl CreateServiceSpecificCredential {
pub fn builder() -> crate::input::create_service_specific_credential_input::Builder {
crate::input::create_service_specific_credential_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateUser {
_private: (),
}
impl CreateUser {
pub fn builder() -> crate::input::create_user_input::Builder {
crate::input::create_user_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateVirtualMFADevice {
_private: (),
}
impl CreateVirtualMFADevice {
pub fn builder() -> crate::input::create_virtual_mfa_device_input::Builder {
crate::input::create_virtual_mfa_device_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeactivateMFADevice {
_private: (),
}
impl DeactivateMFADevice {
pub fn builder() -> crate::input::deactivate_mfa_device_input::Builder {
crate::input::deactivate_mfa_device_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteAccessKey {
_private: (),
}
impl DeleteAccessKey {
pub fn builder() -> crate::input::delete_access_key_input::Builder {
crate::input::delete_access_key_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteAccountAlias {
_private: (),
}
impl DeleteAccountAlias {
pub fn builder() -> crate::input::delete_account_alias_input::Builder {
crate::input::delete_account_alias_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteAccountPasswordPolicy {
_private: (),
}
impl DeleteAccountPasswordPolicy {
pub fn builder() -> crate::input::delete_account_password_policy_input::Builder {
crate::input::delete_account_password_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteGroup {
_private: (),
}
impl DeleteGroup {
pub fn builder() -> crate::input::delete_group_input::Builder {
crate::input::delete_group_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteGroupPolicy {
_private: (),
}
impl DeleteGroupPolicy {
pub fn builder() -> crate::input::delete_group_policy_input::Builder {
crate::input::delete_group_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteInstanceProfile {
_private: (),
}
impl DeleteInstanceProfile {
pub fn builder() -> crate::input::delete_instance_profile_input::Builder {
crate::input::delete_instance_profile_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteLoginProfile {
_private: (),
}
impl DeleteLoginProfile {
pub fn builder() -> crate::input::delete_login_profile_input::Builder {
crate::input::delete_login_profile_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteOpenIDConnectProvider {
_private: (),
}
impl DeleteOpenIDConnectProvider {
pub fn builder() -> crate::input::delete_open_id_connect_provider_input::Builder {
crate::input::delete_open_id_connect_provider_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeletePolicy {
_private: (),
}
impl DeletePolicy {
pub fn builder() -> crate::input::delete_policy_input::Builder {
crate::input::delete_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeletePolicyVersion {
_private: (),
}
impl DeletePolicyVersion {
pub fn builder() -> crate::input::delete_policy_version_input::Builder {
crate::input::delete_policy_version_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteRole {
_private: (),
}
impl DeleteRole {
pub fn builder() -> crate::input::delete_role_input::Builder {
crate::input::delete_role_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteRolePermissionsBoundary {
_private: (),
}
impl DeleteRolePermissionsBoundary {
pub fn builder() -> crate::input::delete_role_permissions_boundary_input::Builder {
crate::input::delete_role_permissions_boundary_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteRolePolicy {
_private: (),
}
impl DeleteRolePolicy {
pub fn builder() -> crate::input::delete_role_policy_input::Builder {
crate::input::delete_role_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteSAMLProvider {
_private: (),
}
impl DeleteSAMLProvider {
pub fn builder() -> crate::input::delete_saml_provider_input::Builder {
crate::input::delete_saml_provider_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteServerCertificate {
_private: (),
}
impl DeleteServerCertificate {
pub fn builder() -> crate::input::delete_server_certificate_input::Builder {
crate::input::delete_server_certificate_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteServiceLinkedRole {
_private: (),
}
impl DeleteServiceLinkedRole {
pub fn builder() -> crate::input::delete_service_linked_role_input::Builder {
crate::input::delete_service_linked_role_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteServiceSpecificCredential {
_private: (),
}
impl DeleteServiceSpecificCredential {
pub fn builder() -> crate::input::delete_service_specific_credential_input::Builder {
crate::input::delete_service_specific_credential_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteSigningCertificate {
_private: (),
}
impl DeleteSigningCertificate {
pub fn builder() -> crate::input::delete_signing_certificate_input::Builder {
crate::input::delete_signing_certificate_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteSSHPublicKey {
_private: (),
}
impl DeleteSSHPublicKey {
pub fn builder() -> crate::input::delete_ssh_public_key_input::Builder {
crate::input::delete_ssh_public_key_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteUser {
_private: (),
}
impl DeleteUser {
pub fn builder() -> crate::input::delete_user_input::Builder {
crate::input::delete_user_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteUserPermissionsBoundary {
_private: (),
}
impl DeleteUserPermissionsBoundary {
pub fn builder() -> crate::input::delete_user_permissions_boundary_input::Builder {
crate::input::delete_user_permissions_boundary_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteUserPolicy {
_private: (),
}
impl DeleteUserPolicy {
pub fn builder() -> crate::input::delete_user_policy_input::Builder {
crate::input::delete_user_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteVirtualMFADevice {
_private: (),
}
impl DeleteVirtualMFADevice {
pub fn builder() -> crate::input::delete_virtual_mfa_device_input::Builder {
crate::input::delete_virtual_mfa_device_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DetachGroupPolicy {
_private: (),
}
impl DetachGroupPolicy {
pub fn builder() -> crate::input::detach_group_policy_input::Builder {
crate::input::detach_group_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DetachRolePolicy {
_private: (),
}
impl DetachRolePolicy {
pub fn builder() -> crate::input::detach_role_policy_input::Builder {
crate::input::detach_role_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DetachUserPolicy {
_private: (),
}
impl DetachUserPolicy {
pub fn builder() -> crate::input::detach_user_policy_input::Builder {
crate::input::detach_user_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct EnableMFADevice {
_private: (),
}
impl EnableMFADevice {
pub fn builder() -> crate::input::enable_mfa_device_input::Builder {
crate::input::enable_mfa_device_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GenerateCredentialReport {
_private: (),
}
impl GenerateCredentialReport {
pub fn builder() -> crate::input::generate_credential_report_input::Builder {
crate::input::generate_credential_report_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GenerateOrganizationsAccessReport {
_private: (),
}
impl GenerateOrganizationsAccessReport {
pub fn builder() -> crate::input::generate_organizations_access_report_input::Builder {
crate::input::generate_organizations_access_report_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GenerateServiceLastAccessedDetails {
_private: (),
}
impl GenerateServiceLastAccessedDetails {
pub fn builder() -> crate::input::generate_service_last_accessed_details_input::Builder {
crate::input::generate_service_last_accessed_details_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetAccessKeyLastUsed {
_private: (),
}
impl GetAccessKeyLastUsed {
pub fn builder() -> crate::input::get_access_key_last_used_input::Builder {
crate::input::get_access_key_last_used_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetAccountAuthorizationDetails {
_private: (),
}
impl GetAccountAuthorizationDetails {
pub fn builder() -> crate::input::get_account_authorization_details_input::Builder {
crate::input::get_account_authorization_details_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetAccountPasswordPolicy {
_private: (),
}
impl GetAccountPasswordPolicy {
pub fn builder() -> crate::input::get_account_password_policy_input::Builder {
crate::input::get_account_password_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetAccountSummary {
_private: (),
}
impl GetAccountSummary {
pub fn builder() -> crate::input::get_account_summary_input::Builder {
crate::input::get_account_summary_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetContextKeysForCustomPolicy {
_private: (),
}
impl GetContextKeysForCustomPolicy {
pub fn builder() -> crate::input::get_context_keys_for_custom_policy_input::Builder {
crate::input::get_context_keys_for_custom_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetContextKeysForPrincipalPolicy {
_private: (),
}
impl GetContextKeysForPrincipalPolicy {
pub fn builder() -> crate::input::get_context_keys_for_principal_policy_input::Builder {
crate::input::get_context_keys_for_principal_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetCredentialReport {
_private: (),
}
impl GetCredentialReport {
pub fn builder() -> crate::input::get_credential_report_input::Builder {
crate::input::get_credential_report_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetGroup {
_private: (),
}
impl GetGroup {
pub fn builder() -> crate::input::get_group_input::Builder {
crate::input::get_group_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetGroupPolicy {
_private: (),
}
impl GetGroupPolicy {
pub fn builder() -> crate::input::get_group_policy_input::Builder {
crate::input::get_group_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetInstanceProfile {
_private: (),
}
impl GetInstanceProfile {
pub fn builder() -> crate::input::get_instance_profile_input::Builder {
crate::input::get_instance_profile_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetLoginProfile {
_private: (),
}
impl GetLoginProfile {
pub fn builder() -> crate::input::get_login_profile_input::Builder {
crate::input::get_login_profile_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetOpenIDConnectProvider {
_private: (),
}
impl GetOpenIDConnectProvider {
pub fn builder() -> crate::input::get_open_id_connect_provider_input::Builder {
crate::input::get_open_id_connect_provider_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetOrganizationsAccessReport {
_private: (),
}
impl GetOrganizationsAccessReport {
pub fn builder() -> crate::input::get_organizations_access_report_input::Builder {
crate::input::get_organizations_access_report_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetPolicy {
_private: (),
}
impl GetPolicy {
pub fn builder() -> crate::input::get_policy_input::Builder {
crate::input::get_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetPolicyVersion {
_private: (),
}
impl GetPolicyVersion {
pub fn builder() -> crate::input::get_policy_version_input::Builder {
crate::input::get_policy_version_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetRole {
_private: (),
}
impl GetRole {
pub fn builder() -> crate::input::get_role_input::Builder {
crate::input::get_role_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetRolePolicy {
_private: (),
}
impl GetRolePolicy {
pub fn builder() -> crate::input::get_role_policy_input::Builder {
crate::input::get_role_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetSAMLProvider {
_private: (),
}
impl GetSAMLProvider {
pub fn builder() -> crate::input::get_saml_provider_input::Builder {
crate::input::get_saml_provider_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetServerCertificate {
_private: (),
}
impl GetServerCertificate {
pub fn builder() -> crate::input::get_server_certificate_input::Builder {
crate::input::get_server_certificate_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetServiceLastAccessedDetails {
_private: (),
}
impl GetServiceLastAccessedDetails {
pub fn builder() -> crate::input::get_service_last_accessed_details_input::Builder {
crate::input::get_service_last_accessed_details_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetServiceLastAccessedDetailsWithEntities {
_private: (),
}
impl GetServiceLastAccessedDetailsWithEntities {
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()
}
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,
)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetServiceLinkedRoleDeletionStatus {
_private: (),
}
impl GetServiceLinkedRoleDeletionStatus {
pub fn builder() -> crate::input::get_service_linked_role_deletion_status_input::Builder {
crate::input::get_service_linked_role_deletion_status_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetSSHPublicKey {
_private: (),
}
impl GetSSHPublicKey {
pub fn builder() -> crate::input::get_ssh_public_key_input::Builder {
crate::input::get_ssh_public_key_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetUser {
_private: (),
}
impl GetUser {
pub fn builder() -> crate::input::get_user_input::Builder {
crate::input::get_user_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetUserPolicy {
_private: (),
}
impl GetUserPolicy {
pub fn builder() -> crate::input::get_user_policy_input::Builder {
crate::input::get_user_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListAccessKeys {
_private: (),
}
impl ListAccessKeys {
pub fn builder() -> crate::input::list_access_keys_input::Builder {
crate::input::list_access_keys_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListAccountAliases {
_private: (),
}
impl ListAccountAliases {
pub fn builder() -> crate::input::list_account_aliases_input::Builder {
crate::input::list_account_aliases_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListAttachedGroupPolicies {
_private: (),
}
impl ListAttachedGroupPolicies {
pub fn builder() -> crate::input::list_attached_group_policies_input::Builder {
crate::input::list_attached_group_policies_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListAttachedRolePolicies {
_private: (),
}
impl ListAttachedRolePolicies {
pub fn builder() -> crate::input::list_attached_role_policies_input::Builder {
crate::input::list_attached_role_policies_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListAttachedUserPolicies {
_private: (),
}
impl ListAttachedUserPolicies {
pub fn builder() -> crate::input::list_attached_user_policies_input::Builder {
crate::input::list_attached_user_policies_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListEntitiesForPolicy {
_private: (),
}
impl ListEntitiesForPolicy {
pub fn builder() -> crate::input::list_entities_for_policy_input::Builder {
crate::input::list_entities_for_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListGroupPolicies {
_private: (),
}
impl ListGroupPolicies {
pub fn builder() -> crate::input::list_group_policies_input::Builder {
crate::input::list_group_policies_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListGroups {
_private: (),
}
impl ListGroups {
pub fn builder() -> crate::input::list_groups_input::Builder {
crate::input::list_groups_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListGroupsForUser {
_private: (),
}
impl ListGroupsForUser {
pub fn builder() -> crate::input::list_groups_for_user_input::Builder {
crate::input::list_groups_for_user_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListInstanceProfiles {
_private: (),
}
impl ListInstanceProfiles {
pub fn builder() -> crate::input::list_instance_profiles_input::Builder {
crate::input::list_instance_profiles_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListInstanceProfilesForRole {
_private: (),
}
impl ListInstanceProfilesForRole {
pub fn builder() -> crate::input::list_instance_profiles_for_role_input::Builder {
crate::input::list_instance_profiles_for_role_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListInstanceProfileTags {
_private: (),
}
impl ListInstanceProfileTags {
pub fn builder() -> crate::input::list_instance_profile_tags_input::Builder {
crate::input::list_instance_profile_tags_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListMFADevices {
_private: (),
}
impl ListMFADevices {
pub fn builder() -> crate::input::list_mfa_devices_input::Builder {
crate::input::list_mfa_devices_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListMFADeviceTags {
_private: (),
}
impl ListMFADeviceTags {
pub fn builder() -> crate::input::list_mfa_device_tags_input::Builder {
crate::input::list_mfa_device_tags_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListOpenIDConnectProviders {
_private: (),
}
impl ListOpenIDConnectProviders {
pub fn builder() -> crate::input::list_open_id_connect_providers_input::Builder {
crate::input::list_open_id_connect_providers_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListOpenIDConnectProviderTags {
_private: (),
}
impl ListOpenIDConnectProviderTags {
pub fn builder() -> crate::input::list_open_id_connect_provider_tags_input::Builder {
crate::input::list_open_id_connect_provider_tags_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListPolicies {
_private: (),
}
impl ListPolicies {
pub fn builder() -> crate::input::list_policies_input::Builder {
crate::input::list_policies_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListPoliciesGrantingServiceAccess {
_private: (),
}
impl ListPoliciesGrantingServiceAccess {
pub fn builder() -> crate::input::list_policies_granting_service_access_input::Builder {
crate::input::list_policies_granting_service_access_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListPolicyTags {
_private: (),
}
impl ListPolicyTags {
pub fn builder() -> crate::input::list_policy_tags_input::Builder {
crate::input::list_policy_tags_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListPolicyVersions {
_private: (),
}
impl ListPolicyVersions {
pub fn builder() -> crate::input::list_policy_versions_input::Builder {
crate::input::list_policy_versions_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListRolePolicies {
_private: (),
}
impl ListRolePolicies {
pub fn builder() -> crate::input::list_role_policies_input::Builder {
crate::input::list_role_policies_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListRoles {
_private: (),
}
impl ListRoles {
pub fn builder() -> crate::input::list_roles_input::Builder {
crate::input::list_roles_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListRoleTags {
_private: (),
}
impl ListRoleTags {
pub fn builder() -> crate::input::list_role_tags_input::Builder {
crate::input::list_role_tags_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListSAMLProviders {
_private: (),
}
impl ListSAMLProviders {
pub fn builder() -> crate::input::list_saml_providers_input::Builder {
crate::input::list_saml_providers_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListSAMLProviderTags {
_private: (),
}
impl ListSAMLProviderTags {
pub fn builder() -> crate::input::list_saml_provider_tags_input::Builder {
crate::input::list_saml_provider_tags_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListServerCertificates {
_private: (),
}
impl ListServerCertificates {
pub fn builder() -> crate::input::list_server_certificates_input::Builder {
crate::input::list_server_certificates_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListServerCertificateTags {
_private: (),
}
impl ListServerCertificateTags {
pub fn builder() -> crate::input::list_server_certificate_tags_input::Builder {
crate::input::list_server_certificate_tags_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListServiceSpecificCredentials {
_private: (),
}
impl ListServiceSpecificCredentials {
pub fn builder() -> crate::input::list_service_specific_credentials_input::Builder {
crate::input::list_service_specific_credentials_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListSigningCertificates {
_private: (),
}
impl ListSigningCertificates {
pub fn builder() -> crate::input::list_signing_certificates_input::Builder {
crate::input::list_signing_certificates_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListSSHPublicKeys {
_private: (),
}
impl ListSSHPublicKeys {
pub fn builder() -> crate::input::list_ssh_public_keys_input::Builder {
crate::input::list_ssh_public_keys_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListUserPolicies {
_private: (),
}
impl ListUserPolicies {
pub fn builder() -> crate::input::list_user_policies_input::Builder {
crate::input::list_user_policies_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListUsers {
_private: (),
}
impl ListUsers {
pub fn builder() -> crate::input::list_users_input::Builder {
crate::input::list_users_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListUserTags {
_private: (),
}
impl ListUserTags {
pub fn builder() -> crate::input::list_user_tags_input::Builder {
crate::input::list_user_tags_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListVirtualMFADevices {
_private: (),
}
impl ListVirtualMFADevices {
pub fn builder() -> crate::input::list_virtual_mfa_devices_input::Builder {
crate::input::list_virtual_mfa_devices_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct PutGroupPolicy {
_private: (),
}
impl PutGroupPolicy {
pub fn builder() -> crate::input::put_group_policy_input::Builder {
crate::input::put_group_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct PutRolePermissionsBoundary {
_private: (),
}
impl PutRolePermissionsBoundary {
pub fn builder() -> crate::input::put_role_permissions_boundary_input::Builder {
crate::input::put_role_permissions_boundary_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct PutRolePolicy {
_private: (),
}
impl PutRolePolicy {
pub fn builder() -> crate::input::put_role_policy_input::Builder {
crate::input::put_role_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct PutUserPermissionsBoundary {
_private: (),
}
impl PutUserPermissionsBoundary {
pub fn builder() -> crate::input::put_user_permissions_boundary_input::Builder {
crate::input::put_user_permissions_boundary_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct PutUserPolicy {
_private: (),
}
impl PutUserPolicy {
pub fn builder() -> crate::input::put_user_policy_input::Builder {
crate::input::put_user_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct RemoveClientIDFromOpenIDConnectProvider {
_private: (),
}
impl RemoveClientIDFromOpenIDConnectProvider {
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()
}
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,
)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct RemoveRoleFromInstanceProfile {
_private: (),
}
impl RemoveRoleFromInstanceProfile {
pub fn builder() -> crate::input::remove_role_from_instance_profile_input::Builder {
crate::input::remove_role_from_instance_profile_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct RemoveUserFromGroup {
_private: (),
}
impl RemoveUserFromGroup {
pub fn builder() -> crate::input::remove_user_from_group_input::Builder {
crate::input::remove_user_from_group_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ResetServiceSpecificCredential {
_private: (),
}
impl ResetServiceSpecificCredential {
pub fn builder() -> crate::input::reset_service_specific_credential_input::Builder {
crate::input::reset_service_specific_credential_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ResyncMFADevice {
_private: (),
}
impl ResyncMFADevice {
pub fn builder() -> crate::input::resync_mfa_device_input::Builder {
crate::input::resync_mfa_device_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct SetDefaultPolicyVersion {
_private: (),
}
impl SetDefaultPolicyVersion {
pub fn builder() -> crate::input::set_default_policy_version_input::Builder {
crate::input::set_default_policy_version_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct SetSecurityTokenServicePreferences {
_private: (),
}
impl SetSecurityTokenServicePreferences {
pub fn builder() -> crate::input::set_security_token_service_preferences_input::Builder {
crate::input::set_security_token_service_preferences_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct SimulateCustomPolicy {
_private: (),
}
impl SimulateCustomPolicy {
pub fn builder() -> crate::input::simulate_custom_policy_input::Builder {
crate::input::simulate_custom_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct SimulatePrincipalPolicy {
_private: (),
}
impl SimulatePrincipalPolicy {
pub fn builder() -> crate::input::simulate_principal_policy_input::Builder {
crate::input::simulate_principal_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct TagInstanceProfile {
_private: (),
}
impl TagInstanceProfile {
pub fn builder() -> crate::input::tag_instance_profile_input::Builder {
crate::input::tag_instance_profile_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct TagMFADevice {
_private: (),
}
impl TagMFADevice {
pub fn builder() -> crate::input::tag_mfa_device_input::Builder {
crate::input::tag_mfa_device_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct TagOpenIDConnectProvider {
_private: (),
}
impl TagOpenIDConnectProvider {
pub fn builder() -> crate::input::tag_open_id_connect_provider_input::Builder {
crate::input::tag_open_id_connect_provider_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct TagPolicy {
_private: (),
}
impl TagPolicy {
pub fn builder() -> crate::input::tag_policy_input::Builder {
crate::input::tag_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct TagRole {
_private: (),
}
impl TagRole {
pub fn builder() -> crate::input::tag_role_input::Builder {
crate::input::tag_role_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct TagSAMLProvider {
_private: (),
}
impl TagSAMLProvider {
pub fn builder() -> crate::input::tag_saml_provider_input::Builder {
crate::input::tag_saml_provider_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct TagServerCertificate {
_private: (),
}
impl TagServerCertificate {
pub fn builder() -> crate::input::tag_server_certificate_input::Builder {
crate::input::tag_server_certificate_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct TagUser {
_private: (),
}
impl TagUser {
pub fn builder() -> crate::input::tag_user_input::Builder {
crate::input::tag_user_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UntagInstanceProfile {
_private: (),
}
impl UntagInstanceProfile {
pub fn builder() -> crate::input::untag_instance_profile_input::Builder {
crate::input::untag_instance_profile_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UntagMFADevice {
_private: (),
}
impl UntagMFADevice {
pub fn builder() -> crate::input::untag_mfa_device_input::Builder {
crate::input::untag_mfa_device_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UntagOpenIDConnectProvider {
_private: (),
}
impl UntagOpenIDConnectProvider {
pub fn builder() -> crate::input::untag_open_id_connect_provider_input::Builder {
crate::input::untag_open_id_connect_provider_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UntagPolicy {
_private: (),
}
impl UntagPolicy {
pub fn builder() -> crate::input::untag_policy_input::Builder {
crate::input::untag_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UntagRole {
_private: (),
}
impl UntagRole {
pub fn builder() -> crate::input::untag_role_input::Builder {
crate::input::untag_role_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UntagSAMLProvider {
_private: (),
}
impl UntagSAMLProvider {
pub fn builder() -> crate::input::untag_saml_provider_input::Builder {
crate::input::untag_saml_provider_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UntagServerCertificate {
_private: (),
}
impl UntagServerCertificate {
pub fn builder() -> crate::input::untag_server_certificate_input::Builder {
crate::input::untag_server_certificate_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UntagUser {
_private: (),
}
impl UntagUser {
pub fn builder() -> crate::input::untag_user_input::Builder {
crate::input::untag_user_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateAccessKey {
_private: (),
}
impl UpdateAccessKey {
pub fn builder() -> crate::input::update_access_key_input::Builder {
crate::input::update_access_key_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateAccountPasswordPolicy {
_private: (),
}
impl UpdateAccountPasswordPolicy {
pub fn builder() -> crate::input::update_account_password_policy_input::Builder {
crate::input::update_account_password_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateAssumeRolePolicy {
_private: (),
}
impl UpdateAssumeRolePolicy {
pub fn builder() -> crate::input::update_assume_role_policy_input::Builder {
crate::input::update_assume_role_policy_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateGroup {
_private: (),
}
impl UpdateGroup {
pub fn builder() -> crate::input::update_group_input::Builder {
crate::input::update_group_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateLoginProfile {
_private: (),
}
impl UpdateLoginProfile {
pub fn builder() -> crate::input::update_login_profile_input::Builder {
crate::input::update_login_profile_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateOpenIDConnectProviderThumbprint {
_private: (),
}
impl UpdateOpenIDConnectProviderThumbprint {
pub fn builder() -> crate::input::update_open_id_connect_provider_thumbprint_input::Builder {
crate::input::update_open_id_connect_provider_thumbprint_input::Builder::default()
}
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,
)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateRole {
_private: (),
}
impl UpdateRole {
pub fn builder() -> crate::input::update_role_input::Builder {
crate::input::update_role_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateRoleDescription {
_private: (),
}
impl UpdateRoleDescription {
pub fn builder() -> crate::input::update_role_description_input::Builder {
crate::input::update_role_description_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateSAMLProvider {
_private: (),
}
impl UpdateSAMLProvider {
pub fn builder() -> crate::input::update_saml_provider_input::Builder {
crate::input::update_saml_provider_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateServerCertificate {
_private: (),
}
impl UpdateServerCertificate {
pub fn builder() -> crate::input::update_server_certificate_input::Builder {
crate::input::update_server_certificate_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateServiceSpecificCredential {
_private: (),
}
impl UpdateServiceSpecificCredential {
pub fn builder() -> crate::input::update_service_specific_credential_input::Builder {
crate::input::update_service_specific_credential_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateSigningCertificate {
_private: (),
}
impl UpdateSigningCertificate {
pub fn builder() -> crate::input::update_signing_certificate_input::Builder {
crate::input::update_signing_certificate_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateSSHPublicKey {
_private: (),
}
impl UpdateSSHPublicKey {
pub fn builder() -> crate::input::update_ssh_public_key_input::Builder {
crate::input::update_ssh_public_key_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateUser {
_private: (),
}
impl UpdateUser {
pub fn builder() -> crate::input::update_user_input::Builder {
crate::input::update_user_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UploadServerCertificate {
_private: (),
}
impl UploadServerCertificate {
pub fn builder() -> crate::input::upload_server_certificate_input::Builder {
crate::input::upload_server_certificate_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UploadSigningCertificate {
_private: (),
}
impl UploadSigningCertificate {
pub fn builder() -> crate::input::upload_signing_certificate_input::Builder {
crate::input::upload_signing_certificate_input::Builder::default()
}
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)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UploadSSHPublicKey {
_private: (),
}
impl UploadSSHPublicKey {
pub fn builder() -> crate::input::upload_ssh_public_key_input::Builder {
crate::input::upload_ssh_public_key_input::Builder::default()
}
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)
}
}
}
pub mod customize;