IAMClient.h

 
#pragma once
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/iam/IAMPaginationBase.h>
#include <aws/iam/IAMServiceClientModel.h>
#include <aws/iam/IAMWaiter.h>
#include <aws/iam/IAM_EXPORTS.h>
 
namespace Aws {
namespace IAM {
class AWS_IAM_API IAMClient : public Aws::Client::AWSXMLClient,
                              public Aws::Client::ClientWithAsyncTemplateMethods<IAMClient>,
                              public IAMPaginationBase<IAMClient>,
                              public IAMWaiter<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::AcceptDelegationRequestOutcome AcceptDelegationRequest(const Model::AcceptDelegationRequestRequest& request) const;
 
  template <typename AcceptDelegationRequestRequestT = Model::AcceptDelegationRequestRequest>
  Model::AcceptDelegationRequestOutcomeCallable AcceptDelegationRequestCallable(const AcceptDelegationRequestRequestT& request) const {
    return SubmitCallable(&IAMClient::AcceptDelegationRequest, request);
  }
 
  template <typename AcceptDelegationRequestRequestT = Model::AcceptDelegationRequestRequest>
  void AcceptDelegationRequestAsync(const AcceptDelegationRequestRequestT& request,
                                    const AcceptDelegationRequestResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IAMClient::AcceptDelegationRequest, request, handler, context);
  }
 
  virtual Model::AcquireRoleOutcome AcquireRole(const Model::AcquireRoleRequest& request) const;
 
  template <typename AcquireRoleRequestT = Model::AcquireRoleRequest>
  Model::AcquireRoleOutcomeCallable AcquireRoleCallable(const AcquireRoleRequestT& request) const {
    return SubmitCallable(&IAMClient::AcquireRole, request);
  }
 
