IAMClient.h

 
#pragma once
#include <aws/iam/IAM_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/iam/IAMServiceClientModel.h>
 
namespace Aws
{
namespace IAM
{
  class AWS_IAM_API IAMClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods<IAMClient>
  {
    public:
      typedef Aws::Client::AWSXMLClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef IAMClientConfiguration ClientConfigurationType;
      typedef IAMEndpointProvider EndpointProviderType;
 
        IAMClient(const Aws::IAM::IAMClientConfiguration& clientConfiguration = Aws::IAM::IAMClientConfiguration(),
                  std::shared_ptr<IAMEndpointProviderBase> endpointProvider = nullptr);
 
        IAMClient(const Aws::Auth::AWSCredentials& credentials,
                  std::shared_ptr<IAMEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::IAM::IAMClientConfiguration& clientConfiguration = Aws::IAM::IAMClientConfiguration());
 
        IAMClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<IAMEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::IAM::IAMClientConfiguration& clientConfiguration = Aws::IAM::IAMClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        IAMClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        IAMClient(const Aws::Auth::AWSCredentials& credentials,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        IAMClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~IAMClient();
 
 
        Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const;
 
 
        virtual Model::AddClientIDToOpenIDConnectProviderOutcome AddClientIDToOpenIDConnectProvider(const Model::AddClientIDToOpenIDConnectProviderRequest& request) const;
 
        template<typename AddClientIDToOpenIDConnectProviderRequestT = Model::AddClientIDToOpenIDConnectProviderRequest>
        Model::AddClientIDToOpenIDConnectProviderOutcomeCallable AddClientIDToOpenIDConnectProviderCallable(const AddClientIDToOpenIDConnectProviderRequestT& request) const
        {
            return SubmitCallable(&IAMClient::AddClientIDToOpenIDConnectProvider, request);
        }
 
        template<typename AddClientIDToOpenIDConnectProviderRequestT = Model::AddClientIDToOpenIDConnectProviderRequest>
        void AddClientIDToOpenIDConnectProviderAsync(const AddClientIDToOpenIDConnectProviderRequestT& request, const AddClientIDToOpenIDConnectProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::AddClientIDToOpenIDConnectProvider, request, handler, context);
        }
 
        virtual Model::AddRoleToInstanceProfileOutcome AddRoleToInstanceProfile(const Model::AddRoleToInstanceProfileRequest& request) const;
 
        template<typename AddRoleToInstanceProfileRequestT = Model::AddRoleToInstanceProfileRequest>
        Model::AddRoleToInstanceProfileOutcomeCallable AddRoleToInstanceProfileCallable(const AddRoleToInstanceProfileRequestT& request) const
        {
            return SubmitCallable(&IAMClient::AddRoleToInstanceProfile, request);
        }
 
        template<typename AddRoleToInstanceProfileRequestT = Model::AddRoleToInstanceProfileRequest>
        void AddRoleToInstanceProfileAsync(const AddRoleToInstanceProfileRequestT& request, const AddRoleToInstanceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::AddRoleToInstanceProfile, request, handler, context);
        }
 
        virtual Model::AddUserToGroupOutcome AddUserToGroup(const Model::AddUserToGroupRequest& request) const;
 
        template<typename AddUserToGroupRequestT = Model::AddUserToGroupRequest>
        Model::AddUserToGroupOutcomeCallable AddUserToGroupCallable(const AddUserToGroupRequestT& request) const
        {
            return SubmitCallable(&IAMClient::AddUserToGroup, request);
        }
 
        template<typename AddUserToGroupRequestT = Model::AddUserToGroupRequest>
        void AddUserToGroupAsync(const AddUserToGroupRequestT& request, const AddUserToGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::AddUserToGroup, request, handler, context);
        }
 
        virtual Model::AttachGroupPolicyOutcome AttachGroupPolicy(const Model::AttachGroupPolicyRequest& request) const;
 
        template<typename AttachGroupPolicyRequestT = Model::AttachGroupPolicyRequest>
        Model::AttachGroupPolicyOutcomeCallable AttachGroupPolicyCallable(const AttachGroupPolicyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::AttachGroupPolicy, request);
        }
 
        template<typename AttachGroupPolicyRequestT = Model::AttachGroupPolicyRequest>
        void AttachGroupPolicyAsync(const AttachGroupPolicyRequestT& request, const AttachGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::AttachGroupPolicy, request, handler, context);
        }
 
        virtual Model::AttachRolePolicyOutcome AttachRolePolicy(const Model::AttachRolePolicyRequest& request) const;
 
        template<typename AttachRolePolicyRequestT = Model::AttachRolePolicyRequest>
        Model::AttachRolePolicyOutcomeCallable AttachRolePolicyCallable(const AttachRolePolicyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::AttachRolePolicy, request);
        }
 
        template<typename AttachRolePolicyRequestT = Model::AttachRolePolicyRequest>
        void AttachRolePolicyAsync(const AttachRolePolicyRequestT& request, const AttachRolePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::AttachRolePolicy, request, handler, context);
        }
 
        virtual Model::AttachUserPolicyOutcome AttachUserPolicy(const Model::AttachUserPolicyRequest& request) const;
 
        template<typename AttachUserPolicyRequestT = Model::AttachUserPolicyRequest>
        Model::AttachUserPolicyOutcomeCallable AttachUserPolicyCallable(const AttachUserPolicyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::AttachUserPolicy, request);
        }
 
        template<typename AttachUserPolicyRequestT = Model::AttachUserPolicyRequest>
        void AttachUserPolicyAsync(const AttachUserPolicyRequestT& request, const AttachUserPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::AttachUserPolicy, request, handler, context);
        }
 
        virtual Model::ChangePasswordOutcome ChangePassword(const Model::ChangePasswordRequest& request) const;
 
        template<typename ChangePasswordRequestT = Model::ChangePasswordRequest>
        Model::ChangePasswordOutcomeCallable ChangePasswordCallable(const ChangePasswordRequestT& request) const
        {
            return SubmitCallable(&IAMClient::ChangePassword, request);
        }
 
        template<typename ChangePasswordRequestT = Model::ChangePasswordRequest>
        void ChangePasswordAsync(const ChangePasswordRequestT& request, const ChangePasswordResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::ChangePassword, request, handler, context);
        }
 
        virtual Model::CreateAccessKeyOutcome CreateAccessKey(const Model::CreateAccessKeyRequest& request = {}) const;
 
        template<typename CreateAccessKeyRequestT = Model::CreateAccessKeyRequest>
        Model::CreateAccessKeyOutcomeCallable CreateAccessKeyCallable(const CreateAccessKeyRequestT& request = {}) const
        {
            return SubmitCallable(&IAMClient::CreateAccessKey, request);
        }
 
        template<typename CreateAccessKeyRequestT = Model::CreateAccessKeyRequest>
        void CreateAccessKeyAsync(const CreateAccessKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateAccessKeyRequestT& request = {}) const
        {
            return SubmitAsync(&IAMClient::CreateAccessKey, request, handler, context);
        }
 
        virtual Model::CreateAccountAliasOutcome CreateAccountAlias(const Model::CreateAccountAliasRequest& request) const;
 
        template<typename CreateAccountAliasRequestT = Model::CreateAccountAliasRequest>
        Model::CreateAccountAliasOutcomeCallable CreateAccountAliasCallable(const CreateAccountAliasRequestT& request) const
        {
            return SubmitCallable(&IAMClient::CreateAccountAlias, request);
        }
 
        template<typename CreateAccountAliasRequestT = Model::CreateAccountAliasRequest>
        void CreateAccountAliasAsync(const CreateAccountAliasRequestT& request, const CreateAccountAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::CreateAccountAlias, request, handler, context);
        }
 
        virtual Model::CreateGroupOutcome CreateGroup(const Model::CreateGroupRequest& request) const;
 
        template<typename CreateGroupRequestT = Model::CreateGroupRequest>
        Model::CreateGroupOutcomeCallable CreateGroupCallable(const CreateGroupRequestT& request) const
        {
            return SubmitCallable(&IAMClient::CreateGroup, request);
        }
 
        template<typename CreateGroupRequestT = Model::CreateGroupRequest>
        void CreateGroupAsync(const CreateGroupRequestT& request, const CreateGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::CreateGroup, request, handler, context);
        }
 
        virtual Model::CreateInstanceProfileOutcome CreateInstanceProfile(const Model::CreateInstanceProfileRequest& request) const;
 
        template<typename CreateInstanceProfileRequestT = Model::CreateInstanceProfileRequest>
        Model::CreateInstanceProfileOutcomeCallable CreateInstanceProfileCallable(const CreateInstanceProfileRequestT& request) const
        {
            return SubmitCallable(&IAMClient::CreateInstanceProfile, request);
        }
 
        template<typename CreateInstanceProfileRequestT = Model::CreateInstanceProfileRequest>
        void CreateInstanceProfileAsync(const CreateInstanceProfileRequestT& request, const CreateInstanceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::CreateInstanceProfile, request, handler, context);
        }
 
        virtual Model::CreateLoginProfileOutcome CreateLoginProfile(const Model::CreateLoginProfileRequest& request) const;
 
        template<typename CreateLoginProfileRequestT = Model::CreateLoginProfileRequest>
        Model::CreateLoginProfileOutcomeCallable CreateLoginProfileCallable(const CreateLoginProfileRequestT& request) const
        {
            return SubmitCallable(&IAMClient::CreateLoginProfile, request);
        }
 
        template<typename CreateLoginProfileRequestT = Model::CreateLoginProfileRequest>
        void CreateLoginProfileAsync(const CreateLoginProfileRequestT& request, const CreateLoginProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::CreateLoginProfile, request, handler, context);
        }
 
        virtual Model::CreateOpenIDConnectProviderOutcome CreateOpenIDConnectProvider(const Model::CreateOpenIDConnectProviderRequest& request) const;
 
        template<typename CreateOpenIDConnectProviderRequestT = Model::CreateOpenIDConnectProviderRequest>
        Model::CreateOpenIDConnectProviderOutcomeCallable CreateOpenIDConnectProviderCallable(const CreateOpenIDConnectProviderRequestT& request) const
        {
            return SubmitCallable(&IAMClient::CreateOpenIDConnectProvider, request);
        }
 
        template<typename CreateOpenIDConnectProviderRequestT = Model::CreateOpenIDConnectProviderRequest>
        void CreateOpenIDConnectProviderAsync(const CreateOpenIDConnectProviderRequestT& request, const CreateOpenIDConnectProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::CreateOpenIDConnectProvider, request, handler, context);
        }
 
        virtual Model::CreatePolicyOutcome CreatePolicy(const Model::CreatePolicyRequest& request) const;
 
        template<typename CreatePolicyRequestT = Model::CreatePolicyRequest>
        Model::CreatePolicyOutcomeCallable CreatePolicyCallable(const CreatePolicyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::CreatePolicy, request);
        }
 
        template<typename CreatePolicyRequestT = Model::CreatePolicyRequest>
        void CreatePolicyAsync(const CreatePolicyRequestT& request, const CreatePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::CreatePolicy, request, handler, context);
        }
 
        virtual Model::CreatePolicyVersionOutcome CreatePolicyVersion(const Model::CreatePolicyVersionRequest& request) const;
 
        template<typename CreatePolicyVersionRequestT = Model::CreatePolicyVersionRequest>
        Model::CreatePolicyVersionOutcomeCallable CreatePolicyVersionCallable(const CreatePolicyVersionRequestT& request) const
        {
            return SubmitCallable(&IAMClient::CreatePolicyVersion, request);
        }
 
        template<typename CreatePolicyVersionRequestT = Model::CreatePolicyVersionRequest>
        void CreatePolicyVersionAsync(const CreatePolicyVersionRequestT& request, const CreatePolicyVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::CreatePolicyVersion, request, handler, context);
        }
 
        virtual Model::CreateRoleOutcome CreateRole(const Model::CreateRoleRequest& request) const;
 
        template<typename CreateRoleRequestT = Model::CreateRoleRequest>
        Model::CreateRoleOutcomeCallable CreateRoleCallable(const CreateRoleRequestT& request) const
        {
            return SubmitCallable(&IAMClient::CreateRole, request);
        }
 
        template<typename CreateRoleRequestT = Model::CreateRoleRequest>
        void CreateRoleAsync(const CreateRoleRequestT& request, const CreateRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::CreateRole, request, handler, context);
        }
 
        virtual Model::CreateSAMLProviderOutcome CreateSAMLProvider(const Model::CreateSAMLProviderRequest& request) const;
 
        template<typename CreateSAMLProviderRequestT = Model::CreateSAMLProviderRequest>
        Model::CreateSAMLProviderOutcomeCallable CreateSAMLProviderCallable(const CreateSAMLProviderRequestT& request) const
        {
            return SubmitCallable(&IAMClient::CreateSAMLProvider, request);
        }
 
        template<typename CreateSAMLProviderRequestT = Model::CreateSAMLProviderRequest>
        void CreateSAMLProviderAsync(const CreateSAMLProviderRequestT& request, const CreateSAMLProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::CreateSAMLProvider, request, handler, context);
        }
 
        virtual Model::CreateServiceLinkedRoleOutcome CreateServiceLinkedRole(const Model::CreateServiceLinkedRoleRequest& request) const;
 
        template<typename CreateServiceLinkedRoleRequestT = Model::CreateServiceLinkedRoleRequest>
        Model::CreateServiceLinkedRoleOutcomeCallable CreateServiceLinkedRoleCallable(const CreateServiceLinkedRoleRequestT& request) const
        {
            return SubmitCallable(&IAMClient::CreateServiceLinkedRole, request);
        }
 
        template<typename CreateServiceLinkedRoleRequestT = Model::CreateServiceLinkedRoleRequest>
        void CreateServiceLinkedRoleAsync(const CreateServiceLinkedRoleRequestT& request, const CreateServiceLinkedRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::CreateServiceLinkedRole, request, handler, context);
        }
 
        virtual Model::CreateServiceSpecificCredentialOutcome CreateServiceSpecificCredential(const Model::CreateServiceSpecificCredentialRequest& request) const;
 
        template<typename CreateServiceSpecificCredentialRequestT = Model::CreateServiceSpecificCredentialRequest>
        Model::CreateServiceSpecificCredentialOutcomeCallable CreateServiceSpecificCredentialCallable(const CreateServiceSpecificCredentialRequestT& request) const
        {
            return SubmitCallable(&IAMClient::CreateServiceSpecificCredential, request);
        }
 
        template<typename CreateServiceSpecificCredentialRequestT = Model::CreateServiceSpecificCredentialRequest>
        void CreateServiceSpecificCredentialAsync(const CreateServiceSpecificCredentialRequestT& request, const CreateServiceSpecificCredentialResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::CreateServiceSpecificCredential, request, handler, context);
        }
 
        virtual Model::CreateUserOutcome CreateUser(const Model::CreateUserRequest& request) const;
 
        template<typename CreateUserRequestT = Model::CreateUserRequest>
        Model::CreateUserOutcomeCallable CreateUserCallable(const CreateUserRequestT& request) const
        {
            return SubmitCallable(&IAMClient::CreateUser, request);
        }
 
        template<typename CreateUserRequestT = Model::CreateUserRequest>
        void CreateUserAsync(const CreateUserRequestT& request, const CreateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::CreateUser, request, handler, context);
        }
 
        virtual Model::CreateVirtualMFADeviceOutcome CreateVirtualMFADevice(const Model::CreateVirtualMFADeviceRequest& request) const;
 
        template<typename CreateVirtualMFADeviceRequestT = Model::CreateVirtualMFADeviceRequest>
        Model::CreateVirtualMFADeviceOutcomeCallable CreateVirtualMFADeviceCallable(const CreateVirtualMFADeviceRequestT& request) const
        {
            return SubmitCallable(&IAMClient::CreateVirtualMFADevice, request);
        }
 
        template<typename CreateVirtualMFADeviceRequestT = Model::CreateVirtualMFADeviceRequest>
        void CreateVirtualMFADeviceAsync(const CreateVirtualMFADeviceRequestT& request, const CreateVirtualMFADeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::CreateVirtualMFADevice, request, handler, context);
        }
 
        virtual Model::DeactivateMFADeviceOutcome DeactivateMFADevice(const Model::DeactivateMFADeviceRequest& request) const;
 
        template<typename DeactivateMFADeviceRequestT = Model::DeactivateMFADeviceRequest>
        Model::DeactivateMFADeviceOutcomeCallable DeactivateMFADeviceCallable(const DeactivateMFADeviceRequestT& request) const
        {
            return SubmitCallable(&IAMClient::DeactivateMFADevice, request);
        }
 
        template<typename DeactivateMFADeviceRequestT = Model::DeactivateMFADeviceRequest>
        void DeactivateMFADeviceAsync(const DeactivateMFADeviceRequestT& request, const DeactivateMFADeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::DeactivateMFADevice, request, handler, context);
        }
 
        virtual Model::DeleteAccessKeyOutcome DeleteAccessKey(const Model::DeleteAccessKeyRequest& request) const;
 
        template<typename DeleteAccessKeyRequestT = Model::DeleteAccessKeyRequest>
        Model::DeleteAccessKeyOutcomeCallable DeleteAccessKeyCallable(const DeleteAccessKeyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::DeleteAccessKey, request);
        }
 
        template<typename DeleteAccessKeyRequestT = Model::DeleteAccessKeyRequest>
        void DeleteAccessKeyAsync(const DeleteAccessKeyRequestT& request, const DeleteAccessKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::DeleteAccessKey, request, handler, context);
        }
 
        virtual Model::DeleteAccountAliasOutcome DeleteAccountAlias(const Model::DeleteAccountAliasRequest& request) const;
 
        template<typename DeleteAccountAliasRequestT = Model::DeleteAccountAliasRequest>
        Model::DeleteAccountAliasOutcomeCallable DeleteAccountAliasCallable(const DeleteAccountAliasRequestT& request) const
        {
            return SubmitCallable(&IAMClient::DeleteAccountAlias, request);
        }
 
        template<typename DeleteAccountAliasRequestT = Model::DeleteAccountAliasRequest>
        void DeleteAccountAliasAsync(const DeleteAccountAliasRequestT& request, const DeleteAccountAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::DeleteAccountAlias, request, handler, context);
        }
 
        virtual Model::DeleteAccountPasswordPolicyOutcome DeleteAccountPasswordPolicy(const Model::DeleteAccountPasswordPolicyRequest& request = {}) const;
 
        template<typename DeleteAccountPasswordPolicyRequestT = Model::DeleteAccountPasswordPolicyRequest>
        Model::DeleteAccountPasswordPolicyOutcomeCallable DeleteAccountPasswordPolicyCallable(const DeleteAccountPasswordPolicyRequestT& request = {}) const
        {
            return SubmitCallable(&IAMClient::DeleteAccountPasswordPolicy, request);
        }
 
        template<typename DeleteAccountPasswordPolicyRequestT = Model::DeleteAccountPasswordPolicyRequest>
        void DeleteAccountPasswordPolicyAsync(const DeleteAccountPasswordPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteAccountPasswordPolicyRequestT& request = {}) const
        {
            return SubmitAsync(&IAMClient::DeleteAccountPasswordPolicy, request, handler, context);
        }
 
        virtual Model::DeleteGroupOutcome DeleteGroup(const Model::DeleteGroupRequest& request) const;
 
        template<typename DeleteGroupRequestT = Model::DeleteGroupRequest>
        Model::DeleteGroupOutcomeCallable DeleteGroupCallable(const DeleteGroupRequestT& request) const
        {
            return SubmitCallable(&IAMClient::DeleteGroup, request);
        }
 
        template<typename DeleteGroupRequestT = Model::DeleteGroupRequest>
        void DeleteGroupAsync(const DeleteGroupRequestT& request, const DeleteGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::DeleteGroup, request, handler, context);
        }
 
        virtual Model::DeleteGroupPolicyOutcome DeleteGroupPolicy(const Model::DeleteGroupPolicyRequest& request) const;
 
        template<typename DeleteGroupPolicyRequestT = Model::DeleteGroupPolicyRequest>
        Model::DeleteGroupPolicyOutcomeCallable DeleteGroupPolicyCallable(const DeleteGroupPolicyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::DeleteGroupPolicy, request);
        }
 
        template<typename DeleteGroupPolicyRequestT = Model::DeleteGroupPolicyRequest>
        void DeleteGroupPolicyAsync(const DeleteGroupPolicyRequestT& request, const DeleteGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::DeleteGroupPolicy, request, handler, context);
        }
 
        virtual Model::DeleteInstanceProfileOutcome DeleteInstanceProfile(const Model::DeleteInstanceProfileRequest& request) const;
 
        template<typename DeleteInstanceProfileRequestT = Model::DeleteInstanceProfileRequest>
        Model::DeleteInstanceProfileOutcomeCallable DeleteInstanceProfileCallable(const DeleteInstanceProfileRequestT& request) const
        {
            return SubmitCallable(&IAMClient::DeleteInstanceProfile, request);
        }
 
        template<typename DeleteInstanceProfileRequestT = Model::DeleteInstanceProfileRequest>
        void DeleteInstanceProfileAsync(const DeleteInstanceProfileRequestT& request, const DeleteInstanceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::DeleteInstanceProfile, request, handler, context);
        }
 
        virtual Model::DeleteLoginProfileOutcome DeleteLoginProfile(const Model::DeleteLoginProfileRequest& request) const;
 
        template<typename DeleteLoginProfileRequestT = Model::DeleteLoginProfileRequest>
        Model::DeleteLoginProfileOutcomeCallable DeleteLoginProfileCallable(const DeleteLoginProfileRequestT& request) const
        {
            return SubmitCallable(&IAMClient::DeleteLoginProfile, request);
        }
 
        template<typename DeleteLoginProfileRequestT = Model::DeleteLoginProfileRequest>
        void DeleteLoginProfileAsync(const DeleteLoginProfileRequestT& request, const DeleteLoginProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::DeleteLoginProfile, request, handler, context);
        }
 
        virtual Model::DeleteOpenIDConnectProviderOutcome DeleteOpenIDConnectProvider(const Model::DeleteOpenIDConnectProviderRequest& request) const;
 
        template<typename DeleteOpenIDConnectProviderRequestT = Model::DeleteOpenIDConnectProviderRequest>
        Model::DeleteOpenIDConnectProviderOutcomeCallable DeleteOpenIDConnectProviderCallable(const DeleteOpenIDConnectProviderRequestT& request) const
        {
            return SubmitCallable(&IAMClient::DeleteOpenIDConnectProvider, request);
        }
 
        template<typename DeleteOpenIDConnectProviderRequestT = Model::DeleteOpenIDConnectProviderRequest>
        void DeleteOpenIDConnectProviderAsync(const DeleteOpenIDConnectProviderRequestT& request, const DeleteOpenIDConnectProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::DeleteOpenIDConnectProvider, request, handler, context);
        }
 
        virtual Model::DeletePolicyOutcome DeletePolicy(const Model::DeletePolicyRequest& request) const;
 
        template<typename DeletePolicyRequestT = Model::DeletePolicyRequest>
        Model::DeletePolicyOutcomeCallable DeletePolicyCallable(const DeletePolicyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::DeletePolicy, request);
        }
 
        template<typename DeletePolicyRequestT = Model::DeletePolicyRequest>
        void DeletePolicyAsync(const DeletePolicyRequestT& request, const DeletePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::DeletePolicy, request, handler, context);
        }
 
        virtual Model::DeletePolicyVersionOutcome DeletePolicyVersion(const Model::DeletePolicyVersionRequest& request) const;
 
        template<typename DeletePolicyVersionRequestT = Model::DeletePolicyVersionRequest>
        Model::DeletePolicyVersionOutcomeCallable DeletePolicyVersionCallable(const DeletePolicyVersionRequestT& request) const
        {
            return SubmitCallable(&IAMClient::DeletePolicyVersion, request);
        }
 
        template<typename DeletePolicyVersionRequestT = Model::DeletePolicyVersionRequest>
        void DeletePolicyVersionAsync(const DeletePolicyVersionRequestT& request, const DeletePolicyVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::DeletePolicyVersion, request, handler, context);
        }
 
        virtual Model::DeleteRoleOutcome DeleteRole(const Model::DeleteRoleRequest& request) const;
 
        template<typename DeleteRoleRequestT = Model::DeleteRoleRequest>
        Model::DeleteRoleOutcomeCallable DeleteRoleCallable(const DeleteRoleRequestT& request) const
        {
            return SubmitCallable(&IAMClient::DeleteRole, request);
        }
 
        template<typename DeleteRoleRequestT = Model::DeleteRoleRequest>
        void DeleteRoleAsync(const DeleteRoleRequestT& request, const DeleteRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::DeleteRole, request, handler, context);
        }
 
        virtual Model::DeleteRolePermissionsBoundaryOutcome DeleteRolePermissionsBoundary(const Model::DeleteRolePermissionsBoundaryRequest& request) const;
 
        template<typename DeleteRolePermissionsBoundaryRequestT = Model::DeleteRolePermissionsBoundaryRequest>
        Model::DeleteRolePermissionsBoundaryOutcomeCallable DeleteRolePermissionsBoundaryCallable(const DeleteRolePermissionsBoundaryRequestT& request) const
        {
            return SubmitCallable(&IAMClient::DeleteRolePermissionsBoundary, request);
        }
 
        template<typename DeleteRolePermissionsBoundaryRequestT = Model::DeleteRolePermissionsBoundaryRequest>
        void DeleteRolePermissionsBoundaryAsync(const DeleteRolePermissionsBoundaryRequestT& request, const DeleteRolePermissionsBoundaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::DeleteRolePermissionsBoundary, request, handler, context);
        }
 
        virtual Model::DeleteRolePolicyOutcome DeleteRolePolicy(const Model::DeleteRolePolicyRequest& request) const;
 
        template<typename DeleteRolePolicyRequestT = Model::DeleteRolePolicyRequest>
        Model::DeleteRolePolicyOutcomeCallable DeleteRolePolicyCallable(const DeleteRolePolicyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::DeleteRolePolicy, request);
        }
 
        template<typename DeleteRolePolicyRequestT = Model::DeleteRolePolicyRequest>
        void DeleteRolePolicyAsync(const DeleteRolePolicyRequestT& request, const DeleteRolePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::DeleteRolePolicy, request, handler, context);
        }
 
        virtual Model::DeleteSAMLProviderOutcome DeleteSAMLProvider(const Model::DeleteSAMLProviderRequest& request) const;
 
        template<typename DeleteSAMLProviderRequestT = Model::DeleteSAMLProviderRequest>
        Model::DeleteSAMLProviderOutcomeCallable DeleteSAMLProviderCallable(const DeleteSAMLProviderRequestT& request) const
        {
            return SubmitCallable(&IAMClient::DeleteSAMLProvider, request);
        }
 
        template<typename DeleteSAMLProviderRequestT = Model::DeleteSAMLProviderRequest>
        void DeleteSAMLProviderAsync(const DeleteSAMLProviderRequestT& request, const DeleteSAMLProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::DeleteSAMLProvider, request, handler, context);
        }
 
        virtual Model::DeleteSSHPublicKeyOutcome DeleteSSHPublicKey(const Model::DeleteSSHPublicKeyRequest& request) const;
 
        template<typename DeleteSSHPublicKeyRequestT = Model::DeleteSSHPublicKeyRequest>
        Model::DeleteSSHPublicKeyOutcomeCallable DeleteSSHPublicKeyCallable(const DeleteSSHPublicKeyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::DeleteSSHPublicKey, request);
        }
 
        template<typename DeleteSSHPublicKeyRequestT = Model::DeleteSSHPublicKeyRequest>
        void DeleteSSHPublicKeyAsync(const DeleteSSHPublicKeyRequestT& request, const DeleteSSHPublicKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::DeleteSSHPublicKey, request, handler, context);
        }
 
        virtual Model::DeleteServerCertificateOutcome DeleteServerCertificate(const Model::DeleteServerCertificateRequest& request) const;
 
        template<typename DeleteServerCertificateRequestT = Model::DeleteServerCertificateRequest>
        Model::DeleteServerCertificateOutcomeCallable DeleteServerCertificateCallable(const DeleteServerCertificateRequestT& request) const
        {
            return SubmitCallable(&IAMClient::DeleteServerCertificate, request);
        }
 
        template<typename DeleteServerCertificateRequestT = Model::DeleteServerCertificateRequest>
        void DeleteServerCertificateAsync(const DeleteServerCertificateRequestT& request, const DeleteServerCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::DeleteServerCertificate, request, handler, context);
        }
 
        virtual Model::DeleteServiceLinkedRoleOutcome DeleteServiceLinkedRole(const Model::DeleteServiceLinkedRoleRequest& request) const;
 
        template<typename DeleteServiceLinkedRoleRequestT = Model::DeleteServiceLinkedRoleRequest>
        Model::DeleteServiceLinkedRoleOutcomeCallable DeleteServiceLinkedRoleCallable(const DeleteServiceLinkedRoleRequestT& request) const
        {
            return SubmitCallable(&IAMClient::DeleteServiceLinkedRole, request);
        }
 
        template<typename DeleteServiceLinkedRoleRequestT = Model::DeleteServiceLinkedRoleRequest>
        void DeleteServiceLinkedRoleAsync(const DeleteServiceLinkedRoleRequestT& request, const DeleteServiceLinkedRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::DeleteServiceLinkedRole, request, handler, context);
        }
 
        virtual Model::DeleteServiceSpecificCredentialOutcome DeleteServiceSpecificCredential(const Model::DeleteServiceSpecificCredentialRequest& request) const;
 
        template<typename DeleteServiceSpecificCredentialRequestT = Model::DeleteServiceSpecificCredentialRequest>
        Model::DeleteServiceSpecificCredentialOutcomeCallable DeleteServiceSpecificCredentialCallable(const DeleteServiceSpecificCredentialRequestT& request) const
        {
            return SubmitCallable(&IAMClient::DeleteServiceSpecificCredential, request);
        }
 
        template<typename DeleteServiceSpecificCredentialRequestT = Model::DeleteServiceSpecificCredentialRequest>
        void DeleteServiceSpecificCredentialAsync(const DeleteServiceSpecificCredentialRequestT& request, const DeleteServiceSpecificCredentialResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::DeleteServiceSpecificCredential, request, handler, context);
        }
 
        virtual Model::DeleteSigningCertificateOutcome DeleteSigningCertificate(const Model::DeleteSigningCertificateRequest& request) const;
 
        template<typename DeleteSigningCertificateRequestT = Model::DeleteSigningCertificateRequest>
        Model::DeleteSigningCertificateOutcomeCallable DeleteSigningCertificateCallable(const DeleteSigningCertificateRequestT& request) const
        {
            return SubmitCallable(&IAMClient::DeleteSigningCertificate, request);
        }
 
        template<typename DeleteSigningCertificateRequestT = Model::DeleteSigningCertificateRequest>
        void DeleteSigningCertificateAsync(const DeleteSigningCertificateRequestT& request, const DeleteSigningCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::DeleteSigningCertificate, request, handler, context);
        }
 
        virtual Model::DeleteUserOutcome DeleteUser(const Model::DeleteUserRequest& request) const;
 
        template<typename DeleteUserRequestT = Model::DeleteUserRequest>
        Model::DeleteUserOutcomeCallable DeleteUserCallable(const DeleteUserRequestT& request) const
        {
            return SubmitCallable(&IAMClient::DeleteUser, request);
        }
 
        template<typename DeleteUserRequestT = Model::DeleteUserRequest>
        void DeleteUserAsync(const DeleteUserRequestT& request, const DeleteUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::DeleteUser, request, handler, context);
        }
 
        virtual Model::DeleteUserPermissionsBoundaryOutcome DeleteUserPermissionsBoundary(const Model::DeleteUserPermissionsBoundaryRequest& request) const;
 
        template<typename DeleteUserPermissionsBoundaryRequestT = Model::DeleteUserPermissionsBoundaryRequest>
        Model::DeleteUserPermissionsBoundaryOutcomeCallable DeleteUserPermissionsBoundaryCallable(const DeleteUserPermissionsBoundaryRequestT& request) const
        {
            return SubmitCallable(&IAMClient::DeleteUserPermissionsBoundary, request);
        }
 
        template<typename DeleteUserPermissionsBoundaryRequestT = Model::DeleteUserPermissionsBoundaryRequest>
        void DeleteUserPermissionsBoundaryAsync(const DeleteUserPermissionsBoundaryRequestT& request, const DeleteUserPermissionsBoundaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::DeleteUserPermissionsBoundary, request, handler, context);
        }
 
        virtual Model::DeleteUserPolicyOutcome DeleteUserPolicy(const Model::DeleteUserPolicyRequest& request) const;
 
        template<typename DeleteUserPolicyRequestT = Model::DeleteUserPolicyRequest>
        Model::DeleteUserPolicyOutcomeCallable DeleteUserPolicyCallable(const DeleteUserPolicyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::DeleteUserPolicy, request);
        }
 
        template<typename DeleteUserPolicyRequestT = Model::DeleteUserPolicyRequest>
        void DeleteUserPolicyAsync(const DeleteUserPolicyRequestT& request, const DeleteUserPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::DeleteUserPolicy, request, handler, context);
        }
 
        virtual Model::DeleteVirtualMFADeviceOutcome DeleteVirtualMFADevice(const Model::DeleteVirtualMFADeviceRequest& request) const;
 
        template<typename DeleteVirtualMFADeviceRequestT = Model::DeleteVirtualMFADeviceRequest>
        Model::DeleteVirtualMFADeviceOutcomeCallable DeleteVirtualMFADeviceCallable(const DeleteVirtualMFADeviceRequestT& request) const
        {
            return SubmitCallable(&IAMClient::DeleteVirtualMFADevice, request);
        }
 
        template<typename DeleteVirtualMFADeviceRequestT = Model::DeleteVirtualMFADeviceRequest>
        void DeleteVirtualMFADeviceAsync(const DeleteVirtualMFADeviceRequestT& request, const DeleteVirtualMFADeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::DeleteVirtualMFADevice, request, handler, context);
        }
 
        virtual Model::DetachGroupPolicyOutcome DetachGroupPolicy(const Model::DetachGroupPolicyRequest& request) const;
 
        template<typename DetachGroupPolicyRequestT = Model::DetachGroupPolicyRequest>
        Model::DetachGroupPolicyOutcomeCallable DetachGroupPolicyCallable(const DetachGroupPolicyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::DetachGroupPolicy, request);
        }
 
        template<typename DetachGroupPolicyRequestT = Model::DetachGroupPolicyRequest>
        void DetachGroupPolicyAsync(const DetachGroupPolicyRequestT& request, const DetachGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::DetachGroupPolicy, request, handler, context);
        }
 
        virtual Model::DetachRolePolicyOutcome DetachRolePolicy(const Model::DetachRolePolicyRequest& request) const;
 
        template<typename DetachRolePolicyRequestT = Model::DetachRolePolicyRequest>
        Model::DetachRolePolicyOutcomeCallable DetachRolePolicyCallable(const DetachRolePolicyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::DetachRolePolicy, request);
        }
 
        template<typename DetachRolePolicyRequestT = Model::DetachRolePolicyRequest>
        void DetachRolePolicyAsync(const DetachRolePolicyRequestT& request, const DetachRolePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::DetachRolePolicy, request, handler, context);
        }
 
        virtual Model::DetachUserPolicyOutcome DetachUserPolicy(const Model::DetachUserPolicyRequest& request) const;
 
        template<typename DetachUserPolicyRequestT = Model::DetachUserPolicyRequest>
        Model::DetachUserPolicyOutcomeCallable DetachUserPolicyCallable(const DetachUserPolicyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::DetachUserPolicy, request);
        }
 
        template<typename DetachUserPolicyRequestT = Model::DetachUserPolicyRequest>
        void DetachUserPolicyAsync(const DetachUserPolicyRequestT& request, const DetachUserPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::DetachUserPolicy, request, handler, context);
        }
 
        virtual Model::EnableMFADeviceOutcome EnableMFADevice(const Model::EnableMFADeviceRequest& request) const;
 
        template<typename EnableMFADeviceRequestT = Model::EnableMFADeviceRequest>
        Model::EnableMFADeviceOutcomeCallable EnableMFADeviceCallable(const EnableMFADeviceRequestT& request) const
        {
            return SubmitCallable(&IAMClient::EnableMFADevice, request);
        }
 
        template<typename EnableMFADeviceRequestT = Model::EnableMFADeviceRequest>
        void EnableMFADeviceAsync(const EnableMFADeviceRequestT& request, const EnableMFADeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::EnableMFADevice, request, handler, context);
        }
 
        virtual Model::GenerateCredentialReportOutcome GenerateCredentialReport(const Model::GenerateCredentialReportRequest& request = {}) const;
 
        template<typename GenerateCredentialReportRequestT = Model::GenerateCredentialReportRequest>
        Model::GenerateCredentialReportOutcomeCallable GenerateCredentialReportCallable(const GenerateCredentialReportRequestT& request = {}) const
        {
            return SubmitCallable(&IAMClient::GenerateCredentialReport, request);
        }
 
        template<typename GenerateCredentialReportRequestT = Model::GenerateCredentialReportRequest>
        void GenerateCredentialReportAsync(const GenerateCredentialReportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GenerateCredentialReportRequestT& request = {}) const
        {
            return SubmitAsync(&IAMClient::GenerateCredentialReport, request, handler, context);
        }
 
        virtual Model::GenerateOrganizationsAccessReportOutcome GenerateOrganizationsAccessReport(const Model::GenerateOrganizationsAccessReportRequest& request) const;
 
        template<typename GenerateOrganizationsAccessReportRequestT = Model::GenerateOrganizationsAccessReportRequest>
        Model::GenerateOrganizationsAccessReportOutcomeCallable GenerateOrganizationsAccessReportCallable(const GenerateOrganizationsAccessReportRequestT& request) const
        {
            return SubmitCallable(&IAMClient::GenerateOrganizationsAccessReport, request);
        }
 
        template<typename GenerateOrganizationsAccessReportRequestT = Model::GenerateOrganizationsAccessReportRequest>
        void GenerateOrganizationsAccessReportAsync(const GenerateOrganizationsAccessReportRequestT& request, const GenerateOrganizationsAccessReportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::GenerateOrganizationsAccessReport, request, handler, context);
        }
 
        virtual Model::GenerateServiceLastAccessedDetailsOutcome GenerateServiceLastAccessedDetails(const Model::GenerateServiceLastAccessedDetailsRequest& request) const;
 
        template<typename GenerateServiceLastAccessedDetailsRequestT = Model::GenerateServiceLastAccessedDetailsRequest>
        Model::GenerateServiceLastAccessedDetailsOutcomeCallable GenerateServiceLastAccessedDetailsCallable(const GenerateServiceLastAccessedDetailsRequestT& request) const
        {
            return SubmitCallable(&IAMClient::GenerateServiceLastAccessedDetails, request);
        }
 
        template<typename GenerateServiceLastAccessedDetailsRequestT = Model::GenerateServiceLastAccessedDetailsRequest>
        void GenerateServiceLastAccessedDetailsAsync(const GenerateServiceLastAccessedDetailsRequestT& request, const GenerateServiceLastAccessedDetailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::GenerateServiceLastAccessedDetails, request, handler, context);
        }
 
        virtual Model::GetAccessKeyLastUsedOutcome GetAccessKeyLastUsed(const Model::GetAccessKeyLastUsedRequest& request) const;
 
        template<typename GetAccessKeyLastUsedRequestT = Model::GetAccessKeyLastUsedRequest>
        Model::GetAccessKeyLastUsedOutcomeCallable GetAccessKeyLastUsedCallable(const GetAccessKeyLastUsedRequestT& request) const
        {
            return SubmitCallable(&IAMClient::GetAccessKeyLastUsed, request);
        }
 
        template<typename GetAccessKeyLastUsedRequestT = Model::GetAccessKeyLastUsedRequest>
        void GetAccessKeyLastUsedAsync(const GetAccessKeyLastUsedRequestT& request, const GetAccessKeyLastUsedResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::GetAccessKeyLastUsed, request, handler, context);
        }
 
        virtual Model::GetAccountAuthorizationDetailsOutcome GetAccountAuthorizationDetails(const Model::GetAccountAuthorizationDetailsRequest& request = {}) const;
 
        template<typename GetAccountAuthorizationDetailsRequestT = Model::GetAccountAuthorizationDetailsRequest>
        Model::GetAccountAuthorizationDetailsOutcomeCallable GetAccountAuthorizationDetailsCallable(const GetAccountAuthorizationDetailsRequestT& request = {}) const
        {
            return SubmitCallable(&IAMClient::GetAccountAuthorizationDetails, request);
        }
 
        template<typename GetAccountAuthorizationDetailsRequestT = Model::GetAccountAuthorizationDetailsRequest>
        void GetAccountAuthorizationDetailsAsync(const GetAccountAuthorizationDetailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetAccountAuthorizationDetailsRequestT& request = {}) const
        {
            return SubmitAsync(&IAMClient::GetAccountAuthorizationDetails, request, handler, context);
        }
 
        virtual Model::GetAccountPasswordPolicyOutcome GetAccountPasswordPolicy(const Model::GetAccountPasswordPolicyRequest& request = {}) const;
 
        template<typename GetAccountPasswordPolicyRequestT = Model::GetAccountPasswordPolicyRequest>
        Model::GetAccountPasswordPolicyOutcomeCallable GetAccountPasswordPolicyCallable(const GetAccountPasswordPolicyRequestT& request = {}) const
        {
            return SubmitCallable(&IAMClient::GetAccountPasswordPolicy, request);
        }
 
        template<typename GetAccountPasswordPolicyRequestT = Model::GetAccountPasswordPolicyRequest>
        void GetAccountPasswordPolicyAsync(const GetAccountPasswordPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetAccountPasswordPolicyRequestT& request = {}) const
        {
            return SubmitAsync(&IAMClient::GetAccountPasswordPolicy, request, handler, context);
        }
 
        virtual Model::GetAccountSummaryOutcome GetAccountSummary(const Model::GetAccountSummaryRequest& request = {}) const;
 
        template<typename GetAccountSummaryRequestT = Model::GetAccountSummaryRequest>
        Model::GetAccountSummaryOutcomeCallable GetAccountSummaryCallable(const GetAccountSummaryRequestT& request = {}) const
        {
            return SubmitCallable(&IAMClient::GetAccountSummary, request);
        }
 
        template<typename GetAccountSummaryRequestT = Model::GetAccountSummaryRequest>
        void GetAccountSummaryAsync(const GetAccountSummaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetAccountSummaryRequestT& request = {}) const
        {
            return SubmitAsync(&IAMClient::GetAccountSummary, request, handler, context);
        }
 
        virtual Model::GetContextKeysForCustomPolicyOutcome GetContextKeysForCustomPolicy(const Model::GetContextKeysForCustomPolicyRequest& request) const;
 
        template<typename GetContextKeysForCustomPolicyRequestT = Model::GetContextKeysForCustomPolicyRequest>
        Model::GetContextKeysForCustomPolicyOutcomeCallable GetContextKeysForCustomPolicyCallable(const GetContextKeysForCustomPolicyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::GetContextKeysForCustomPolicy, request);
        }
 
        template<typename GetContextKeysForCustomPolicyRequestT = Model::GetContextKeysForCustomPolicyRequest>
        void GetContextKeysForCustomPolicyAsync(const GetContextKeysForCustomPolicyRequestT& request, const GetContextKeysForCustomPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::GetContextKeysForCustomPolicy, request, handler, context);
        }
 
        virtual Model::GetContextKeysForPrincipalPolicyOutcome GetContextKeysForPrincipalPolicy(const Model::GetContextKeysForPrincipalPolicyRequest& request) const;
 
        template<typename GetContextKeysForPrincipalPolicyRequestT = Model::GetContextKeysForPrincipalPolicyRequest>
        Model::GetContextKeysForPrincipalPolicyOutcomeCallable GetContextKeysForPrincipalPolicyCallable(const GetContextKeysForPrincipalPolicyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::GetContextKeysForPrincipalPolicy, request);
        }
 
        template<typename GetContextKeysForPrincipalPolicyRequestT = Model::GetContextKeysForPrincipalPolicyRequest>
        void GetContextKeysForPrincipalPolicyAsync(const GetContextKeysForPrincipalPolicyRequestT& request, const GetContextKeysForPrincipalPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::GetContextKeysForPrincipalPolicy, request, handler, context);
        }
 
        virtual Model::GetCredentialReportOutcome GetCredentialReport(const Model::GetCredentialReportRequest& request = {}) const;
 
        template<typename GetCredentialReportRequestT = Model::GetCredentialReportRequest>
        Model::GetCredentialReportOutcomeCallable GetCredentialReportCallable(const GetCredentialReportRequestT& request = {}) const
        {
            return SubmitCallable(&IAMClient::GetCredentialReport, request);
        }
 
        template<typename GetCredentialReportRequestT = Model::GetCredentialReportRequest>
        void GetCredentialReportAsync(const GetCredentialReportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetCredentialReportRequestT& request = {}) const
        {
            return SubmitAsync(&IAMClient::GetCredentialReport, request, handler, context);
        }
 
        virtual Model::GetGroupOutcome GetGroup(const Model::GetGroupRequest& request) const;
 
        template<typename GetGroupRequestT = Model::GetGroupRequest>
        Model::GetGroupOutcomeCallable GetGroupCallable(const GetGroupRequestT& request) const
        {
            return SubmitCallable(&IAMClient::GetGroup, request);
        }
 
        template<typename GetGroupRequestT = Model::GetGroupRequest>
        void GetGroupAsync(const GetGroupRequestT& request, const GetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::GetGroup, request, handler, context);
        }
 
        virtual Model::GetGroupPolicyOutcome GetGroupPolicy(const Model::GetGroupPolicyRequest& request) const;
 
        template<typename GetGroupPolicyRequestT = Model::GetGroupPolicyRequest>
        Model::GetGroupPolicyOutcomeCallable GetGroupPolicyCallable(const GetGroupPolicyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::GetGroupPolicy, request);
        }
 
        template<typename GetGroupPolicyRequestT = Model::GetGroupPolicyRequest>
        void GetGroupPolicyAsync(const GetGroupPolicyRequestT& request, const GetGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::GetGroupPolicy, request, handler, context);
        }
 
        virtual Model::GetInstanceProfileOutcome GetInstanceProfile(const Model::GetInstanceProfileRequest& request) const;
 
        template<typename GetInstanceProfileRequestT = Model::GetInstanceProfileRequest>
        Model::GetInstanceProfileOutcomeCallable GetInstanceProfileCallable(const GetInstanceProfileRequestT& request) const
        {
            return SubmitCallable(&IAMClient::GetInstanceProfile, request);
        }
 
        template<typename GetInstanceProfileRequestT = Model::GetInstanceProfileRequest>
        void GetInstanceProfileAsync(const GetInstanceProfileRequestT& request, const GetInstanceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::GetInstanceProfile, request, handler, context);
        }
 
        virtual Model::GetLoginProfileOutcome GetLoginProfile(const Model::GetLoginProfileRequest& request) const;
 
        template<typename GetLoginProfileRequestT = Model::GetLoginProfileRequest>
        Model::GetLoginProfileOutcomeCallable GetLoginProfileCallable(const GetLoginProfileRequestT& request) const
        {
            return SubmitCallable(&IAMClient::GetLoginProfile, request);
        }
 
        template<typename GetLoginProfileRequestT = Model::GetLoginProfileRequest>
        void GetLoginProfileAsync(const GetLoginProfileRequestT& request, const GetLoginProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::GetLoginProfile, request, handler, context);
        }
 
        virtual Model::GetMFADeviceOutcome GetMFADevice(const Model::GetMFADeviceRequest& request) const;
 
        template<typename GetMFADeviceRequestT = Model::GetMFADeviceRequest>
        Model::GetMFADeviceOutcomeCallable GetMFADeviceCallable(const GetMFADeviceRequestT& request) const
        {
            return SubmitCallable(&IAMClient::GetMFADevice, request);
        }
 
        template<typename GetMFADeviceRequestT = Model::GetMFADeviceRequest>
        void GetMFADeviceAsync(const GetMFADeviceRequestT& request, const GetMFADeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::GetMFADevice, request, handler, context);
        }
 
        virtual Model::GetOpenIDConnectProviderOutcome GetOpenIDConnectProvider(const Model::GetOpenIDConnectProviderRequest& request) const;
 
        template<typename GetOpenIDConnectProviderRequestT = Model::GetOpenIDConnectProviderRequest>
        Model::GetOpenIDConnectProviderOutcomeCallable GetOpenIDConnectProviderCallable(const GetOpenIDConnectProviderRequestT& request) const
        {
            return SubmitCallable(&IAMClient::GetOpenIDConnectProvider, request);
        }
 
        template<typename GetOpenIDConnectProviderRequestT = Model::GetOpenIDConnectProviderRequest>
        void GetOpenIDConnectProviderAsync(const GetOpenIDConnectProviderRequestT& request, const GetOpenIDConnectProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::GetOpenIDConnectProvider, request, handler, context);
        }
 
        virtual Model::GetOrganizationsAccessReportOutcome GetOrganizationsAccessReport(const Model::GetOrganizationsAccessReportRequest& request) const;
 
        template<typename GetOrganizationsAccessReportRequestT = Model::GetOrganizationsAccessReportRequest>
        Model::GetOrganizationsAccessReportOutcomeCallable GetOrganizationsAccessReportCallable(const GetOrganizationsAccessReportRequestT& request) const
        {
            return SubmitCallable(&IAMClient::GetOrganizationsAccessReport, request);
        }
 
        template<typename GetOrganizationsAccessReportRequestT = Model::GetOrganizationsAccessReportRequest>
        void GetOrganizationsAccessReportAsync(const GetOrganizationsAccessReportRequestT& request, const GetOrganizationsAccessReportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::GetOrganizationsAccessReport, request, handler, context);
        }
 
        virtual Model::GetPolicyOutcome GetPolicy(const Model::GetPolicyRequest& request) const;
 
        template<typename GetPolicyRequestT = Model::GetPolicyRequest>
        Model::GetPolicyOutcomeCallable GetPolicyCallable(const GetPolicyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::GetPolicy, request);
        }
 
        template<typename GetPolicyRequestT = Model::GetPolicyRequest>
        void GetPolicyAsync(const GetPolicyRequestT& request, const GetPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::GetPolicy, request, handler, context);
        }
 
        virtual Model::GetPolicyVersionOutcome GetPolicyVersion(const Model::GetPolicyVersionRequest& request) const;
 
        template<typename GetPolicyVersionRequestT = Model::GetPolicyVersionRequest>
        Model::GetPolicyVersionOutcomeCallable GetPolicyVersionCallable(const GetPolicyVersionRequestT& request) const
        {
            return SubmitCallable(&IAMClient::GetPolicyVersion, request);
        }
 
        template<typename GetPolicyVersionRequestT = Model::GetPolicyVersionRequest>
        void GetPolicyVersionAsync(const GetPolicyVersionRequestT& request, const GetPolicyVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::GetPolicyVersion, request, handler, context);
        }
 
        virtual Model::GetRoleOutcome GetRole(const Model::GetRoleRequest& request) const;
 
        template<typename GetRoleRequestT = Model::GetRoleRequest>
        Model::GetRoleOutcomeCallable GetRoleCallable(const GetRoleRequestT& request) const
        {
            return SubmitCallable(&IAMClient::GetRole, request);
        }
 
        template<typename GetRoleRequestT = Model::GetRoleRequest>
        void GetRoleAsync(const GetRoleRequestT& request, const GetRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::GetRole, request, handler, context);
        }
 
        virtual Model::GetRolePolicyOutcome GetRolePolicy(const Model::GetRolePolicyRequest& request) const;
 
        template<typename GetRolePolicyRequestT = Model::GetRolePolicyRequest>
        Model::GetRolePolicyOutcomeCallable GetRolePolicyCallable(const GetRolePolicyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::GetRolePolicy, request);
        }
 
        template<typename GetRolePolicyRequestT = Model::GetRolePolicyRequest>
        void GetRolePolicyAsync(const GetRolePolicyRequestT& request, const GetRolePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::GetRolePolicy, request, handler, context);
        }
 
        virtual Model::GetSAMLProviderOutcome GetSAMLProvider(const Model::GetSAMLProviderRequest& request) const;
 
        template<typename GetSAMLProviderRequestT = Model::GetSAMLProviderRequest>
        Model::GetSAMLProviderOutcomeCallable GetSAMLProviderCallable(const GetSAMLProviderRequestT& request) const
        {
            return SubmitCallable(&IAMClient::GetSAMLProvider, request);
        }
 
        template<typename GetSAMLProviderRequestT = Model::GetSAMLProviderRequest>
        void GetSAMLProviderAsync(const GetSAMLProviderRequestT& request, const GetSAMLProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::GetSAMLProvider, request, handler, context);
        }
 
        virtual Model::GetSSHPublicKeyOutcome GetSSHPublicKey(const Model::GetSSHPublicKeyRequest& request) const;
 
        template<typename GetSSHPublicKeyRequestT = Model::GetSSHPublicKeyRequest>
        Model::GetSSHPublicKeyOutcomeCallable GetSSHPublicKeyCallable(const GetSSHPublicKeyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::GetSSHPublicKey, request);
        }
 
        template<typename GetSSHPublicKeyRequestT = Model::GetSSHPublicKeyRequest>
        void GetSSHPublicKeyAsync(const GetSSHPublicKeyRequestT& request, const GetSSHPublicKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::GetSSHPublicKey, request, handler, context);
        }
 
        virtual Model::GetServerCertificateOutcome GetServerCertificate(const Model::GetServerCertificateRequest& request) const;
 
        template<typename GetServerCertificateRequestT = Model::GetServerCertificateRequest>
        Model::GetServerCertificateOutcomeCallable GetServerCertificateCallable(const GetServerCertificateRequestT& request) const
        {
            return SubmitCallable(&IAMClient::GetServerCertificate, request);
        }
 
        template<typename GetServerCertificateRequestT = Model::GetServerCertificateRequest>
        void GetServerCertificateAsync(const GetServerCertificateRequestT& request, const GetServerCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::GetServerCertificate, request, handler, context);
        }
 
        virtual Model::GetServiceLastAccessedDetailsOutcome GetServiceLastAccessedDetails(const Model::GetServiceLastAccessedDetailsRequest& request) const;
 
        template<typename GetServiceLastAccessedDetailsRequestT = Model::GetServiceLastAccessedDetailsRequest>
        Model::GetServiceLastAccessedDetailsOutcomeCallable GetServiceLastAccessedDetailsCallable(const GetServiceLastAccessedDetailsRequestT& request) const
        {
            return SubmitCallable(&IAMClient::GetServiceLastAccessedDetails, request);
        }
 
        template<typename GetServiceLastAccessedDetailsRequestT = Model::GetServiceLastAccessedDetailsRequest>
        void GetServiceLastAccessedDetailsAsync(const GetServiceLastAccessedDetailsRequestT& request, const GetServiceLastAccessedDetailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::GetServiceLastAccessedDetails, request, handler, context);
        }
 
        virtual Model::GetServiceLastAccessedDetailsWithEntitiesOutcome GetServiceLastAccessedDetailsWithEntities(const Model::GetServiceLastAccessedDetailsWithEntitiesRequest& request) const;
 
        template<typename GetServiceLastAccessedDetailsWithEntitiesRequestT = Model::GetServiceLastAccessedDetailsWithEntitiesRequest>
        Model::GetServiceLastAccessedDetailsWithEntitiesOutcomeCallable GetServiceLastAccessedDetailsWithEntitiesCallable(const GetServiceLastAccessedDetailsWithEntitiesRequestT& request) const
        {
            return SubmitCallable(&IAMClient::GetServiceLastAccessedDetailsWithEntities, request);
        }
 
        template<typename GetServiceLastAccessedDetailsWithEntitiesRequestT = Model::GetServiceLastAccessedDetailsWithEntitiesRequest>
        void GetServiceLastAccessedDetailsWithEntitiesAsync(const GetServiceLastAccessedDetailsWithEntitiesRequestT& request, const GetServiceLastAccessedDetailsWithEntitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::GetServiceLastAccessedDetailsWithEntities, request, handler, context);
        }
 
        virtual Model::GetServiceLinkedRoleDeletionStatusOutcome GetServiceLinkedRoleDeletionStatus(const Model::GetServiceLinkedRoleDeletionStatusRequest& request) const;
 
        template<typename GetServiceLinkedRoleDeletionStatusRequestT = Model::GetServiceLinkedRoleDeletionStatusRequest>
        Model::GetServiceLinkedRoleDeletionStatusOutcomeCallable GetServiceLinkedRoleDeletionStatusCallable(const GetServiceLinkedRoleDeletionStatusRequestT& request) const
        {
            return SubmitCallable(&IAMClient::GetServiceLinkedRoleDeletionStatus, request);
        }
 
        template<typename GetServiceLinkedRoleDeletionStatusRequestT = Model::GetServiceLinkedRoleDeletionStatusRequest>
        void GetServiceLinkedRoleDeletionStatusAsync(const GetServiceLinkedRoleDeletionStatusRequestT& request, const GetServiceLinkedRoleDeletionStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::GetServiceLinkedRoleDeletionStatus, request, handler, context);
        }
 
        virtual Model::GetUserOutcome GetUser(const Model::GetUserRequest& request = {}) const;
 
        template<typename GetUserRequestT = Model::GetUserRequest>
        Model::GetUserOutcomeCallable GetUserCallable(const GetUserRequestT& request = {}) const
        {
            return SubmitCallable(&IAMClient::GetUser, request);
        }
 
        template<typename GetUserRequestT = Model::GetUserRequest>
        void GetUserAsync(const GetUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetUserRequestT& request = {}) const
        {
            return SubmitAsync(&IAMClient::GetUser, request, handler, context);
        }
 
        virtual Model::GetUserPolicyOutcome GetUserPolicy(const Model::GetUserPolicyRequest& request) const;
 
        template<typename GetUserPolicyRequestT = Model::GetUserPolicyRequest>
        Model::GetUserPolicyOutcomeCallable GetUserPolicyCallable(const GetUserPolicyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::GetUserPolicy, request);
        }
 
        template<typename GetUserPolicyRequestT = Model::GetUserPolicyRequest>
        void GetUserPolicyAsync(const GetUserPolicyRequestT& request, const GetUserPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::GetUserPolicy, request, handler, context);
        }
 
        virtual Model::ListAccessKeysOutcome ListAccessKeys(const Model::ListAccessKeysRequest& request = {}) const;
 
        template<typename ListAccessKeysRequestT = Model::ListAccessKeysRequest>
        Model::ListAccessKeysOutcomeCallable ListAccessKeysCallable(const ListAccessKeysRequestT& request = {}) const
        {
            return SubmitCallable(&IAMClient::ListAccessKeys, request);
        }
 
        template<typename ListAccessKeysRequestT = Model::ListAccessKeysRequest>
        void ListAccessKeysAsync(const ListAccessKeysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAccessKeysRequestT& request = {}) const
        {
            return SubmitAsync(&IAMClient::ListAccessKeys, request, handler, context);
        }
 
        virtual Model::ListAccountAliasesOutcome ListAccountAliases(const Model::ListAccountAliasesRequest& request = {}) const;
 
        template<typename ListAccountAliasesRequestT = Model::ListAccountAliasesRequest>
        Model::ListAccountAliasesOutcomeCallable ListAccountAliasesCallable(const ListAccountAliasesRequestT& request = {}) const
        {
            return SubmitCallable(&IAMClient::ListAccountAliases, request);
        }
 
        template<typename ListAccountAliasesRequestT = Model::ListAccountAliasesRequest>
        void ListAccountAliasesAsync(const ListAccountAliasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAccountAliasesRequestT& request = {}) const
        {
            return SubmitAsync(&IAMClient::ListAccountAliases, request, handler, context);
        }
 
        virtual Model::ListAttachedGroupPoliciesOutcome ListAttachedGroupPolicies(const Model::ListAttachedGroupPoliciesRequest& request) const;
 
        template<typename ListAttachedGroupPoliciesRequestT = Model::ListAttachedGroupPoliciesRequest>
        Model::ListAttachedGroupPoliciesOutcomeCallable ListAttachedGroupPoliciesCallable(const ListAttachedGroupPoliciesRequestT& request) const
        {
            return SubmitCallable(&IAMClient::ListAttachedGroupPolicies, request);
        }
 
        template<typename ListAttachedGroupPoliciesRequestT = Model::ListAttachedGroupPoliciesRequest>
        void ListAttachedGroupPoliciesAsync(const ListAttachedGroupPoliciesRequestT& request, const ListAttachedGroupPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::ListAttachedGroupPolicies, request, handler, context);
        }
 
        virtual Model::ListAttachedRolePoliciesOutcome ListAttachedRolePolicies(const Model::ListAttachedRolePoliciesRequest& request) const;
 
        template<typename ListAttachedRolePoliciesRequestT = Model::ListAttachedRolePoliciesRequest>
        Model::ListAttachedRolePoliciesOutcomeCallable ListAttachedRolePoliciesCallable(const ListAttachedRolePoliciesRequestT& request) const
        {
            return SubmitCallable(&IAMClient::ListAttachedRolePolicies, request);
        }
 
        template<typename ListAttachedRolePoliciesRequestT = Model::ListAttachedRolePoliciesRequest>
        void ListAttachedRolePoliciesAsync(const ListAttachedRolePoliciesRequestT& request, const ListAttachedRolePoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::ListAttachedRolePolicies, request, handler, context);
        }
 
        virtual Model::ListAttachedUserPoliciesOutcome ListAttachedUserPolicies(const Model::ListAttachedUserPoliciesRequest& request) const;
 
        template<typename ListAttachedUserPoliciesRequestT = Model::ListAttachedUserPoliciesRequest>
        Model::ListAttachedUserPoliciesOutcomeCallable ListAttachedUserPoliciesCallable(const ListAttachedUserPoliciesRequestT& request) const
        {
            return SubmitCallable(&IAMClient::ListAttachedUserPolicies, request);
        }
 
        template<typename ListAttachedUserPoliciesRequestT = Model::ListAttachedUserPoliciesRequest>
        void ListAttachedUserPoliciesAsync(const ListAttachedUserPoliciesRequestT& request, const ListAttachedUserPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::ListAttachedUserPolicies, request, handler, context);
        }
 
        virtual Model::ListEntitiesForPolicyOutcome ListEntitiesForPolicy(const Model::ListEntitiesForPolicyRequest& request) const;
 
        template<typename ListEntitiesForPolicyRequestT = Model::ListEntitiesForPolicyRequest>
        Model::ListEntitiesForPolicyOutcomeCallable ListEntitiesForPolicyCallable(const ListEntitiesForPolicyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::ListEntitiesForPolicy, request);
        }
 
        template<typename ListEntitiesForPolicyRequestT = Model::ListEntitiesForPolicyRequest>
        void ListEntitiesForPolicyAsync(const ListEntitiesForPolicyRequestT& request, const ListEntitiesForPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::ListEntitiesForPolicy, request, handler, context);
        }
 
        virtual Model::ListGroupPoliciesOutcome ListGroupPolicies(const Model::ListGroupPoliciesRequest& request) const;
 
        template<typename ListGroupPoliciesRequestT = Model::ListGroupPoliciesRequest>
        Model::ListGroupPoliciesOutcomeCallable ListGroupPoliciesCallable(const ListGroupPoliciesRequestT& request) const
        {
            return SubmitCallable(&IAMClient::ListGroupPolicies, request);
        }
 
        template<typename ListGroupPoliciesRequestT = Model::ListGroupPoliciesRequest>
        void ListGroupPoliciesAsync(const ListGroupPoliciesRequestT& request, const ListGroupPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::ListGroupPolicies, request, handler, context);
        }
 
        virtual Model::ListGroupsOutcome ListGroups(const Model::ListGroupsRequest& request = {}) const;
 
        template<typename ListGroupsRequestT = Model::ListGroupsRequest>
        Model::ListGroupsOutcomeCallable ListGroupsCallable(const ListGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&IAMClient::ListGroups, request);
        }
 
        template<typename ListGroupsRequestT = Model::ListGroupsRequest>
        void ListGroupsAsync(const ListGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&IAMClient::ListGroups, request, handler, context);
        }
 
        virtual Model::ListGroupsForUserOutcome ListGroupsForUser(const Model::ListGroupsForUserRequest& request) const;
 
        template<typename ListGroupsForUserRequestT = Model::ListGroupsForUserRequest>
        Model::ListGroupsForUserOutcomeCallable ListGroupsForUserCallable(const ListGroupsForUserRequestT& request) const
        {
            return SubmitCallable(&IAMClient::ListGroupsForUser, request);
        }
 
        template<typename ListGroupsForUserRequestT = Model::ListGroupsForUserRequest>
        void ListGroupsForUserAsync(const ListGroupsForUserRequestT& request, const ListGroupsForUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::ListGroupsForUser, request, handler, context);
        }
 
        virtual Model::ListInstanceProfileTagsOutcome ListInstanceProfileTags(const Model::ListInstanceProfileTagsRequest& request) const;
 
        template<typename ListInstanceProfileTagsRequestT = Model::ListInstanceProfileTagsRequest>
        Model::ListInstanceProfileTagsOutcomeCallable ListInstanceProfileTagsCallable(const ListInstanceProfileTagsRequestT& request) const
        {
            return SubmitCallable(&IAMClient::ListInstanceProfileTags, request);
        }
 
        template<typename ListInstanceProfileTagsRequestT = Model::ListInstanceProfileTagsRequest>
        void ListInstanceProfileTagsAsync(const ListInstanceProfileTagsRequestT& request, const ListInstanceProfileTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::ListInstanceProfileTags, request, handler, context);
        }
 
        virtual Model::ListInstanceProfilesOutcome ListInstanceProfiles(const Model::ListInstanceProfilesRequest& request = {}) const;
 
        template<typename ListInstanceProfilesRequestT = Model::ListInstanceProfilesRequest>
        Model::ListInstanceProfilesOutcomeCallable ListInstanceProfilesCallable(const ListInstanceProfilesRequestT& request = {}) const
        {
            return SubmitCallable(&IAMClient::ListInstanceProfiles, request);
        }
 
        template<typename ListInstanceProfilesRequestT = Model::ListInstanceProfilesRequest>
        void ListInstanceProfilesAsync(const ListInstanceProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListInstanceProfilesRequestT& request = {}) const
        {
            return SubmitAsync(&IAMClient::ListInstanceProfiles, request, handler, context);
        }
 
        virtual Model::ListInstanceProfilesForRoleOutcome ListInstanceProfilesForRole(const Model::ListInstanceProfilesForRoleRequest& request) const;
 
        template<typename ListInstanceProfilesForRoleRequestT = Model::ListInstanceProfilesForRoleRequest>
        Model::ListInstanceProfilesForRoleOutcomeCallable ListInstanceProfilesForRoleCallable(const ListInstanceProfilesForRoleRequestT& request) const
        {
            return SubmitCallable(&IAMClient::ListInstanceProfilesForRole, request);
        }
 
        template<typename ListInstanceProfilesForRoleRequestT = Model::ListInstanceProfilesForRoleRequest>
        void ListInstanceProfilesForRoleAsync(const ListInstanceProfilesForRoleRequestT& request, const ListInstanceProfilesForRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::ListInstanceProfilesForRole, request, handler, context);
        }
 
        virtual Model::ListMFADeviceTagsOutcome ListMFADeviceTags(const Model::ListMFADeviceTagsRequest& request) const;
 
        template<typename ListMFADeviceTagsRequestT = Model::ListMFADeviceTagsRequest>
        Model::ListMFADeviceTagsOutcomeCallable ListMFADeviceTagsCallable(const ListMFADeviceTagsRequestT& request) const
        {
            return SubmitCallable(&IAMClient::ListMFADeviceTags, request);
        }
 
        template<typename ListMFADeviceTagsRequestT = Model::ListMFADeviceTagsRequest>
        void ListMFADeviceTagsAsync(const ListMFADeviceTagsRequestT& request, const ListMFADeviceTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::ListMFADeviceTags, request, handler, context);
        }
 
        virtual Model::ListMFADevicesOutcome ListMFADevices(const Model::ListMFADevicesRequest& request = {}) const;
 
        template<typename ListMFADevicesRequestT = Model::ListMFADevicesRequest>
        Model::ListMFADevicesOutcomeCallable ListMFADevicesCallable(const ListMFADevicesRequestT& request = {}) const
        {
            return SubmitCallable(&IAMClient::ListMFADevices, request);
        }
 
        template<typename ListMFADevicesRequestT = Model::ListMFADevicesRequest>
        void ListMFADevicesAsync(const ListMFADevicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListMFADevicesRequestT& request = {}) const
        {
            return SubmitAsync(&IAMClient::ListMFADevices, request, handler, context);
        }
 
        virtual Model::ListOpenIDConnectProviderTagsOutcome ListOpenIDConnectProviderTags(const Model::ListOpenIDConnectProviderTagsRequest& request) const;
 
        template<typename ListOpenIDConnectProviderTagsRequestT = Model::ListOpenIDConnectProviderTagsRequest>
        Model::ListOpenIDConnectProviderTagsOutcomeCallable ListOpenIDConnectProviderTagsCallable(const ListOpenIDConnectProviderTagsRequestT& request) const
        {
            return SubmitCallable(&IAMClient::ListOpenIDConnectProviderTags, request);
        }
 
        template<typename ListOpenIDConnectProviderTagsRequestT = Model::ListOpenIDConnectProviderTagsRequest>
        void ListOpenIDConnectProviderTagsAsync(const ListOpenIDConnectProviderTagsRequestT& request, const ListOpenIDConnectProviderTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::ListOpenIDConnectProviderTags, request, handler, context);
        }
 
        virtual Model::ListOpenIDConnectProvidersOutcome ListOpenIDConnectProviders(const Model::ListOpenIDConnectProvidersRequest& request = {}) const;
 
        template<typename ListOpenIDConnectProvidersRequestT = Model::ListOpenIDConnectProvidersRequest>
        Model::ListOpenIDConnectProvidersOutcomeCallable ListOpenIDConnectProvidersCallable(const ListOpenIDConnectProvidersRequestT& request = {}) const
        {
            return SubmitCallable(&IAMClient::ListOpenIDConnectProviders, request);
        }
 
        template<typename ListOpenIDConnectProvidersRequestT = Model::ListOpenIDConnectProvidersRequest>
        void ListOpenIDConnectProvidersAsync(const ListOpenIDConnectProvidersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListOpenIDConnectProvidersRequestT& request = {}) const
        {
            return SubmitAsync(&IAMClient::ListOpenIDConnectProviders, request, handler, context);
        }
 
        virtual Model::ListPoliciesOutcome ListPolicies(const Model::ListPoliciesRequest& request = {}) const;
 
        template<typename ListPoliciesRequestT = Model::ListPoliciesRequest>
        Model::ListPoliciesOutcomeCallable ListPoliciesCallable(const ListPoliciesRequestT& request = {}) const
        {
            return SubmitCallable(&IAMClient::ListPolicies, request);
        }
 
        template<typename ListPoliciesRequestT = Model::ListPoliciesRequest>
        void ListPoliciesAsync(const ListPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPoliciesRequestT& request = {}) const
        {
            return SubmitAsync(&IAMClient::ListPolicies, request, handler, context);
        }
 
        virtual Model::ListPoliciesGrantingServiceAccessOutcome ListPoliciesGrantingServiceAccess(const Model::ListPoliciesGrantingServiceAccessRequest& request) const;
 
        template<typename ListPoliciesGrantingServiceAccessRequestT = Model::ListPoliciesGrantingServiceAccessRequest>
        Model::ListPoliciesGrantingServiceAccessOutcomeCallable ListPoliciesGrantingServiceAccessCallable(const ListPoliciesGrantingServiceAccessRequestT& request) const
        {
            return SubmitCallable(&IAMClient::ListPoliciesGrantingServiceAccess, request);
        }
 
        template<typename ListPoliciesGrantingServiceAccessRequestT = Model::ListPoliciesGrantingServiceAccessRequest>
        void ListPoliciesGrantingServiceAccessAsync(const ListPoliciesGrantingServiceAccessRequestT& request, const ListPoliciesGrantingServiceAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::ListPoliciesGrantingServiceAccess, request, handler, context);
        }
 
        virtual Model::ListPolicyTagsOutcome ListPolicyTags(const Model::ListPolicyTagsRequest& request) const;
 
        template<typename ListPolicyTagsRequestT = Model::ListPolicyTagsRequest>
        Model::ListPolicyTagsOutcomeCallable ListPolicyTagsCallable(const ListPolicyTagsRequestT& request) const
        {
            return SubmitCallable(&IAMClient::ListPolicyTags, request);
        }
 
        template<typename ListPolicyTagsRequestT = Model::ListPolicyTagsRequest>
        void ListPolicyTagsAsync(const ListPolicyTagsRequestT& request, const ListPolicyTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::ListPolicyTags, request, handler, context);
        }
 
        virtual Model::ListPolicyVersionsOutcome ListPolicyVersions(const Model::ListPolicyVersionsRequest& request) const;
 
        template<typename ListPolicyVersionsRequestT = Model::ListPolicyVersionsRequest>
        Model::ListPolicyVersionsOutcomeCallable ListPolicyVersionsCallable(const ListPolicyVersionsRequestT& request) const
        {
            return SubmitCallable(&IAMClient::ListPolicyVersions, request);
        }
 
        template<typename ListPolicyVersionsRequestT = Model::ListPolicyVersionsRequest>
        void ListPolicyVersionsAsync(const ListPolicyVersionsRequestT& request, const ListPolicyVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::ListPolicyVersions, request, handler, context);
        }
 
        virtual Model::ListRolePoliciesOutcome ListRolePolicies(const Model::ListRolePoliciesRequest& request) const;
 
        template<typename ListRolePoliciesRequestT = Model::ListRolePoliciesRequest>
        Model::ListRolePoliciesOutcomeCallable ListRolePoliciesCallable(const ListRolePoliciesRequestT& request) const
        {
            return SubmitCallable(&IAMClient::ListRolePolicies, request);
        }
 
        template<typename ListRolePoliciesRequestT = Model::ListRolePoliciesRequest>
        void ListRolePoliciesAsync(const ListRolePoliciesRequestT& request, const ListRolePoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::ListRolePolicies, request, handler, context);
        }
 
        virtual Model::ListRoleTagsOutcome ListRoleTags(const Model::ListRoleTagsRequest& request) const;
 
        template<typename ListRoleTagsRequestT = Model::ListRoleTagsRequest>
        Model::ListRoleTagsOutcomeCallable ListRoleTagsCallable(const ListRoleTagsRequestT& request) const
        {
            return SubmitCallable(&IAMClient::ListRoleTags, request);
        }
 
        template<typename ListRoleTagsRequestT = Model::ListRoleTagsRequest>
        void ListRoleTagsAsync(const ListRoleTagsRequestT& request, const ListRoleTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::ListRoleTags, request, handler, context);
        }
 
        virtual Model::ListRolesOutcome ListRoles(const Model::ListRolesRequest& request = {}) const;
 
        template<typename ListRolesRequestT = Model::ListRolesRequest>
        Model::ListRolesOutcomeCallable ListRolesCallable(const ListRolesRequestT& request = {}) const
        {
            return SubmitCallable(&IAMClient::ListRoles, request);
        }
 
        template<typename ListRolesRequestT = Model::ListRolesRequest>
        void ListRolesAsync(const ListRolesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRolesRequestT& request = {}) const
        {
            return SubmitAsync(&IAMClient::ListRoles, request, handler, context);
        }
 
        virtual Model::ListSAMLProviderTagsOutcome ListSAMLProviderTags(const Model::ListSAMLProviderTagsRequest& request) const;
 
        template<typename ListSAMLProviderTagsRequestT = Model::ListSAMLProviderTagsRequest>
        Model::ListSAMLProviderTagsOutcomeCallable ListSAMLProviderTagsCallable(const ListSAMLProviderTagsRequestT& request) const
        {
            return SubmitCallable(&IAMClient::ListSAMLProviderTags, request);
        }
 
        template<typename ListSAMLProviderTagsRequestT = Model::ListSAMLProviderTagsRequest>
        void ListSAMLProviderTagsAsync(const ListSAMLProviderTagsRequestT& request, const ListSAMLProviderTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::ListSAMLProviderTags, request, handler, context);
        }
 
        virtual Model::ListSAMLProvidersOutcome ListSAMLProviders(const Model::ListSAMLProvidersRequest& request = {}) const;
 
        template<typename ListSAMLProvidersRequestT = Model::ListSAMLProvidersRequest>
        Model::ListSAMLProvidersOutcomeCallable ListSAMLProvidersCallable(const ListSAMLProvidersRequestT& request = {}) const
        {
            return SubmitCallable(&IAMClient::ListSAMLProviders, request);
        }
 
        template<typename ListSAMLProvidersRequestT = Model::ListSAMLProvidersRequest>
        void ListSAMLProvidersAsync(const ListSAMLProvidersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSAMLProvidersRequestT& request = {}) const
        {
            return SubmitAsync(&IAMClient::ListSAMLProviders, request, handler, context);
        }
 
        virtual Model::ListSSHPublicKeysOutcome ListSSHPublicKeys(const Model::ListSSHPublicKeysRequest& request = {}) const;
 
        template<typename ListSSHPublicKeysRequestT = Model::ListSSHPublicKeysRequest>
        Model::ListSSHPublicKeysOutcomeCallable ListSSHPublicKeysCallable(const ListSSHPublicKeysRequestT& request = {}) const
        {
            return SubmitCallable(&IAMClient::ListSSHPublicKeys, request);
        }
 
        template<typename ListSSHPublicKeysRequestT = Model::ListSSHPublicKeysRequest>
        void ListSSHPublicKeysAsync(const ListSSHPublicKeysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSSHPublicKeysRequestT& request = {}) const
        {
            return SubmitAsync(&IAMClient::ListSSHPublicKeys, request, handler, context);
        }
 
        virtual Model::ListServerCertificateTagsOutcome ListServerCertificateTags(const Model::ListServerCertificateTagsRequest& request) const;
 
        template<typename ListServerCertificateTagsRequestT = Model::ListServerCertificateTagsRequest>
        Model::ListServerCertificateTagsOutcomeCallable ListServerCertificateTagsCallable(const ListServerCertificateTagsRequestT& request) const
        {
            return SubmitCallable(&IAMClient::ListServerCertificateTags, request);
        }
 
        template<typename ListServerCertificateTagsRequestT = Model::ListServerCertificateTagsRequest>
        void ListServerCertificateTagsAsync(const ListServerCertificateTagsRequestT& request, const ListServerCertificateTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::ListServerCertificateTags, request, handler, context);
        }
 
        virtual Model::ListServerCertificatesOutcome ListServerCertificates(const Model::ListServerCertificatesRequest& request = {}) const;
 
        template<typename ListServerCertificatesRequestT = Model::ListServerCertificatesRequest>
        Model::ListServerCertificatesOutcomeCallable ListServerCertificatesCallable(const ListServerCertificatesRequestT& request = {}) const
        {
            return SubmitCallable(&IAMClient::ListServerCertificates, request);
        }
 
        template<typename ListServerCertificatesRequestT = Model::ListServerCertificatesRequest>
        void ListServerCertificatesAsync(const ListServerCertificatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListServerCertificatesRequestT& request = {}) const
        {
            return SubmitAsync(&IAMClient::ListServerCertificates, request, handler, context);
        }
 
        virtual Model::ListServiceSpecificCredentialsOutcome ListServiceSpecificCredentials(const Model::ListServiceSpecificCredentialsRequest& request = {}) const;
 
        template<typename ListServiceSpecificCredentialsRequestT = Model::ListServiceSpecificCredentialsRequest>
        Model::ListServiceSpecificCredentialsOutcomeCallable ListServiceSpecificCredentialsCallable(const ListServiceSpecificCredentialsRequestT& request = {}) const
        {
            return SubmitCallable(&IAMClient::ListServiceSpecificCredentials, request);
        }
 
        template<typename ListServiceSpecificCredentialsRequestT = Model::ListServiceSpecificCredentialsRequest>
        void ListServiceSpecificCredentialsAsync(const ListServiceSpecificCredentialsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListServiceSpecificCredentialsRequestT& request = {}) const
        {
            return SubmitAsync(&IAMClient::ListServiceSpecificCredentials, request, handler, context);
        }
 
        virtual Model::ListSigningCertificatesOutcome ListSigningCertificates(const Model::ListSigningCertificatesRequest& request = {}) const;
 
        template<typename ListSigningCertificatesRequestT = Model::ListSigningCertificatesRequest>
        Model::ListSigningCertificatesOutcomeCallable ListSigningCertificatesCallable(const ListSigningCertificatesRequestT& request = {}) const
        {
            return SubmitCallable(&IAMClient::ListSigningCertificates, request);
        }
 
        template<typename ListSigningCertificatesRequestT = Model::ListSigningCertificatesRequest>
        void ListSigningCertificatesAsync(const ListSigningCertificatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSigningCertificatesRequestT& request = {}) const
        {
            return SubmitAsync(&IAMClient::ListSigningCertificates, request, handler, context);
        }
 
        virtual Model::ListUserPoliciesOutcome ListUserPolicies(const Model::ListUserPoliciesRequest& request) const;
 
        template<typename ListUserPoliciesRequestT = Model::ListUserPoliciesRequest>
        Model::ListUserPoliciesOutcomeCallable ListUserPoliciesCallable(const ListUserPoliciesRequestT& request) const
        {
            return SubmitCallable(&IAMClient::ListUserPolicies, request);
        }
 
        template<typename ListUserPoliciesRequestT = Model::ListUserPoliciesRequest>
        void ListUserPoliciesAsync(const ListUserPoliciesRequestT& request, const ListUserPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::ListUserPolicies, request, handler, context);
        }
 
        virtual Model::ListUserTagsOutcome ListUserTags(const Model::ListUserTagsRequest& request) const;
 
        template<typename ListUserTagsRequestT = Model::ListUserTagsRequest>
        Model::ListUserTagsOutcomeCallable ListUserTagsCallable(const ListUserTagsRequestT& request) const
        {
            return SubmitCallable(&IAMClient::ListUserTags, request);
        }
 
        template<typename ListUserTagsRequestT = Model::ListUserTagsRequest>
        void ListUserTagsAsync(const ListUserTagsRequestT& request, const ListUserTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::ListUserTags, request, handler, context);
        }
 
        virtual Model::ListUsersOutcome ListUsers(const Model::ListUsersRequest& request = {}) const;
 
        template<typename ListUsersRequestT = Model::ListUsersRequest>
        Model::ListUsersOutcomeCallable ListUsersCallable(const ListUsersRequestT& request = {}) const
        {
            return SubmitCallable(&IAMClient::ListUsers, request);
        }
 
        template<typename ListUsersRequestT = Model::ListUsersRequest>
        void ListUsersAsync(const ListUsersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListUsersRequestT& request = {}) const
        {
            return SubmitAsync(&IAMClient::ListUsers, request, handler, context);
        }
 
        virtual Model::ListVirtualMFADevicesOutcome ListVirtualMFADevices(const Model::ListVirtualMFADevicesRequest& request = {}) const;
 
        template<typename ListVirtualMFADevicesRequestT = Model::ListVirtualMFADevicesRequest>
        Model::ListVirtualMFADevicesOutcomeCallable ListVirtualMFADevicesCallable(const ListVirtualMFADevicesRequestT& request = {}) const
        {
            return SubmitCallable(&IAMClient::ListVirtualMFADevices, request);
        }
 
        template<typename ListVirtualMFADevicesRequestT = Model::ListVirtualMFADevicesRequest>
        void ListVirtualMFADevicesAsync(const ListVirtualMFADevicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListVirtualMFADevicesRequestT& request = {}) const
        {
            return SubmitAsync(&IAMClient::ListVirtualMFADevices, request, handler, context);
        }
 
        virtual Model::PutGroupPolicyOutcome PutGroupPolicy(const Model::PutGroupPolicyRequest& request) const;
 
        template<typename PutGroupPolicyRequestT = Model::PutGroupPolicyRequest>
        Model::PutGroupPolicyOutcomeCallable PutGroupPolicyCallable(const PutGroupPolicyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::PutGroupPolicy, request);
        }
 
        template<typename PutGroupPolicyRequestT = Model::PutGroupPolicyRequest>
        void PutGroupPolicyAsync(const PutGroupPolicyRequestT& request, const PutGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::PutGroupPolicy, request, handler, context);
        }
 
        virtual Model::PutRolePermissionsBoundaryOutcome PutRolePermissionsBoundary(const Model::PutRolePermissionsBoundaryRequest& request) const;
 
        template<typename PutRolePermissionsBoundaryRequestT = Model::PutRolePermissionsBoundaryRequest>
        Model::PutRolePermissionsBoundaryOutcomeCallable PutRolePermissionsBoundaryCallable(const PutRolePermissionsBoundaryRequestT& request) const
        {
            return SubmitCallable(&IAMClient::PutRolePermissionsBoundary, request);
        }
 
        template<typename PutRolePermissionsBoundaryRequestT = Model::PutRolePermissionsBoundaryRequest>
        void PutRolePermissionsBoundaryAsync(const PutRolePermissionsBoundaryRequestT& request, const PutRolePermissionsBoundaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::PutRolePermissionsBoundary, request, handler, context);
        }
 
        virtual Model::PutRolePolicyOutcome PutRolePolicy(const Model::PutRolePolicyRequest& request) const;
 
        template<typename PutRolePolicyRequestT = Model::PutRolePolicyRequest>
        Model::PutRolePolicyOutcomeCallable PutRolePolicyCallable(const PutRolePolicyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::PutRolePolicy, request);
        }
 
        template<typename PutRolePolicyRequestT = Model::PutRolePolicyRequest>
        void PutRolePolicyAsync(const PutRolePolicyRequestT& request, const PutRolePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::PutRolePolicy, request, handler, context);
        }
 
        virtual Model::PutUserPermissionsBoundaryOutcome PutUserPermissionsBoundary(const Model::PutUserPermissionsBoundaryRequest& request) const;
 
        template<typename PutUserPermissionsBoundaryRequestT = Model::PutUserPermissionsBoundaryRequest>
        Model::PutUserPermissionsBoundaryOutcomeCallable PutUserPermissionsBoundaryCallable(const PutUserPermissionsBoundaryRequestT& request) const
        {
            return SubmitCallable(&IAMClient::PutUserPermissionsBoundary, request);
        }
 
        template<typename PutUserPermissionsBoundaryRequestT = Model::PutUserPermissionsBoundaryRequest>
        void PutUserPermissionsBoundaryAsync(const PutUserPermissionsBoundaryRequestT& request, const PutUserPermissionsBoundaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::PutUserPermissionsBoundary, request, handler, context);
        }
 
        virtual Model::PutUserPolicyOutcome PutUserPolicy(const Model::PutUserPolicyRequest& request) const;
 
        template<typename PutUserPolicyRequestT = Model::PutUserPolicyRequest>
        Model::PutUserPolicyOutcomeCallable PutUserPolicyCallable(const PutUserPolicyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::PutUserPolicy, request);
        }
 
        template<typename PutUserPolicyRequestT = Model::PutUserPolicyRequest>
        void PutUserPolicyAsync(const PutUserPolicyRequestT& request, const PutUserPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::PutUserPolicy, request, handler, context);
        }
 
        virtual Model::RemoveClientIDFromOpenIDConnectProviderOutcome RemoveClientIDFromOpenIDConnectProvider(const Model::RemoveClientIDFromOpenIDConnectProviderRequest& request) const;
 
        template<typename RemoveClientIDFromOpenIDConnectProviderRequestT = Model::RemoveClientIDFromOpenIDConnectProviderRequest>
        Model::RemoveClientIDFromOpenIDConnectProviderOutcomeCallable RemoveClientIDFromOpenIDConnectProviderCallable(const RemoveClientIDFromOpenIDConnectProviderRequestT& request) const
        {
            return SubmitCallable(&IAMClient::RemoveClientIDFromOpenIDConnectProvider, request);
        }
 
        template<typename RemoveClientIDFromOpenIDConnectProviderRequestT = Model::RemoveClientIDFromOpenIDConnectProviderRequest>
        void RemoveClientIDFromOpenIDConnectProviderAsync(const RemoveClientIDFromOpenIDConnectProviderRequestT& request, const RemoveClientIDFromOpenIDConnectProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::RemoveClientIDFromOpenIDConnectProvider, request, handler, context);
        }
 
        virtual Model::RemoveRoleFromInstanceProfileOutcome RemoveRoleFromInstanceProfile(const Model::RemoveRoleFromInstanceProfileRequest& request) const;
 
        template<typename RemoveRoleFromInstanceProfileRequestT = Model::RemoveRoleFromInstanceProfileRequest>
        Model::RemoveRoleFromInstanceProfileOutcomeCallable RemoveRoleFromInstanceProfileCallable(const RemoveRoleFromInstanceProfileRequestT& request) const
        {
            return SubmitCallable(&IAMClient::RemoveRoleFromInstanceProfile, request);
        }
 
        template<typename RemoveRoleFromInstanceProfileRequestT = Model::RemoveRoleFromInstanceProfileRequest>
        void RemoveRoleFromInstanceProfileAsync(const RemoveRoleFromInstanceProfileRequestT& request, const RemoveRoleFromInstanceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::RemoveRoleFromInstanceProfile, request, handler, context);
        }
 
        virtual Model::RemoveUserFromGroupOutcome RemoveUserFromGroup(const Model::RemoveUserFromGroupRequest& request) const;
 
        template<typename RemoveUserFromGroupRequestT = Model::RemoveUserFromGroupRequest>
        Model::RemoveUserFromGroupOutcomeCallable RemoveUserFromGroupCallable(const RemoveUserFromGroupRequestT& request) const
        {
            return SubmitCallable(&IAMClient::RemoveUserFromGroup, request);
        }
 
        template<typename RemoveUserFromGroupRequestT = Model::RemoveUserFromGroupRequest>
        void RemoveUserFromGroupAsync(const RemoveUserFromGroupRequestT& request, const RemoveUserFromGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::RemoveUserFromGroup, request, handler, context);
        }
 
        virtual Model::ResetServiceSpecificCredentialOutcome ResetServiceSpecificCredential(const Model::ResetServiceSpecificCredentialRequest& request) const;
 
        template<typename ResetServiceSpecificCredentialRequestT = Model::ResetServiceSpecificCredentialRequest>
        Model::ResetServiceSpecificCredentialOutcomeCallable ResetServiceSpecificCredentialCallable(const ResetServiceSpecificCredentialRequestT& request) const
        {
            return SubmitCallable(&IAMClient::ResetServiceSpecificCredential, request);
        }
 
        template<typename ResetServiceSpecificCredentialRequestT = Model::ResetServiceSpecificCredentialRequest>
        void ResetServiceSpecificCredentialAsync(const ResetServiceSpecificCredentialRequestT& request, const ResetServiceSpecificCredentialResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::ResetServiceSpecificCredential, request, handler, context);
        }
 
        virtual Model::ResyncMFADeviceOutcome ResyncMFADevice(const Model::ResyncMFADeviceRequest& request) const;
 
        template<typename ResyncMFADeviceRequestT = Model::ResyncMFADeviceRequest>
        Model::ResyncMFADeviceOutcomeCallable ResyncMFADeviceCallable(const ResyncMFADeviceRequestT& request) const
        {
            return SubmitCallable(&IAMClient::ResyncMFADevice, request);
        }
 
        template<typename ResyncMFADeviceRequestT = Model::ResyncMFADeviceRequest>
        void ResyncMFADeviceAsync(const ResyncMFADeviceRequestT& request, const ResyncMFADeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::ResyncMFADevice, request, handler, context);
        }
 
        virtual Model::SetDefaultPolicyVersionOutcome SetDefaultPolicyVersion(const Model::SetDefaultPolicyVersionRequest& request) const;
 
        template<typename SetDefaultPolicyVersionRequestT = Model::SetDefaultPolicyVersionRequest>
        Model::SetDefaultPolicyVersionOutcomeCallable SetDefaultPolicyVersionCallable(const SetDefaultPolicyVersionRequestT& request) const
        {
            return SubmitCallable(&IAMClient::SetDefaultPolicyVersion, request);
        }
 
        template<typename SetDefaultPolicyVersionRequestT = Model::SetDefaultPolicyVersionRequest>
        void SetDefaultPolicyVersionAsync(const SetDefaultPolicyVersionRequestT& request, const SetDefaultPolicyVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::SetDefaultPolicyVersion, request, handler, context);
        }
 
        virtual Model::SetSecurityTokenServicePreferencesOutcome SetSecurityTokenServicePreferences(const Model::SetSecurityTokenServicePreferencesRequest& request) const;
 
        template<typename SetSecurityTokenServicePreferencesRequestT = Model::SetSecurityTokenServicePreferencesRequest>
        Model::SetSecurityTokenServicePreferencesOutcomeCallable SetSecurityTokenServicePreferencesCallable(const SetSecurityTokenServicePreferencesRequestT& request) const
        {
            return SubmitCallable(&IAMClient::SetSecurityTokenServicePreferences, request);
        }
 
        template<typename SetSecurityTokenServicePreferencesRequestT = Model::SetSecurityTokenServicePreferencesRequest>
        void SetSecurityTokenServicePreferencesAsync(const SetSecurityTokenServicePreferencesRequestT& request, const SetSecurityTokenServicePreferencesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::SetSecurityTokenServicePreferences, request, handler, context);
        }
 
        virtual Model::SimulateCustomPolicyOutcome SimulateCustomPolicy(const Model::SimulateCustomPolicyRequest& request) const;
 
        template<typename SimulateCustomPolicyRequestT = Model::SimulateCustomPolicyRequest>
        Model::SimulateCustomPolicyOutcomeCallable SimulateCustomPolicyCallable(const SimulateCustomPolicyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::SimulateCustomPolicy, request);
        }
 
        template<typename SimulateCustomPolicyRequestT = Model::SimulateCustomPolicyRequest>
        void SimulateCustomPolicyAsync(const SimulateCustomPolicyRequestT& request, const SimulateCustomPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::SimulateCustomPolicy, request, handler, context);
        }
 
        virtual Model::SimulatePrincipalPolicyOutcome SimulatePrincipalPolicy(const Model::SimulatePrincipalPolicyRequest& request) const;
 
        template<typename SimulatePrincipalPolicyRequestT = Model::SimulatePrincipalPolicyRequest>
        Model::SimulatePrincipalPolicyOutcomeCallable SimulatePrincipalPolicyCallable(const SimulatePrincipalPolicyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::SimulatePrincipalPolicy, request);
        }
 
        template<typename SimulatePrincipalPolicyRequestT = Model::SimulatePrincipalPolicyRequest>
        void SimulatePrincipalPolicyAsync(const SimulatePrincipalPolicyRequestT& request, const SimulatePrincipalPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::SimulatePrincipalPolicy, request, handler, context);
        }
 
        virtual Model::TagInstanceProfileOutcome TagInstanceProfile(const Model::TagInstanceProfileRequest& request) const;
 
        template<typename TagInstanceProfileRequestT = Model::TagInstanceProfileRequest>
        Model::TagInstanceProfileOutcomeCallable TagInstanceProfileCallable(const TagInstanceProfileRequestT& request) const
        {
            return SubmitCallable(&IAMClient::TagInstanceProfile, request);
        }
 
        template<typename TagInstanceProfileRequestT = Model::TagInstanceProfileRequest>
        void TagInstanceProfileAsync(const TagInstanceProfileRequestT& request, const TagInstanceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::TagInstanceProfile, request, handler, context);
        }
 
        virtual Model::TagMFADeviceOutcome TagMFADevice(const Model::TagMFADeviceRequest& request) const;
 
        template<typename TagMFADeviceRequestT = Model::TagMFADeviceRequest>
        Model::TagMFADeviceOutcomeCallable TagMFADeviceCallable(const TagMFADeviceRequestT& request) const
        {
            return SubmitCallable(&IAMClient::TagMFADevice, request);
        }
 
        template<typename TagMFADeviceRequestT = Model::TagMFADeviceRequest>
        void TagMFADeviceAsync(const TagMFADeviceRequestT& request, const TagMFADeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::TagMFADevice, request, handler, context);
        }
 
        virtual Model::TagOpenIDConnectProviderOutcome TagOpenIDConnectProvider(const Model::TagOpenIDConnectProviderRequest& request) const;
 
        template<typename TagOpenIDConnectProviderRequestT = Model::TagOpenIDConnectProviderRequest>
        Model::TagOpenIDConnectProviderOutcomeCallable TagOpenIDConnectProviderCallable(const TagOpenIDConnectProviderRequestT& request) const
        {
            return SubmitCallable(&IAMClient::TagOpenIDConnectProvider, request);
        }
 
        template<typename TagOpenIDConnectProviderRequestT = Model::TagOpenIDConnectProviderRequest>
        void TagOpenIDConnectProviderAsync(const TagOpenIDConnectProviderRequestT& request, const TagOpenIDConnectProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::TagOpenIDConnectProvider, request, handler, context);
        }
 
        virtual Model::TagPolicyOutcome TagPolicy(const Model::TagPolicyRequest& request) const;
 
        template<typename TagPolicyRequestT = Model::TagPolicyRequest>
        Model::TagPolicyOutcomeCallable TagPolicyCallable(const TagPolicyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::TagPolicy, request);
        }
 
        template<typename TagPolicyRequestT = Model::TagPolicyRequest>
        void TagPolicyAsync(const TagPolicyRequestT& request, const TagPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::TagPolicy, request, handler, context);
        }
 
        virtual Model::TagRoleOutcome TagRole(const Model::TagRoleRequest& request) const;
 
        template<typename TagRoleRequestT = Model::TagRoleRequest>
        Model::TagRoleOutcomeCallable TagRoleCallable(const TagRoleRequestT& request) const
        {
            return SubmitCallable(&IAMClient::TagRole, request);
        }
 
        template<typename TagRoleRequestT = Model::TagRoleRequest>
        void TagRoleAsync(const TagRoleRequestT& request, const TagRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::TagRole, request, handler, context);
        }
 
        virtual Model::TagSAMLProviderOutcome TagSAMLProvider(const Model::TagSAMLProviderRequest& request) const;
 
        template<typename TagSAMLProviderRequestT = Model::TagSAMLProviderRequest>
        Model::TagSAMLProviderOutcomeCallable TagSAMLProviderCallable(const TagSAMLProviderRequestT& request) const
        {
            return SubmitCallable(&IAMClient::TagSAMLProvider, request);
        }
 
        template<typename TagSAMLProviderRequestT = Model::TagSAMLProviderRequest>
        void TagSAMLProviderAsync(const TagSAMLProviderRequestT& request, const TagSAMLProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::TagSAMLProvider, request, handler, context);
        }
 
        virtual Model::TagServerCertificateOutcome TagServerCertificate(const Model::TagServerCertificateRequest& request) const;
 
        template<typename TagServerCertificateRequestT = Model::TagServerCertificateRequest>
        Model::TagServerCertificateOutcomeCallable TagServerCertificateCallable(const TagServerCertificateRequestT& request) const
        {
            return SubmitCallable(&IAMClient::TagServerCertificate, request);
        }
 
        template<typename TagServerCertificateRequestT = Model::TagServerCertificateRequest>
        void TagServerCertificateAsync(const TagServerCertificateRequestT& request, const TagServerCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::TagServerCertificate, request, handler, context);
        }
 
        virtual Model::TagUserOutcome TagUser(const Model::TagUserRequest& request) const;
 
        template<typename TagUserRequestT = Model::TagUserRequest>
        Model::TagUserOutcomeCallable TagUserCallable(const TagUserRequestT& request) const
        {
            return SubmitCallable(&IAMClient::TagUser, request);
        }
 
        template<typename TagUserRequestT = Model::TagUserRequest>
        void TagUserAsync(const TagUserRequestT& request, const TagUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::TagUser, request, handler, context);
        }
 
        virtual Model::UntagInstanceProfileOutcome UntagInstanceProfile(const Model::UntagInstanceProfileRequest& request) const;
 
        template<typename UntagInstanceProfileRequestT = Model::UntagInstanceProfileRequest>
        Model::UntagInstanceProfileOutcomeCallable UntagInstanceProfileCallable(const UntagInstanceProfileRequestT& request) const
        {
            return SubmitCallable(&IAMClient::UntagInstanceProfile, request);
        }
 
        template<typename UntagInstanceProfileRequestT = Model::UntagInstanceProfileRequest>
        void UntagInstanceProfileAsync(const UntagInstanceProfileRequestT& request, const UntagInstanceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::UntagInstanceProfile, request, handler, context);
        }
 
        virtual Model::UntagMFADeviceOutcome UntagMFADevice(const Model::UntagMFADeviceRequest& request) const;
 
        template<typename UntagMFADeviceRequestT = Model::UntagMFADeviceRequest>
        Model::UntagMFADeviceOutcomeCallable UntagMFADeviceCallable(const UntagMFADeviceRequestT& request) const
        {
            return SubmitCallable(&IAMClient::UntagMFADevice, request);
        }
 
        template<typename UntagMFADeviceRequestT = Model::UntagMFADeviceRequest>
        void UntagMFADeviceAsync(const UntagMFADeviceRequestT& request, const UntagMFADeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::UntagMFADevice, request, handler, context);
        }
 
        virtual Model::UntagOpenIDConnectProviderOutcome UntagOpenIDConnectProvider(const Model::UntagOpenIDConnectProviderRequest& request) const;
 
        template<typename UntagOpenIDConnectProviderRequestT = Model::UntagOpenIDConnectProviderRequest>
        Model::UntagOpenIDConnectProviderOutcomeCallable UntagOpenIDConnectProviderCallable(const UntagOpenIDConnectProviderRequestT& request) const
        {
            return SubmitCallable(&IAMClient::UntagOpenIDConnectProvider, request);
        }
 
        template<typename UntagOpenIDConnectProviderRequestT = Model::UntagOpenIDConnectProviderRequest>
        void UntagOpenIDConnectProviderAsync(const UntagOpenIDConnectProviderRequestT& request, const UntagOpenIDConnectProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::UntagOpenIDConnectProvider, request, handler, context);
        }
 
        virtual Model::UntagPolicyOutcome UntagPolicy(const Model::UntagPolicyRequest& request) const;
 
        template<typename UntagPolicyRequestT = Model::UntagPolicyRequest>
        Model::UntagPolicyOutcomeCallable UntagPolicyCallable(const UntagPolicyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::UntagPolicy, request);
        }
 
        template<typename UntagPolicyRequestT = Model::UntagPolicyRequest>
        void UntagPolicyAsync(const UntagPolicyRequestT& request, const UntagPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::UntagPolicy, request, handler, context);
        }
 
        virtual Model::UntagRoleOutcome UntagRole(const Model::UntagRoleRequest& request) const;
 
        template<typename UntagRoleRequestT = Model::UntagRoleRequest>
        Model::UntagRoleOutcomeCallable UntagRoleCallable(const UntagRoleRequestT& request) const
        {
            return SubmitCallable(&IAMClient::UntagRole, request);
        }
 
        template<typename UntagRoleRequestT = Model::UntagRoleRequest>
        void UntagRoleAsync(const UntagRoleRequestT& request, const UntagRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::UntagRole, request, handler, context);
        }
 
        virtual Model::UntagSAMLProviderOutcome UntagSAMLProvider(const Model::UntagSAMLProviderRequest& request) const;
 
        template<typename UntagSAMLProviderRequestT = Model::UntagSAMLProviderRequest>
        Model::UntagSAMLProviderOutcomeCallable UntagSAMLProviderCallable(const UntagSAMLProviderRequestT& request) const
        {
            return SubmitCallable(&IAMClient::UntagSAMLProvider, request);
        }
 
        template<typename UntagSAMLProviderRequestT = Model::UntagSAMLProviderRequest>
        void UntagSAMLProviderAsync(const UntagSAMLProviderRequestT& request, const UntagSAMLProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::UntagSAMLProvider, request, handler, context);
        }
 
        virtual Model::UntagServerCertificateOutcome UntagServerCertificate(const Model::UntagServerCertificateRequest& request) const;
 
        template<typename UntagServerCertificateRequestT = Model::UntagServerCertificateRequest>
        Model::UntagServerCertificateOutcomeCallable UntagServerCertificateCallable(const UntagServerCertificateRequestT& request) const
        {
            return SubmitCallable(&IAMClient::UntagServerCertificate, request);
        }
 
        template<typename UntagServerCertificateRequestT = Model::UntagServerCertificateRequest>
        void UntagServerCertificateAsync(const UntagServerCertificateRequestT& request, const UntagServerCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::UntagServerCertificate, request, handler, context);
        }
 
        virtual Model::UntagUserOutcome UntagUser(const Model::UntagUserRequest& request) const;
 
        template<typename UntagUserRequestT = Model::UntagUserRequest>
        Model::UntagUserOutcomeCallable UntagUserCallable(const UntagUserRequestT& request) const
        {
            return SubmitCallable(&IAMClient::UntagUser, request);
        }
 
        template<typename UntagUserRequestT = Model::UntagUserRequest>
        void UntagUserAsync(const UntagUserRequestT& request, const UntagUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::UntagUser, request, handler, context);
        }
 
        virtual Model::UpdateAccessKeyOutcome UpdateAccessKey(const Model::UpdateAccessKeyRequest& request) const;
 
        template<typename UpdateAccessKeyRequestT = Model::UpdateAccessKeyRequest>
        Model::UpdateAccessKeyOutcomeCallable UpdateAccessKeyCallable(const UpdateAccessKeyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::UpdateAccessKey, request);
        }
 
        template<typename UpdateAccessKeyRequestT = Model::UpdateAccessKeyRequest>
        void UpdateAccessKeyAsync(const UpdateAccessKeyRequestT& request, const UpdateAccessKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::UpdateAccessKey, request, handler, context);
        }
 
        virtual Model::UpdateAccountPasswordPolicyOutcome UpdateAccountPasswordPolicy(const Model::UpdateAccountPasswordPolicyRequest& request = {}) const;
 
        template<typename UpdateAccountPasswordPolicyRequestT = Model::UpdateAccountPasswordPolicyRequest>
        Model::UpdateAccountPasswordPolicyOutcomeCallable UpdateAccountPasswordPolicyCallable(const UpdateAccountPasswordPolicyRequestT& request = {}) const
        {
            return SubmitCallable(&IAMClient::UpdateAccountPasswordPolicy, request);
        }
 
        template<typename UpdateAccountPasswordPolicyRequestT = Model::UpdateAccountPasswordPolicyRequest>
        void UpdateAccountPasswordPolicyAsync(const UpdateAccountPasswordPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateAccountPasswordPolicyRequestT& request = {}) const
        {
            return SubmitAsync(&IAMClient::UpdateAccountPasswordPolicy, request, handler, context);
        }
 
        virtual Model::UpdateAssumeRolePolicyOutcome UpdateAssumeRolePolicy(const Model::UpdateAssumeRolePolicyRequest& request) const;
 
        template<typename UpdateAssumeRolePolicyRequestT = Model::UpdateAssumeRolePolicyRequest>
        Model::UpdateAssumeRolePolicyOutcomeCallable UpdateAssumeRolePolicyCallable(const UpdateAssumeRolePolicyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::UpdateAssumeRolePolicy, request);
        }
 
        template<typename UpdateAssumeRolePolicyRequestT = Model::UpdateAssumeRolePolicyRequest>
        void UpdateAssumeRolePolicyAsync(const UpdateAssumeRolePolicyRequestT& request, const UpdateAssumeRolePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::UpdateAssumeRolePolicy, request, handler, context);
        }
 
        virtual Model::UpdateGroupOutcome UpdateGroup(const Model::UpdateGroupRequest& request) const;
 
        template<typename UpdateGroupRequestT = Model::UpdateGroupRequest>
        Model::UpdateGroupOutcomeCallable UpdateGroupCallable(const UpdateGroupRequestT& request) const
        {
            return SubmitCallable(&IAMClient::UpdateGroup, request);
        }
 
        template<typename UpdateGroupRequestT = Model::UpdateGroupRequest>
        void UpdateGroupAsync(const UpdateGroupRequestT& request, const UpdateGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::UpdateGroup, request, handler, context);
        }
 
        virtual Model::UpdateLoginProfileOutcome UpdateLoginProfile(const Model::UpdateLoginProfileRequest& request) const;
 
        template<typename UpdateLoginProfileRequestT = Model::UpdateLoginProfileRequest>
        Model::UpdateLoginProfileOutcomeCallable UpdateLoginProfileCallable(const UpdateLoginProfileRequestT& request) const
        {
            return SubmitCallable(&IAMClient::UpdateLoginProfile, request);
        }
 
        template<typename UpdateLoginProfileRequestT = Model::UpdateLoginProfileRequest>
        void UpdateLoginProfileAsync(const UpdateLoginProfileRequestT& request, const UpdateLoginProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::UpdateLoginProfile, request, handler, context);
        }
 
        virtual Model::UpdateOpenIDConnectProviderThumbprintOutcome UpdateOpenIDConnectProviderThumbprint(const Model::UpdateOpenIDConnectProviderThumbprintRequest& request) const;
 
        template<typename UpdateOpenIDConnectProviderThumbprintRequestT = Model::UpdateOpenIDConnectProviderThumbprintRequest>
        Model::UpdateOpenIDConnectProviderThumbprintOutcomeCallable UpdateOpenIDConnectProviderThumbprintCallable(const UpdateOpenIDConnectProviderThumbprintRequestT& request) const
        {
            return SubmitCallable(&IAMClient::UpdateOpenIDConnectProviderThumbprint, request);
        }
 
        template<typename UpdateOpenIDConnectProviderThumbprintRequestT = Model::UpdateOpenIDConnectProviderThumbprintRequest>
        void UpdateOpenIDConnectProviderThumbprintAsync(const UpdateOpenIDConnectProviderThumbprintRequestT& request, const UpdateOpenIDConnectProviderThumbprintResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::UpdateOpenIDConnectProviderThumbprint, request, handler, context);
        }
 
        virtual Model::UpdateRoleOutcome UpdateRole(const Model::UpdateRoleRequest& request) const;
 
        template<typename UpdateRoleRequestT = Model::UpdateRoleRequest>
        Model::UpdateRoleOutcomeCallable UpdateRoleCallable(const UpdateRoleRequestT& request) const
        {
            return SubmitCallable(&IAMClient::UpdateRole, request);
        }
 
        template<typename UpdateRoleRequestT = Model::UpdateRoleRequest>
        void UpdateRoleAsync(const UpdateRoleRequestT& request, const UpdateRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::UpdateRole, request, handler, context);
        }
 
        virtual Model::UpdateRoleDescriptionOutcome UpdateRoleDescription(const Model::UpdateRoleDescriptionRequest& request) const;
 
        template<typename UpdateRoleDescriptionRequestT = Model::UpdateRoleDescriptionRequest>
        Model::UpdateRoleDescriptionOutcomeCallable UpdateRoleDescriptionCallable(const UpdateRoleDescriptionRequestT& request) const
        {
            return SubmitCallable(&IAMClient::UpdateRoleDescription, request);
        }
 
        template<typename UpdateRoleDescriptionRequestT = Model::UpdateRoleDescriptionRequest>
        void UpdateRoleDescriptionAsync(const UpdateRoleDescriptionRequestT& request, const UpdateRoleDescriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::UpdateRoleDescription, request, handler, context);
        }
 
        virtual Model::UpdateSAMLProviderOutcome UpdateSAMLProvider(const Model::UpdateSAMLProviderRequest& request) const;
 
        template<typename UpdateSAMLProviderRequestT = Model::UpdateSAMLProviderRequest>
        Model::UpdateSAMLProviderOutcomeCallable UpdateSAMLProviderCallable(const UpdateSAMLProviderRequestT& request) const
        {
            return SubmitCallable(&IAMClient::UpdateSAMLProvider, request);
        }
 
        template<typename UpdateSAMLProviderRequestT = Model::UpdateSAMLProviderRequest>
        void UpdateSAMLProviderAsync(const UpdateSAMLProviderRequestT& request, const UpdateSAMLProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::UpdateSAMLProvider, request, handler, context);
        }
 
        virtual Model::UpdateSSHPublicKeyOutcome UpdateSSHPublicKey(const Model::UpdateSSHPublicKeyRequest& request) const;
 
        template<typename UpdateSSHPublicKeyRequestT = Model::UpdateSSHPublicKeyRequest>
        Model::UpdateSSHPublicKeyOutcomeCallable UpdateSSHPublicKeyCallable(const UpdateSSHPublicKeyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::UpdateSSHPublicKey, request);
        }
 
        template<typename UpdateSSHPublicKeyRequestT = Model::UpdateSSHPublicKeyRequest>
        void UpdateSSHPublicKeyAsync(const UpdateSSHPublicKeyRequestT& request, const UpdateSSHPublicKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::UpdateSSHPublicKey, request, handler, context);
        }
 
        virtual Model::UpdateServerCertificateOutcome UpdateServerCertificate(const Model::UpdateServerCertificateRequest& request) const;
 
        template<typename UpdateServerCertificateRequestT = Model::UpdateServerCertificateRequest>
        Model::UpdateServerCertificateOutcomeCallable UpdateServerCertificateCallable(const UpdateServerCertificateRequestT& request) const
        {
            return SubmitCallable(&IAMClient::UpdateServerCertificate, request);
        }
 
        template<typename UpdateServerCertificateRequestT = Model::UpdateServerCertificateRequest>
        void UpdateServerCertificateAsync(const UpdateServerCertificateRequestT& request, const UpdateServerCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::UpdateServerCertificate, request, handler, context);
        }
 
        virtual Model::UpdateServiceSpecificCredentialOutcome UpdateServiceSpecificCredential(const Model::UpdateServiceSpecificCredentialRequest& request) const;
 
        template<typename UpdateServiceSpecificCredentialRequestT = Model::UpdateServiceSpecificCredentialRequest>
        Model::UpdateServiceSpecificCredentialOutcomeCallable UpdateServiceSpecificCredentialCallable(const UpdateServiceSpecificCredentialRequestT& request) const
        {
            return SubmitCallable(&IAMClient::UpdateServiceSpecificCredential, request);
        }
 
        template<typename UpdateServiceSpecificCredentialRequestT = Model::UpdateServiceSpecificCredentialRequest>
        void UpdateServiceSpecificCredentialAsync(const UpdateServiceSpecificCredentialRequestT& request, const UpdateServiceSpecificCredentialResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::UpdateServiceSpecificCredential, request, handler, context);
        }
 
        virtual Model::UpdateSigningCertificateOutcome UpdateSigningCertificate(const Model::UpdateSigningCertificateRequest& request) const;
 
        template<typename UpdateSigningCertificateRequestT = Model::UpdateSigningCertificateRequest>
        Model::UpdateSigningCertificateOutcomeCallable UpdateSigningCertificateCallable(const UpdateSigningCertificateRequestT& request) const
        {
            return SubmitCallable(&IAMClient::UpdateSigningCertificate, request);
        }
 
        template<typename UpdateSigningCertificateRequestT = Model::UpdateSigningCertificateRequest>
        void UpdateSigningCertificateAsync(const UpdateSigningCertificateRequestT& request, const UpdateSigningCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::UpdateSigningCertificate, request, handler, context);
        }
 
        virtual Model::UpdateUserOutcome UpdateUser(const Model::UpdateUserRequest& request) const;
 
        template<typename UpdateUserRequestT = Model::UpdateUserRequest>
        Model::UpdateUserOutcomeCallable UpdateUserCallable(const UpdateUserRequestT& request) const
        {
            return SubmitCallable(&IAMClient::UpdateUser, request);
        }
 
        template<typename UpdateUserRequestT = Model::UpdateUserRequest>
        void UpdateUserAsync(const UpdateUserRequestT& request, const UpdateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::UpdateUser, request, handler, context);
        }
 
        virtual Model::UploadSSHPublicKeyOutcome UploadSSHPublicKey(const Model::UploadSSHPublicKeyRequest& request) const;
 
        template<typename UploadSSHPublicKeyRequestT = Model::UploadSSHPublicKeyRequest>
        Model::UploadSSHPublicKeyOutcomeCallable UploadSSHPublicKeyCallable(const UploadSSHPublicKeyRequestT& request) const
        {
            return SubmitCallable(&IAMClient::UploadSSHPublicKey, request);
        }
 
        template<typename UploadSSHPublicKeyRequestT = Model::UploadSSHPublicKeyRequest>
        void UploadSSHPublicKeyAsync(const UploadSSHPublicKeyRequestT& request, const UploadSSHPublicKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::UploadSSHPublicKey, request, handler, context);
        }
 
        virtual Model::UploadServerCertificateOutcome UploadServerCertificate(const Model::UploadServerCertificateRequest& request) const;
 
        template<typename UploadServerCertificateRequestT = Model::UploadServerCertificateRequest>
        Model::UploadServerCertificateOutcomeCallable UploadServerCertificateCallable(const UploadServerCertificateRequestT& request) const
        {
            return SubmitCallable(&IAMClient::UploadServerCertificate, request);
        }
 
        template<typename UploadServerCertificateRequestT = Model::UploadServerCertificateRequest>
        void UploadServerCertificateAsync(const UploadServerCertificateRequestT& request, const UploadServerCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::UploadServerCertificate, request, handler, context);
        }
 
        virtual Model::UploadSigningCertificateOutcome UploadSigningCertificate(const Model::UploadSigningCertificateRequest& request) const;
 
        template<typename UploadSigningCertificateRequestT = Model::UploadSigningCertificateRequest>
        Model::UploadSigningCertificateOutcomeCallable UploadSigningCertificateCallable(const UploadSigningCertificateRequestT& request) const
        {
            return SubmitCallable(&IAMClient::UploadSigningCertificate, request);
        }
 
        template<typename UploadSigningCertificateRequestT = Model::UploadSigningCertificateRequest>
        void UploadSigningCertificateAsync(const UploadSigningCertificateRequestT& request, const UploadSigningCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IAMClient::UploadSigningCertificate, request, handler, context);
        }
 
 
        void OverrideEndpoint(const Aws::String& endpoint);
        std::shared_ptr<IAMEndpointProviderBase>& accessEndpointProvider();
  private:
        friend class Aws::Client::ClientWithAsyncTemplateMethods<IAMClient>;
        void init(const IAMClientConfiguration& clientConfiguration);
 
        IAMClientConfiguration m_clientConfiguration;
        std::shared_ptr<IAMEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace IAM
} // namespace Aws