  template <typename AcquireRoleRequestT = Model::AcquireRoleRequest>
  void AcquireRoleAsync(const AcquireRoleRequestT& request, const AcquireRoleResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IAMClient::AcquireRole, request, handler, context);
  }
 
  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::AssociateDelegationRequestOutcome AssociateDelegationRequest(
      const Model::AssociateDelegationRequestRequest& request) const;
 
  template <typename AssociateDelegationRequestRequestT = Model::AssociateDelegationRequestRequest>
  Model::AssociateDelegationRequestOutcomeCallable AssociateDelegationRequestCallable(
      const AssociateDelegationRequestRequestT& request) const {
    return SubmitCallable(&IAMClient::AssociateDelegationRequest, request);
  }
 
  template <typename AssociateDelegationRequestRequestT = Model::AssociateDelegationRequestRequest>
  void AssociateDelegationRequestAsync(const AssociateDelegationRequestRequestT& request,
                                       const AssociateDelegationRequestResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IAMClient::AssociateDelegationRequest, 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::CreateDelegationRequestOutcome CreateDelegationRequest(const Model::CreateDelegationRequestRequest& request) const;
 
  template <typename CreateDelegationRequestRequestT = Model::CreateDelegationRequestRequest>
  Model::CreateDelegationRequestOutcomeCallable CreateDelegationRequestCallable(const CreateDelegationRequestRequestT& request) const {
    return SubmitCallable(&IAMClient::CreateDelegationRequest, request);
  }
 
  template <typename CreateDelegationRequestRequestT = Model::CreateDelegationRequestRequest>
  void CreateDelegationRequestAsync(const CreateDelegationRequestRequestT& request,
                                    const CreateDelegationRequestResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IAMClient::CreateDelegationRequest, 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 CreateLoginProfileResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const CreateLoginProfileRequestT& request = {}) 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 DeleteLoginProfileResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const DeleteLoginProfileRequestT& request = {}) 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::DisableOrganizationsRootCredentialsManagementOutcome DisableOrganizationsRootCredentialsManagement(
      const Model::DisableOrganizationsRootCredentialsManagementRequest& request = {}) const;
 
  template <typename DisableOrganizationsRootCredentialsManagementRequestT = Model::DisableOrganizationsRootCredentialsManagementRequest>
  Model::DisableOrganizationsRootCredentialsManagementOutcomeCallable DisableOrganizationsRootCredentialsManagementCallable(
      const DisableOrganizationsRootCredentialsManagementRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::DisableOrganizationsRootCredentialsManagement, request);
  }
 
  template <typename DisableOrganizationsRootCredentialsManagementRequestT = Model::DisableOrganizationsRootCredentialsManagementRequest>
  void DisableOrganizationsRootCredentialsManagementAsync(
      const DisableOrganizationsRootCredentialsManagementResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
      const DisableOrganizationsRootCredentialsManagementRequestT& request = {}) const {
    return SubmitAsync(&IAMClient::DisableOrganizationsRootCredentialsManagement, request, handler, context);
  }
 
  virtual Model::DisableOrganizationsRootSessionsOutcome DisableOrganizationsRootSessions(
      const Model::DisableOrganizationsRootSessionsRequest& request = {}) const;
 
  template <typename DisableOrganizationsRootSessionsRequestT = Model::DisableOrganizationsRootSessionsRequest>
  Model::DisableOrganizationsRootSessionsOutcomeCallable DisableOrganizationsRootSessionsCallable(
      const DisableOrganizationsRootSessionsRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::DisableOrganizationsRootSessions, request);
  }
 
  template <typename DisableOrganizationsRootSessionsRequestT = Model::DisableOrganizationsRootSessionsRequest>
  void DisableOrganizationsRootSessionsAsync(const DisableOrganizationsRootSessionsResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                             const DisableOrganizationsRootSessionsRequestT& request = {}) const {
    return SubmitAsync(&IAMClient::DisableOrganizationsRootSessions, request, handler, context);
  }
 
  virtual Model::DisableOutboundWebIdentityFederationOutcome DisableOutboundWebIdentityFederation(
      const Model::DisableOutboundWebIdentityFederationRequest& request = {}) const;
 
  template <typename DisableOutboundWebIdentityFederationRequestT = Model::DisableOutboundWebIdentityFederationRequest>
  Model::DisableOutboundWebIdentityFederationOutcomeCallable DisableOutboundWebIdentityFederationCallable(
      const DisableOutboundWebIdentityFederationRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::DisableOutboundWebIdentityFederation, request);
  }
 
  template <typename DisableOutboundWebIdentityFederationRequestT = Model::DisableOutboundWebIdentityFederationRequest>
  void DisableOutboundWebIdentityFederationAsync(const DisableOutboundWebIdentityFederationResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                 const DisableOutboundWebIdentityFederationRequestT& request = {}) const {
    return SubmitAsync(&IAMClient::DisableOutboundWebIdentityFederation, 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::EnableOrganizationsRootCredentialsManagementOutcome EnableOrganizationsRootCredentialsManagement(
      const Model::EnableOrganizationsRootCredentialsManagementRequest& request = {}) const;
 
  template <typename EnableOrganizationsRootCredentialsManagementRequestT = Model::EnableOrganizationsRootCredentialsManagementRequest>
  Model::EnableOrganizationsRootCredentialsManagementOutcomeCallable EnableOrganizationsRootCredentialsManagementCallable(
      const EnableOrganizationsRootCredentialsManagementRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::EnableOrganizationsRootCredentialsManagement, request);
  }
 
  template <typename EnableOrganizationsRootCredentialsManagementRequestT = Model::EnableOrganizationsRootCredentialsManagementRequest>
  void EnableOrganizationsRootCredentialsManagementAsync(const EnableOrganizationsRootCredentialsManagementResponseReceivedHandler& handler,
                                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                         const EnableOrganizationsRootCredentialsManagementRequestT& request = {}) const {
    return SubmitAsync(&IAMClient::EnableOrganizationsRootCredentialsManagement, request, handler, context);
  }
 
  virtual Model::EnableOrganizationsRootSessionsOutcome EnableOrganizationsRootSessions(
      const Model::EnableOrganizationsRootSessionsRequest& request = {}) const;
 
  template <typename EnableOrganizationsRootSessionsRequestT = Model::EnableOrganizationsRootSessionsRequest>
  Model::EnableOrganizationsRootSessionsOutcomeCallable EnableOrganizationsRootSessionsCallable(
      const EnableOrganizationsRootSessionsRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::EnableOrganizationsRootSessions, request);
  }
 
  template <typename EnableOrganizationsRootSessionsRequestT = Model::EnableOrganizationsRootSessionsRequest>
  void EnableOrganizationsRootSessionsAsync(const EnableOrganizationsRootSessionsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                            const EnableOrganizationsRootSessionsRequestT& request = {}) const {
    return SubmitAsync(&IAMClient::EnableOrganizationsRootSessions, request, handler, context);
  }
 
  virtual Model::EnableOutboundWebIdentityFederationOutcome EnableOutboundWebIdentityFederation(
      const Model::EnableOutboundWebIdentityFederationRequest& request = {}) const;
 
  template <typename EnableOutboundWebIdentityFederationRequestT = Model::EnableOutboundWebIdentityFederationRequest>
  Model::EnableOutboundWebIdentityFederationOutcomeCallable EnableOutboundWebIdentityFederationCallable(
      const EnableOutboundWebIdentityFederationRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::EnableOutboundWebIdentityFederation, request);
  }
 
  template <typename EnableOutboundWebIdentityFederationRequestT = Model::EnableOutboundWebIdentityFederationRequest>
  void EnableOutboundWebIdentityFederationAsync(const EnableOutboundWebIdentityFederationResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                const EnableOutboundWebIdentityFederationRequestT& request = {}) const {
    return SubmitAsync(&IAMClient::EnableOutboundWebIdentityFederation, 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::GetAccountPropertiesOutcome GetAccountProperties(const Model::GetAccountPropertiesRequest& request = {}) const;
 
  template <typename GetAccountPropertiesRequestT = Model::GetAccountPropertiesRequest>
  Model::GetAccountPropertiesOutcomeCallable GetAccountPropertiesCallable(const GetAccountPropertiesRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::GetAccountProperties, request);
  }
 
  template <typename GetAccountPropertiesRequestT = Model::GetAccountPropertiesRequest>
  void GetAccountPropertiesAsync(const GetAccountPropertiesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const GetAccountPropertiesRequestT& request = {}) const {
    return SubmitAsync(&IAMClient::GetAccountProperties, 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::GetDelegationRequestOutcome GetDelegationRequest(const Model::GetDelegationRequestRequest& request) const;
 
  template <typename GetDelegationRequestRequestT = Model::GetDelegationRequestRequest>
  Model::GetDelegationRequestOutcomeCallable GetDelegationRequestCallable(const GetDelegationRequestRequestT& request) const {
    return SubmitCallable(&IAMClient::GetDelegationRequest, request);
  }
 
  template <typename GetDelegationRequestRequestT = Model::GetDelegationRequestRequest>
  void GetDelegationRequestAsync(const GetDelegationRequestRequestT& request, const GetDelegationRequestResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IAMClient::GetDelegationRequest, 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::GetHumanReadableSummaryOutcome GetHumanReadableSummary(const Model::GetHumanReadableSummaryRequest& request) const;
 
  template <typename GetHumanReadableSummaryRequestT = Model::GetHumanReadableSummaryRequest>
  Model::GetHumanReadableSummaryOutcomeCallable GetHumanReadableSummaryCallable(const GetHumanReadableSummaryRequestT& request) const {
    return SubmitCallable(&IAMClient::GetHumanReadableSummary, request);
  }
 
  template <typename GetHumanReadableSummaryRequestT = Model::GetHumanReadableSummaryRequest>
  void GetHumanReadableSummaryAsync(const GetHumanReadableSummaryRequestT& request,
                                    const GetHumanReadableSummaryResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IAMClient::GetHumanReadableSummary, 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 GetLoginProfileResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const GetLoginProfileRequestT& request = {}) 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::GetOutboundWebIdentityFederationInfoOutcome GetOutboundWebIdentityFederationInfo(
      const Model::GetOutboundWebIdentityFederationInfoRequest& request = {}) const;
 
  template <typename GetOutboundWebIdentityFederationInfoRequestT = Model::GetOutboundWebIdentityFederationInfoRequest>
  Model::GetOutboundWebIdentityFederationInfoOutcomeCallable GetOutboundWebIdentityFederationInfoCallable(
      const GetOutboundWebIdentityFederationInfoRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::GetOutboundWebIdentityFederationInfo, request);
  }
 
  template <typename GetOutboundWebIdentityFederationInfoRequestT = Model::GetOutboundWebIdentityFederationInfoRequest>
  void GetOutboundWebIdentityFederationInfoAsync(const GetOutboundWebIdentityFederationInfoResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                 const GetOutboundWebIdentityFederationInfoRequestT& request = {}) const {
    return SubmitAsync(&IAMClient::GetOutboundWebIdentityFederationInfo, 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::GetRoleTemplateVersionOutcome GetRoleTemplateVersion(const Model::GetRoleTemplateVersionRequest& request) const;
 
  template <typename GetRoleTemplateVersionRequestT = Model::GetRoleTemplateVersionRequest>
  Model::GetRoleTemplateVersionOutcomeCallable GetRoleTemplateVersionCallable(const GetRoleTemplateVersionRequestT& request) const {
    return SubmitCallable(&IAMClient::GetRoleTemplateVersion, request);
  }
 
  template <typename GetRoleTemplateVersionRequestT = Model::GetRoleTemplateVersionRequest>
  void GetRoleTemplateVersionAsync(const GetRoleTemplateVersionRequestT& request,
                                   const GetRoleTemplateVersionResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IAMClient::GetRoleTemplateVersion, 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::ListDelegationRequestsOutcome ListDelegationRequests(const Model::ListDelegationRequestsRequest& request = {}) const;
 
  template <typename ListDelegationRequestsRequestT = Model::ListDelegationRequestsRequest>
  Model::ListDelegationRequestsOutcomeCallable ListDelegationRequestsCallable(const ListDelegationRequestsRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::ListDelegationRequests, request);
  }
 
  template <typename ListDelegationRequestsRequestT = Model::ListDelegationRequestsRequest>
  void ListDelegationRequestsAsync(const ListDelegationRequestsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListDelegationRequestsRequestT& request = {}) const {
    return SubmitAsync(&IAMClient::ListDelegationRequests, 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::ListOrganizationsFeaturesOutcome ListOrganizationsFeatures(
      const Model::ListOrganizationsFeaturesRequest& request = {}) const;
 
  template <typename ListOrganizationsFeaturesRequestT = Model::ListOrganizationsFeaturesRequest>
  Model::ListOrganizationsFeaturesOutcomeCallable ListOrganizationsFeaturesCallable(
      const ListOrganizationsFeaturesRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::ListOrganizationsFeatures, request);
  }
 
  template <typename ListOrganizationsFeaturesRequestT = Model::ListOrganizationsFeaturesRequest>
  void ListOrganizationsFeaturesAsync(const ListOrganizationsFeaturesResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListOrganizationsFeaturesRequestT& request = {}) const {
    return SubmitAsync(&IAMClient::ListOrganizationsFeatures, 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::PutAccountPropertiesOutcome PutAccountProperties(const Model::PutAccountPropertiesRequest& request) const;
 
  template <typename PutAccountPropertiesRequestT = Model::PutAccountPropertiesRequest>
  Model::PutAccountPropertiesOutcomeCallable PutAccountPropertiesCallable(const PutAccountPropertiesRequestT& request) const {
    return SubmitCallable(&IAMClient::PutAccountProperties, request);
  }
 
  template <typename PutAccountPropertiesRequestT = Model::PutAccountPropertiesRequest>
  void PutAccountPropertiesAsync(const PutAccountPropertiesRequestT& request, const PutAccountPropertiesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IAMClient::PutAccountProperties, 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::RejectDelegationRequestOutcome RejectDelegationRequest(const Model::RejectDelegationRequestRequest& request) const;
 
  template <typename RejectDelegationRequestRequestT = Model::RejectDelegationRequestRequest>
  Model::RejectDelegationRequestOutcomeCallable RejectDelegationRequestCallable(const RejectDelegationRequestRequestT& request) const {
    return SubmitCallable(&IAMClient::RejectDelegationRequest, request);
  }
 
  template <typename RejectDelegationRequestRequestT = Model::RejectDelegationRequestRequest>
  void RejectDelegationRequestAsync(const RejectDelegationRequestRequestT& request,
                                    const RejectDelegationRequestResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IAMClient::RejectDelegationRequest, 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::SendDelegationTokenOutcome SendDelegationToken(const Model::SendDelegationTokenRequest& request) const;
 
  template <typename SendDelegationTokenRequestT = Model::SendDelegationTokenRequest>
  Model::SendDelegationTokenOutcomeCallable SendDelegationTokenCallable(const SendDelegationTokenRequestT& request) const {
    return SubmitCallable(&IAMClient::SendDelegationToken, request);
  }
 
  template <typename SendDelegationTokenRequestT = Model::SendDelegationTokenRequest>
  void SendDelegationTokenAsync(const SendDelegationTokenRequestT& request, const SendDelegationTokenResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IAMClient::SendDelegationToken, 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::UpdateDelegationRequestOutcome UpdateDelegationRequest(const Model::UpdateDelegationRequestRequest& request) const;
 
  template <typename UpdateDelegationRequestRequestT = Model::UpdateDelegationRequestRequest>
  Model::UpdateDelegationRequestOutcomeCallable UpdateDelegationRequestCallable(const UpdateDelegationRequestRequestT& request) const {
    return SubmitCallable(&IAMClient::UpdateDelegationRequest, request);
  }
 
  template <typename UpdateDelegationRequestRequestT = Model::UpdateDelegationRequestRequest>
  void UpdateDelegationRequestAsync(const UpdateDelegationRequestRequestT& request,
                                    const UpdateDelegationRequestResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IAMClient::UpdateDelegationRequest, 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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<IAMEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<IAMClient>;
  void init(const IAMClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, IAMError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  IAMClientConfiguration m_clientConfiguration;
  std::shared_ptr<IAMEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace IAM
}  // namespace Aws