/**
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 * SPDX-License-Identifier: Apache-2.0.
 */

#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 {
/**
 * <fullname>Identity and Access Management</fullname> <p>Identity and Access
 * Management (IAM) is a web service for securely controlling access to Amazon Web
 * Services services. With IAM, you can centrally manage users, security
 * credentials such as access keys, and permissions that control which Amazon Web
 * Services resources users and applications can access. For more information about
 * IAM, see <a href="http://aws.amazon.com/iam/">Identity and Access Management
 * (IAM)</a> and the <a
 * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/">Identity and Access
 * Management User Guide</a>.</p>
 */
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;

  /**
   * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client
   * config is not specified, it will be initialized to default values.
   */
  IAMClient(const Aws::IAM::IAMClientConfiguration& clientConfiguration = Aws::IAM::IAMClientConfiguration(),
            std::shared_ptr<IAMEndpointProviderBase> endpointProvider = nullptr);

  /**
   * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config
   * is not specified, it will be initialized to default values.
   */
  IAMClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<IAMEndpointProviderBase> endpointProvider = nullptr,
            const Aws::IAM::IAMClientConfiguration& clientConfiguration = Aws::IAM::IAMClientConfiguration());

  /**
   * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied,
   * the default http client factory will be used
   */
  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 */
  /**
   * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client
   * config is not specified, it will be initialized to default values.
   */
  IAMClient(const Aws::Client::ClientConfiguration& clientConfiguration);

  /**
   * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config
   * is not specified, it will be initialized to default values.
   */
  IAMClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);

  /**
   * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied,
   * the default http client factory will be used
   */
  IAMClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            const Aws::Client::ClientConfiguration& clientConfiguration);

  /* End of legacy constructors due deprecation */
  virtual ~IAMClient();

  /**
   * Converts any request object to a presigned URL with the GET method, using region for the signer and a timeout of 15 minutes.
   */
  Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const;

  /**
   * <p>Accepts a delegation request, granting the requested temporary access.</p>
   * <p>Once the delegation request is accepted, it is eligible to send the exchange
   * token to the partner. The <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_SendDelegationToken.html">SendDelegationToken</a>
   * API has to be explicitly called to send the delegation token. </p> <p>At the
   * time of acceptance, IAM records the details and the state of the identity that
   * called this API. This is the identity that gets mapped to the delegated
   * credential. </p> <p>An accepted request may be rejected before the exchange
   * token is sent to the partner.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/AcceptDelegationRequest">AWS
   * API Reference</a></p>
   */
  virtual Model::AcceptDelegationRequestOutcome AcceptDelegationRequest(const Model::AcceptDelegationRequestRequest& request) const;

  /**
   * A Callable wrapper for AcceptDelegationRequest that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename AcceptDelegationRequestRequestT = Model::AcceptDelegationRequestRequest>
  Model::AcceptDelegationRequestOutcomeCallable AcceptDelegationRequestCallable(const AcceptDelegationRequestRequestT& request) const {
    return SubmitCallable(&IAMClient::AcceptDelegationRequest, request);
  }

  /**
   * An Async wrapper for AcceptDelegationRequest that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Adds a new client ID (also known as audience) to the list of client IDs
   * already registered for the specified IAM OpenID Connect (OIDC) provider
   * resource.</p> <p>This operation is idempotent; it does not fail or return an
   * error if you add an existing client ID to the provider.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/AddClientIDToOpenIDConnectProvider">AWS
   * API Reference</a></p>
   */
  virtual Model::AddClientIDToOpenIDConnectProviderOutcome AddClientIDToOpenIDConnectProvider(
      const Model::AddClientIDToOpenIDConnectProviderRequest& request) const;

  /**
   * A Callable wrapper for AddClientIDToOpenIDConnectProvider that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename AddClientIDToOpenIDConnectProviderRequestT = Model::AddClientIDToOpenIDConnectProviderRequest>
  Model::AddClientIDToOpenIDConnectProviderOutcomeCallable AddClientIDToOpenIDConnectProviderCallable(
      const AddClientIDToOpenIDConnectProviderRequestT& request) const {
    return SubmitCallable(&IAMClient::AddClientIDToOpenIDConnectProvider, request);
  }

  /**
   * An Async wrapper for AddClientIDToOpenIDConnectProvider that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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);
  }

  /**
   * <p>Adds the specified IAM role to the specified instance profile. An instance
   * profile can contain only one role, and this quota cannot be increased. You can
   * remove the existing role and then add a different role to an instance profile.
   * You must then wait for the change to appear across all of Amazon Web Services
   * because of <a href="https://en.wikipedia.org/wiki/Eventual_consistency">eventual
   * consistency</a>. To force the change, you must <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DisassociateIamInstanceProfile.html">disassociate
   * the instance profile</a> and then <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AssociateIamInstanceProfile.html">associate
   * the instance profile</a>, or you can stop your instance and then restart it.</p>
   *  <p>The caller of this operation must be granted the <code>PassRole</code>
   * permission on the IAM role by a permissions policy.</p>
   * <p>When using the <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_iam-condition-keys.html#available-keys-for-iam">iam:AssociatedResourceArn</a>
   * condition in a policy to restrict the <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html">PassRole</a>
   * IAM action, special considerations apply if the policy is intended to define
   * access for the <code>AddRoleToInstanceProfile</code> action. In this case, you
   * cannot specify a Region or instance ID in the EC2 instance ARN. The ARN value
   * must be <code>arn:aws:ec2:*:CallerAccountId:instance/ *</code>. Using any other
   * ARN value may lead to unexpected evaluation results.</p>  <p> For
   * more information about roles, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html">IAM
   * roles</a> in the <i>IAM User Guide</i>. For more information about instance
   * profiles, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html">Using
   * instance profiles</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/AddRoleToInstanceProfile">AWS
   * API Reference</a></p>
   */
  virtual Model::AddRoleToInstanceProfileOutcome AddRoleToInstanceProfile(const Model::AddRoleToInstanceProfileRequest& request) const;

  /**
   * A Callable wrapper for AddRoleToInstanceProfile that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename AddRoleToInstanceProfileRequestT = Model::AddRoleToInstanceProfileRequest>
  Model::AddRoleToInstanceProfileOutcomeCallable AddRoleToInstanceProfileCallable(const AddRoleToInstanceProfileRequestT& request) const {
    return SubmitCallable(&IAMClient::AddRoleToInstanceProfile, request);
  }

  /**
   * An Async wrapper for AddRoleToInstanceProfile that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Adds the specified user to the specified group.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/AddUserToGroup">AWS
   * API Reference</a></p>
   */
  virtual Model::AddUserToGroupOutcome AddUserToGroup(const Model::AddUserToGroupRequest& request) const;

  /**
   * A Callable wrapper for AddUserToGroup that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename AddUserToGroupRequestT = Model::AddUserToGroupRequest>
  Model::AddUserToGroupOutcomeCallable AddUserToGroupCallable(const AddUserToGroupRequestT& request) const {
    return SubmitCallable(&IAMClient::AddUserToGroup, request);
  }

  /**
   * An Async wrapper for AddUserToGroup that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Associates a delegation request with the current identity.</p> <p>If the
   * partner that created the delegation request has specified the owner account
   * during creation, only an identity from that owner account can call the
   * <code>AssociateDelegationRequest</code> API for the specified delegation
   * request. Once the <code>AssociateDelegationRequest</code> API call is
   * successful, the ARN of the current calling identity will be stored as the
   * <code>ownerId</code> of the request. </p> <p>If the partner that created the
   * delegation request has not specified the owner account during creation, any
   * caller from any account can call the <code>AssociateDelegationRequest</code> API
   * for the delegation request. Once this API call is successful, the ARN of the
   * current calling identity will be stored as the <code>ownerId</code> and the
   * Amazon Web Services account ID of the current calling identity will be stored as
   * the <code>ownerAccount</code> of the request. </p> <p> For more details, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-temporary-delegation.html#temporary-delegation-managing-permissions">
   * Managing Permissions for Delegation Requests</a>. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/AssociateDelegationRequest">AWS
   * API Reference</a></p>
   */
  virtual Model::AssociateDelegationRequestOutcome AssociateDelegationRequest(
      const Model::AssociateDelegationRequestRequest& request) const;

  /**
   * A Callable wrapper for AssociateDelegationRequest that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename AssociateDelegationRequestRequestT = Model::AssociateDelegationRequestRequest>
  Model::AssociateDelegationRequestOutcomeCallable AssociateDelegationRequestCallable(
      const AssociateDelegationRequestRequestT& request) const {
    return SubmitCallable(&IAMClient::AssociateDelegationRequest, request);
  }

  /**
   * An Async wrapper for AssociateDelegationRequest that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Attaches the specified managed policy to the specified IAM group.</p> <p>You
   * use this operation to attach a managed policy to a group. To embed an inline
   * policy in a group, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutGroupPolicy.html">
   * <code>PutGroupPolicy</code> </a>.</p> <p>As a best practice, you can validate
   * your IAM policies. To learn more, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_policy-validator.html">Validating
   * IAM policies</a> in the <i>IAM User Guide</i>.</p> <p>For more information about
   * policies, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/AttachGroupPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::AttachGroupPolicyOutcome AttachGroupPolicy(const Model::AttachGroupPolicyRequest& request) const;

  /**
   * A Callable wrapper for AttachGroupPolicy that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename AttachGroupPolicyRequestT = Model::AttachGroupPolicyRequest>
  Model::AttachGroupPolicyOutcomeCallable AttachGroupPolicyCallable(const AttachGroupPolicyRequestT& request) const {
    return SubmitCallable(&IAMClient::AttachGroupPolicy, request);
  }

  /**
   * An Async wrapper for AttachGroupPolicy that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Attaches the specified managed policy to the specified IAM role. When you
   * attach a managed policy to a role, the managed policy becomes part of the role's
   * permission (access) policy.</p>  <p>You cannot use a managed policy as the
   * role's trust policy. The role's trust policy is created at the same time as the
   * role, using <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html">
   * <code>CreateRole</code> </a>. You can update a role's trust policy using <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateAssumeRolePolicy.html">
   * <code>UpdateAssumerolePolicy</code> </a>.</p>  <p>Use this operation to
   * attach a <i>managed</i> policy to a role. To embed an inline policy in a role,
   * use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePolicy.html">
   * <code>PutRolePolicy</code> </a>. For more information about policies, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p> <p>As a best
   * practice, you can validate your IAM policies. To learn more, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_policy-validator.html">Validating
   * IAM policies</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/AttachRolePolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::AttachRolePolicyOutcome AttachRolePolicy(const Model::AttachRolePolicyRequest& request) const;

  /**
   * A Callable wrapper for AttachRolePolicy that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename AttachRolePolicyRequestT = Model::AttachRolePolicyRequest>
  Model::AttachRolePolicyOutcomeCallable AttachRolePolicyCallable(const AttachRolePolicyRequestT& request) const {
    return SubmitCallable(&IAMClient::AttachRolePolicy, request);
  }

  /**
   * An Async wrapper for AttachRolePolicy that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Attaches the specified managed policy to the specified user.</p> <p>You use
   * this operation to attach a <i>managed</i> policy to a user. To embed an inline
   * policy in a user, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutUserPolicy.html">
   * <code>PutUserPolicy</code> </a>.</p> <p>As a best practice, you can validate
   * your IAM policies. To learn more, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_policy-validator.html">Validating
   * IAM policies</a> in the <i>IAM User Guide</i>.</p> <p>For more information about
   * policies, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/AttachUserPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::AttachUserPolicyOutcome AttachUserPolicy(const Model::AttachUserPolicyRequest& request) const;

  /**
   * A Callable wrapper for AttachUserPolicy that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename AttachUserPolicyRequestT = Model::AttachUserPolicyRequest>
  Model::AttachUserPolicyOutcomeCallable AttachUserPolicyCallable(const AttachUserPolicyRequestT& request) const {
    return SubmitCallable(&IAMClient::AttachUserPolicy, request);
  }

  /**
   * An Async wrapper for AttachUserPolicy that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Changes the password of the IAM user who is calling this operation. This
   * operation can be performed using the CLI, the Amazon Web Services API, or the
   * <b>My Security Credentials</b> page in the Amazon Web Services Management
   * Console. The Amazon Web Services account root user password is not affected by
   * this operation.</p> <p>Use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateLoginProfile.html">UpdateLoginProfile</a>
   * to use the CLI, the Amazon Web Services API, or the <b>Users</b> page in the IAM
   * console to change the password for any IAM user. For more information about
   * modifying passwords, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_ManagingLogins.html">Managing
   * passwords</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ChangePassword">AWS
   * API Reference</a></p>
   */
  virtual Model::ChangePasswordOutcome ChangePassword(const Model::ChangePasswordRequest& request) const;

  /**
   * A Callable wrapper for ChangePassword that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename ChangePasswordRequestT = Model::ChangePasswordRequest>
  Model::ChangePasswordOutcomeCallable ChangePasswordCallable(const ChangePasswordRequestT& request) const {
    return SubmitCallable(&IAMClient::ChangePassword, request);
  }

  /**
   * An Async wrapper for ChangePassword that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p> Creates a new Amazon Web Services secret access key and corresponding Amazon
   * Web Services access key ID for the specified user. The default status for new
   * keys is <code>Active</code>.</p> <p>If you do not specify a user name, IAM
   * determines the user name implicitly based on the Amazon Web Services access key
   * ID signing the request. This operation works for access keys under the Amazon
   * Web Services account. Consequently, you can use this operation to manage Amazon
   * Web Services account root user credentials. This is true even if the Amazon Web
   * Services account has no associated users.</p> <p> For information about quotas
   * on the number of keys you can create, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html">IAM
   * and STS quotas</a> in the <i>IAM User Guide</i>.</p>  <p>To ensure
   * the security of your Amazon Web Services account, the secret access key is
   * accessible only during key and user creation. You must save the key (for
   * example, in a text file) if you want to be able to access it again. If a secret
   * key is lost, you can delete the access keys for the associated user and then
   * create new keys.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateAccessKey">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateAccessKeyOutcome CreateAccessKey(const Model::CreateAccessKeyRequest& request = {}) const;

  /**
   * A Callable wrapper for CreateAccessKey that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename CreateAccessKeyRequestT = Model::CreateAccessKeyRequest>
  Model::CreateAccessKeyOutcomeCallable CreateAccessKeyCallable(const CreateAccessKeyRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::CreateAccessKey, request);
  }

  /**
   * An Async wrapper for CreateAccessKey that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Creates an alias for your Amazon Web Services account. For information about
   * using an Amazon Web Services account alias, see <a
   * href="https://docs.aws.amazon.com/signin/latest/userguide/CreateAccountAlias.html">Creating,
   * deleting, and listing an Amazon Web Services account alias</a> in the <i>Amazon
   * Web Services Sign-In User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateAccountAlias">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateAccountAliasOutcome CreateAccountAlias(const Model::CreateAccountAliasRequest& request) const;

  /**
   * A Callable wrapper for CreateAccountAlias that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename CreateAccountAliasRequestT = Model::CreateAccountAliasRequest>
  Model::CreateAccountAliasOutcomeCallable CreateAccountAliasCallable(const CreateAccountAliasRequestT& request) const {
    return SubmitCallable(&IAMClient::CreateAccountAlias, request);
  }

  /**
   * An Async wrapper for CreateAccountAlias that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Creates an IAM delegation request for temporary access delegation.</p>
   * <p>This API is not available for general use. In order to use this API, a caller
   * first need to go through an onboarding process described in the <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-temporary-delegation-partner-guide.html">partner
   * onboarding documentation</a>. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateDelegationRequest">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateDelegationRequestOutcome CreateDelegationRequest(const Model::CreateDelegationRequestRequest& request) const;

  /**
   * A Callable wrapper for CreateDelegationRequest that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename CreateDelegationRequestRequestT = Model::CreateDelegationRequestRequest>
  Model::CreateDelegationRequestOutcomeCallable CreateDelegationRequestCallable(const CreateDelegationRequestRequestT& request) const {
    return SubmitCallable(&IAMClient::CreateDelegationRequest, request);
  }

  /**
   * An Async wrapper for CreateDelegationRequest that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Creates a new group.</p> <p> For information about the number of groups you
   * can create, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html">IAM
   * and STS quotas</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateGroup">AWS API
   * Reference</a></p>
   */
  virtual Model::CreateGroupOutcome CreateGroup(const Model::CreateGroupRequest& request) const;

  /**
   * A Callable wrapper for CreateGroup that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename CreateGroupRequestT = Model::CreateGroupRequest>
  Model::CreateGroupOutcomeCallable CreateGroupCallable(const CreateGroupRequestT& request) const {
    return SubmitCallable(&IAMClient::CreateGroup, request);
  }

  /**
   * An Async wrapper for CreateGroup that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p> Creates a new instance profile. For information about instance profiles, see
   * <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2.html">Using
   * roles for applications on Amazon EC2</a> in the <i>IAM User Guide</i>, and <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#ec2-instance-profile">Instance
   * profiles</a> in the <i>Amazon EC2 User Guide</i>.</p> <p> For information about
   * the number of instance profiles you can create, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html">IAM
   * object quotas</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateInstanceProfile">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateInstanceProfileOutcome CreateInstanceProfile(const Model::CreateInstanceProfileRequest& request) const;

  /**
   * A Callable wrapper for CreateInstanceProfile that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename CreateInstanceProfileRequestT = Model::CreateInstanceProfileRequest>
  Model::CreateInstanceProfileOutcomeCallable CreateInstanceProfileCallable(const CreateInstanceProfileRequestT& request) const {
    return SubmitCallable(&IAMClient::CreateInstanceProfile, request);
  }

  /**
   * An Async wrapper for CreateInstanceProfile that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Creates a password for the specified IAM user. A password allows an IAM user
   * to access Amazon Web Services services through the Amazon Web Services
   * Management Console.</p> <p>You can use the CLI, the Amazon Web Services API, or
   * the <b>Users</b> page in the IAM console to create a password for any IAM user.
   * Use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_ChangePassword.html">ChangePassword</a>
   * to update your own existing password in the <b>My Security Credentials</b> page
   * in the Amazon Web Services Management Console.</p> <p>For more information about
   * managing passwords, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_ManagingLogins.html">Managing
   * passwords</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateLoginProfile">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateLoginProfileOutcome CreateLoginProfile(const Model::CreateLoginProfileRequest& request = {}) const;

  /**
   * A Callable wrapper for CreateLoginProfile that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename CreateLoginProfileRequestT = Model::CreateLoginProfileRequest>
  Model::CreateLoginProfileOutcomeCallable CreateLoginProfileCallable(const CreateLoginProfileRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::CreateLoginProfile, request);
  }

  /**
   * An Async wrapper for CreateLoginProfile that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Creates an IAM entity to describe an identity provider (IdP) that supports <a
   * href="http://openid.net/connect/">OpenID Connect (OIDC)</a>.</p> <p>The OIDC
   * provider that you create with this operation can be used as a principal in a
   * role's trust policy. Such a policy establishes a trust relationship between
   * Amazon Web Services and the OIDC provider.</p> <p>If you are using an OIDC
   * identity provider from Google, Facebook, or Amazon Cognito, you don't need to
   * create a separate IAM identity provider. These OIDC identity providers are
   * already built-in to Amazon Web Services and are available for your use. Instead,
   * you can move directly to creating new roles using your identity provider. To
   * learn more, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html">Creating
   * a role for web identity or OpenID connect federation</a> in the <i>IAM User
   * Guide</i>.</p> <p>When you create the IAM OIDC provider, you specify the
   * following:</p> <ul> <li> <p>The URL of the OIDC identity provider (IdP) to
   * trust</p> </li> <li> <p>A list of client IDs (also known as audiences) that
   * identify the application or applications allowed to authenticate using the OIDC
   * provider</p> </li> <li> <p>A list of tags that are attached to the specified IAM
   * OIDC provider</p> </li> <li> <p>A list of thumbprints of one or more server
   * certificates that the IdP uses</p> </li> </ul> <p>You get all of this
   * information from the OIDC IdP you want to use to access Amazon Web Services.</p>
   *  <p>Amazon Web Services secures communication with OIDC identity providers
   * (IdPs) using our library of trusted root certificate authorities (CAs) to verify
   * the JSON Web Key Set (JWKS) endpoint's TLS certificate. If your OIDC IdP relies
   * on a certificate that is not signed by one of these trusted CAs, only then we
   * secure communication using the thumbprints set in the IdP's configuration.</p>
   *   <p>The trust for the OIDC provider is derived from the IAM
   * provider that this operation creates. Therefore, it is best to limit access to
   * the <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateOpenIDConnectProvider.html">CreateOpenIDConnectProvider</a>
   * operation to highly privileged users.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateOpenIDConnectProvider">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateOpenIDConnectProviderOutcome CreateOpenIDConnectProvider(
      const Model::CreateOpenIDConnectProviderRequest& request) const;

  /**
   * A Callable wrapper for CreateOpenIDConnectProvider that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename CreateOpenIDConnectProviderRequestT = Model::CreateOpenIDConnectProviderRequest>
  Model::CreateOpenIDConnectProviderOutcomeCallable CreateOpenIDConnectProviderCallable(
      const CreateOpenIDConnectProviderRequestT& request) const {
    return SubmitCallable(&IAMClient::CreateOpenIDConnectProvider, request);
  }

  /**
   * An Async wrapper for CreateOpenIDConnectProvider that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Creates a new managed policy for your Amazon Web Services account.</p>
   * <p>This operation creates a policy version with a version identifier of
   * <code>v1</code> and sets v1 as the policy's default version. For more
   * information about policy versions, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-versions.html">Versioning
   * for managed policies</a> in the <i>IAM User Guide</i>.</p> <p>As a best
   * practice, you can validate your IAM policies. To learn more, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_policy-validator.html">Validating
   * IAM policies</a> in the <i>IAM User Guide</i>.</p> <p>For more information about
   * managed policies in general, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreatePolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::CreatePolicyOutcome CreatePolicy(const Model::CreatePolicyRequest& request) const;

  /**
   * A Callable wrapper for CreatePolicy that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename CreatePolicyRequestT = Model::CreatePolicyRequest>
  Model::CreatePolicyOutcomeCallable CreatePolicyCallable(const CreatePolicyRequestT& request) const {
    return SubmitCallable(&IAMClient::CreatePolicy, request);
  }

  /**
   * An Async wrapper for CreatePolicy that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Creates a new version of the specified managed policy. To update a managed
   * policy, you create a new policy version. A managed policy can have up to five
   * versions. If the policy has five versions, you must delete an existing version
   * using <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeletePolicyVersion.html">DeletePolicyVersion</a>
   * before you create a new version.</p> <p>Optionally, you can set the new version
   * as the policy's default version. The default version is the version that is in
   * effect for the IAM users, groups, and roles to which the policy is attached.</p>
   * <p>For more information about managed policy versions, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-versions.html">Versioning
   * for managed policies</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreatePolicyVersion">AWS
   * API Reference</a></p>
   */
  virtual Model::CreatePolicyVersionOutcome CreatePolicyVersion(const Model::CreatePolicyVersionRequest& request) const;

  /**
   * A Callable wrapper for CreatePolicyVersion that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename CreatePolicyVersionRequestT = Model::CreatePolicyVersionRequest>
  Model::CreatePolicyVersionOutcomeCallable CreatePolicyVersionCallable(const CreatePolicyVersionRequestT& request) const {
    return SubmitCallable(&IAMClient::CreatePolicyVersion, request);
  }

  /**
   * An Async wrapper for CreatePolicyVersion that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Creates a new role for your Amazon Web Services account.</p> <p> For more
   * information about roles, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html">IAM
   * roles</a> in the <i>IAM User Guide</i>. For information about quotas for role
   * names and the number of roles you can create, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html">IAM
   * and STS quotas</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateRole">AWS API
   * Reference</a></p>
   */
  virtual Model::CreateRoleOutcome CreateRole(const Model::CreateRoleRequest& request) const;

  /**
   * A Callable wrapper for CreateRole that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename CreateRoleRequestT = Model::CreateRoleRequest>
  Model::CreateRoleOutcomeCallable CreateRoleCallable(const CreateRoleRequestT& request) const {
    return SubmitCallable(&IAMClient::CreateRole, request);
  }

  /**
   * An Async wrapper for CreateRole that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Creates an IAM resource that describes an identity provider (IdP) that
   * supports SAML 2.0.</p> <p>The SAML provider resource that you create with this
   * operation can be used as a principal in an IAM role's trust policy. Such a
   * policy can enable federated users who sign in using the SAML IdP to assume the
   * role. You can create an IAM role that supports Web-based single sign-on (SSO) to
   * the Amazon Web Services Management Console or one that supports API access to
   * Amazon Web Services.</p> <p>When you create the SAML provider resource, you
   * upload a SAML metadata document that you get from your IdP. That document
   * includes the issuer's name, expiration information, and keys that can be used to
   * validate the SAML authentication response (assertions) that the IdP sends. You
   * must generate the metadata document using the identity management software that
   * is used as your organization's IdP.</p>  <p> This operation requires <a
   * href="https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html">Signature
   * Version 4</a>.</p>  <p> For more information, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_enable-console-saml.html">Enabling
   * SAML 2.0 federated users to access the Amazon Web Services Management
   * Console</a> and <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_saml.html">About
   * SAML 2.0-based federation</a> in the <i>IAM User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateSAMLProvider">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateSAMLProviderOutcome CreateSAMLProvider(const Model::CreateSAMLProviderRequest& request) const;

  /**
   * A Callable wrapper for CreateSAMLProvider that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename CreateSAMLProviderRequestT = Model::CreateSAMLProviderRequest>
  Model::CreateSAMLProviderOutcomeCallable CreateSAMLProviderCallable(const CreateSAMLProviderRequestT& request) const {
    return SubmitCallable(&IAMClient::CreateSAMLProvider, request);
  }

  /**
   * An Async wrapper for CreateSAMLProvider that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Creates an IAM role that is linked to a specific Amazon Web Services service.
   * The service controls the attached policies and when the role can be deleted.
   * This helps ensure that the service is not broken by an unexpectedly changed or
   * deleted role, which could put your Amazon Web Services resources into an unknown
   * state. Allowing the service to control the role helps improve service stability
   * and proper cleanup when a service and its role are no longer needed. For more
   * information, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html">Using
   * service-linked roles</a> in the <i>IAM User Guide</i>. </p> <p>To attach a
   * policy to this service-linked role, you must make the request using the Amazon
   * Web Services service that depends on this role.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateServiceLinkedRole">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateServiceLinkedRoleOutcome CreateServiceLinkedRole(const Model::CreateServiceLinkedRoleRequest& request) const;

  /**
   * A Callable wrapper for CreateServiceLinkedRole that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename CreateServiceLinkedRoleRequestT = Model::CreateServiceLinkedRoleRequest>
  Model::CreateServiceLinkedRoleOutcomeCallable CreateServiceLinkedRoleCallable(const CreateServiceLinkedRoleRequestT& request) const {
    return SubmitCallable(&IAMClient::CreateServiceLinkedRole, request);
  }

  /**
   * An Async wrapper for CreateServiceLinkedRole that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Generates a set of credentials consisting of a user name and password that
   * can be used to access the service specified in the request. These credentials
   * are generated by IAM, and can be used only for the specified service. </p>
   * <p>You can have a maximum of two sets of service-specific credentials for each
   * supported service per user.</p> <p>You can create service-specific credentials
   * for Amazon Bedrock, Amazon CloudWatch Logs, CodeCommit and Amazon Keyspaces (for
   * Apache Cassandra).</p> <p>You can reset the password to a new service-generated
   * value by calling <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_ResetServiceSpecificCredential.html">ResetServiceSpecificCredential</a>.</p>
   * <p>For more information about service-specific credentials, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_bedrock.html">Service-specific
   * credentials for IAM users</a> in the <i>IAM User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateServiceSpecificCredential">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateServiceSpecificCredentialOutcome CreateServiceSpecificCredential(
      const Model::CreateServiceSpecificCredentialRequest& request) const;

  /**
   * A Callable wrapper for CreateServiceSpecificCredential that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename CreateServiceSpecificCredentialRequestT = Model::CreateServiceSpecificCredentialRequest>
  Model::CreateServiceSpecificCredentialOutcomeCallable CreateServiceSpecificCredentialCallable(
      const CreateServiceSpecificCredentialRequestT& request) const {
    return SubmitCallable(&IAMClient::CreateServiceSpecificCredential, request);
  }

  /**
   * An Async wrapper for CreateServiceSpecificCredential that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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);
  }

  /**
   * <p>Creates a new IAM user for your Amazon Web Services account.</p> <p> For
   * information about quotas for the number of IAM users you can create, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html">IAM
   * and STS quotas</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateUser">AWS API
   * Reference</a></p>
   */
  virtual Model::CreateUserOutcome CreateUser(const Model::CreateUserRequest& request) const;

  /**
   * A Callable wrapper for CreateUser that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename CreateUserRequestT = Model::CreateUserRequest>
  Model::CreateUserOutcomeCallable CreateUserCallable(const CreateUserRequestT& request) const {
    return SubmitCallable(&IAMClient::CreateUser, request);
  }

  /**
   * An Async wrapper for CreateUser that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Creates a new virtual MFA device for the Amazon Web Services account. After
   * creating the virtual MFA, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_EnableMFADevice.html">EnableMFADevice</a>
   * to attach the MFA device to an IAM user. For more information about creating and
   * working with virtual MFA devices, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_VirtualMFA.html">Using
   * a virtual MFA device</a> in the <i>IAM User Guide</i>.</p> <p>For information
   * about the maximum number of MFA devices you can create, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html">IAM
   * and STS quotas</a> in the <i>IAM User Guide</i>.</p>  <p>The seed
   * information contained in the QR code and the Base32 string should be treated
   * like any other secret access information. In other words, protect the seed
   * information as you would your Amazon Web Services access keys or your passwords.
   * After you provision your virtual device, you should ensure that the information
   * is destroyed following secure procedures.</p> <p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateVirtualMFADevice">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateVirtualMFADeviceOutcome CreateVirtualMFADevice(const Model::CreateVirtualMFADeviceRequest& request) const;

  /**
   * A Callable wrapper for CreateVirtualMFADevice that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename CreateVirtualMFADeviceRequestT = Model::CreateVirtualMFADeviceRequest>
  Model::CreateVirtualMFADeviceOutcomeCallable CreateVirtualMFADeviceCallable(const CreateVirtualMFADeviceRequestT& request) const {
    return SubmitCallable(&IAMClient::CreateVirtualMFADevice, request);
  }

  /**
   * An Async wrapper for CreateVirtualMFADevice that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Deactivates the specified MFA device and removes it from association with the
   * user name for which it was originally enabled.</p> <p>For more information about
   * creating and working with virtual MFA devices, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_VirtualMFA.html">Enabling
   * a virtual multi-factor authentication (MFA) device</a> in the <i>IAM User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeactivateMFADevice">AWS
   * API Reference</a></p>
   */
  virtual Model::DeactivateMFADeviceOutcome DeactivateMFADevice(const Model::DeactivateMFADeviceRequest& request) const;

  /**
   * A Callable wrapper for DeactivateMFADevice that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeactivateMFADeviceRequestT = Model::DeactivateMFADeviceRequest>
  Model::DeactivateMFADeviceOutcomeCallable DeactivateMFADeviceCallable(const DeactivateMFADeviceRequestT& request) const {
    return SubmitCallable(&IAMClient::DeactivateMFADevice, request);
  }

  /**
   * An Async wrapper for DeactivateMFADevice that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Deletes the access key pair associated with the specified IAM user.</p> <p>If
   * you do not specify a user name, IAM determines the user name implicitly based on
   * the Amazon Web Services access key ID signing the request. This operation works
   * for access keys under the Amazon Web Services account. Consequently, you can use
   * this operation to manage Amazon Web Services account root user credentials even
   * if the Amazon Web Services account has no associated users.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteAccessKey">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteAccessKeyOutcome DeleteAccessKey(const Model::DeleteAccessKeyRequest& request) const;

  /**
   * A Callable wrapper for DeleteAccessKey that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename DeleteAccessKeyRequestT = Model::DeleteAccessKeyRequest>
  Model::DeleteAccessKeyOutcomeCallable DeleteAccessKeyCallable(const DeleteAccessKeyRequestT& request) const {
    return SubmitCallable(&IAMClient::DeleteAccessKey, request);
  }

  /**
   * An Async wrapper for DeleteAccessKey that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p> Deletes the specified Amazon Web Services account alias. For information
   * about using an Amazon Web Services account alias, see <a
   * href="https://docs.aws.amazon.com/signin/latest/userguide/CreateAccountAlias.html">Creating,
   * deleting, and listing an Amazon Web Services account alias</a> in the <i>Amazon
   * Web Services Sign-In User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteAccountAlias">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteAccountAliasOutcome DeleteAccountAlias(const Model::DeleteAccountAliasRequest& request) const;

  /**
   * A Callable wrapper for DeleteAccountAlias that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeleteAccountAliasRequestT = Model::DeleteAccountAliasRequest>
  Model::DeleteAccountAliasOutcomeCallable DeleteAccountAliasCallable(const DeleteAccountAliasRequestT& request) const {
    return SubmitCallable(&IAMClient::DeleteAccountAlias, request);
  }

  /**
   * An Async wrapper for DeleteAccountAlias that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Deletes the password policy for the Amazon Web Services account. There are no
   * parameters.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteAccountPasswordPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteAccountPasswordPolicyOutcome DeleteAccountPasswordPolicy(
      const Model::DeleteAccountPasswordPolicyRequest& request = {}) const;

  /**
   * A Callable wrapper for DeleteAccountPasswordPolicy that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DeleteAccountPasswordPolicyRequestT = Model::DeleteAccountPasswordPolicyRequest>
  Model::DeleteAccountPasswordPolicyOutcomeCallable DeleteAccountPasswordPolicyCallable(
      const DeleteAccountPasswordPolicyRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::DeleteAccountPasswordPolicy, request);
  }

  /**
   * An Async wrapper for DeleteAccountPasswordPolicy that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Deletes the specified IAM group. The group must not contain any users or have
   * any attached policies.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteGroup">AWS API
   * Reference</a></p>
   */
  virtual Model::DeleteGroupOutcome DeleteGroup(const Model::DeleteGroupRequest& request) const;

  /**
   * A Callable wrapper for DeleteGroup that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename DeleteGroupRequestT = Model::DeleteGroupRequest>
  Model::DeleteGroupOutcomeCallable DeleteGroupCallable(const DeleteGroupRequestT& request) const {
    return SubmitCallable(&IAMClient::DeleteGroup, request);
  }

  /**
   * An Async wrapper for DeleteGroup that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Deletes the specified inline policy that is embedded in the specified IAM
   * group.</p> <p>A group can also have managed policies attached to it. To detach a
   * managed policy from a group, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DetachGroupPolicy.html">DetachGroupPolicy</a>.
   * For more information about policies, refer to <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteGroupPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteGroupPolicyOutcome DeleteGroupPolicy(const Model::DeleteGroupPolicyRequest& request) const;

  /**
   * A Callable wrapper for DeleteGroupPolicy that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeleteGroupPolicyRequestT = Model::DeleteGroupPolicyRequest>
  Model::DeleteGroupPolicyOutcomeCallable DeleteGroupPolicyCallable(const DeleteGroupPolicyRequestT& request) const {
    return SubmitCallable(&IAMClient::DeleteGroupPolicy, request);
  }

  /**
   * An Async wrapper for DeleteGroupPolicy that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Deletes the specified instance profile. The instance profile must not have an
   * associated role.</p>  <p>Make sure that you do not have any Amazon
   * EC2 instances running with the instance profile you are about to delete.
   * Deleting a role or instance profile that is associated with a running instance
   * will break any applications running on the instance.</p>  <p>For
   * more information about instance profiles, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html">Using
   * instance profiles</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteInstanceProfile">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteInstanceProfileOutcome DeleteInstanceProfile(const Model::DeleteInstanceProfileRequest& request) const;

  /**
   * A Callable wrapper for DeleteInstanceProfile that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeleteInstanceProfileRequestT = Model::DeleteInstanceProfileRequest>
  Model::DeleteInstanceProfileOutcomeCallable DeleteInstanceProfileCallable(const DeleteInstanceProfileRequestT& request) const {
    return SubmitCallable(&IAMClient::DeleteInstanceProfile, request);
  }

  /**
   * An Async wrapper for DeleteInstanceProfile that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Deletes the password for the specified IAM user or root user, For more
   * information, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_passwords_admin-change-user.html">Managing
   * passwords for IAM users</a>.</p> <p>You can use the CLI, the Amazon Web Services
   * API, or the <b>Users</b> page in the IAM console to delete a password for any
   * IAM user. You can use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_ChangePassword.html">ChangePassword</a>
   * to update, but not delete, your own password in the <b>My Security
   * Credentials</b> page in the Amazon Web Services Management Console.</p>
   *  <p>Deleting a user's password does not prevent a user from accessing
   * Amazon Web Services through the command line interface or the API. To prevent
   * all user access, you must also either make any access keys inactive or delete
   * them. For more information about making keys inactive or deleting them, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateAccessKey.html">UpdateAccessKey</a>
   * and <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteAccessKey.html">DeleteAccessKey</a>.</p>
   * <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteLoginProfile">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteLoginProfileOutcome DeleteLoginProfile(const Model::DeleteLoginProfileRequest& request = {}) const;

  /**
   * A Callable wrapper for DeleteLoginProfile that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeleteLoginProfileRequestT = Model::DeleteLoginProfileRequest>
  Model::DeleteLoginProfileOutcomeCallable DeleteLoginProfileCallable(const DeleteLoginProfileRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::DeleteLoginProfile, request);
  }

  /**
   * An Async wrapper for DeleteLoginProfile that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Deletes an OpenID Connect identity provider (IdP) resource object in IAM.</p>
   * <p>Deleting an IAM OIDC provider resource does not update any roles that
   * reference the provider as a principal in their trust policies. Any attempt to
   * assume a role that references a deleted provider fails.</p> <p>This operation is
   * idempotent; it does not fail or return an error if you call the operation for a
   * provider that does not exist.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteOpenIDConnectProvider">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteOpenIDConnectProviderOutcome DeleteOpenIDConnectProvider(
      const Model::DeleteOpenIDConnectProviderRequest& request) const;

  /**
   * A Callable wrapper for DeleteOpenIDConnectProvider that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DeleteOpenIDConnectProviderRequestT = Model::DeleteOpenIDConnectProviderRequest>
  Model::DeleteOpenIDConnectProviderOutcomeCallable DeleteOpenIDConnectProviderCallable(
      const DeleteOpenIDConnectProviderRequestT& request) const {
    return SubmitCallable(&IAMClient::DeleteOpenIDConnectProvider, request);
  }

  /**
   * An Async wrapper for DeleteOpenIDConnectProvider that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Deletes the specified managed policy.</p> <p>Before you can delete a managed
   * policy, you must first detach the policy from all users, groups, and roles that
   * it is attached to. In addition, you must delete all the policy's versions. The
   * following steps describe the process for deleting a managed policy:</p> <ul>
   * <li> <p>Detach the policy from all users, groups, and roles that the policy is
   * attached to, using <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DetachUserPolicy.html">DetachUserPolicy</a>,
   * <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DetachGroupPolicy.html">DetachGroupPolicy</a>,
   * or <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DetachRolePolicy.html">DetachRolePolicy</a>.
   * To list all the users, groups, and roles that a policy is attached to, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListEntitiesForPolicy.html">ListEntitiesForPolicy</a>.</p>
   * </li> <li> <p>Delete all versions of the policy using <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeletePolicyVersion.html">DeletePolicyVersion</a>.
   * To list the policy's versions, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListPolicyVersions.html">ListPolicyVersions</a>.
   * You cannot use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeletePolicyVersion.html">DeletePolicyVersion</a>
   * to delete the version that is marked as the default version. You delete the
   * policy's default version in the next step of the process.</p> </li> <li>
   * <p>Delete the policy (this automatically deletes the policy's default version)
   * using this operation.</p> </li> </ul> <p>For information about managed policies,
   * see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeletePolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::DeletePolicyOutcome DeletePolicy(const Model::DeletePolicyRequest& request) const;

  /**
   * A Callable wrapper for DeletePolicy that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename DeletePolicyRequestT = Model::DeletePolicyRequest>
  Model::DeletePolicyOutcomeCallable DeletePolicyCallable(const DeletePolicyRequestT& request) const {
    return SubmitCallable(&IAMClient::DeletePolicy, request);
  }

  /**
   * An Async wrapper for DeletePolicy that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Deletes the specified version from the specified managed policy.</p> <p>You
   * cannot delete the default version from a policy using this operation. To delete
   * the default version from a policy, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeletePolicy.html">DeletePolicy</a>.
   * To find out which version of a policy is marked as the default version, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListPolicyVersions.html">ListPolicyVersions</a>.</p>
   * <p>For information about versions for managed policies, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-versions.html">Versioning
   * for managed policies</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeletePolicyVersion">AWS
   * API Reference</a></p>
   */
  virtual Model::DeletePolicyVersionOutcome DeletePolicyVersion(const Model::DeletePolicyVersionRequest& request) const;

  /**
   * A Callable wrapper for DeletePolicyVersion that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeletePolicyVersionRequestT = Model::DeletePolicyVersionRequest>
  Model::DeletePolicyVersionOutcomeCallable DeletePolicyVersionCallable(const DeletePolicyVersionRequestT& request) const {
    return SubmitCallable(&IAMClient::DeletePolicyVersion, request);
  }

  /**
   * An Async wrapper for DeletePolicyVersion that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Deletes the specified role. Unlike the Amazon Web Services Management
   * Console, when you delete a role programmatically, you must delete the items
   * attached to the role manually, or the deletion fails. For more information, see
   * <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage_delete.html#roles-managingrole-deleting-cli">Deleting
   * an IAM role</a>. Before attempting to delete a role, remove the following
   * attached items: </p> <ul> <li> <p>Inline policies (<a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteRolePolicy.html">DeleteRolePolicy</a>)</p>
   * </li> <li> <p>Attached managed policies (<a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DetachRolePolicy.html">DetachRolePolicy</a>)</p>
   * </li> <li> <p>Instance profile (<a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_RemoveRoleFromInstanceProfile.html">RemoveRoleFromInstanceProfile</a>)</p>
   * </li> <li> <p>Optional – Delete instance profile after detaching from role for
   * resource clean up (<a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteInstanceProfile.html">DeleteInstanceProfile</a>)</p>
   * </li> </ul>  <p>Make sure that you do not have any Amazon EC2
   * instances running with the role you are about to delete. Deleting a role or
   * instance profile that is associated with a running instance will break any
   * applications running on the instance.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteRole">AWS API
   * Reference</a></p>
   */
  virtual Model::DeleteRoleOutcome DeleteRole(const Model::DeleteRoleRequest& request) const;

  /**
   * A Callable wrapper for DeleteRole that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename DeleteRoleRequestT = Model::DeleteRoleRequest>
  Model::DeleteRoleOutcomeCallable DeleteRoleCallable(const DeleteRoleRequestT& request) const {
    return SubmitCallable(&IAMClient::DeleteRole, request);
  }

  /**
   * An Async wrapper for DeleteRole that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Deletes the permissions boundary for the specified IAM role. </p> <p>You
   * cannot set the boundary for a service-linked role.</p>  <p>Deleting
   * the permissions boundary for a role might increase its permissions. For example,
   * it might allow anyone who assumes the role to perform all the actions granted in
   * its permissions policies.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteRolePermissionsBoundary">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteRolePermissionsBoundaryOutcome DeleteRolePermissionsBoundary(
      const Model::DeleteRolePermissionsBoundaryRequest& request) const;

  /**
   * A Callable wrapper for DeleteRolePermissionsBoundary that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DeleteRolePermissionsBoundaryRequestT = Model::DeleteRolePermissionsBoundaryRequest>
  Model::DeleteRolePermissionsBoundaryOutcomeCallable DeleteRolePermissionsBoundaryCallable(
      const DeleteRolePermissionsBoundaryRequestT& request) const {
    return SubmitCallable(&IAMClient::DeleteRolePermissionsBoundary, request);
  }

  /**
   * An Async wrapper for DeleteRolePermissionsBoundary that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Deletes the specified inline policy that is embedded in the specified IAM
   * role.</p> <p>A role can also have managed policies attached to it. To detach a
   * managed policy from a role, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DetachRolePolicy.html">DetachRolePolicy</a>.
   * For more information about policies, refer to <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteRolePolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteRolePolicyOutcome DeleteRolePolicy(const Model::DeleteRolePolicyRequest& request) const;

  /**
   * A Callable wrapper for DeleteRolePolicy that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeleteRolePolicyRequestT = Model::DeleteRolePolicyRequest>
  Model::DeleteRolePolicyOutcomeCallable DeleteRolePolicyCallable(const DeleteRolePolicyRequestT& request) const {
    return SubmitCallable(&IAMClient::DeleteRolePolicy, request);
  }

  /**
   * An Async wrapper for DeleteRolePolicy that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Deletes a SAML provider resource in IAM.</p> <p>Deleting the provider
   * resource from IAM does not update any roles that reference the SAML provider
   * resource's ARN as a principal in their trust policies. Any attempt to assume a
   * role that references a non-existent provider resource ARN fails.</p>  <p>
   * This operation requires <a
   * href="https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html">Signature
   * Version 4</a>.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteSAMLProvider">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteSAMLProviderOutcome DeleteSAMLProvider(const Model::DeleteSAMLProviderRequest& request) const;

  /**
   * A Callable wrapper for DeleteSAMLProvider that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeleteSAMLProviderRequestT = Model::DeleteSAMLProviderRequest>
  Model::DeleteSAMLProviderOutcomeCallable DeleteSAMLProviderCallable(const DeleteSAMLProviderRequestT& request) const {
    return SubmitCallable(&IAMClient::DeleteSAMLProvider, request);
  }

  /**
   * An Async wrapper for DeleteSAMLProvider that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Deletes the specified SSH public key.</p> <p>The SSH public key deleted by
   * this operation is used only for authenticating the associated IAM user to an
   * CodeCommit repository. For more information about using SSH keys to authenticate
   * to an CodeCommit repository, see <a
   * href="https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up-credentials-ssh.html">Set
   * up CodeCommit for SSH connections</a> in the <i>CodeCommit User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteSSHPublicKey">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteSSHPublicKeyOutcome DeleteSSHPublicKey(const Model::DeleteSSHPublicKeyRequest& request) const;

  /**
   * A Callable wrapper for DeleteSSHPublicKey that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeleteSSHPublicKeyRequestT = Model::DeleteSSHPublicKeyRequest>
  Model::DeleteSSHPublicKeyOutcomeCallable DeleteSSHPublicKeyCallable(const DeleteSSHPublicKeyRequestT& request) const {
    return SubmitCallable(&IAMClient::DeleteSSHPublicKey, request);
  }

  /**
   * An Async wrapper for DeleteSSHPublicKey that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Deletes the specified server certificate.</p> <p>For more information about
   * working with server certificates, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html">Working
   * with server certificates</a> in the <i>IAM User Guide</i>. This topic also
   * includes a list of Amazon Web Services services that can use the server
   * certificates that you manage with IAM.</p>  <p> If you are using a
   * server certificate with Elastic Load Balancing, deleting the certificate could
   * have implications for your application. If Elastic Load Balancing doesn't detect
   * the deletion of bound certificates, it may continue to use the certificates.
   * This could cause Elastic Load Balancing to stop accepting traffic. We recommend
   * that you remove the reference to the certificate from Elastic Load Balancing
   * before using this command to delete the certificate. For more information, see
   * <a
   * href="https://docs.aws.amazon.com/ElasticLoadBalancing/latest/APIReference/API_DeleteLoadBalancerListeners.html">DeleteLoadBalancerListeners</a>
   * in the <i>Elastic Load Balancing API Reference</i>.</p> <p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteServerCertificate">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteServerCertificateOutcome DeleteServerCertificate(const Model::DeleteServerCertificateRequest& request) const;

  /**
   * A Callable wrapper for DeleteServerCertificate that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeleteServerCertificateRequestT = Model::DeleteServerCertificateRequest>
  Model::DeleteServerCertificateOutcomeCallable DeleteServerCertificateCallable(const DeleteServerCertificateRequestT& request) const {
    return SubmitCallable(&IAMClient::DeleteServerCertificate, request);
  }

  /**
   * An Async wrapper for DeleteServerCertificate that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Submits a service-linked role deletion request and returns a
   * <code>DeletionTaskId</code>, which you can use to check the status of the
   * deletion. Before you call this operation, confirm that the role has no active
   * sessions and that any resources used by the role in the linked service are
   * deleted. If you call this operation more than once for the same service-linked
   * role and an earlier deletion task is not complete, then the
   * <code>DeletionTaskId</code> of the earlier request is returned.</p> <p>If you
   * submit a deletion request for a service-linked role whose linked service is
   * still accessing a resource, then the deletion task fails. If it fails, the <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetServiceLinkedRoleDeletionStatus.html">GetServiceLinkedRoleDeletionStatus</a>
   * operation returns the reason for the failure, usually including the resources
   * that must be deleted. To delete the service-linked role, you must first remove
   * those resources from the linked service and then submit the deletion request
   * again. Resources are specific to the service that is linked to the role. For
   * more information about removing resources from a service, see the <a
   * href="http://docs.aws.amazon.com/">Amazon Web Services documentation</a> for
   * your service.</p> <p>For more information about service-linked roles, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-linked-role">Roles
   * terms and concepts: Amazon Web Services service-linked role</a> in the <i>IAM
   * User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteServiceLinkedRole">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteServiceLinkedRoleOutcome DeleteServiceLinkedRole(const Model::DeleteServiceLinkedRoleRequest& request) const;

  /**
   * A Callable wrapper for DeleteServiceLinkedRole that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeleteServiceLinkedRoleRequestT = Model::DeleteServiceLinkedRoleRequest>
  Model::DeleteServiceLinkedRoleOutcomeCallable DeleteServiceLinkedRoleCallable(const DeleteServiceLinkedRoleRequestT& request) const {
    return SubmitCallable(&IAMClient::DeleteServiceLinkedRole, request);
  }

  /**
   * An Async wrapper for DeleteServiceLinkedRole that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Deletes the specified service-specific credential.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteServiceSpecificCredential">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteServiceSpecificCredentialOutcome DeleteServiceSpecificCredential(
      const Model::DeleteServiceSpecificCredentialRequest& request) const;

  /**
   * A Callable wrapper for DeleteServiceSpecificCredential that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DeleteServiceSpecificCredentialRequestT = Model::DeleteServiceSpecificCredentialRequest>
  Model::DeleteServiceSpecificCredentialOutcomeCallable DeleteServiceSpecificCredentialCallable(
      const DeleteServiceSpecificCredentialRequestT& request) const {
    return SubmitCallable(&IAMClient::DeleteServiceSpecificCredential, request);
  }

  /**
   * An Async wrapper for DeleteServiceSpecificCredential that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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);
  }

  /**
   * <p>Deletes a signing certificate associated with the specified IAM user.</p>
   * <p>If you do not specify a user name, IAM determines the user name implicitly
   * based on the Amazon Web Services access key ID signing the request. This
   * operation works for access keys under the Amazon Web Services account.
   * Consequently, you can use this operation to manage Amazon Web Services account
   * root user credentials even if the Amazon Web Services account has no associated
   * IAM users.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteSigningCertificate">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteSigningCertificateOutcome DeleteSigningCertificate(const Model::DeleteSigningCertificateRequest& request) const;

  /**
   * A Callable wrapper for DeleteSigningCertificate that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeleteSigningCertificateRequestT = Model::DeleteSigningCertificateRequest>
  Model::DeleteSigningCertificateOutcomeCallable DeleteSigningCertificateCallable(const DeleteSigningCertificateRequestT& request) const {
    return SubmitCallable(&IAMClient::DeleteSigningCertificate, request);
  }

  /**
   * An Async wrapper for DeleteSigningCertificate that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Deletes the specified IAM user. Unlike the Amazon Web Services Management
   * Console, when you delete a user programmatically, you must delete the items
   * attached to the user manually, or the deletion fails. For more information, see
   * <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_manage.html#id_users_deleting_cli">Deleting
   * an IAM user</a>. Before attempting to delete a user, remove the following
   * items:</p> <ul> <li> <p>Password (<a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteLoginProfile.html">DeleteLoginProfile</a>)</p>
   * </li> <li> <p>Access keys (<a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteAccessKey.html">DeleteAccessKey</a>)</p>
   * </li> <li> <p>Signing certificate (<a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteSigningCertificate.html">DeleteSigningCertificate</a>)</p>
   * </li> <li> <p>SSH public key (<a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteSSHPublicKey.html">DeleteSSHPublicKey</a>)</p>
   * </li> <li> <p>Git credentials (<a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteServiceSpecificCredential.html">DeleteServiceSpecificCredential</a>)</p>
   * </li> <li> <p>Multi-factor authentication (MFA) device (<a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeactivateMFADevice.html">DeactivateMFADevice</a>,
   * <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteVirtualMFADevice.html">DeleteVirtualMFADevice</a>)</p>
   * </li> <li> <p>Inline policies (<a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteUserPolicy.html">DeleteUserPolicy</a>)</p>
   * </li> <li> <p>Attached managed policies (<a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DetachUserPolicy.html">DetachUserPolicy</a>)</p>
   * </li> <li> <p>Group memberships (<a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_RemoveUserFromGroup.html">RemoveUserFromGroup</a>)</p>
   * </li> </ul><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteUser">AWS API
   * Reference</a></p>
   */
  virtual Model::DeleteUserOutcome DeleteUser(const Model::DeleteUserRequest& request) const;

  /**
   * A Callable wrapper for DeleteUser that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename DeleteUserRequestT = Model::DeleteUserRequest>
  Model::DeleteUserOutcomeCallable DeleteUserCallable(const DeleteUserRequestT& request) const {
    return SubmitCallable(&IAMClient::DeleteUser, request);
  }

  /**
   * An Async wrapper for DeleteUser that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Deletes the permissions boundary for the specified IAM user.</p>
   * <p>Deleting the permissions boundary for a user might increase its permissions
   * by allowing the user to perform all the actions granted in its permissions
   * policies. </p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteUserPermissionsBoundary">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteUserPermissionsBoundaryOutcome DeleteUserPermissionsBoundary(
      const Model::DeleteUserPermissionsBoundaryRequest& request) const;

  /**
   * A Callable wrapper for DeleteUserPermissionsBoundary that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DeleteUserPermissionsBoundaryRequestT = Model::DeleteUserPermissionsBoundaryRequest>
  Model::DeleteUserPermissionsBoundaryOutcomeCallable DeleteUserPermissionsBoundaryCallable(
      const DeleteUserPermissionsBoundaryRequestT& request) const {
    return SubmitCallable(&IAMClient::DeleteUserPermissionsBoundary, request);
  }

  /**
   * An Async wrapper for DeleteUserPermissionsBoundary that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Deletes the specified inline policy that is embedded in the specified IAM
   * user.</p> <p>A user can also have managed policies attached to it. To detach a
   * managed policy from a user, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DetachUserPolicy.html">DetachUserPolicy</a>.
   * For more information about policies, refer to <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteUserPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteUserPolicyOutcome DeleteUserPolicy(const Model::DeleteUserPolicyRequest& request) const;

  /**
   * A Callable wrapper for DeleteUserPolicy that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeleteUserPolicyRequestT = Model::DeleteUserPolicyRequest>
  Model::DeleteUserPolicyOutcomeCallable DeleteUserPolicyCallable(const DeleteUserPolicyRequestT& request) const {
    return SubmitCallable(&IAMClient::DeleteUserPolicy, request);
  }

  /**
   * An Async wrapper for DeleteUserPolicy that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Deletes a virtual MFA device.</p>  <p> You must deactivate a user's
   * virtual MFA device before you can delete it. For information about deactivating
   * MFA devices, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeactivateMFADevice.html">DeactivateMFADevice</a>.
   * </p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteVirtualMFADevice">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteVirtualMFADeviceOutcome DeleteVirtualMFADevice(const Model::DeleteVirtualMFADeviceRequest& request) const;

  /**
   * A Callable wrapper for DeleteVirtualMFADevice that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeleteVirtualMFADeviceRequestT = Model::DeleteVirtualMFADeviceRequest>
  Model::DeleteVirtualMFADeviceOutcomeCallable DeleteVirtualMFADeviceCallable(const DeleteVirtualMFADeviceRequestT& request) const {
    return SubmitCallable(&IAMClient::DeleteVirtualMFADevice, request);
  }

  /**
   * An Async wrapper for DeleteVirtualMFADevice that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Removes the specified managed policy from the specified IAM group.</p> <p>A
   * group can also have inline policies embedded with it. To delete an inline
   * policy, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteGroupPolicy.html">DeleteGroupPolicy</a>.
   * For information about policies, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DetachGroupPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::DetachGroupPolicyOutcome DetachGroupPolicy(const Model::DetachGroupPolicyRequest& request) const;

  /**
   * A Callable wrapper for DetachGroupPolicy that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DetachGroupPolicyRequestT = Model::DetachGroupPolicyRequest>
  Model::DetachGroupPolicyOutcomeCallable DetachGroupPolicyCallable(const DetachGroupPolicyRequestT& request) const {
    return SubmitCallable(&IAMClient::DetachGroupPolicy, request);
  }

  /**
   * An Async wrapper for DetachGroupPolicy that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Removes the specified managed policy from the specified role.</p> <p>A role
   * can also have inline policies embedded with it. To delete an inline policy, use
   * <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteRolePolicy.html">DeleteRolePolicy</a>.
   * For information about policies, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DetachRolePolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::DetachRolePolicyOutcome DetachRolePolicy(const Model::DetachRolePolicyRequest& request) const;

  /**
   * A Callable wrapper for DetachRolePolicy that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DetachRolePolicyRequestT = Model::DetachRolePolicyRequest>
  Model::DetachRolePolicyOutcomeCallable DetachRolePolicyCallable(const DetachRolePolicyRequestT& request) const {
    return SubmitCallable(&IAMClient::DetachRolePolicy, request);
  }

  /**
   * An Async wrapper for DetachRolePolicy that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Removes the specified managed policy from the specified user.</p> <p>A user
   * can also have inline policies embedded with it. To delete an inline policy, use
   * <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteUserPolicy.html">DeleteUserPolicy</a>.
   * For information about policies, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DetachUserPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::DetachUserPolicyOutcome DetachUserPolicy(const Model::DetachUserPolicyRequest& request) const;

  /**
   * A Callable wrapper for DetachUserPolicy that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DetachUserPolicyRequestT = Model::DetachUserPolicyRequest>
  Model::DetachUserPolicyOutcomeCallable DetachUserPolicyCallable(const DetachUserPolicyRequestT& request) const {
    return SubmitCallable(&IAMClient::DetachUserPolicy, request);
  }

  /**
   * An Async wrapper for DetachUserPolicy that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Disables the management of privileged root user credentials across member
   * accounts in your organization. When you disable this feature, the management
   * account and the delegated administrator for IAM can no longer manage root user
   * credentials for member accounts in your organization.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DisableOrganizationsRootCredentialsManagement">AWS
   * API Reference</a></p>
   */
  virtual Model::DisableOrganizationsRootCredentialsManagementOutcome DisableOrganizationsRootCredentialsManagement(
      const Model::DisableOrganizationsRootCredentialsManagementRequest& request = {}) const;

  /**
   * A Callable wrapper for DisableOrganizationsRootCredentialsManagement that returns a future to the operation so that it can be executed
   * in parallel to other requests.
   */
  template <typename DisableOrganizationsRootCredentialsManagementRequestT = Model::DisableOrganizationsRootCredentialsManagementRequest>
  Model::DisableOrganizationsRootCredentialsManagementOutcomeCallable DisableOrganizationsRootCredentialsManagementCallable(
      const DisableOrganizationsRootCredentialsManagementRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::DisableOrganizationsRootCredentialsManagement, request);
  }

  /**
   * An Async wrapper for DisableOrganizationsRootCredentialsManagement that queues the request into a thread executor and triggers
   * associated callback when operation has finished.
   */
  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);
  }

  /**
   * <p>Disables root user sessions for privileged tasks across member accounts in
   * your organization. When you disable this feature, the management account and the
   * delegated administrator for IAM can no longer perform privileged tasks on member
   * accounts in your organization.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DisableOrganizationsRootSessions">AWS
   * API Reference</a></p>
   */
  virtual Model::DisableOrganizationsRootSessionsOutcome DisableOrganizationsRootSessions(
      const Model::DisableOrganizationsRootSessionsRequest& request = {}) const;

  /**
   * A Callable wrapper for DisableOrganizationsRootSessions that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename DisableOrganizationsRootSessionsRequestT = Model::DisableOrganizationsRootSessionsRequest>
  Model::DisableOrganizationsRootSessionsOutcomeCallable DisableOrganizationsRootSessionsCallable(
      const DisableOrganizationsRootSessionsRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::DisableOrganizationsRootSessions, request);
  }

  /**
   * An Async wrapper for DisableOrganizationsRootSessions that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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);
  }

  /**
   * <p>Disables the outbound identity federation feature for your Amazon Web
   * Services account. When disabled, IAM principals in the account cannot use the
   * <code>GetWebIdentityToken</code> API to obtain JSON Web Tokens (JWTs) for
   * authentication with external services. This operation does not affect tokens
   * that were issued before the feature was disabled.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DisableOutboundWebIdentityFederation">AWS
   * API Reference</a></p>
   */
  virtual Model::DisableOutboundWebIdentityFederationOutcome DisableOutboundWebIdentityFederation(
      const Model::DisableOutboundWebIdentityFederationRequest& request = {}) const;

  /**
   * A Callable wrapper for DisableOutboundWebIdentityFederation that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename DisableOutboundWebIdentityFederationRequestT = Model::DisableOutboundWebIdentityFederationRequest>
  Model::DisableOutboundWebIdentityFederationOutcomeCallable DisableOutboundWebIdentityFederationCallable(
      const DisableOutboundWebIdentityFederationRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::DisableOutboundWebIdentityFederation, request);
  }

  /**
   * An Async wrapper for DisableOutboundWebIdentityFederation that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  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);
  }

  /**
   * <p>Enables the specified MFA device and associates it with the specified IAM
   * user. When enabled, the MFA device is required for every subsequent login by the
   * IAM user associated with the device.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/EnableMFADevice">AWS
   * API Reference</a></p>
   */
  virtual Model::EnableMFADeviceOutcome EnableMFADevice(const Model::EnableMFADeviceRequest& request) const;

  /**
   * A Callable wrapper for EnableMFADevice that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename EnableMFADeviceRequestT = Model::EnableMFADeviceRequest>
  Model::EnableMFADeviceOutcomeCallable EnableMFADeviceCallable(const EnableMFADeviceRequestT& request) const {
    return SubmitCallable(&IAMClient::EnableMFADevice, request);
  }

  /**
   * An Async wrapper for EnableMFADevice that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Enables the management of privileged root user credentials across member
   * accounts in your organization. When you enable root credentials management for
   * <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#id_root-user-access-management">centralized
   * root access</a>, the management account and the delegated administrator for IAM
   * can manage root user credentials for member accounts in your organization.</p>
   * <p>Before you enable centralized root access, you must have an account
   * configured with the following settings:</p> <ul> <li> <p>You must manage your
   * Amazon Web Services accounts in <a
   * href="https://docs.aws.amazon.com/organizations/latest/userguide/orgs_introduction.html">Organizations</a>.</p>
   * </li> <li> <p>Enable trusted access for Identity and Access Management in
   * Organizations. For details, see <a
   * href="https://docs.aws.amazon.com/organizations/latest/userguide/services-that-can-integrate-iam.html">IAM
   * and Organizations</a> in the <i>Organizations User Guide</i>.</p> </li>
   * </ul><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/EnableOrganizationsRootCredentialsManagement">AWS
   * API Reference</a></p>
   */
  virtual Model::EnableOrganizationsRootCredentialsManagementOutcome EnableOrganizationsRootCredentialsManagement(
      const Model::EnableOrganizationsRootCredentialsManagementRequest& request = {}) const;

  /**
   * A Callable wrapper for EnableOrganizationsRootCredentialsManagement that returns a future to the operation so that it can be executed
   * in parallel to other requests.
   */
  template <typename EnableOrganizationsRootCredentialsManagementRequestT = Model::EnableOrganizationsRootCredentialsManagementRequest>
  Model::EnableOrganizationsRootCredentialsManagementOutcomeCallable EnableOrganizationsRootCredentialsManagementCallable(
      const EnableOrganizationsRootCredentialsManagementRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::EnableOrganizationsRootCredentialsManagement, request);
  }

  /**
   * An Async wrapper for EnableOrganizationsRootCredentialsManagement that queues the request into a thread executor and triggers
   * associated callback when operation has finished.
   */
  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);
  }

  /**
   * <p>Allows the management account or delegated administrator to perform
   * privileged tasks on member accounts in your organization. For more information,
   * see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#id_root-user-access-management">Centrally
   * manage root access for member accounts</a> in the <i>Identity and Access
   * Management User Guide</i>.</p> <p>Before you enable this feature, you must have
   * an account configured with the following settings:</p> <ul> <li> <p>You must
   * manage your Amazon Web Services accounts in <a
   * href="https://docs.aws.amazon.com/organizations/latest/userguide/orgs_introduction.html">Organizations</a>.</p>
   * </li> <li> <p>Enable trusted access for Identity and Access Management in
   * Organizations. For details, see <a
   * href="https://docs.aws.amazon.com/organizations/latest/userguide/services-that-can-integrate-ra.html">IAM
   * and Organizations</a> in the <i>Organizations User Guide</i>.</p> </li>
   * </ul><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/EnableOrganizationsRootSessions">AWS
   * API Reference</a></p>
   */
  virtual Model::EnableOrganizationsRootSessionsOutcome EnableOrganizationsRootSessions(
      const Model::EnableOrganizationsRootSessionsRequest& request = {}) const;

  /**
   * A Callable wrapper for EnableOrganizationsRootSessions that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename EnableOrganizationsRootSessionsRequestT = Model::EnableOrganizationsRootSessionsRequest>
  Model::EnableOrganizationsRootSessionsOutcomeCallable EnableOrganizationsRootSessionsCallable(
      const EnableOrganizationsRootSessionsRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::EnableOrganizationsRootSessions, request);
  }

  /**
   * An Async wrapper for EnableOrganizationsRootSessions that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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);
  }

  /**
   * <p>Enables the outbound identity federation feature for your Amazon Web Services
   * account. When enabled, IAM principals in your account can use the
   * <code>GetWebIdentityToken</code> API to obtain JSON Web Tokens (JWTs) for secure
   * authentication with external services. This operation also generates a unique
   * issuer URL for your Amazon Web Services account. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/EnableOutboundWebIdentityFederation">AWS
   * API Reference</a></p>
   */
  virtual Model::EnableOutboundWebIdentityFederationOutcome EnableOutboundWebIdentityFederation(
      const Model::EnableOutboundWebIdentityFederationRequest& request = {}) const;

  /**
   * A Callable wrapper for EnableOutboundWebIdentityFederation that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename EnableOutboundWebIdentityFederationRequestT = Model::EnableOutboundWebIdentityFederationRequest>
  Model::EnableOutboundWebIdentityFederationOutcomeCallable EnableOutboundWebIdentityFederationCallable(
      const EnableOutboundWebIdentityFederationRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::EnableOutboundWebIdentityFederation, request);
  }

  /**
   * An Async wrapper for EnableOutboundWebIdentityFederation that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  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);
  }

  /**
   * <p> Generates a credential report for the Amazon Web Services account. For more
   * information about the credential report, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/credential-reports.html">Getting
   * credential reports</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GenerateCredentialReport">AWS
   * API Reference</a></p>
   */
  virtual Model::GenerateCredentialReportOutcome GenerateCredentialReport(const Model::GenerateCredentialReportRequest& request = {}) const;

  /**
   * A Callable wrapper for GenerateCredentialReport that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename GenerateCredentialReportRequestT = Model::GenerateCredentialReportRequest>
  Model::GenerateCredentialReportOutcomeCallable GenerateCredentialReportCallable(
      const GenerateCredentialReportRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::GenerateCredentialReport, request);
  }

  /**
   * An Async wrapper for GenerateCredentialReport that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Generates a report for service last accessed data for Organizations. You can
   * generate a report for any entities (organization root, organizational unit, or
   * account) or policies in your organization.</p> <p>To call this operation, you
   * must be signed in using your Organizations management account credentials. You
   * can use your long-term IAM user or root user credentials, or temporary
   * credentials from assuming an IAM role. SCPs must be enabled for your
   * organization root. You must have the required IAM and Organizations permissions.
   * For more information, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html">Refining
   * permissions using service last accessed data</a> in the <i>IAM User
   * Guide</i>.</p> <p>You can generate a service last accessed data report for
   * entities by specifying only the entity's path. This data includes a list of
   * services that are allowed by any service control policies (SCPs) that apply to
   * the entity.</p> <p>You can generate a service last accessed data report for a
   * policy by specifying an entity's path and an optional Organizations policy ID.
   * This data includes a list of services that are allowed by the specified SCP.</p>
   * <p>For each service in both report types, the data includes the most recent
   * account activity that the policy allows to account principals in the entity or
   * the entity's children. For important information about the data, reporting
   * period, permissions required, troubleshooting, and supported Regions see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html">Reducing
   * permissions using service last accessed data</a> in the <i>IAM User
   * Guide</i>.</p>  <p>The data includes all attempts to access Amazon
   * Web Services, not just the successful ones. This includes all attempts that were
   * made using the Amazon Web Services Management Console, the Amazon Web Services
   * API through any of the SDKs, or any of the command line tools. An unexpected
   * entry in the service last accessed data does not mean that an account has been
   * compromised, because the request might have been denied. Refer to your
   * CloudTrail logs as the authoritative source for information about all API calls
   * and whether they were successful or denied access. For more information, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/cloudtrail-integration.html">Logging
   * IAM events with CloudTrail</a> in the <i>IAM User Guide</i>.</p>
   * <p>This operation returns a <code>JobId</code>. Use this parameter in the <code>
   * <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetOrganizationsAccessReport.html">GetOrganizationsAccessReport</a>
   * </code> operation to check the status of the report generation. To check the
   * status of this request, use the <code>JobId</code> parameter in the <code> <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetOrganizationsAccessReport.html">GetOrganizationsAccessReport</a>
   * </code> operation and test the <code>JobStatus</code> response parameter. When
   * the job is complete, you can retrieve the report.</p> <p>To generate a service
   * last accessed data report for entities, specify an entity path without
   * specifying the optional Organizations policy ID. The type of entity that you
   * specify determines the data returned in the report.</p> <ul> <li> <p>
   * <b>Root</b> – When you specify the organizations root as the entity, the
   * resulting report lists all of the services allowed by SCPs that are attached to
   * your root. For each service, the report includes data for all accounts in your
   * organization except the management account, because the management account is
   * not limited by SCPs.</p> </li> <li> <p> <b>OU</b> – When you specify an
   * organizational unit (OU) as the entity, the resulting report lists all of the
   * services allowed by SCPs that are attached to the OU and its parents. For each
   * service, the report includes data for all accounts in the OU or its children.
   * This data excludes the management account, because the management account is not
   * limited by SCPs.</p> </li> <li> <p> <b>management account</b> – When you specify
   * the management account, the resulting report lists all Amazon Web Services
   * services, because the management account is not limited by SCPs. For each
   * service, the report includes data for only the management account.</p> </li>
   * <li> <p> <b>Account</b> – When you specify another account as the entity, the
   * resulting report lists all of the services allowed by SCPs that are attached to
   * the account and its parents. For each service, the report includes data for only
   * the specified account.</p> </li> </ul> <p>To generate a service last accessed
   * data report for policies, specify an entity path and the optional Organizations
   * policy ID. The type of entity that you specify determines the data returned for
   * each service.</p> <ul> <li> <p> <b>Root</b> – When you specify the root entity
   * and a policy ID, the resulting report lists all of the services that are allowed
   * by the specified SCP. For each service, the report includes data for all
   * accounts in your organization to which the SCP applies. This data excludes the
   * management account, because the management account is not limited by SCPs. If
   * the SCP is not attached to any entities in the organization, then the report
   * will return a list of services with no data.</p> </li> <li> <p> <b>OU</b> – When
   * you specify an OU entity and a policy ID, the resulting report lists all of the
   * services that are allowed by the specified SCP. For each service, the report
   * includes data for all accounts in the OU or its children to which the SCP
   * applies. This means that other accounts outside the OU that are affected by the
   * SCP might not be included in the data. This data excludes the management
   * account, because the management account is not limited by SCPs. If the SCP is
   * not attached to the OU or one of its children, the report will return a list of
   * services with no data.</p> </li> <li> <p> <b>management account</b> – When you
   * specify the management account, the resulting report lists all Amazon Web
   * Services services, because the management account is not limited by SCPs. If you
   * specify a policy ID in the CLI or API, the policy is ignored. For each service,
   * the report includes data for only the management account.</p> </li> <li> <p>
   * <b>Account</b> – When you specify another account entity and a policy ID, the
   * resulting report lists all of the services that are allowed by the specified
   * SCP. For each service, the report includes data for only the specified account.
   * This means that other accounts in the organization that are affected by the SCP
   * might not be included in the data. If the SCP is not attached to the account,
   * the report will return a list of services with no data.</p> </li> </ul>
   * <p>Service last accessed data does not use other policy types when determining
   * whether a principal could access a service. These other policy types include
   * identity-based policies, resource-based policies, access control lists, IAM
   * permissions boundaries, and STS assume role policies. It only applies SCP logic.
   * For more about the evaluation of policy types, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html#policy-eval-basics">Evaluating
   * policies</a> in the <i>IAM User Guide</i>.</p>  <p>For more information
   * about service last accessed data, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html">Reducing
   * policy scope by viewing user activity</a> in the <i>IAM User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GenerateOrganizationsAccessReport">AWS
   * API Reference</a></p>
   */
  virtual Model::GenerateOrganizationsAccessReportOutcome GenerateOrganizationsAccessReport(
      const Model::GenerateOrganizationsAccessReportRequest& request) const;

  /**
   * A Callable wrapper for GenerateOrganizationsAccessReport that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename GenerateOrganizationsAccessReportRequestT = Model::GenerateOrganizationsAccessReportRequest>
  Model::GenerateOrganizationsAccessReportOutcomeCallable GenerateOrganizationsAccessReportCallable(
      const GenerateOrganizationsAccessReportRequestT& request) const {
    return SubmitCallable(&IAMClient::GenerateOrganizationsAccessReport, request);
  }

  /**
   * An Async wrapper for GenerateOrganizationsAccessReport that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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);
  }

  /**
   * <p>Generates a report that includes details about when an IAM resource (user,
   * group, role, or policy) was last used in an attempt to access Amazon Web
   * Services services. Recent activity usually appears within four hours. IAM
   * reports activity for at least the last 400 days, or less if your Region began
   * supporting this feature within the last year. For more information, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html#access-advisor_tracking-period">Regions
   * where data is tracked</a>. For more information about services and actions for
   * which action last accessed information is displayed, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor-action-last-accessed.html">IAM
   * action last accessed information services and actions</a>.</p>
   * <p>The service last accessed data includes all attempts to access an Amazon Web
   * Services API, not just the successful ones. This includes all attempts that were
   * made using the Amazon Web Services Management Console, the Amazon Web Services
   * API through any of the SDKs, or any of the command line tools. An unexpected
   * entry in the service last accessed data does not mean that your account has been
   * compromised, because the request might have been denied. Refer to your
   * CloudTrail logs as the authoritative source for information about all API calls
   * and whether they were successful or denied access. For more information, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/cloudtrail-integration.html">Logging
   * IAM events with CloudTrail</a> in the <i>IAM User Guide</i>.</p>
   * <p>The <code>GenerateServiceLastAccessedDetails</code> operation returns a
   * <code>JobId</code>. Use this parameter in the following operations to retrieve
   * the following details from your report: </p> <ul> <li> <p> <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetServiceLastAccessedDetails.html">GetServiceLastAccessedDetails</a>
   * – Use this operation for users, groups, roles, or policies to list every Amazon
   * Web Services service that the resource could access using permissions policies.
   * For each service, the response includes information about the most recent access
   * attempt.</p> <p>The <code>JobId</code> returned by
   * <code>GenerateServiceLastAccessedDetail</code> must be used by the same role
   * within a session, or by the same user when used to call
   * <code>GetServiceLastAccessedDetail</code>.</p> </li> <li> <p> <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetServiceLastAccessedDetailsWithEntities.html">GetServiceLastAccessedDetailsWithEntities</a>
   * – Use this operation for groups and policies to list information about the
   * associated entities (users or roles) that attempted to access a specific Amazon
   * Web Services service. </p> </li> </ul> <p>To check the status of the
   * <code>GenerateServiceLastAccessedDetails</code> request, use the
   * <code>JobId</code> parameter in the same operations and test the
   * <code>JobStatus</code> response parameter.</p> <p>For additional information
   * about the permissions policies that allow an identity (user, group, or role) to
   * access specific services, use the <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListPoliciesGrantingServiceAccess.html">ListPoliciesGrantingServiceAccess</a>
   * operation.</p>  <p>Service last accessed data does not use other policy
   * types when determining whether a resource could access a service. These other
   * policy types include resource-based policies, access control lists,
   * Organizations policies, IAM permissions boundaries, and STS assume role
   * policies. It only applies permissions policy logic. For more about the
   * evaluation of policy types, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html#policy-eval-basics">Evaluating
   * policies</a> in the <i>IAM User Guide</i>.</p>  <p>For more information
   * about service and action last accessed data, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html">Reducing
   * permissions using service last accessed data</a> in the <i>IAM User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GenerateServiceLastAccessedDetails">AWS
   * API Reference</a></p>
   */
  virtual Model::GenerateServiceLastAccessedDetailsOutcome GenerateServiceLastAccessedDetails(
      const Model::GenerateServiceLastAccessedDetailsRequest& request) const;

  /**
   * A Callable wrapper for GenerateServiceLastAccessedDetails that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename GenerateServiceLastAccessedDetailsRequestT = Model::GenerateServiceLastAccessedDetailsRequest>
  Model::GenerateServiceLastAccessedDetailsOutcomeCallable GenerateServiceLastAccessedDetailsCallable(
      const GenerateServiceLastAccessedDetailsRequestT& request) const {
    return SubmitCallable(&IAMClient::GenerateServiceLastAccessedDetails, request);
  }

  /**
   * An Async wrapper for GenerateServiceLastAccessedDetails that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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);
  }

  /**
   * <p>Retrieves information about when the specified access key was last used. The
   * information includes the date and time of last use, along with the Amazon Web
   * Services service and Region that were specified in the last request made with
   * that key.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetAccessKeyLastUsed">AWS
   * API Reference</a></p>
   */
  virtual Model::GetAccessKeyLastUsedOutcome GetAccessKeyLastUsed(const Model::GetAccessKeyLastUsedRequest& request) const;

  /**
   * A Callable wrapper for GetAccessKeyLastUsed that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename GetAccessKeyLastUsedRequestT = Model::GetAccessKeyLastUsedRequest>
  Model::GetAccessKeyLastUsedOutcomeCallable GetAccessKeyLastUsedCallable(const GetAccessKeyLastUsedRequestT& request) const {
    return SubmitCallable(&IAMClient::GetAccessKeyLastUsed, request);
  }

  /**
   * An Async wrapper for GetAccessKeyLastUsed that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Retrieves information about all IAM users, groups, roles, and policies in
   * your Amazon Web Services account, including their relationships to one another.
   * Use this operation to obtain a snapshot of the configuration of IAM permissions
   * (users, groups, roles, and policies) in your account.</p>  <p>Policies
   * returned by this operation are URL-encoded compliant with <a
   * href="https://tools.ietf.org/html/rfc3986">RFC 3986</a>. You can use a URL
   * decoding method to convert the policy back to plain JSON text. For example, if
   * you use Java, you can use the <code>decode</code> method of the
   * <code>java.net.URLDecoder</code> utility class in the Java SDK. Other languages
   * and SDKs provide similar functionality, and some SDKs do this decoding
   * automatically.</p>  <p>You can optionally filter the results using the
   * <code>Filter</code> parameter. You can paginate the results using the
   * <code>MaxItems</code> and <code>Marker</code> parameters.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetAccountAuthorizationDetails">AWS
   * API Reference</a></p>
   */
  virtual Model::GetAccountAuthorizationDetailsOutcome GetAccountAuthorizationDetails(
      const Model::GetAccountAuthorizationDetailsRequest& request = {}) const;

  /**
   * A Callable wrapper for GetAccountAuthorizationDetails that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename GetAccountAuthorizationDetailsRequestT = Model::GetAccountAuthorizationDetailsRequest>
  Model::GetAccountAuthorizationDetailsOutcomeCallable GetAccountAuthorizationDetailsCallable(
      const GetAccountAuthorizationDetailsRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::GetAccountAuthorizationDetails, request);
  }

  /**
   * An Async wrapper for GetAccountAuthorizationDetails that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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);
  }

  /**
   * <p>Retrieves the password policy for the Amazon Web Services account. This tells
   * you the complexity requirements and mandatory rotation periods for the IAM user
   * passwords in your account. For more information about using a password policy,
   * see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_ManagingPasswordPolicies.html">Managing
   * an IAM password policy</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetAccountPasswordPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::GetAccountPasswordPolicyOutcome GetAccountPasswordPolicy(const Model::GetAccountPasswordPolicyRequest& request = {}) const;

  /**
   * A Callable wrapper for GetAccountPasswordPolicy that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename GetAccountPasswordPolicyRequestT = Model::GetAccountPasswordPolicyRequest>
  Model::GetAccountPasswordPolicyOutcomeCallable GetAccountPasswordPolicyCallable(
      const GetAccountPasswordPolicyRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::GetAccountPasswordPolicy, request);
  }

  /**
   * An Async wrapper for GetAccountPasswordPolicy that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Retrieves information about IAM entity usage and IAM quotas in the Amazon Web
   * Services account.</p> <p> For information about IAM quotas, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html">IAM
   * and STS quotas</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetAccountSummary">AWS
   * API Reference</a></p>
   */
  virtual Model::GetAccountSummaryOutcome GetAccountSummary(const Model::GetAccountSummaryRequest& request = {}) const;

  /**
   * A Callable wrapper for GetAccountSummary that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename GetAccountSummaryRequestT = Model::GetAccountSummaryRequest>
  Model::GetAccountSummaryOutcomeCallable GetAccountSummaryCallable(const GetAccountSummaryRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::GetAccountSummary, request);
  }

  /**
   * An Async wrapper for GetAccountSummary that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Gets a list of all of the context keys referenced in the input policies. The
   * policies are supplied as a list of one or more strings. To get the context keys
   * from policies associated with an IAM user, group, or role, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetContextKeysForPrincipalPolicy.html">GetContextKeysForPrincipalPolicy</a>.</p>
   * <p>Context keys are variables maintained by Amazon Web Services and its services
   * that provide details about the context of an API query request. Context keys can
   * be evaluated by testing against a value specified in an IAM policy. Use
   * <code>GetContextKeysForCustomPolicy</code> to understand what key names and
   * values you must supply when you call <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_SimulateCustomPolicy.html">SimulateCustomPolicy</a>.
   * Note that all parameters are shown in unencoded form here for clarity but must
   * be URL encoded to be included as a part of a real HTML request.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetContextKeysForCustomPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::GetContextKeysForCustomPolicyOutcome GetContextKeysForCustomPolicy(
      const Model::GetContextKeysForCustomPolicyRequest& request) const;

  /**
   * A Callable wrapper for GetContextKeysForCustomPolicy that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename GetContextKeysForCustomPolicyRequestT = Model::GetContextKeysForCustomPolicyRequest>
  Model::GetContextKeysForCustomPolicyOutcomeCallable GetContextKeysForCustomPolicyCallable(
      const GetContextKeysForCustomPolicyRequestT& request) const {
    return SubmitCallable(&IAMClient::GetContextKeysForCustomPolicy, request);
  }

  /**
   * An Async wrapper for GetContextKeysForCustomPolicy that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Gets a list of all of the context keys referenced in all the IAM policies
   * that are attached to the specified IAM entity. The entity can be an IAM user,
   * group, or role. If you specify a user, then the request also includes all of the
   * policies attached to groups that the user is a member of.</p> <p>You can
   * optionally include a list of one or more additional policies, specified as
   * strings. If you want to include <i>only</i> a list of policies by string, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetContextKeysForCustomPolicy.html">GetContextKeysForCustomPolicy</a>
   * instead.</p> <p> <b>Note:</b> This operation discloses information about the
   * permissions granted to other users. If you do not want users to see other user's
   * permissions, then consider allowing them to use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetContextKeysForCustomPolicy.html">GetContextKeysForCustomPolicy</a>
   * instead.</p> <p>Context keys are variables maintained by Amazon Web Services and
   * its services that provide details about the context of an API query request.
   * Context keys can be evaluated by testing against a value in an IAM policy. Use
   * <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetContextKeysForPrincipalPolicy.html">GetContextKeysForPrincipalPolicy</a>
   * to understand what key names and values you must supply when you call <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_SimulatePrincipalPolicy.html">SimulatePrincipalPolicy</a>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetContextKeysForPrincipalPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::GetContextKeysForPrincipalPolicyOutcome GetContextKeysForPrincipalPolicy(
      const Model::GetContextKeysForPrincipalPolicyRequest& request) const;

  /**
   * A Callable wrapper for GetContextKeysForPrincipalPolicy that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename GetContextKeysForPrincipalPolicyRequestT = Model::GetContextKeysForPrincipalPolicyRequest>
  Model::GetContextKeysForPrincipalPolicyOutcomeCallable GetContextKeysForPrincipalPolicyCallable(
      const GetContextKeysForPrincipalPolicyRequestT& request) const {
    return SubmitCallable(&IAMClient::GetContextKeysForPrincipalPolicy, request);
  }

  /**
   * An Async wrapper for GetContextKeysForPrincipalPolicy that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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);
  }

  /**
   * <p> Retrieves a credential report for the Amazon Web Services account. For more
   * information about the credential report, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/credential-reports.html">Getting
   * credential reports</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetCredentialReport">AWS
   * API Reference</a></p>
   */
  virtual Model::GetCredentialReportOutcome GetCredentialReport(const Model::GetCredentialReportRequest& request = {}) const;

  /**
   * A Callable wrapper for GetCredentialReport that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename GetCredentialReportRequestT = Model::GetCredentialReportRequest>
  Model::GetCredentialReportOutcomeCallable GetCredentialReportCallable(const GetCredentialReportRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::GetCredentialReport, request);
  }

  /**
   * An Async wrapper for GetCredentialReport that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Retrieves information about a specific delegation request.</p> <p> If a
   * delegation request has no owner or owner account,
   * <code>GetDelegationRequest</code> for that delegation request can be called by
   * any account. If the owner account is assigned but there is no owner id, only
   * identities within that owner account can call <code>GetDelegationRequest</code>
   * for the delegation request. Once the delegation request is fully owned, the
   * owner of the request gets a default permission to get that delegation request.
   * For more details, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-temporary-delegation.html#temporary-delegation-managing-permissions">
   * Managing Permissions for Delegation Requests</a>. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetDelegationRequest">AWS
   * API Reference</a></p>
   */
  virtual Model::GetDelegationRequestOutcome GetDelegationRequest(const Model::GetDelegationRequestRequest& request) const;

  /**
   * A Callable wrapper for GetDelegationRequest that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename GetDelegationRequestRequestT = Model::GetDelegationRequestRequest>
  Model::GetDelegationRequestOutcomeCallable GetDelegationRequestCallable(const GetDelegationRequestRequestT& request) const {
    return SubmitCallable(&IAMClient::GetDelegationRequest, request);
  }

  /**
   * An Async wrapper for GetDelegationRequest that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p> Returns a list of IAM users that are in the specified IAM group. You can
   * paginate the results using the <code>MaxItems</code> and <code>Marker</code>
   * parameters.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetGroup">AWS API
   * Reference</a></p>
   */
  virtual Model::GetGroupOutcome GetGroup(const Model::GetGroupRequest& request) const;

  /**
   * A Callable wrapper for GetGroup that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename GetGroupRequestT = Model::GetGroupRequest>
  Model::GetGroupOutcomeCallable GetGroupCallable(const GetGroupRequestT& request) const {
    return SubmitCallable(&IAMClient::GetGroup, request);
  }

  /**
   * An Async wrapper for GetGroup that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Retrieves the specified inline policy document that is embedded in the
   * specified IAM group.</p>  <p>Policies returned by this operation are
   * URL-encoded compliant with <a href="https://tools.ietf.org/html/rfc3986">RFC
   * 3986</a>. You can use a URL decoding method to convert the policy back to plain
   * JSON text. For example, if you use Java, you can use the <code>decode</code>
   * method of the <code>java.net.URLDecoder</code> utility class in the Java SDK.
   * Other languages and SDKs provide similar functionality, and some SDKs do this
   * decoding automatically.</p>  <p>An IAM group can also have managed
   * policies attached to it. To retrieve a managed policy document that is attached
   * to a group, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetPolicy.html">GetPolicy</a>
   * to determine the policy's default version, then use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetPolicyVersion.html">GetPolicyVersion</a>
   * to retrieve the policy document.</p> <p>For more information about policies, see
   * <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetGroupPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::GetGroupPolicyOutcome GetGroupPolicy(const Model::GetGroupPolicyRequest& request) const;

  /**
   * A Callable wrapper for GetGroupPolicy that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename GetGroupPolicyRequestT = Model::GetGroupPolicyRequest>
  Model::GetGroupPolicyOutcomeCallable GetGroupPolicyCallable(const GetGroupPolicyRequestT& request) const {
    return SubmitCallable(&IAMClient::GetGroupPolicy, request);
  }

  /**
   * An Async wrapper for GetGroupPolicy that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Retrieves a human readable summary for a given entity. At this time, the only
   * supported entity type is <code>delegation-request</code> </p> <p>This method
   * uses a Large Language Model (LLM) to generate the summary.</p> <p> If a
   * delegation request has no owner or owner account,
   * <code>GetHumanReadableSummary</code> for that delegation request can be called
   * by any account. If the owner account is assigned but there is no owner id, only
   * identities within that owner account can call
   * <code>GetHumanReadableSummary</code> for the delegation request to retrieve a
   * summary of that request. Once the delegation request is fully owned, the owner
   * of the request gets a default permission to get that delegation request. For
   * more details, read <a href="">default permissions granted to delegation
   * requests</a>. These rules are identical to <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetDelegationRequest.html">GetDelegationRequest</a>
   * API behavior, such that a party who has permissions to call <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetDelegationRequest.html">GetDelegationRequest</a>
   * for a given delegation request will always be able to retrieve the human
   * readable summary for that request. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetHumanReadableSummary">AWS
   * API Reference</a></p>
   */
  virtual Model::GetHumanReadableSummaryOutcome GetHumanReadableSummary(const Model::GetHumanReadableSummaryRequest& request) const;

  /**
   * A Callable wrapper for GetHumanReadableSummary that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename GetHumanReadableSummaryRequestT = Model::GetHumanReadableSummaryRequest>
  Model::GetHumanReadableSummaryOutcomeCallable GetHumanReadableSummaryCallable(const GetHumanReadableSummaryRequestT& request) const {
    return SubmitCallable(&IAMClient::GetHumanReadableSummary, request);
  }

  /**
   * An Async wrapper for GetHumanReadableSummary that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p> Retrieves information about the specified instance profile, including the
   * instance profile's path, GUID, ARN, and role. For more information about
   * instance profiles, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html">Using
   * instance profiles</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetInstanceProfile">AWS
   * API Reference</a></p>
   */
  virtual Model::GetInstanceProfileOutcome GetInstanceProfile(const Model::GetInstanceProfileRequest& request) const;

  /**
   * A Callable wrapper for GetInstanceProfile that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename GetInstanceProfileRequestT = Model::GetInstanceProfileRequest>
  Model::GetInstanceProfileOutcomeCallable GetInstanceProfileCallable(const GetInstanceProfileRequestT& request) const {
    return SubmitCallable(&IAMClient::GetInstanceProfile, request);
  }

  /**
   * An Async wrapper for GetInstanceProfile that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Retrieves the user name for the specified IAM user. A login profile is
   * created when you create a password for the user to access the Amazon Web
   * Services Management Console. If the user does not exist or does not have a
   * password, the operation returns a 404 (<code>NoSuchEntity</code>) error.</p>
   * <p>If you create an IAM user with access to the console, the
   * <code>CreateDate</code> reflects the date you created the initial password for
   * the user.</p> <p>If you create an IAM user with programmatic access, and then
   * later add a password for the user to access the Amazon Web Services Management
   * Console, the <code>CreateDate</code> reflects the initial password creation
   * date. A user with programmatic access does not have a login profile unless you
   * create a password for the user to access the Amazon Web Services Management
   * Console.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetLoginProfile">AWS
   * API Reference</a></p>
   */
  virtual Model::GetLoginProfileOutcome GetLoginProfile(const Model::GetLoginProfileRequest& request = {}) const;

  /**
   * A Callable wrapper for GetLoginProfile that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename GetLoginProfileRequestT = Model::GetLoginProfileRequest>
  Model::GetLoginProfileOutcomeCallable GetLoginProfileCallable(const GetLoginProfileRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::GetLoginProfile, request);
  }

  /**
   * An Async wrapper for GetLoginProfile that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Retrieves information about an MFA device for a specified user.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetMFADevice">AWS
   * API Reference</a></p>
   */
  virtual Model::GetMFADeviceOutcome GetMFADevice(const Model::GetMFADeviceRequest& request) const;

  /**
   * A Callable wrapper for GetMFADevice that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename GetMFADeviceRequestT = Model::GetMFADeviceRequest>
  Model::GetMFADeviceOutcomeCallable GetMFADeviceCallable(const GetMFADeviceRequestT& request) const {
    return SubmitCallable(&IAMClient::GetMFADevice, request);
  }

  /**
   * An Async wrapper for GetMFADevice that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Returns information about the specified OpenID Connect (OIDC) provider
   * resource object in IAM.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetOpenIDConnectProvider">AWS
   * API Reference</a></p>
   */
  virtual Model::GetOpenIDConnectProviderOutcome GetOpenIDConnectProvider(const Model::GetOpenIDConnectProviderRequest& request) const;

  /**
   * A Callable wrapper for GetOpenIDConnectProvider that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename GetOpenIDConnectProviderRequestT = Model::GetOpenIDConnectProviderRequest>
  Model::GetOpenIDConnectProviderOutcomeCallable GetOpenIDConnectProviderCallable(const GetOpenIDConnectProviderRequestT& request) const {
    return SubmitCallable(&IAMClient::GetOpenIDConnectProvider, request);
  }

  /**
   * An Async wrapper for GetOpenIDConnectProvider that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Retrieves the service last accessed data report for Organizations that was
   * previously generated using the <code> <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GenerateOrganizationsAccessReport.html">GenerateOrganizationsAccessReport</a>
   * </code> operation. This operation retrieves the status of your report job and
   * the report contents.</p> <p>Depending on the parameters that you passed when you
   * generated the report, the data returned could include different information. For
   * details, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GenerateOrganizationsAccessReport.html">GenerateOrganizationsAccessReport</a>.</p>
   * <p>To call this operation, you must be signed in to the management account in
   * your organization. SCPs must be enabled for your organization root. You must
   * have permissions to perform this operation. For more information, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html">Refining
   * permissions using service last accessed data</a> in the <i>IAM User
   * Guide</i>.</p> <p>For each service that principals in an account (root user, IAM
   * users, or IAM roles) could access using SCPs, the operation returns details
   * about the most recent access attempt. If there was no attempt, the service is
   * listed without details about the most recent attempt to access the service. If
   * the operation fails, it returns the reason that it failed.</p> <p>By default,
   * the list is sorted by service namespace.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetOrganizationsAccessReport">AWS
   * API Reference</a></p>
   */
  virtual Model::GetOrganizationsAccessReportOutcome GetOrganizationsAccessReport(
      const Model::GetOrganizationsAccessReportRequest& request) const;

  /**
   * A Callable wrapper for GetOrganizationsAccessReport that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename GetOrganizationsAccessReportRequestT = Model::GetOrganizationsAccessReportRequest>
  Model::GetOrganizationsAccessReportOutcomeCallable GetOrganizationsAccessReportCallable(
      const GetOrganizationsAccessReportRequestT& request) const {
    return SubmitCallable(&IAMClient::GetOrganizationsAccessReport, request);
  }

  /**
   * An Async wrapper for GetOrganizationsAccessReport that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Retrieves the configuration information for the outbound identity federation
   * feature in your Amazon Web Services account. The response includes the unique
   * issuer URL for your Amazon Web Services account and the current enabled/disabled
   * status of the feature. Use this operation to obtain the issuer URL that you need
   * to configure trust relationships with external services.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetOutboundWebIdentityFederationInfo">AWS
   * API Reference</a></p>
   */
  virtual Model::GetOutboundWebIdentityFederationInfoOutcome GetOutboundWebIdentityFederationInfo(
      const Model::GetOutboundWebIdentityFederationInfoRequest& request = {}) const;

  /**
   * A Callable wrapper for GetOutboundWebIdentityFederationInfo that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename GetOutboundWebIdentityFederationInfoRequestT = Model::GetOutboundWebIdentityFederationInfoRequest>
  Model::GetOutboundWebIdentityFederationInfoOutcomeCallable GetOutboundWebIdentityFederationInfoCallable(
      const GetOutboundWebIdentityFederationInfoRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::GetOutboundWebIdentityFederationInfo, request);
  }

  /**
   * An Async wrapper for GetOutboundWebIdentityFederationInfo that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  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);
  }

  /**
   * <p>Retrieves information about the specified managed policy, including the
   * policy's default version and the total number of IAM users, groups, and roles to
   * which the policy is attached. To retrieve the list of the specific users,
   * groups, and roles that the policy is attached to, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListEntitiesForPolicy.html">ListEntitiesForPolicy</a>.
   * This operation returns metadata about the policy. To retrieve the actual policy
   * document for a specific version of the policy, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetPolicyVersion.html">GetPolicyVersion</a>.</p>
   * <p>This operation retrieves information about managed policies. To retrieve
   * information about an inline policy that is embedded with an IAM user, group, or
   * role, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetUserPolicy.html">GetUserPolicy</a>,
   * <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetGroupPolicy.html">GetGroupPolicy</a>,
   * or <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRolePolicy.html">GetRolePolicy</a>.</p>
   * <p>For more information about policies, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetPolicy">AWS API
   * Reference</a></p>
   */
  virtual Model::GetPolicyOutcome GetPolicy(const Model::GetPolicyRequest& request) const;

  /**
   * A Callable wrapper for GetPolicy that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename GetPolicyRequestT = Model::GetPolicyRequest>
  Model::GetPolicyOutcomeCallable GetPolicyCallable(const GetPolicyRequestT& request) const {
    return SubmitCallable(&IAMClient::GetPolicy, request);
  }

  /**
   * An Async wrapper for GetPolicy that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Retrieves information about the specified version of the specified managed
   * policy, including the policy document.</p>  <p>Policies returned by this
   * operation are URL-encoded compliant with <a
   * href="https://tools.ietf.org/html/rfc3986">RFC 3986</a>. You can use a URL
   * decoding method to convert the policy back to plain JSON text. For example, if
   * you use Java, you can use the <code>decode</code> method of the
   * <code>java.net.URLDecoder</code> utility class in the Java SDK. Other languages
   * and SDKs provide similar functionality, and some SDKs do this decoding
   * automatically.</p>  <p>To list the available versions for a policy, use
   * <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListPolicyVersions.html">ListPolicyVersions</a>.</p>
   * <p>This operation retrieves information about managed policies. To retrieve
   * information about an inline policy that is embedded in a user, group, or role,
   * use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetUserPolicy.html">GetUserPolicy</a>,
   * <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetGroupPolicy.html">GetGroupPolicy</a>,
   * or <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRolePolicy.html">GetRolePolicy</a>.</p>
   * <p>For more information about the types of policies, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p> <p>For more
   * information about managed policy versions, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-versions.html">Versioning
   * for managed policies</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetPolicyVersion">AWS
   * API Reference</a></p>
   */
  virtual Model::GetPolicyVersionOutcome GetPolicyVersion(const Model::GetPolicyVersionRequest& request) const;

  /**
   * A Callable wrapper for GetPolicyVersion that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename GetPolicyVersionRequestT = Model::GetPolicyVersionRequest>
  Model::GetPolicyVersionOutcomeCallable GetPolicyVersionCallable(const GetPolicyVersionRequestT& request) const {
    return SubmitCallable(&IAMClient::GetPolicyVersion, request);
  }

  /**
   * An Async wrapper for GetPolicyVersion that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Retrieves information about the specified role, including the role's path,
   * GUID, ARN, and the role's trust policy that grants permission to assume the
   * role. For more information about roles, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html">IAM
   * roles</a> in the <i>IAM User Guide</i>.</p>  <p>Policies returned by this
   * operation are URL-encoded compliant with <a
   * href="https://tools.ietf.org/html/rfc3986">RFC 3986</a>. You can use a URL
   * decoding method to convert the policy back to plain JSON text. For example, if
   * you use Java, you can use the <code>decode</code> method of the
   * <code>java.net.URLDecoder</code> utility class in the Java SDK. Other languages
   * and SDKs provide similar functionality, and some SDKs do this decoding
   * automatically.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetRole">AWS API
   * Reference</a></p>
   */
  virtual Model::GetRoleOutcome GetRole(const Model::GetRoleRequest& request) const;

  /**
   * A Callable wrapper for GetRole that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename GetRoleRequestT = Model::GetRoleRequest>
  Model::GetRoleOutcomeCallable GetRoleCallable(const GetRoleRequestT& request) const {
    return SubmitCallable(&IAMClient::GetRole, request);
  }

  /**
   * An Async wrapper for GetRole that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Retrieves the specified inline policy document that is embedded with the
   * specified IAM role.</p>  <p>Policies returned by this operation are
   * URL-encoded compliant with <a href="https://tools.ietf.org/html/rfc3986">RFC
   * 3986</a>. You can use a URL decoding method to convert the policy back to plain
   * JSON text. For example, if you use Java, you can use the <code>decode</code>
   * method of the <code>java.net.URLDecoder</code> utility class in the Java SDK.
   * Other languages and SDKs provide similar functionality, and some SDKs do this
   * decoding automatically.</p>  <p>An IAM role can also have managed
   * policies attached to it. To retrieve a managed policy document that is attached
   * to a role, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetPolicy.html">GetPolicy</a>
   * to determine the policy's default version, then use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetPolicyVersion.html">GetPolicyVersion</a>
   * to retrieve the policy document.</p> <p>For more information about policies, see
   * <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p> <p> For more
   * information about roles, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html">IAM
   * roles</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetRolePolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::GetRolePolicyOutcome GetRolePolicy(const Model::GetRolePolicyRequest& request) const;

  /**
   * A Callable wrapper for GetRolePolicy that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename GetRolePolicyRequestT = Model::GetRolePolicyRequest>
  Model::GetRolePolicyOutcomeCallable GetRolePolicyCallable(const GetRolePolicyRequestT& request) const {
    return SubmitCallable(&IAMClient::GetRolePolicy, request);
  }

  /**
   * An Async wrapper for GetRolePolicy that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Returns the SAML provider metadocument that was uploaded when the IAM SAML
   * provider resource object was created or updated.</p>  <p>This operation
   * requires <a
   * href="https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html">Signature
   * Version 4</a>.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetSAMLProvider">AWS
   * API Reference</a></p>
   */
  virtual Model::GetSAMLProviderOutcome GetSAMLProvider(const Model::GetSAMLProviderRequest& request) const;

  /**
   * A Callable wrapper for GetSAMLProvider that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename GetSAMLProviderRequestT = Model::GetSAMLProviderRequest>
  Model::GetSAMLProviderOutcomeCallable GetSAMLProviderCallable(const GetSAMLProviderRequestT& request) const {
    return SubmitCallable(&IAMClient::GetSAMLProvider, request);
  }

  /**
   * An Async wrapper for GetSAMLProvider that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Retrieves the specified SSH public key, including metadata about the key.</p>
   * <p>The SSH public key retrieved by this operation is used only for
   * authenticating the associated IAM user to an CodeCommit repository. For more
   * information about using SSH keys to authenticate to an CodeCommit repository,
   * see <a
   * href="https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up-credentials-ssh.html">Set
   * up CodeCommit for SSH connections</a> in the <i>CodeCommit User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetSSHPublicKey">AWS
   * API Reference</a></p>
   */
  virtual Model::GetSSHPublicKeyOutcome GetSSHPublicKey(const Model::GetSSHPublicKeyRequest& request) const;

  /**
   * A Callable wrapper for GetSSHPublicKey that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename GetSSHPublicKeyRequestT = Model::GetSSHPublicKeyRequest>
  Model::GetSSHPublicKeyOutcomeCallable GetSSHPublicKeyCallable(const GetSSHPublicKeyRequestT& request) const {
    return SubmitCallable(&IAMClient::GetSSHPublicKey, request);
  }

  /**
   * An Async wrapper for GetSSHPublicKey that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Retrieves information about the specified server certificate stored in
   * IAM.</p> <p>For more information about working with server certificates, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html">Working
   * with server certificates</a> in the <i>IAM User Guide</i>. This topic includes a
   * list of Amazon Web Services services that can use the server certificates that
   * you manage with IAM.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetServerCertificate">AWS
   * API Reference</a></p>
   */
  virtual Model::GetServerCertificateOutcome GetServerCertificate(const Model::GetServerCertificateRequest& request) const;

  /**
   * A Callable wrapper for GetServerCertificate that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename GetServerCertificateRequestT = Model::GetServerCertificateRequest>
  Model::GetServerCertificateOutcomeCallable GetServerCertificateCallable(const GetServerCertificateRequestT& request) const {
    return SubmitCallable(&IAMClient::GetServerCertificate, request);
  }

  /**
   * An Async wrapper for GetServerCertificate that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Retrieves a service last accessed report that was created using the
   * <code>GenerateServiceLastAccessedDetails</code> operation. You can use the
   * <code>JobId</code> parameter in <code>GetServiceLastAccessedDetails</code> to
   * retrieve the status of your report job. When the report is complete, you can
   * retrieve the generated report. The report includes a list of Amazon Web Services
   * services that the resource (user, group, role, or managed policy) can
   * access.</p>  <p>Service last accessed data does not use other policy types
   * when determining whether a resource could access a service. These other policy
   * types include resource-based policies, access control lists, Organizations
   * policies, IAM permissions boundaries, and STS assume role policies. It only
   * applies permissions policy logic. For more about the evaluation of policy types,
   * see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html#policy-eval-basics">Evaluating
   * policies</a> in the <i>IAM User Guide</i>.</p>  <p>For each service that
   * the resource could access using permissions policies, the operation returns
   * details about the most recent access attempt. If there was no attempt, the
   * service is listed without details about the most recent attempt to access the
   * service. If the operation fails, the <code>GetServiceLastAccessedDetails</code>
   * operation returns the reason that it failed.</p> <p>The
   * <code>GetServiceLastAccessedDetails</code> operation returns a list of services.
   * This list includes the number of entities that have attempted to access the
   * service and the date and time of the last attempt. It also returns the ARN of
   * the following entity, depending on the resource ARN that you used to generate
   * the report:</p> <ul> <li> <p> <b>User</b> – Returns the user ARN that you used
   * to generate the report</p> </li> <li> <p> <b>Group</b> – Returns the ARN of the
   * group member (user) that last attempted to access the service</p> </li> <li> <p>
   * <b>Role</b> – Returns the role ARN that you used to generate the report</p>
   * </li> <li> <p> <b>Policy</b> – Returns the ARN of the user or role that last
   * used the policy to attempt to access the service</p> </li> </ul> <p>By default,
   * the list is sorted by service namespace.</p> <p>If you specified
   * <code>ACTION_LEVEL</code> granularity when you generated the report, this
   * operation returns service and action last accessed data. This includes the most
   * recent access attempt for each tracked action within a service. Otherwise, this
   * operation returns only service data.</p> <p>For more information about service
   * and action last accessed data, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html">Reducing
   * permissions using service last accessed data</a> in the <i>IAM User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetServiceLastAccessedDetails">AWS
   * API Reference</a></p>
   */
  virtual Model::GetServiceLastAccessedDetailsOutcome GetServiceLastAccessedDetails(
      const Model::GetServiceLastAccessedDetailsRequest& request) const;

  /**
   * A Callable wrapper for GetServiceLastAccessedDetails that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename GetServiceLastAccessedDetailsRequestT = Model::GetServiceLastAccessedDetailsRequest>
  Model::GetServiceLastAccessedDetailsOutcomeCallable GetServiceLastAccessedDetailsCallable(
      const GetServiceLastAccessedDetailsRequestT& request) const {
    return SubmitCallable(&IAMClient::GetServiceLastAccessedDetails, request);
  }

  /**
   * An Async wrapper for GetServiceLastAccessedDetails that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>After you generate a group or policy report using the
   * <code>GenerateServiceLastAccessedDetails</code> operation, you can use the
   * <code>JobId</code> parameter in
   * <code>GetServiceLastAccessedDetailsWithEntities</code>. This operation retrieves
   * the status of your report job and a list of entities that could have used group
   * or policy permissions to access the specified service.</p> <ul> <li> <p>
   * <b>Group</b> – For a group report, this operation returns a list of users in the
   * group that could have used the group’s policies in an attempt to access the
   * service.</p> </li> <li> <p> <b>Policy</b> – For a policy report, this operation
   * returns a list of entities (users or roles) that could have used the policy in
   * an attempt to access the service.</p> </li> </ul> <p>You can also use this
   * operation for user or role reports to retrieve details about those entities.</p>
   * <p>If the operation fails, the
   * <code>GetServiceLastAccessedDetailsWithEntities</code> operation returns the
   * reason that it failed.</p> <p>By default, the list of associated entities is
   * sorted by date, with the most recent access listed first.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetServiceLastAccessedDetailsWithEntities">AWS
   * API Reference</a></p>
   */
  virtual Model::GetServiceLastAccessedDetailsWithEntitiesOutcome GetServiceLastAccessedDetailsWithEntities(
      const Model::GetServiceLastAccessedDetailsWithEntitiesRequest& request) const;

  /**
   * A Callable wrapper for GetServiceLastAccessedDetailsWithEntities that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename GetServiceLastAccessedDetailsWithEntitiesRequestT = Model::GetServiceLastAccessedDetailsWithEntitiesRequest>
  Model::GetServiceLastAccessedDetailsWithEntitiesOutcomeCallable GetServiceLastAccessedDetailsWithEntitiesCallable(
      const GetServiceLastAccessedDetailsWithEntitiesRequestT& request) const {
    return SubmitCallable(&IAMClient::GetServiceLastAccessedDetailsWithEntities, request);
  }

  /**
   * An Async wrapper for GetServiceLastAccessedDetailsWithEntities that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  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);
  }

  /**
   * <p>Retrieves the status of your service-linked role deletion. After you use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteServiceLinkedRole.html">DeleteServiceLinkedRole</a>
   * to submit a service-linked role for deletion, you can use the
   * <code>DeletionTaskId</code> parameter in
   * <code>GetServiceLinkedRoleDeletionStatus</code> to check the status of the
   * deletion. If the deletion fails, this operation returns the reason that it
   * failed, if that information is returned by the service.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetServiceLinkedRoleDeletionStatus">AWS
   * API Reference</a></p>
   */
  virtual Model::GetServiceLinkedRoleDeletionStatusOutcome GetServiceLinkedRoleDeletionStatus(
      const Model::GetServiceLinkedRoleDeletionStatusRequest& request) const;

  /**
   * A Callable wrapper for GetServiceLinkedRoleDeletionStatus that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename GetServiceLinkedRoleDeletionStatusRequestT = Model::GetServiceLinkedRoleDeletionStatusRequest>
  Model::GetServiceLinkedRoleDeletionStatusOutcomeCallable GetServiceLinkedRoleDeletionStatusCallable(
      const GetServiceLinkedRoleDeletionStatusRequestT& request) const {
    return SubmitCallable(&IAMClient::GetServiceLinkedRoleDeletionStatus, request);
  }

  /**
   * An Async wrapper for GetServiceLinkedRoleDeletionStatus that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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);
  }

  /**
   * <p>Retrieves information about the specified IAM user, including the user's
   * creation date, path, unique ID, and ARN.</p> <p>If you do not specify a user
   * name, IAM determines the user name implicitly based on the Amazon Web Services
   * access key ID used to sign the request to this operation.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetUser">AWS API
   * Reference</a></p>
   */
  virtual Model::GetUserOutcome GetUser(const Model::GetUserRequest& request = {}) const;

  /**
   * A Callable wrapper for GetUser that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename GetUserRequestT = Model::GetUserRequest>
  Model::GetUserOutcomeCallable GetUserCallable(const GetUserRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::GetUser, request);
  }

  /**
   * An Async wrapper for GetUser that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Retrieves the specified inline policy document that is embedded in the
   * specified IAM user.</p>  <p>Policies returned by this operation are
   * URL-encoded compliant with <a href="https://tools.ietf.org/html/rfc3986">RFC
   * 3986</a>. You can use a URL decoding method to convert the policy back to plain
   * JSON text. For example, if you use Java, you can use the <code>decode</code>
   * method of the <code>java.net.URLDecoder</code> utility class in the Java SDK.
   * Other languages and SDKs provide similar functionality, and some SDKs do this
   * decoding automatically.</p>  <p>An IAM user can also have managed
   * policies attached to it. To retrieve a managed policy document that is attached
   * to a user, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetPolicy.html">GetPolicy</a>
   * to determine the policy's default version. Then use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetPolicyVersion.html">GetPolicyVersion</a>
   * to retrieve the policy document.</p> <p>For more information about policies, see
   * <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetUserPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::GetUserPolicyOutcome GetUserPolicy(const Model::GetUserPolicyRequest& request) const;

  /**
   * A Callable wrapper for GetUserPolicy that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename GetUserPolicyRequestT = Model::GetUserPolicyRequest>
  Model::GetUserPolicyOutcomeCallable GetUserPolicyCallable(const GetUserPolicyRequestT& request) const {
    return SubmitCallable(&IAMClient::GetUserPolicy, request);
  }

  /**
   * An Async wrapper for GetUserPolicy that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Returns information about the access key IDs associated with the specified
   * IAM user. If there is none, the operation returns an empty list.</p> <p>Although
   * each user is limited to a small number of keys, you can still paginate the
   * results using the <code>MaxItems</code> and <code>Marker</code> parameters.</p>
   * <p>If the <code>UserName</code> is not specified, the user name is determined
   * implicitly based on the Amazon Web Services access key ID used to sign the
   * request. If a temporary access key is used, then <code>UserName</code> is
   * required. If a long-term key is assigned to the user, then <code>UserName</code>
   * is not required.</p> <p>This operation works for access keys under the Amazon
   * Web Services account. If the Amazon Web Services account has no associated
   * users, the root user returns it's own access key IDs by running this
   * command.</p>  <p>To ensure the security of your Amazon Web Services
   * account, the secret access key is accessible only during key and user
   * creation.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListAccessKeys">AWS
   * API Reference</a></p>
   */
  virtual Model::ListAccessKeysOutcome ListAccessKeys(const Model::ListAccessKeysRequest& request = {}) const;

  /**
   * A Callable wrapper for ListAccessKeys that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename ListAccessKeysRequestT = Model::ListAccessKeysRequest>
  Model::ListAccessKeysOutcomeCallable ListAccessKeysCallable(const ListAccessKeysRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::ListAccessKeys, request);
  }

  /**
   * An Async wrapper for ListAccessKeys that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Lists the account alias associated with the Amazon Web Services account
   * (Note: you can have only one). For information about using an Amazon Web
   * Services account alias, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/console_account-alias.html#CreateAccountAlias">Creating,
   * deleting, and listing an Amazon Web Services account alias</a> in the <i>IAM
   * User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListAccountAliases">AWS
   * API Reference</a></p>
   */
  virtual Model::ListAccountAliasesOutcome ListAccountAliases(const Model::ListAccountAliasesRequest& request = {}) const;

  /**
   * A Callable wrapper for ListAccountAliases that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListAccountAliasesRequestT = Model::ListAccountAliasesRequest>
  Model::ListAccountAliasesOutcomeCallable ListAccountAliasesCallable(const ListAccountAliasesRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::ListAccountAliases, request);
  }

  /**
   * An Async wrapper for ListAccountAliases that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Lists all managed policies that are attached to the specified IAM group.</p>
   * <p>An IAM group can also have inline policies embedded with it. To list the
   * inline policies for a group, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListGroupPolicies.html">ListGroupPolicies</a>.
   * For information about policies, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p> <p>You can
   * paginate the results using the <code>MaxItems</code> and <code>Marker</code>
   * parameters. You can use the <code>PathPrefix</code> parameter to limit the list
   * of policies to only those matching the specified path prefix. If there are no
   * policies attached to the specified group (or none that match the specified path
   * prefix), the operation returns an empty list.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListAttachedGroupPolicies">AWS
   * API Reference</a></p>
   */
  virtual Model::ListAttachedGroupPoliciesOutcome ListAttachedGroupPolicies(const Model::ListAttachedGroupPoliciesRequest& request) const;

  /**
   * A Callable wrapper for ListAttachedGroupPolicies that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListAttachedGroupPoliciesRequestT = Model::ListAttachedGroupPoliciesRequest>
  Model::ListAttachedGroupPoliciesOutcomeCallable ListAttachedGroupPoliciesCallable(
      const ListAttachedGroupPoliciesRequestT& request) const {
    return SubmitCallable(&IAMClient::ListAttachedGroupPolicies, request);
  }

  /**
   * An Async wrapper for ListAttachedGroupPolicies that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Lists all managed policies that are attached to the specified IAM role.</p>
   * <p>An IAM role can also have inline policies embedded with it. To list the
   * inline policies for a role, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListRolePolicies.html">ListRolePolicies</a>.
   * For information about policies, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p> <p>You can
   * paginate the results using the <code>MaxItems</code> and <code>Marker</code>
   * parameters. You can use the <code>PathPrefix</code> parameter to limit the list
   * of policies to only those matching the specified path prefix. If there are no
   * policies attached to the specified role (or none that match the specified path
   * prefix), the operation returns an empty list.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListAttachedRolePolicies">AWS
   * API Reference</a></p>
   */
  virtual Model::ListAttachedRolePoliciesOutcome ListAttachedRolePolicies(const Model::ListAttachedRolePoliciesRequest& request) const;

  /**
   * A Callable wrapper for ListAttachedRolePolicies that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListAttachedRolePoliciesRequestT = Model::ListAttachedRolePoliciesRequest>
  Model::ListAttachedRolePoliciesOutcomeCallable ListAttachedRolePoliciesCallable(const ListAttachedRolePoliciesRequestT& request) const {
    return SubmitCallable(&IAMClient::ListAttachedRolePolicies, request);
  }

  /**
   * An Async wrapper for ListAttachedRolePolicies that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Lists all managed policies that are attached to the specified IAM user.</p>
   * <p>An IAM user can also have inline policies embedded with it. To list the
   * inline policies for a user, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListUserPolicies.html">ListUserPolicies</a>.
   * For information about policies, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p> <p>You can
   * paginate the results using the <code>MaxItems</code> and <code>Marker</code>
   * parameters. You can use the <code>PathPrefix</code> parameter to limit the list
   * of policies to only those matching the specified path prefix. If there are no
   * policies attached to the specified group (or none that match the specified path
   * prefix), the operation returns an empty list.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListAttachedUserPolicies">AWS
   * API Reference</a></p>
   */
  virtual Model::ListAttachedUserPoliciesOutcome ListAttachedUserPolicies(const Model::ListAttachedUserPoliciesRequest& request) const;

  /**
   * A Callable wrapper for ListAttachedUserPolicies that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListAttachedUserPoliciesRequestT = Model::ListAttachedUserPoliciesRequest>
  Model::ListAttachedUserPoliciesOutcomeCallable ListAttachedUserPoliciesCallable(const ListAttachedUserPoliciesRequestT& request) const {
    return SubmitCallable(&IAMClient::ListAttachedUserPolicies, request);
  }

  /**
   * An Async wrapper for ListAttachedUserPolicies that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Lists delegation requests based on the specified criteria.</p> <p>If a
   * delegation request has no owner, even if it is assigned to a specific account,
   * it will not be part of the <code>ListDelegationRequests</code> output for that
   * account.</p> <p> For more details, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-temporary-delegation.html#temporary-delegation-managing-permissions">
   * Managing Permissions for Delegation Requests</a>. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListDelegationRequests">AWS
   * API Reference</a></p>
   */
  virtual Model::ListDelegationRequestsOutcome ListDelegationRequests(const Model::ListDelegationRequestsRequest& request = {}) const;

  /**
   * A Callable wrapper for ListDelegationRequests that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListDelegationRequestsRequestT = Model::ListDelegationRequestsRequest>
  Model::ListDelegationRequestsOutcomeCallable ListDelegationRequestsCallable(const ListDelegationRequestsRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::ListDelegationRequests, request);
  }

  /**
   * An Async wrapper for ListDelegationRequests that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Lists all IAM users, groups, and roles that the specified managed policy is
   * attached to.</p> <p>You can use the optional <code>EntityFilter</code> parameter
   * to limit the results to a particular type of entity (users, groups, or roles).
   * For example, to list only the roles that are attached to the specified policy,
   * set <code>EntityFilter</code> to <code>Role</code>.</p> <p>You can paginate the
   * results using the <code>MaxItems</code> and <code>Marker</code>
   * parameters.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListEntitiesForPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::ListEntitiesForPolicyOutcome ListEntitiesForPolicy(const Model::ListEntitiesForPolicyRequest& request) const;

  /**
   * A Callable wrapper for ListEntitiesForPolicy that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListEntitiesForPolicyRequestT = Model::ListEntitiesForPolicyRequest>
  Model::ListEntitiesForPolicyOutcomeCallable ListEntitiesForPolicyCallable(const ListEntitiesForPolicyRequestT& request) const {
    return SubmitCallable(&IAMClient::ListEntitiesForPolicy, request);
  }

  /**
   * An Async wrapper for ListEntitiesForPolicy that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Lists the names of the inline policies that are embedded in the specified IAM
   * group.</p> <p>An IAM group can also have managed policies attached to it. To
   * list the managed policies that are attached to a group, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAttachedGroupPolicies.html">ListAttachedGroupPolicies</a>.
   * For more information about policies, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p> <p>You can
   * paginate the results using the <code>MaxItems</code> and <code>Marker</code>
   * parameters. If there are no inline policies embedded with the specified group,
   * the operation returns an empty list.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListGroupPolicies">AWS
   * API Reference</a></p>
   */
  virtual Model::ListGroupPoliciesOutcome ListGroupPolicies(const Model::ListGroupPoliciesRequest& request) const;

  /**
   * A Callable wrapper for ListGroupPolicies that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListGroupPoliciesRequestT = Model::ListGroupPoliciesRequest>
  Model::ListGroupPoliciesOutcomeCallable ListGroupPoliciesCallable(const ListGroupPoliciesRequestT& request) const {
    return SubmitCallable(&IAMClient::ListGroupPolicies, request);
  }

  /**
   * An Async wrapper for ListGroupPolicies that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Lists the IAM groups that have the specified path prefix.</p> <p> You can
   * paginate the results using the <code>MaxItems</code> and <code>Marker</code>
   * parameters.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListGroups">AWS API
   * Reference</a></p>
   */
  virtual Model::ListGroupsOutcome ListGroups(const Model::ListGroupsRequest& request = {}) const;

  /**
   * A Callable wrapper for ListGroups that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename ListGroupsRequestT = Model::ListGroupsRequest>
  Model::ListGroupsOutcomeCallable ListGroupsCallable(const ListGroupsRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::ListGroups, request);
  }

  /**
   * An Async wrapper for ListGroups that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Lists the IAM groups that the specified IAM user belongs to.</p> <p>You can
   * paginate the results using the <code>MaxItems</code> and <code>Marker</code>
   * parameters.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListGroupsForUser">AWS
   * API Reference</a></p>
   */
  virtual Model::ListGroupsForUserOutcome ListGroupsForUser(const Model::ListGroupsForUserRequest& request) const;

  /**
   * A Callable wrapper for ListGroupsForUser that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListGroupsForUserRequestT = Model::ListGroupsForUserRequest>
  Model::ListGroupsForUserOutcomeCallable ListGroupsForUserCallable(const ListGroupsForUserRequestT& request) const {
    return SubmitCallable(&IAMClient::ListGroupsForUser, request);
  }

  /**
   * An Async wrapper for ListGroupsForUser that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Lists the tags that are attached to the specified IAM instance profile. The
   * returned list of tags is sorted by tag key. For more information about tagging,
   * see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html">Tagging IAM
   * resources</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListInstanceProfileTags">AWS
   * API Reference</a></p>
   */
  virtual Model::ListInstanceProfileTagsOutcome ListInstanceProfileTags(const Model::ListInstanceProfileTagsRequest& request) const;

  /**
   * A Callable wrapper for ListInstanceProfileTags that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListInstanceProfileTagsRequestT = Model::ListInstanceProfileTagsRequest>
  Model::ListInstanceProfileTagsOutcomeCallable ListInstanceProfileTagsCallable(const ListInstanceProfileTagsRequestT& request) const {
    return SubmitCallable(&IAMClient::ListInstanceProfileTags, request);
  }

  /**
   * An Async wrapper for ListInstanceProfileTags that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Lists the instance profiles that have the specified path prefix. If there are
   * none, the operation returns an empty list. For more information about instance
   * profiles, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html">Using
   * instance profiles</a> in the <i>IAM User Guide</i>.</p>  <p>IAM
   * resource-listing operations return a subset of the available attributes for the
   * resource. For example, this operation does not return tags, even though they are
   * an attribute of the returned object. To view all of the information for an
   * instance profile, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetInstanceProfile.html">GetInstanceProfile</a>.</p>
   *  <p>You can paginate the results using the <code>MaxItems</code> and
   * <code>Marker</code> parameters.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListInstanceProfiles">AWS
   * API Reference</a></p>
   */
  virtual Model::ListInstanceProfilesOutcome ListInstanceProfiles(const Model::ListInstanceProfilesRequest& request = {}) const;

  /**
   * A Callable wrapper for ListInstanceProfiles that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListInstanceProfilesRequestT = Model::ListInstanceProfilesRequest>
  Model::ListInstanceProfilesOutcomeCallable ListInstanceProfilesCallable(const ListInstanceProfilesRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::ListInstanceProfiles, request);
  }

  /**
   * An Async wrapper for ListInstanceProfiles that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Lists the instance profiles that have the specified associated IAM role. If
   * there are none, the operation returns an empty list. For more information about
   * instance profiles, go to <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html">Using
   * instance profiles</a> in the <i>IAM User Guide</i>.</p> <p>You can paginate the
   * results using the <code>MaxItems</code> and <code>Marker</code>
   * parameters.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListInstanceProfilesForRole">AWS
   * API Reference</a></p>
   */
  virtual Model::ListInstanceProfilesForRoleOutcome ListInstanceProfilesForRole(
      const Model::ListInstanceProfilesForRoleRequest& request) const;

  /**
   * A Callable wrapper for ListInstanceProfilesForRole that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename ListInstanceProfilesForRoleRequestT = Model::ListInstanceProfilesForRoleRequest>
  Model::ListInstanceProfilesForRoleOutcomeCallable ListInstanceProfilesForRoleCallable(
      const ListInstanceProfilesForRoleRequestT& request) const {
    return SubmitCallable(&IAMClient::ListInstanceProfilesForRole, request);
  }

  /**
   * An Async wrapper for ListInstanceProfilesForRole that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Lists the tags that are attached to the specified IAM virtual multi-factor
   * authentication (MFA) device. The returned list of tags is sorted by tag key. For
   * more information about tagging, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html">Tagging IAM
   * resources</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListMFADeviceTags">AWS
   * API Reference</a></p>
   */
  virtual Model::ListMFADeviceTagsOutcome ListMFADeviceTags(const Model::ListMFADeviceTagsRequest& request) const;

  /**
   * A Callable wrapper for ListMFADeviceTags that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListMFADeviceTagsRequestT = Model::ListMFADeviceTagsRequest>
  Model::ListMFADeviceTagsOutcomeCallable ListMFADeviceTagsCallable(const ListMFADeviceTagsRequestT& request) const {
    return SubmitCallable(&IAMClient::ListMFADeviceTags, request);
  }

  /**
   * An Async wrapper for ListMFADeviceTags that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Lists the MFA devices for an IAM user. If the request includes a IAM user
   * name, then this operation lists all the MFA devices associated with the
   * specified user. If you do not specify a user name, IAM determines the user name
   * implicitly based on the Amazon Web Services access key ID signing the request
   * for this operation.</p> <p>You can paginate the results using the
   * <code>MaxItems</code> and <code>Marker</code> parameters.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListMFADevices">AWS
   * API Reference</a></p>
   */
  virtual Model::ListMFADevicesOutcome ListMFADevices(const Model::ListMFADevicesRequest& request = {}) const;

  /**
   * A Callable wrapper for ListMFADevices that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename ListMFADevicesRequestT = Model::ListMFADevicesRequest>
  Model::ListMFADevicesOutcomeCallable ListMFADevicesCallable(const ListMFADevicesRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::ListMFADevices, request);
  }

  /**
   * An Async wrapper for ListMFADevices that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Lists the tags that are attached to the specified OpenID Connect
   * (OIDC)-compatible identity provider. The returned list of tags is sorted by tag
   * key. For more information, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc.html">About
   * web identity federation</a>.</p> <p>For more information about tagging, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html">Tagging IAM
   * resources</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListOpenIDConnectProviderTags">AWS
   * API Reference</a></p>
   */
  virtual Model::ListOpenIDConnectProviderTagsOutcome ListOpenIDConnectProviderTags(
      const Model::ListOpenIDConnectProviderTagsRequest& request) const;

  /**
   * A Callable wrapper for ListOpenIDConnectProviderTags that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename ListOpenIDConnectProviderTagsRequestT = Model::ListOpenIDConnectProviderTagsRequest>
  Model::ListOpenIDConnectProviderTagsOutcomeCallable ListOpenIDConnectProviderTagsCallable(
      const ListOpenIDConnectProviderTagsRequestT& request) const {
    return SubmitCallable(&IAMClient::ListOpenIDConnectProviderTags, request);
  }

  /**
   * An Async wrapper for ListOpenIDConnectProviderTags that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Lists information about the IAM OpenID Connect (OIDC) provider resource
   * objects defined in the Amazon Web Services account.</p>  <p>IAM
   * resource-listing operations return a subset of the available attributes for the
   * resource. For example, this operation does not return tags, even though they are
   * an attribute of the returned object. To view all of the information for an OIDC
   * provider, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetOpenIDConnectProvider.html">GetOpenIDConnectProvider</a>.</p>
   * <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListOpenIDConnectProviders">AWS
   * API Reference</a></p>
   */
  virtual Model::ListOpenIDConnectProvidersOutcome ListOpenIDConnectProviders(
      const Model::ListOpenIDConnectProvidersRequest& request = {}) const;

  /**
   * A Callable wrapper for ListOpenIDConnectProviders that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename ListOpenIDConnectProvidersRequestT = Model::ListOpenIDConnectProvidersRequest>
  Model::ListOpenIDConnectProvidersOutcomeCallable ListOpenIDConnectProvidersCallable(
      const ListOpenIDConnectProvidersRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::ListOpenIDConnectProviders, request);
  }

  /**
   * An Async wrapper for ListOpenIDConnectProviders that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Lists the centralized root access features enabled for your organization. For
   * more information, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#id_root-user-access-management">Centrally
   * manage root access for member accounts</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListOrganizationsFeatures">AWS
   * API Reference</a></p>
   */
  virtual Model::ListOrganizationsFeaturesOutcome ListOrganizationsFeatures(
      const Model::ListOrganizationsFeaturesRequest& request = {}) const;

  /**
   * A Callable wrapper for ListOrganizationsFeatures that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListOrganizationsFeaturesRequestT = Model::ListOrganizationsFeaturesRequest>
  Model::ListOrganizationsFeaturesOutcomeCallable ListOrganizationsFeaturesCallable(
      const ListOrganizationsFeaturesRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::ListOrganizationsFeatures, request);
  }

  /**
   * An Async wrapper for ListOrganizationsFeatures that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Lists all the managed policies that are available in your Amazon Web Services
   * account, including your own customer-defined managed policies and all Amazon Web
   * Services managed policies.</p> <p>You can filter the list of policies that is
   * returned using the optional <code>OnlyAttached</code>, <code>Scope</code>, and
   * <code>PathPrefix</code> parameters. For example, to list only the customer
   * managed policies in your Amazon Web Services account, set <code>Scope</code> to
   * <code>Local</code>. To list only Amazon Web Services managed policies, set
   * <code>Scope</code> to <code>AWS</code>.</p> <p>You can paginate the results
   * using the <code>MaxItems</code> and <code>Marker</code> parameters.</p> <p>For
   * more information about managed policies, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p>  <p>IAM
   * resource-listing operations return a subset of the available attributes for the
   * resource. For example, this operation does not return tags, even though they are
   * an attribute of the returned object. To view all of the information for a
   * customer manged policy, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetPolicy.html">GetPolicy</a>.</p>
   * <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListPolicies">AWS
   * API Reference</a></p>
   */
  virtual Model::ListPoliciesOutcome ListPolicies(const Model::ListPoliciesRequest& request = {}) const;

  /**
   * A Callable wrapper for ListPolicies that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename ListPoliciesRequestT = Model::ListPoliciesRequest>
  Model::ListPoliciesOutcomeCallable ListPoliciesCallable(const ListPoliciesRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::ListPolicies, request);
  }

  /**
   * An Async wrapper for ListPolicies that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Retrieves a list of policies that the IAM identity (user, group, or role) can
   * use to access each specified service.</p>  <p>This operation does not use
   * other policy types when determining whether a resource could access a service.
   * These other policy types include resource-based policies, access control lists,
   * Organizations policies, IAM permissions boundaries, and STS assume role
   * policies. It only applies permissions policy logic. For more about the
   * evaluation of policy types, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html#policy-eval-basics">Evaluating
   * policies</a> in the <i>IAM User Guide</i>.</p>  <p>The list of policies
   * returned by the operation depends on the ARN of the identity that you
   * provide.</p> <ul> <li> <p> <b>User</b> – The list of policies includes the
   * managed and inline policies that are attached to the user directly. The list
   * also includes any additional managed and inline policies that are attached to
   * the group to which the user belongs. </p> </li> <li> <p> <b>Group</b> – The list
   * of policies includes only the managed and inline policies that are attached to
   * the group directly. Policies that are attached to the group’s user are not
   * included.</p> </li> <li> <p> <b>Role</b> – The list of policies includes only
   * the managed and inline policies that are attached to the role.</p> </li> </ul>
   * <p>For each managed policy, this operation returns the ARN and policy name. For
   * each inline policy, it returns the policy name and the entity to which it is
   * attached. Inline policies do not have an ARN. For more information about these
   * policy types, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p> <p>Policies
   * that are attached to users and roles as permissions boundaries are not returned.
   * To view which managed policy is currently used to set the permissions boundary
   * for a user or role, use the <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetUser.html">GetUser</a>
   * or <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html">GetRole</a>
   * operations.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListPoliciesGrantingServiceAccess">AWS
   * API Reference</a></p>
   */
  virtual Model::ListPoliciesGrantingServiceAccessOutcome ListPoliciesGrantingServiceAccess(
      const Model::ListPoliciesGrantingServiceAccessRequest& request) const;

  /**
   * A Callable wrapper for ListPoliciesGrantingServiceAccess that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename ListPoliciesGrantingServiceAccessRequestT = Model::ListPoliciesGrantingServiceAccessRequest>
  Model::ListPoliciesGrantingServiceAccessOutcomeCallable ListPoliciesGrantingServiceAccessCallable(
      const ListPoliciesGrantingServiceAccessRequestT& request) const {
    return SubmitCallable(&IAMClient::ListPoliciesGrantingServiceAccess, request);
  }

  /**
   * An Async wrapper for ListPoliciesGrantingServiceAccess that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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);
  }

  /**
   * <p>Lists the tags that are attached to the specified IAM customer managed
   * policy. The returned list of tags is sorted by tag key. For more information
   * about tagging, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html">Tagging IAM
   * resources</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListPolicyTags">AWS
   * API Reference</a></p>
   */
  virtual Model::ListPolicyTagsOutcome ListPolicyTags(const Model::ListPolicyTagsRequest& request) const;

  /**
   * A Callable wrapper for ListPolicyTags that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename ListPolicyTagsRequestT = Model::ListPolicyTagsRequest>
  Model::ListPolicyTagsOutcomeCallable ListPolicyTagsCallable(const ListPolicyTagsRequestT& request) const {
    return SubmitCallable(&IAMClient::ListPolicyTags, request);
  }

  /**
   * An Async wrapper for ListPolicyTags that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Lists information about the versions of the specified managed policy,
   * including the version that is currently set as the policy's default version.</p>
   * <p>For more information about managed policies, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListPolicyVersions">AWS
   * API Reference</a></p>
   */
  virtual Model::ListPolicyVersionsOutcome ListPolicyVersions(const Model::ListPolicyVersionsRequest& request) const;

  /**
   * A Callable wrapper for ListPolicyVersions that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListPolicyVersionsRequestT = Model::ListPolicyVersionsRequest>
  Model::ListPolicyVersionsOutcomeCallable ListPolicyVersionsCallable(const ListPolicyVersionsRequestT& request) const {
    return SubmitCallable(&IAMClient::ListPolicyVersions, request);
  }

  /**
   * An Async wrapper for ListPolicyVersions that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Lists the names of the inline policies that are embedded in the specified IAM
   * role.</p> <p>An IAM role can also have managed policies attached to it. To list
   * the managed policies that are attached to a role, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAttachedRolePolicies.html">ListAttachedRolePolicies</a>.
   * For more information about policies, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p> <p>You can
   * paginate the results using the <code>MaxItems</code> and <code>Marker</code>
   * parameters. If there are no inline policies embedded with the specified role,
   * the operation returns an empty list.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListRolePolicies">AWS
   * API Reference</a></p>
   */
  virtual Model::ListRolePoliciesOutcome ListRolePolicies(const Model::ListRolePoliciesRequest& request) const;

  /**
   * A Callable wrapper for ListRolePolicies that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListRolePoliciesRequestT = Model::ListRolePoliciesRequest>
  Model::ListRolePoliciesOutcomeCallable ListRolePoliciesCallable(const ListRolePoliciesRequestT& request) const {
    return SubmitCallable(&IAMClient::ListRolePolicies, request);
  }

  /**
   * An Async wrapper for ListRolePolicies that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Lists the tags that are attached to the specified role. The returned list of
   * tags is sorted by tag key. For more information about tagging, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html">Tagging IAM
   * resources</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListRoleTags">AWS
   * API Reference</a></p>
   */
  virtual Model::ListRoleTagsOutcome ListRoleTags(const Model::ListRoleTagsRequest& request) const;

  /**
   * A Callable wrapper for ListRoleTags that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename ListRoleTagsRequestT = Model::ListRoleTagsRequest>
  Model::ListRoleTagsOutcomeCallable ListRoleTagsCallable(const ListRoleTagsRequestT& request) const {
    return SubmitCallable(&IAMClient::ListRoleTags, request);
  }

  /**
   * An Async wrapper for ListRoleTags that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Lists the IAM roles that have the specified path prefix. If there are none,
   * the operation returns an empty list. For more information about roles, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html">IAM
   * roles</a> in the <i>IAM User Guide</i>.</p>  <p>IAM resource-listing
   * operations return a subset of the available attributes for the resource. This
   * operation does not return the following attributes, even though they are an
   * attribute of the returned object:</p> <ul> <li> <p>PermissionsBoundary</p> </li>
   * <li> <p>RoleLastUsed</p> </li> <li> <p>Tags</p> </li> </ul> <p>To view all of
   * the information for a role, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html">GetRole</a>.</p>
   *  <p>You can paginate the results using the <code>MaxItems</code> and
   * <code>Marker</code> parameters.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListRoles">AWS API
   * Reference</a></p>
   */
  virtual Model::ListRolesOutcome ListRoles(const Model::ListRolesRequest& request = {}) const;

  /**
   * A Callable wrapper for ListRoles that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename ListRolesRequestT = Model::ListRolesRequest>
  Model::ListRolesOutcomeCallable ListRolesCallable(const ListRolesRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::ListRoles, request);
  }

  /**
   * An Async wrapper for ListRoles that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Lists the tags that are attached to the specified Security Assertion Markup
   * Language (SAML) identity provider. The returned list of tags is sorted by tag
   * key. For more information, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_saml.html">About
   * SAML 2.0-based federation</a>.</p> <p>For more information about tagging, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html">Tagging IAM
   * resources</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListSAMLProviderTags">AWS
   * API Reference</a></p>
   */
  virtual Model::ListSAMLProviderTagsOutcome ListSAMLProviderTags(const Model::ListSAMLProviderTagsRequest& request) const;

  /**
   * A Callable wrapper for ListSAMLProviderTags that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListSAMLProviderTagsRequestT = Model::ListSAMLProviderTagsRequest>
  Model::ListSAMLProviderTagsOutcomeCallable ListSAMLProviderTagsCallable(const ListSAMLProviderTagsRequestT& request) const {
    return SubmitCallable(&IAMClient::ListSAMLProviderTags, request);
  }

  /**
   * An Async wrapper for ListSAMLProviderTags that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Lists the SAML provider resource objects defined in IAM in the account. IAM
   * resource-listing operations return a subset of the available attributes for the
   * resource. For example, this operation does not return tags, even though they are
   * an attribute of the returned object. To view all of the information for a SAML
   * provider, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetSAMLProvider.html">GetSAMLProvider</a>.</p>
   *  <p> This operation requires <a
   * href="https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html">Signature
   * Version 4</a>.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListSAMLProviders">AWS
   * API Reference</a></p>
   */
  virtual Model::ListSAMLProvidersOutcome ListSAMLProviders(const Model::ListSAMLProvidersRequest& request = {}) const;

  /**
   * A Callable wrapper for ListSAMLProviders that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListSAMLProvidersRequestT = Model::ListSAMLProvidersRequest>
  Model::ListSAMLProvidersOutcomeCallable ListSAMLProvidersCallable(const ListSAMLProvidersRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::ListSAMLProviders, request);
  }

  /**
   * An Async wrapper for ListSAMLProviders that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Returns information about the SSH public keys associated with the specified
   * IAM user. If none exists, the operation returns an empty list.</p> <p>The SSH
   * public keys returned by this operation are used only for authenticating the IAM
   * user to an CodeCommit repository. For more information about using SSH keys to
   * authenticate to an CodeCommit repository, see <a
   * href="https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up-credentials-ssh.html">Set
   * up CodeCommit for SSH connections</a> in the <i>CodeCommit User Guide</i>.</p>
   * <p>Although each user is limited to a small number of keys, you can still
   * paginate the results using the <code>MaxItems</code> and <code>Marker</code>
   * parameters.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListSSHPublicKeys">AWS
   * API Reference</a></p>
   */
  virtual Model::ListSSHPublicKeysOutcome ListSSHPublicKeys(const Model::ListSSHPublicKeysRequest& request = {}) const;

  /**
   * A Callable wrapper for ListSSHPublicKeys that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListSSHPublicKeysRequestT = Model::ListSSHPublicKeysRequest>
  Model::ListSSHPublicKeysOutcomeCallable ListSSHPublicKeysCallable(const ListSSHPublicKeysRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::ListSSHPublicKeys, request);
  }

  /**
   * An Async wrapper for ListSSHPublicKeys that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Lists the tags that are attached to the specified IAM server certificate. The
   * returned list of tags is sorted by tag key. For more information about tagging,
   * see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html">Tagging IAM
   * resources</a> in the <i>IAM User Guide</i>.</p>  <p>For certificates in a
   * Region supported by Certificate Manager (ACM), we recommend that you don't use
   * IAM server certificates. Instead, use ACM to provision, manage, and deploy your
   * server certificates. For more information about IAM server certificates, <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html">Working
   * with server certificates</a> in the <i>IAM User Guide</i>.</p> <p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListServerCertificateTags">AWS
   * API Reference</a></p>
   */
  virtual Model::ListServerCertificateTagsOutcome ListServerCertificateTags(const Model::ListServerCertificateTagsRequest& request) const;

  /**
   * A Callable wrapper for ListServerCertificateTags that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListServerCertificateTagsRequestT = Model::ListServerCertificateTagsRequest>
  Model::ListServerCertificateTagsOutcomeCallable ListServerCertificateTagsCallable(
      const ListServerCertificateTagsRequestT& request) const {
    return SubmitCallable(&IAMClient::ListServerCertificateTags, request);
  }

  /**
   * An Async wrapper for ListServerCertificateTags that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Lists the server certificates stored in IAM that have the specified path
   * prefix. If none exist, the operation returns an empty list.</p> <p> You can
   * paginate the results using the <code>MaxItems</code> and <code>Marker</code>
   * parameters.</p> <p>For more information about working with server certificates,
   * see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html">Working
   * with server certificates</a> in the <i>IAM User Guide</i>. This topic also
   * includes a list of Amazon Web Services services that can use the server
   * certificates that you manage with IAM.</p>  <p>IAM resource-listing
   * operations return a subset of the available attributes for the resource. For
   * example, this operation does not return tags, even though they are an attribute
   * of the returned object. To view all of the information for a servercertificate,
   * see <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetServerCertificate.html">GetServerCertificate</a>.</p>
   * <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListServerCertificates">AWS
   * API Reference</a></p>
   */
  virtual Model::ListServerCertificatesOutcome ListServerCertificates(const Model::ListServerCertificatesRequest& request = {}) const;

  /**
   * A Callable wrapper for ListServerCertificates that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListServerCertificatesRequestT = Model::ListServerCertificatesRequest>
  Model::ListServerCertificatesOutcomeCallable ListServerCertificatesCallable(const ListServerCertificatesRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::ListServerCertificates, request);
  }

  /**
   * An Async wrapper for ListServerCertificates that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Returns information about the service-specific credentials associated with
   * the specified IAM user. If none exists, the operation returns an empty list. The
   * service-specific credentials returned by this operation are used only for
   * authenticating the IAM user to a specific service. For more information about
   * using service-specific credentials to authenticate to an Amazon Web Services
   * service, see <a
   * href="https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up-gc.html">Set
   * up service-specific credentials</a> in the CodeCommit User Guide.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListServiceSpecificCredentials">AWS
   * API Reference</a></p>
   */
  virtual Model::ListServiceSpecificCredentialsOutcome ListServiceSpecificCredentials(
      const Model::ListServiceSpecificCredentialsRequest& request = {}) const;

  /**
   * A Callable wrapper for ListServiceSpecificCredentials that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename ListServiceSpecificCredentialsRequestT = Model::ListServiceSpecificCredentialsRequest>
  Model::ListServiceSpecificCredentialsOutcomeCallable ListServiceSpecificCredentialsCallable(
      const ListServiceSpecificCredentialsRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::ListServiceSpecificCredentials, request);
  }

  /**
   * An Async wrapper for ListServiceSpecificCredentials that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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);
  }

  /**
   * <p>Returns information about the signing certificates associated with the
   * specified IAM user. If none exists, the operation returns an empty list.</p>
   * <p>Although each user is limited to a small number of signing certificates, you
   * can still paginate the results using the <code>MaxItems</code> and
   * <code>Marker</code> parameters.</p> <p>If the <code>UserName</code> field is not
   * specified, the user name is determined implicitly based on the Amazon Web
   * Services access key ID used to sign the request for this operation. This
   * operation works for access keys under the Amazon Web Services account.
   * Consequently, you can use this operation to manage Amazon Web Services account
   * root user credentials even if the Amazon Web Services account has no associated
   * users.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListSigningCertificates">AWS
   * API Reference</a></p>
   */
  virtual Model::ListSigningCertificatesOutcome ListSigningCertificates(const Model::ListSigningCertificatesRequest& request = {}) const;

  /**
   * A Callable wrapper for ListSigningCertificates that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListSigningCertificatesRequestT = Model::ListSigningCertificatesRequest>
  Model::ListSigningCertificatesOutcomeCallable ListSigningCertificatesCallable(const ListSigningCertificatesRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::ListSigningCertificates, request);
  }

  /**
   * An Async wrapper for ListSigningCertificates that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Lists the names of the inline policies embedded in the specified IAM
   * user.</p> <p>An IAM user can also have managed policies attached to it. To list
   * the managed policies that are attached to a user, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAttachedUserPolicies.html">ListAttachedUserPolicies</a>.
   * For more information about policies, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p> <p>You can
   * paginate the results using the <code>MaxItems</code> and <code>Marker</code>
   * parameters. If there are no inline policies embedded with the specified user,
   * the operation returns an empty list.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListUserPolicies">AWS
   * API Reference</a></p>
   */
  virtual Model::ListUserPoliciesOutcome ListUserPolicies(const Model::ListUserPoliciesRequest& request) const;

  /**
   * A Callable wrapper for ListUserPolicies that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListUserPoliciesRequestT = Model::ListUserPoliciesRequest>
  Model::ListUserPoliciesOutcomeCallable ListUserPoliciesCallable(const ListUserPoliciesRequestT& request) const {
    return SubmitCallable(&IAMClient::ListUserPolicies, request);
  }

  /**
   * An Async wrapper for ListUserPolicies that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Lists the tags that are attached to the specified IAM user. The returned list
   * of tags is sorted by tag key. For more information about tagging, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html">Tagging IAM
   * resources</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListUserTags">AWS
   * API Reference</a></p>
   */
  virtual Model::ListUserTagsOutcome ListUserTags(const Model::ListUserTagsRequest& request) const;

  /**
   * A Callable wrapper for ListUserTags that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename ListUserTagsRequestT = Model::ListUserTagsRequest>
  Model::ListUserTagsOutcomeCallable ListUserTagsCallable(const ListUserTagsRequestT& request) const {
    return SubmitCallable(&IAMClient::ListUserTags, request);
  }

  /**
   * An Async wrapper for ListUserTags that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Lists the IAM users that have the specified path prefix. If no path prefix is
   * specified, the operation returns all users in the Amazon Web Services account.
   * If there are none, the operation returns an empty list.</p>  <p>IAM
   * resource-listing operations return a subset of the available attributes for the
   * resource. This operation does not return the following attributes, even though
   * they are an attribute of the returned object:</p> <ul> <li>
   * <p>PermissionsBoundary</p> </li> <li> <p>Tags</p> </li> </ul> <p>To view all of
   * the information for a user, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetUser.html">GetUser</a>.</p>
   *  <p>You can paginate the results using the <code>MaxItems</code> and
   * <code>Marker</code> parameters.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListUsers">AWS API
   * Reference</a></p>
   */
  virtual Model::ListUsersOutcome ListUsers(const Model::ListUsersRequest& request = {}) const;

  /**
   * A Callable wrapper for ListUsers that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename ListUsersRequestT = Model::ListUsersRequest>
  Model::ListUsersOutcomeCallable ListUsersCallable(const ListUsersRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::ListUsers, request);
  }

  /**
   * An Async wrapper for ListUsers that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Lists the virtual MFA devices defined in the Amazon Web Services account by
   * assignment status. If you do not specify an assignment status, the operation
   * returns a list of all virtual MFA devices. Assignment status can be
   * <code>Assigned</code>, <code>Unassigned</code>, or <code>Any</code>.</p>
   * <p>IAM resource-listing operations return a subset of the available attributes
   * for the resource. For example, this operation does not return tags, even though
   * they are an attribute of the returned object. To view tag information for a
   * virtual MFA device, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListMFADeviceTags.html">ListMFADeviceTags</a>.</p>
   *  <p>You can paginate the results using the <code>MaxItems</code> and
   * <code>Marker</code> parameters.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListVirtualMFADevices">AWS
   * API Reference</a></p>
   */
  virtual Model::ListVirtualMFADevicesOutcome ListVirtualMFADevices(const Model::ListVirtualMFADevicesRequest& request = {}) const;

  /**
   * A Callable wrapper for ListVirtualMFADevices that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListVirtualMFADevicesRequestT = Model::ListVirtualMFADevicesRequest>
  Model::ListVirtualMFADevicesOutcomeCallable ListVirtualMFADevicesCallable(const ListVirtualMFADevicesRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::ListVirtualMFADevices, request);
  }

  /**
   * An Async wrapper for ListVirtualMFADevices that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Adds or updates an inline policy document that is embedded in the specified
   * IAM group.</p> <p>A user can also have managed policies attached to it. To
   * attach a managed policy to a group, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachGroupPolicy.html">
   * <code>AttachGroupPolicy</code> </a>. To create a new managed policy, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicy.html">
   * <code>CreatePolicy</code> </a>. For information about policies, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p> <p>For
   * information about the maximum number of inline policies that you can embed in a
   * group, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html">IAM
   * and STS quotas</a> in the <i>IAM User Guide</i>.</p>  <p>Because policy
   * documents can be large, you should use POST rather than GET when calling
   * <code>PutGroupPolicy</code>. For general information about using the Query API
   * with IAM, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/IAM_UsingQueryAPI.html">Making
   * query requests</a> in the <i>IAM User Guide</i>.</p> <p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/PutGroupPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::PutGroupPolicyOutcome PutGroupPolicy(const Model::PutGroupPolicyRequest& request) const;

  /**
   * A Callable wrapper for PutGroupPolicy that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename PutGroupPolicyRequestT = Model::PutGroupPolicyRequest>
  Model::PutGroupPolicyOutcomeCallable PutGroupPolicyCallable(const PutGroupPolicyRequestT& request) const {
    return SubmitCallable(&IAMClient::PutGroupPolicy, request);
  }

  /**
   * An Async wrapper for PutGroupPolicy that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Adds or updates the policy that is specified as the IAM role's permissions
   * boundary. You can use an Amazon Web Services managed policy or a customer
   * managed policy to set the boundary for a role. Use the boundary to control the
   * maximum permissions that the role can have. Setting a permissions boundary is an
   * advanced feature that can affect the permissions for the role.</p> <p>You cannot
   * set the boundary for a service-linked role.</p>  <p>Policies used as
   * permissions boundaries do not provide permissions. You must also attach a
   * permissions policy to the role. To learn how the effective permissions for a
   * role are evaluated, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html">IAM
   * JSON policy evaluation logic</a> in the IAM User Guide. </p>
   * <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/PutRolePermissionsBoundary">AWS
   * API Reference</a></p>
   */
  virtual Model::PutRolePermissionsBoundaryOutcome PutRolePermissionsBoundary(
      const Model::PutRolePermissionsBoundaryRequest& request) const;

  /**
   * A Callable wrapper for PutRolePermissionsBoundary that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename PutRolePermissionsBoundaryRequestT = Model::PutRolePermissionsBoundaryRequest>
  Model::PutRolePermissionsBoundaryOutcomeCallable PutRolePermissionsBoundaryCallable(
      const PutRolePermissionsBoundaryRequestT& request) const {
    return SubmitCallable(&IAMClient::PutRolePermissionsBoundary, request);
  }

  /**
   * An Async wrapper for PutRolePermissionsBoundary that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Adds or updates an inline policy document that is embedded in the specified
   * IAM role.</p> <p>When you embed an inline policy in a role, the inline policy is
   * used as part of the role's access (permissions) policy. The role's trust policy
   * is created at the same time as the role, using <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html">
   * <code>CreateRole</code> </a>. You can update a role's trust policy using <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateAssumeRolePolicy.html">
   * <code>UpdateAssumeRolePolicy</code> </a>. For more information about roles, see
   * <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-toplevel.html">IAM
   * roles</a> in the <i>IAM User Guide</i>.</p> <p>A role can also have a managed
   * policy attached to it. To attach a managed policy to a role, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html">
   * <code>AttachRolePolicy</code> </a>. To create a new managed policy, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicy.html">
   * <code>CreatePolicy</code> </a>. For information about policies, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p> <p>For
   * information about the maximum number of inline policies that you can embed with
   * a role, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html">IAM
   * and STS quotas</a> in the <i>IAM User Guide</i>.</p>  <p>Because policy
   * documents can be large, you should use POST rather than GET when calling
   * <code>PutRolePolicy</code>. For general information about using the Query API
   * with IAM, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/IAM_UsingQueryAPI.html">Making
   * query requests</a> in the <i>IAM User Guide</i>.</p> <p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/PutRolePolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::PutRolePolicyOutcome PutRolePolicy(const Model::PutRolePolicyRequest& request) const;

  /**
   * A Callable wrapper for PutRolePolicy that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename PutRolePolicyRequestT = Model::PutRolePolicyRequest>
  Model::PutRolePolicyOutcomeCallable PutRolePolicyCallable(const PutRolePolicyRequestT& request) const {
    return SubmitCallable(&IAMClient::PutRolePolicy, request);
  }

  /**
   * An Async wrapper for PutRolePolicy that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Adds or updates the policy that is specified as the IAM user's permissions
   * boundary. You can use an Amazon Web Services managed policy or a customer
   * managed policy to set the boundary for a user. Use the boundary to control the
   * maximum permissions that the user can have. Setting a permissions boundary is an
   * advanced feature that can affect the permissions for the user.</p>
   * <p>Policies that are used as permissions boundaries do not provide permissions.
   * You must also attach a permissions policy to the user. To learn how the
   * effective permissions for a user are evaluated, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html">IAM
   * JSON policy evaluation logic</a> in the IAM User Guide. </p>
   * <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/PutUserPermissionsBoundary">AWS
   * API Reference</a></p>
   */
  virtual Model::PutUserPermissionsBoundaryOutcome PutUserPermissionsBoundary(
      const Model::PutUserPermissionsBoundaryRequest& request) const;

  /**
   * A Callable wrapper for PutUserPermissionsBoundary that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename PutUserPermissionsBoundaryRequestT = Model::PutUserPermissionsBoundaryRequest>
  Model::PutUserPermissionsBoundaryOutcomeCallable PutUserPermissionsBoundaryCallable(
      const PutUserPermissionsBoundaryRequestT& request) const {
    return SubmitCallable(&IAMClient::PutUserPermissionsBoundary, request);
  }

  /**
   * An Async wrapper for PutUserPermissionsBoundary that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Adds or updates an inline policy document that is embedded in the specified
   * IAM user.</p> <p>An IAM user can also have a managed policy attached to it. To
   * attach a managed policy to a user, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachUserPolicy.html">
   * <code>AttachUserPolicy</code> </a>. To create a new managed policy, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicy.html">
   * <code>CreatePolicy</code> </a>. For information about policies, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p> <p>For
   * information about the maximum number of inline policies that you can embed in a
   * user, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html">IAM
   * and STS quotas</a> in the <i>IAM User Guide</i>.</p>  <p>Because policy
   * documents can be large, you should use POST rather than GET when calling
   * <code>PutUserPolicy</code>. For general information about using the Query API
   * with IAM, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/IAM_UsingQueryAPI.html">Making
   * query requests</a> in the <i>IAM User Guide</i>.</p> <p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/PutUserPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::PutUserPolicyOutcome PutUserPolicy(const Model::PutUserPolicyRequest& request) const;

  /**
   * A Callable wrapper for PutUserPolicy that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename PutUserPolicyRequestT = Model::PutUserPolicyRequest>
  Model::PutUserPolicyOutcomeCallable PutUserPolicyCallable(const PutUserPolicyRequestT& request) const {
    return SubmitCallable(&IAMClient::PutUserPolicy, request);
  }

  /**
   * An Async wrapper for PutUserPolicy that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Rejects a delegation request, denying the requested temporary access.</p>
   * <p>Once a request is rejected, it cannot be accepted or updated later. Rejected
   * requests expire after 7 days.</p> <p>When rejecting a request, an optional
   * explanation can be added using the <code>Notes</code> request parameter.</p> <p>
   * For more details, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-temporary-delegation.html#temporary-delegation-managing-permissions">
   * Managing Permissions for Delegation Requests</a>. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/RejectDelegationRequest">AWS
   * API Reference</a></p>
   */
  virtual Model::RejectDelegationRequestOutcome RejectDelegationRequest(const Model::RejectDelegationRequestRequest& request) const;

  /**
   * A Callable wrapper for RejectDelegationRequest that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename RejectDelegationRequestRequestT = Model::RejectDelegationRequestRequest>
  Model::RejectDelegationRequestOutcomeCallable RejectDelegationRequestCallable(const RejectDelegationRequestRequestT& request) const {
    return SubmitCallable(&IAMClient::RejectDelegationRequest, request);
  }

  /**
   * An Async wrapper for RejectDelegationRequest that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Removes the specified client ID (also known as audience) from the list of
   * client IDs registered for the specified IAM OpenID Connect (OIDC) provider
   * resource object.</p> <p>This operation is idempotent; it does not fail or return
   * an error if you try to remove a client ID that does not exist.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/RemoveClientIDFromOpenIDConnectProvider">AWS
   * API Reference</a></p>
   */
  virtual Model::RemoveClientIDFromOpenIDConnectProviderOutcome RemoveClientIDFromOpenIDConnectProvider(
      const Model::RemoveClientIDFromOpenIDConnectProviderRequest& request) const;

  /**
   * A Callable wrapper for RemoveClientIDFromOpenIDConnectProvider that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename RemoveClientIDFromOpenIDConnectProviderRequestT = Model::RemoveClientIDFromOpenIDConnectProviderRequest>
  Model::RemoveClientIDFromOpenIDConnectProviderOutcomeCallable RemoveClientIDFromOpenIDConnectProviderCallable(
      const RemoveClientIDFromOpenIDConnectProviderRequestT& request) const {
    return SubmitCallable(&IAMClient::RemoveClientIDFromOpenIDConnectProvider, request);
  }

  /**
   * An Async wrapper for RemoveClientIDFromOpenIDConnectProvider that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  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);
  }

  /**
   * <p>Removes the specified IAM role from the specified Amazon EC2 instance
   * profile.</p>  <p>Make sure that you do not have any Amazon EC2
   * instances running with the role you are about to remove from the instance
   * profile. Removing a role from an instance profile that is associated with a
   * running instance might break any applications running on the instance.</p>
   *  <p> For more information about roles, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html">IAM
   * roles</a> in the <i>IAM User Guide</i>. For more information about instance
   * profiles, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html">Using
   * instance profiles</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/RemoveRoleFromInstanceProfile">AWS
   * API Reference</a></p>
   */
  virtual Model::RemoveRoleFromInstanceProfileOutcome RemoveRoleFromInstanceProfile(
      const Model::RemoveRoleFromInstanceProfileRequest& request) const;

  /**
   * A Callable wrapper for RemoveRoleFromInstanceProfile that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename RemoveRoleFromInstanceProfileRequestT = Model::RemoveRoleFromInstanceProfileRequest>
  Model::RemoveRoleFromInstanceProfileOutcomeCallable RemoveRoleFromInstanceProfileCallable(
      const RemoveRoleFromInstanceProfileRequestT& request) const {
    return SubmitCallable(&IAMClient::RemoveRoleFromInstanceProfile, request);
  }

  /**
   * An Async wrapper for RemoveRoleFromInstanceProfile that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Removes the specified user from the specified group.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/RemoveUserFromGroup">AWS
   * API Reference</a></p>
   */
  virtual Model::RemoveUserFromGroupOutcome RemoveUserFromGroup(const Model::RemoveUserFromGroupRequest& request) const;

  /**
   * A Callable wrapper for RemoveUserFromGroup that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename RemoveUserFromGroupRequestT = Model::RemoveUserFromGroupRequest>
  Model::RemoveUserFromGroupOutcomeCallable RemoveUserFromGroupCallable(const RemoveUserFromGroupRequestT& request) const {
    return SubmitCallable(&IAMClient::RemoveUserFromGroup, request);
  }

  /**
   * An Async wrapper for RemoveUserFromGroup that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Resets the password for a service-specific credential. The new password is
   * Amazon Web Services generated and cryptographically strong. It cannot be
   * configured by the user. Resetting the password immediately invalidates the
   * previous password associated with this user.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ResetServiceSpecificCredential">AWS
   * API Reference</a></p>
   */
  virtual Model::ResetServiceSpecificCredentialOutcome ResetServiceSpecificCredential(
      const Model::ResetServiceSpecificCredentialRequest& request) const;

  /**
   * A Callable wrapper for ResetServiceSpecificCredential that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename ResetServiceSpecificCredentialRequestT = Model::ResetServiceSpecificCredentialRequest>
  Model::ResetServiceSpecificCredentialOutcomeCallable ResetServiceSpecificCredentialCallable(
      const ResetServiceSpecificCredentialRequestT& request) const {
    return SubmitCallable(&IAMClient::ResetServiceSpecificCredential, request);
  }

  /**
   * An Async wrapper for ResetServiceSpecificCredential that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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);
  }

  /**
   * <p>Synchronizes the specified MFA device with its IAM resource object on the
   * Amazon Web Services servers.</p> <p>For more information about creating and
   * working with virtual MFA devices, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_VirtualMFA.html">Using
   * a virtual MFA device</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ResyncMFADevice">AWS
   * API Reference</a></p>
   */
  virtual Model::ResyncMFADeviceOutcome ResyncMFADevice(const Model::ResyncMFADeviceRequest& request) const;

  /**
   * A Callable wrapper for ResyncMFADevice that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename ResyncMFADeviceRequestT = Model::ResyncMFADeviceRequest>
  Model::ResyncMFADeviceOutcomeCallable ResyncMFADeviceCallable(const ResyncMFADeviceRequestT& request) const {
    return SubmitCallable(&IAMClient::ResyncMFADevice, request);
  }

  /**
   * An Async wrapper for ResyncMFADevice that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Sends the exchange token for an accepted delegation request.</p> <p>The
   * exchange token is sent to the partner via an asynchronous notification channel,
   * established by the partner.</p> <p>The delegation request must be in the
   * <code>ACCEPTED</code> state when calling this API. After the
   * <code>SendDelegationToken</code> API call is successful, the request transitions
   * to a <code>FINALIZED</code> state and cannot be rolled back. However, a user may
   * reject an accepted request before the <code>SendDelegationToken</code> API is
   * called.</p> <p> For more details, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-temporary-delegation.html#temporary-delegation-managing-permissions">
   * Managing Permissions for Delegation Requests</a>. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/SendDelegationToken">AWS
   * API Reference</a></p>
   */
  virtual Model::SendDelegationTokenOutcome SendDelegationToken(const Model::SendDelegationTokenRequest& request) const;

  /**
   * A Callable wrapper for SendDelegationToken that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename SendDelegationTokenRequestT = Model::SendDelegationTokenRequest>
  Model::SendDelegationTokenOutcomeCallable SendDelegationTokenCallable(const SendDelegationTokenRequestT& request) const {
    return SubmitCallable(&IAMClient::SendDelegationToken, request);
  }

  /**
   * An Async wrapper for SendDelegationToken that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Sets the specified version of the specified policy as the policy's default
   * (operative) version.</p> <p>This operation affects all users, groups, and roles
   * that the policy is attached to. To list the users, groups, and roles that the
   * policy is attached to, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListEntitiesForPolicy.html">ListEntitiesForPolicy</a>.</p>
   * <p>For information about managed policies, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html">Managed
   * policies and inline policies</a> in the <i>IAM User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/SetDefaultPolicyVersion">AWS
   * API Reference</a></p>
   */
  virtual Model::SetDefaultPolicyVersionOutcome SetDefaultPolicyVersion(const Model::SetDefaultPolicyVersionRequest& request) const;

  /**
   * A Callable wrapper for SetDefaultPolicyVersion that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename SetDefaultPolicyVersionRequestT = Model::SetDefaultPolicyVersionRequest>
  Model::SetDefaultPolicyVersionOutcomeCallable SetDefaultPolicyVersionCallable(const SetDefaultPolicyVersionRequestT& request) const {
    return SubmitCallable(&IAMClient::SetDefaultPolicyVersion, request);
  }

  /**
   * An Async wrapper for SetDefaultPolicyVersion that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Sets the specified version of the global endpoint token as the token version
   * used for the Amazon Web Services account.</p> <p>By default, Security Token
   * Service (STS) is available as a global service, and all STS requests go to a
   * single endpoint at <code>https://sts.amazonaws.com</code>. Amazon Web Services
   * recommends using Regional STS endpoints to reduce latency, build in redundancy,
   * and increase session token availability. For information about Regional
   * endpoints for STS, see <a
   * href="https://docs.aws.amazon.com/general/latest/gr/sts.html">Security Token
   * Service endpoints and quotas</a> in the <i>Amazon Web Services General
   * Reference</i>.</p> <p>If you make an STS call to the global endpoint, the
   * resulting session tokens might be valid in some Regions but not others. It
   * depends on the version that is set in this operation. Version 1 tokens are valid
   * only in Amazon Web Services Regions that are available by default. These tokens
   * do not work in manually enabled Regions, such as Asia Pacific (Hong Kong).
   * Version 2 tokens are valid in all Regions. However, version 2 tokens are longer
   * and might affect systems where you temporarily store tokens. For information,
   * see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html">Activating
   * and deactivating STS in an Amazon Web Services Region</a> in the <i>IAM User
   * Guide</i>.</p> <p>To view the current session token version, see the
   * <code>GlobalEndpointTokenVersion</code> entry in the response of the <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetAccountSummary.html">GetAccountSummary</a>
   * operation.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/SetSecurityTokenServicePreferences">AWS
   * API Reference</a></p>
   */
  virtual Model::SetSecurityTokenServicePreferencesOutcome SetSecurityTokenServicePreferences(
      const Model::SetSecurityTokenServicePreferencesRequest& request) const;

  /**
   * A Callable wrapper for SetSecurityTokenServicePreferences that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename SetSecurityTokenServicePreferencesRequestT = Model::SetSecurityTokenServicePreferencesRequest>
  Model::SetSecurityTokenServicePreferencesOutcomeCallable SetSecurityTokenServicePreferencesCallable(
      const SetSecurityTokenServicePreferencesRequestT& request) const {
    return SubmitCallable(&IAMClient::SetSecurityTokenServicePreferences, request);
  }

  /**
   * An Async wrapper for SetSecurityTokenServicePreferences that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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);
  }

  /**
   * <p>Simulate how a set of IAM policies and optionally a resource-based policy
   * works with a list of API operations and Amazon Web Services resources to
   * determine the policies' effective permissions. The policies are provided as
   * strings.</p> <p>The simulation does not perform the API operations; it only
   * checks the authorization to determine if the simulated policies allow or deny
   * the operations. You can simulate resources that don't exist in your account.</p>
   * <p>If you want to simulate existing policies that are attached to an IAM user,
   * group, or role, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_SimulatePrincipalPolicy.html">SimulatePrincipalPolicy</a>
   * instead.</p> <p>Context keys are variables that are maintained by Amazon Web
   * Services and its services and which provide details about the context of an API
   * query request. You can use the <code>Condition</code> element of an IAM policy
   * to evaluate context keys. To get the list of context keys that the policies
   * require for correct simulation, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetContextKeysForCustomPolicy.html">GetContextKeysForCustomPolicy</a>.</p>
   * <p>If the output is long, you can use <code>MaxItems</code> and
   * <code>Marker</code> parameters to paginate the results.</p>  <p>The IAM
   * policy simulator evaluates statements in the identity-based policy and the
   * inputs that you provide during simulation. The policy simulator results can
   * differ from your live Amazon Web Services environment. We recommend that you
   * check your policies against your live Amazon Web Services environment after
   * testing using the policy simulator to confirm that you have the desired results.
   * For more information about using the policy simulator, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_testing-policies.html">Testing
   * IAM policies with the IAM policy simulator </a>in the <i>IAM User Guide</i>.</p>
   * <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/SimulateCustomPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::SimulateCustomPolicyOutcome SimulateCustomPolicy(const Model::SimulateCustomPolicyRequest& request) const;

  /**
   * A Callable wrapper for SimulateCustomPolicy that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename SimulateCustomPolicyRequestT = Model::SimulateCustomPolicyRequest>
  Model::SimulateCustomPolicyOutcomeCallable SimulateCustomPolicyCallable(const SimulateCustomPolicyRequestT& request) const {
    return SubmitCallable(&IAMClient::SimulateCustomPolicy, request);
  }

  /**
   * An Async wrapper for SimulateCustomPolicy that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Simulate how a set of IAM policies attached to an IAM entity works with a
   * list of API operations and Amazon Web Services resources to determine the
   * policies' effective permissions. The entity can be an IAM user, group, or role.
   * If you specify a user, then the simulation also includes all of the policies
   * that are attached to groups that the user belongs to. You can simulate resources
   * that don't exist in your account.</p> <p>You can optionally include a list of
   * one or more additional policies specified as strings to include in the
   * simulation. If you want to simulate only policies specified as strings, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_SimulateCustomPolicy.html">SimulateCustomPolicy</a>
   * instead.</p> <p>You can also optionally include one resource-based policy to be
   * evaluated with each of the resources included in the simulation for IAM users
   * only.</p> <p>The simulation does not perform the API operations; it only checks
   * the authorization to determine if the simulated policies allow or deny the
   * operations.</p> <p> <b>Note:</b> This operation discloses information about the
   * permissions granted to other users. If you do not want users to see other user's
   * permissions, then consider allowing them to use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_SimulateCustomPolicy.html">SimulateCustomPolicy</a>
   * instead.</p> <p>Context keys are variables maintained by Amazon Web Services and
   * its services that provide details about the context of an API query request. You
   * can use the <code>Condition</code> element of an IAM policy to evaluate context
   * keys. To get the list of context keys that the policies require for correct
   * simulation, use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetContextKeysForPrincipalPolicy.html">GetContextKeysForPrincipalPolicy</a>.</p>
   * <p>If the output is long, you can use the <code>MaxItems</code> and
   * <code>Marker</code> parameters to paginate the results.</p>  <p>The IAM
   * policy simulator evaluates statements in the identity-based policy and the
   * inputs that you provide during simulation. The policy simulator results can
   * differ from your live Amazon Web Services environment. We recommend that you
   * check your policies against your live Amazon Web Services environment after
   * testing using the policy simulator to confirm that you have the desired results.
   * For more information about using the policy simulator, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_testing-policies.html">Testing
   * IAM policies with the IAM policy simulator </a>in the <i>IAM User Guide</i>.</p>
   * <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/SimulatePrincipalPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::SimulatePrincipalPolicyOutcome SimulatePrincipalPolicy(const Model::SimulatePrincipalPolicyRequest& request) const;

  /**
   * A Callable wrapper for SimulatePrincipalPolicy that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename SimulatePrincipalPolicyRequestT = Model::SimulatePrincipalPolicyRequest>
  Model::SimulatePrincipalPolicyOutcomeCallable SimulatePrincipalPolicyCallable(const SimulatePrincipalPolicyRequestT& request) const {
    return SubmitCallable(&IAMClient::SimulatePrincipalPolicy, request);
  }

  /**
   * An Async wrapper for SimulatePrincipalPolicy that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Adds one or more tags to an IAM instance profile. If a tag with the same key
   * name already exists, then that tag is overwritten with the new value.</p>
   * <p>Each tag consists of a key name and an associated value. By assigning tags to
   * your resources, you can do the following:</p> <ul> <li> <p> <b>Administrative
   * grouping and discovery</b> - Attach tags to resources to aid in organization and
   * search. For example, you could search for all resources with the key name
   * <i>Project</i> and the value <i>MyImportantProject</i>. Or search for all
   * resources with the key name <i>Cost Center</i> and the value <i>41200</i>. </p>
   * </li> <li> <p> <b>Access control</b> - Include tags in IAM user-based and
   * resource-based policies. You can use tags to restrict access to only an IAM
   * instance profile that has a specified tag attached. For examples of policies
   * that show how to use tags to control access, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html">Control
   * access using IAM tags</a> in the <i>IAM User Guide</i>.</p> </li> </ul>
   * <ul> <li> <p>If any one of the tags is invalid or if you exceed the allowed
   * maximum number of tags, then the entire request fails and the resource is not
   * created. For more information about tagging, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html">Tagging IAM
   * resources</a> in the <i>IAM User Guide</i>.</p> </li> <li> <p>Amazon Web
   * Services always interprets the tag <code>Value</code> as a single string. If you
   * need to store an array, you can store comma-separated values in the string.
   * However, you must interpret the value in your code.</p> </li> </ul>
   * <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/TagInstanceProfile">AWS
   * API Reference</a></p>
   */
  virtual Model::TagInstanceProfileOutcome TagInstanceProfile(const Model::TagInstanceProfileRequest& request) const;

  /**
   * A Callable wrapper for TagInstanceProfile that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename TagInstanceProfileRequestT = Model::TagInstanceProfileRequest>
  Model::TagInstanceProfileOutcomeCallable TagInstanceProfileCallable(const TagInstanceProfileRequestT& request) const {
    return SubmitCallable(&IAMClient::TagInstanceProfile, request);
  }

  /**
   * An Async wrapper for TagInstanceProfile that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Adds one or more tags to an IAM virtual multi-factor authentication (MFA)
   * device. If a tag with the same key name already exists, then that tag is
   * overwritten with the new value.</p> <p>A tag consists of a key name and an
   * associated value. By assigning tags to your resources, you can do the
   * following:</p> <ul> <li> <p> <b>Administrative grouping and discovery</b> -
   * Attach tags to resources to aid in organization and search. For example, you
   * could search for all resources with the key name <i>Project</i> and the value
   * <i>MyImportantProject</i>. Or search for all resources with the key name <i>Cost
   * Center</i> and the value <i>41200</i>. </p> </li> <li> <p> <b>Access control</b>
   * - Include tags in IAM user-based and resource-based policies. You can use tags
   * to restrict access to only an IAM virtual MFA device that has a specified tag
   * attached. For examples of policies that show how to use tags to control access,
   * see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html">Control
   * access using IAM tags</a> in the <i>IAM User Guide</i>.</p> </li> </ul>
   * <ul> <li> <p>If any one of the tags is invalid or if you exceed the allowed
   * maximum number of tags, then the entire request fails and the resource is not
   * created. For more information about tagging, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html">Tagging IAM
   * resources</a> in the <i>IAM User Guide</i>.</p> </li> <li> <p>Amazon Web
   * Services always interprets the tag <code>Value</code> as a single string. If you
   * need to store an array, you can store comma-separated values in the string.
   * However, you must interpret the value in your code.</p> </li> </ul>
   * <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/TagMFADevice">AWS
   * API Reference</a></p>
   */
  virtual Model::TagMFADeviceOutcome TagMFADevice(const Model::TagMFADeviceRequest& request) const;

  /**
   * A Callable wrapper for TagMFADevice that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename TagMFADeviceRequestT = Model::TagMFADeviceRequest>
  Model::TagMFADeviceOutcomeCallable TagMFADeviceCallable(const TagMFADeviceRequestT& request) const {
    return SubmitCallable(&IAMClient::TagMFADevice, request);
  }

  /**
   * An Async wrapper for TagMFADevice that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Adds one or more tags to an OpenID Connect (OIDC)-compatible identity
   * provider. For more information about these providers, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc.html">About
   * web identity federation</a>. If a tag with the same key name already exists,
   * then that tag is overwritten with the new value.</p> <p>A tag consists of a key
   * name and an associated value. By assigning tags to your resources, you can do
   * the following:</p> <ul> <li> <p> <b>Administrative grouping and discovery</b> -
   * Attach tags to resources to aid in organization and search. For example, you
   * could search for all resources with the key name <i>Project</i> and the value
   * <i>MyImportantProject</i>. Or search for all resources with the key name <i>Cost
   * Center</i> and the value <i>41200</i>. </p> </li> <li> <p> <b>Access control</b>
   * - Include tags in IAM identity-based and resource-based policies. You can use
   * tags to restrict access to only an OIDC provider that has a specified tag
   * attached. For examples of policies that show how to use tags to control access,
   * see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html">Control
   * access using IAM tags</a> in the <i>IAM User Guide</i>.</p> </li> </ul>
   * <ul> <li> <p>If any one of the tags is invalid or if you exceed the allowed
   * maximum number of tags, then the entire request fails and the resource is not
   * created. For more information about tagging, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html">Tagging IAM
   * resources</a> in the <i>IAM User Guide</i>.</p> </li> <li> <p>Amazon Web
   * Services always interprets the tag <code>Value</code> as a single string. If you
   * need to store an array, you can store comma-separated values in the string.
   * However, you must interpret the value in your code.</p> </li> </ul>
   * <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/TagOpenIDConnectProvider">AWS
   * API Reference</a></p>
   */
  virtual Model::TagOpenIDConnectProviderOutcome TagOpenIDConnectProvider(const Model::TagOpenIDConnectProviderRequest& request) const;

  /**
   * A Callable wrapper for TagOpenIDConnectProvider that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename TagOpenIDConnectProviderRequestT = Model::TagOpenIDConnectProviderRequest>
  Model::TagOpenIDConnectProviderOutcomeCallable TagOpenIDConnectProviderCallable(const TagOpenIDConnectProviderRequestT& request) const {
    return SubmitCallable(&IAMClient::TagOpenIDConnectProvider, request);
  }

  /**
   * An Async wrapper for TagOpenIDConnectProvider that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Adds one or more tags to an IAM customer managed policy. If a tag with the
   * same key name already exists, then that tag is overwritten with the new
   * value.</p> <p>A tag consists of a key name and an associated value. By assigning
   * tags to your resources, you can do the following:</p> <ul> <li> <p>
   * <b>Administrative grouping and discovery</b> - Attach tags to resources to aid
   * in organization and search. For example, you could search for all resources with
   * the key name <i>Project</i> and the value <i>MyImportantProject</i>. Or search
   * for all resources with the key name <i>Cost Center</i> and the value
   * <i>41200</i>. </p> </li> <li> <p> <b>Access control</b> - Include tags in IAM
   * user-based and resource-based policies. You can use tags to restrict access to
   * only an IAM customer managed policy that has a specified tag attached. For
   * examples of policies that show how to use tags to control access, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html">Control
   * access using IAM tags</a> in the <i>IAM User Guide</i>.</p> </li> </ul>
   * <ul> <li> <p>If any one of the tags is invalid or if you exceed the allowed
   * maximum number of tags, then the entire request fails and the resource is not
   * created. For more information about tagging, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html">Tagging IAM
   * resources</a> in the <i>IAM User Guide</i>.</p> </li> <li> <p>Amazon Web
   * Services always interprets the tag <code>Value</code> as a single string. If you
   * need to store an array, you can store comma-separated values in the string.
   * However, you must interpret the value in your code.</p> </li> </ul>
   * <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/TagPolicy">AWS API
   * Reference</a></p>
   */
  virtual Model::TagPolicyOutcome TagPolicy(const Model::TagPolicyRequest& request) const;

  /**
   * A Callable wrapper for TagPolicy that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename TagPolicyRequestT = Model::TagPolicyRequest>
  Model::TagPolicyOutcomeCallable TagPolicyCallable(const TagPolicyRequestT& request) const {
    return SubmitCallable(&IAMClient::TagPolicy, request);
  }

  /**
   * An Async wrapper for TagPolicy that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Adds one or more tags to an IAM role. The role can be a regular role or a
   * service-linked role. If a tag with the same key name already exists, then that
   * tag is overwritten with the new value.</p> <p>A tag consists of a key name and
   * an associated value. By assigning tags to your resources, you can do the
   * following:</p> <ul> <li> <p> <b>Administrative grouping and discovery</b> -
   * Attach tags to resources to aid in organization and search. For example, you
   * could search for all resources with the key name <i>Project</i> and the value
   * <i>MyImportantProject</i>. Or search for all resources with the key name <i>Cost
   * Center</i> and the value <i>41200</i>. </p> </li> <li> <p> <b>Access control</b>
   * - Include tags in IAM user-based and resource-based policies. You can use tags
   * to restrict access to only an IAM role that has a specified tag attached. You
   * can also restrict access to only those resources that have a certain tag
   * attached. For examples of policies that show how to use tags to control access,
   * see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html">Control
   * access using IAM tags</a> in the <i>IAM User Guide</i>.</p> </li> <li> <p>
   * <b>Cost allocation</b> - Use tags to help track which individuals and teams are
   * using which Amazon Web Services resources.</p> </li> </ul>  <ul> <li>
   * <p>If any one of the tags is invalid or if you exceed the allowed maximum number
   * of tags, then the entire request fails and the resource is not created. For more
   * information about tagging, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html">Tagging IAM
   * resources</a> in the <i>IAM User Guide</i>.</p> </li> <li> <p>Amazon Web
   * Services always interprets the tag <code>Value</code> as a single string. If you
   * need to store an array, you can store comma-separated values in the string.
   * However, you must interpret the value in your code.</p> </li> </ul>
   * <p>For more information about tagging, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html">Tagging IAM
   * identities</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/TagRole">AWS API
   * Reference</a></p>
   */
  virtual Model::TagRoleOutcome TagRole(const Model::TagRoleRequest& request) const;

  /**
   * A Callable wrapper for TagRole that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename TagRoleRequestT = Model::TagRoleRequest>
  Model::TagRoleOutcomeCallable TagRoleCallable(const TagRoleRequestT& request) const {
    return SubmitCallable(&IAMClient::TagRole, request);
  }

  /**
   * An Async wrapper for TagRole that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Adds one or more tags to a Security Assertion Markup Language (SAML) identity
   * provider. For more information about these providers, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_saml.html">About
   * SAML 2.0-based federation </a>. If a tag with the same key name already exists,
   * then that tag is overwritten with the new value.</p> <p>A tag consists of a key
   * name and an associated value. By assigning tags to your resources, you can do
   * the following:</p> <ul> <li> <p> <b>Administrative grouping and discovery</b> -
   * Attach tags to resources to aid in organization and search. For example, you
   * could search for all resources with the key name <i>Project</i> and the value
   * <i>MyImportantProject</i>. Or search for all resources with the key name <i>Cost
   * Center</i> and the value <i>41200</i>. </p> </li> <li> <p> <b>Access control</b>
   * - Include tags in IAM user-based and resource-based policies. You can use tags
   * to restrict access to only a SAML identity provider that has a specified tag
   * attached. For examples of policies that show how to use tags to control access,
   * see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html">Control
   * access using IAM tags</a> in the <i>IAM User Guide</i>.</p> </li> </ul>
   * <ul> <li> <p>If any one of the tags is invalid or if you exceed the allowed
   * maximum number of tags, then the entire request fails and the resource is not
   * created. For more information about tagging, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html">Tagging IAM
   * resources</a> in the <i>IAM User Guide</i>.</p> </li> <li> <p>Amazon Web
   * Services always interprets the tag <code>Value</code> as a single string. If you
   * need to store an array, you can store comma-separated values in the string.
   * However, you must interpret the value in your code.</p> </li> </ul>
   * <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/TagSAMLProvider">AWS
   * API Reference</a></p>
   */
  virtual Model::TagSAMLProviderOutcome TagSAMLProvider(const Model::TagSAMLProviderRequest& request) const;

  /**
   * A Callable wrapper for TagSAMLProvider that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename TagSAMLProviderRequestT = Model::TagSAMLProviderRequest>
  Model::TagSAMLProviderOutcomeCallable TagSAMLProviderCallable(const TagSAMLProviderRequestT& request) const {
    return SubmitCallable(&IAMClient::TagSAMLProvider, request);
  }

  /**
   * An Async wrapper for TagSAMLProvider that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Adds one or more tags to an IAM server certificate. If a tag with the same
   * key name already exists, then that tag is overwritten with the new value.</p>
   *  <p>For certificates in a Region supported by Certificate Manager (ACM),
   * we recommend that you don't use IAM server certificates. Instead, use ACM to
   * provision, manage, and deploy your server certificates. For more information
   * about IAM server certificates, <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html">Working
   * with server certificates</a> in the <i>IAM User Guide</i>.</p>  <p>A tag
   * consists of a key name and an associated value. By assigning tags to your
   * resources, you can do the following:</p> <ul> <li> <p> <b>Administrative
   * grouping and discovery</b> - Attach tags to resources to aid in organization and
   * search. For example, you could search for all resources with the key name
   * <i>Project</i> and the value <i>MyImportantProject</i>. Or search for all
   * resources with the key name <i>Cost Center</i> and the value <i>41200</i>. </p>
   * </li> <li> <p> <b>Access control</b> - Include tags in IAM user-based and
   * resource-based policies. You can use tags to restrict access to only a server
   * certificate that has a specified tag attached. For examples of policies that
   * show how to use tags to control access, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html">Control
   * access using IAM tags</a> in the <i>IAM User Guide</i>.</p> </li> <li> <p>
   * <b>Cost allocation</b> - Use tags to help track which individuals and teams are
   * using which Amazon Web Services resources.</p> </li> </ul>  <ul> <li>
   * <p>If any one of the tags is invalid or if you exceed the allowed maximum number
   * of tags, then the entire request fails and the resource is not created. For more
   * information about tagging, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html">Tagging IAM
   * resources</a> in the <i>IAM User Guide</i>.</p> </li> <li> <p>Amazon Web
   * Services always interprets the tag <code>Value</code> as a single string. If you
   * need to store an array, you can store comma-separated values in the string.
   * However, you must interpret the value in your code.</p> </li> </ul>
   * <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/TagServerCertificate">AWS
   * API Reference</a></p>
   */
  virtual Model::TagServerCertificateOutcome TagServerCertificate(const Model::TagServerCertificateRequest& request) const;

  /**
   * A Callable wrapper for TagServerCertificate that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename TagServerCertificateRequestT = Model::TagServerCertificateRequest>
  Model::TagServerCertificateOutcomeCallable TagServerCertificateCallable(const TagServerCertificateRequestT& request) const {
    return SubmitCallable(&IAMClient::TagServerCertificate, request);
  }

  /**
   * An Async wrapper for TagServerCertificate that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Adds one or more tags to an IAM user. If a tag with the same key name already
   * exists, then that tag is overwritten with the new value.</p> <p>A tag consists
   * of a key name and an associated value. By assigning tags to your resources, you
   * can do the following:</p> <ul> <li> <p> <b>Administrative grouping and
   * discovery</b> - Attach tags to resources to aid in organization and search. For
   * example, you could search for all resources with the key name <i>Project</i> and
   * the value <i>MyImportantProject</i>. Or search for all resources with the key
   * name <i>Cost Center</i> and the value <i>41200</i>. </p> </li> <li> <p>
   * <b>Access control</b> - Include tags in IAM identity-based and resource-based
   * policies. You can use tags to restrict access to only an IAM requesting user
   * that has a specified tag attached. You can also restrict access to only those
   * resources that have a certain tag attached. For examples of policies that show
   * how to use tags to control access, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html">Control
   * access using IAM tags</a> in the <i>IAM User Guide</i>.</p> </li> <li> <p>
   * <b>Cost allocation</b> - Use tags to help track which individuals and teams are
   * using which Amazon Web Services resources.</p> </li> </ul>  <ul> <li>
   * <p>If any one of the tags is invalid or if you exceed the allowed maximum number
   * of tags, then the entire request fails and the resource is not created. For more
   * information about tagging, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html">Tagging IAM
   * resources</a> in the <i>IAM User Guide</i>.</p> </li> <li> <p>Amazon Web
   * Services always interprets the tag <code>Value</code> as a single string. If you
   * need to store an array, you can store comma-separated values in the string.
   * However, you must interpret the value in your code.</p> </li> </ul>
   * <p>For more information about tagging, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html">Tagging IAM
   * identities</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/TagUser">AWS API
   * Reference</a></p>
   */
  virtual Model::TagUserOutcome TagUser(const Model::TagUserRequest& request) const;

  /**
   * A Callable wrapper for TagUser that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename TagUserRequestT = Model::TagUserRequest>
  Model::TagUserOutcomeCallable TagUserCallable(const TagUserRequestT& request) const {
    return SubmitCallable(&IAMClient::TagUser, request);
  }

  /**
   * An Async wrapper for TagUser that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Removes the specified tags from the IAM instance profile. For more
   * information about tagging, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html">Tagging IAM
   * resources</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UntagInstanceProfile">AWS
   * API Reference</a></p>
   */
  virtual Model::UntagInstanceProfileOutcome UntagInstanceProfile(const Model::UntagInstanceProfileRequest& request) const;

  /**
   * A Callable wrapper for UntagInstanceProfile that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename UntagInstanceProfileRequestT = Model::UntagInstanceProfileRequest>
  Model::UntagInstanceProfileOutcomeCallable UntagInstanceProfileCallable(const UntagInstanceProfileRequestT& request) const {
    return SubmitCallable(&IAMClient::UntagInstanceProfile, request);
  }

  /**
   * An Async wrapper for UntagInstanceProfile that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Removes the specified tags from the IAM virtual multi-factor authentication
   * (MFA) device. For more information about tagging, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html">Tagging IAM
   * resources</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UntagMFADevice">AWS
   * API Reference</a></p>
   */
  virtual Model::UntagMFADeviceOutcome UntagMFADevice(const Model::UntagMFADeviceRequest& request) const;

  /**
   * A Callable wrapper for UntagMFADevice that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename UntagMFADeviceRequestT = Model::UntagMFADeviceRequest>
  Model::UntagMFADeviceOutcomeCallable UntagMFADeviceCallable(const UntagMFADeviceRequestT& request) const {
    return SubmitCallable(&IAMClient::UntagMFADevice, request);
  }

  /**
   * An Async wrapper for UntagMFADevice that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Removes the specified tags from the specified OpenID Connect
   * (OIDC)-compatible identity provider in IAM. For more information about OIDC
   * providers, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc.html">About
   * web identity federation</a>. For more information about tagging, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html">Tagging IAM
   * resources</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UntagOpenIDConnectProvider">AWS
   * API Reference</a></p>
   */
  virtual Model::UntagOpenIDConnectProviderOutcome UntagOpenIDConnectProvider(
      const Model::UntagOpenIDConnectProviderRequest& request) const;

  /**
   * A Callable wrapper for UntagOpenIDConnectProvider that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename UntagOpenIDConnectProviderRequestT = Model::UntagOpenIDConnectProviderRequest>
  Model::UntagOpenIDConnectProviderOutcomeCallable UntagOpenIDConnectProviderCallable(
      const UntagOpenIDConnectProviderRequestT& request) const {
    return SubmitCallable(&IAMClient::UntagOpenIDConnectProvider, request);
  }

  /**
   * An Async wrapper for UntagOpenIDConnectProvider that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Removes the specified tags from the customer managed policy. For more
   * information about tagging, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html">Tagging IAM
   * resources</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UntagPolicy">AWS API
   * Reference</a></p>
   */
  virtual Model::UntagPolicyOutcome UntagPolicy(const Model::UntagPolicyRequest& request) const;

  /**
   * A Callable wrapper for UntagPolicy that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename UntagPolicyRequestT = Model::UntagPolicyRequest>
  Model::UntagPolicyOutcomeCallable UntagPolicyCallable(const UntagPolicyRequestT& request) const {
    return SubmitCallable(&IAMClient::UntagPolicy, request);
  }

  /**
   * An Async wrapper for UntagPolicy that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Removes the specified tags from the role. For more information about tagging,
   * see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html">Tagging IAM
   * resources</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UntagRole">AWS API
   * Reference</a></p>
   */
  virtual Model::UntagRoleOutcome UntagRole(const Model::UntagRoleRequest& request) const;

  /**
   * A Callable wrapper for UntagRole that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename UntagRoleRequestT = Model::UntagRoleRequest>
  Model::UntagRoleOutcomeCallable UntagRoleCallable(const UntagRoleRequestT& request) const {
    return SubmitCallable(&IAMClient::UntagRole, request);
  }

  /**
   * An Async wrapper for UntagRole that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Removes the specified tags from the specified Security Assertion Markup
   * Language (SAML) identity provider in IAM. For more information about these
   * providers, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc.html">About
   * web identity federation</a>. For more information about tagging, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html">Tagging IAM
   * resources</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UntagSAMLProvider">AWS
   * API Reference</a></p>
   */
  virtual Model::UntagSAMLProviderOutcome UntagSAMLProvider(const Model::UntagSAMLProviderRequest& request) const;

  /**
   * A Callable wrapper for UntagSAMLProvider that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename UntagSAMLProviderRequestT = Model::UntagSAMLProviderRequest>
  Model::UntagSAMLProviderOutcomeCallable UntagSAMLProviderCallable(const UntagSAMLProviderRequestT& request) const {
    return SubmitCallable(&IAMClient::UntagSAMLProvider, request);
  }

  /**
   * An Async wrapper for UntagSAMLProvider that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Removes the specified tags from the IAM server certificate. For more
   * information about tagging, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html">Tagging IAM
   * resources</a> in the <i>IAM User Guide</i>.</p>  <p>For certificates in a
   * Region supported by Certificate Manager (ACM), we recommend that you don't use
   * IAM server certificates. Instead, use ACM to provision, manage, and deploy your
   * server certificates. For more information about IAM server certificates, <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html">Working
   * with server certificates</a> in the <i>IAM User Guide</i>.</p> <p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UntagServerCertificate">AWS
   * API Reference</a></p>
   */
  virtual Model::UntagServerCertificateOutcome UntagServerCertificate(const Model::UntagServerCertificateRequest& request) const;

  /**
   * A Callable wrapper for UntagServerCertificate that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename UntagServerCertificateRequestT = Model::UntagServerCertificateRequest>
  Model::UntagServerCertificateOutcomeCallable UntagServerCertificateCallable(const UntagServerCertificateRequestT& request) const {
    return SubmitCallable(&IAMClient::UntagServerCertificate, request);
  }

  /**
   * An Async wrapper for UntagServerCertificate that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Removes the specified tags from the user. For more information about tagging,
   * see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html">Tagging IAM
   * resources</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UntagUser">AWS API
   * Reference</a></p>
   */
  virtual Model::UntagUserOutcome UntagUser(const Model::UntagUserRequest& request) const;

  /**
   * A Callable wrapper for UntagUser that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename UntagUserRequestT = Model::UntagUserRequest>
  Model::UntagUserOutcomeCallable UntagUserCallable(const UntagUserRequestT& request) const {
    return SubmitCallable(&IAMClient::UntagUser, request);
  }

  /**
   * An Async wrapper for UntagUser that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Changes the status of the specified access key from Active to Inactive, or
   * vice versa. This operation can be used to disable a user's key as part of a key
   * rotation workflow.</p> <p>If the <code>UserName</code> is not specified, the
   * user name is determined implicitly based on the Amazon Web Services access key
   * ID used to sign the request. If a temporary access key is used, then
   * <code>UserName</code> is required. If a long-term key is assigned to the user,
   * then <code>UserName</code> is not required. This operation works for access keys
   * under the Amazon Web Services account. Consequently, you can use this operation
   * to manage Amazon Web Services account root user credentials even if the Amazon
   * Web Services account has no associated users.</p> <p>For information about
   * rotating keys, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/ManagingCredentials.html">Managing
   * keys and certificates</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateAccessKey">AWS
   * API Reference</a></p>
   */
  virtual Model::UpdateAccessKeyOutcome UpdateAccessKey(const Model::UpdateAccessKeyRequest& request) const;

  /**
   * A Callable wrapper for UpdateAccessKey that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename UpdateAccessKeyRequestT = Model::UpdateAccessKeyRequest>
  Model::UpdateAccessKeyOutcomeCallable UpdateAccessKeyCallable(const UpdateAccessKeyRequestT& request) const {
    return SubmitCallable(&IAMClient::UpdateAccessKey, request);
  }

  /**
   * An Async wrapper for UpdateAccessKey that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Updates the password policy settings for the Amazon Web Services account.</p>
   *  <p>This operation does not support partial updates. No parameters are
   * required, but if you do not specify a parameter, that parameter's value reverts
   * to its default value. See the <b>Request Parameters</b> section for each
   * parameter's default value. Also note that some parameters do not allow the
   * default parameter to be explicitly set. Instead, to invoke the default value, do
   * not include that parameter when you invoke the operation.</p>  <p> For
   * more information about using a password policy, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_ManagingPasswordPolicies.html">Managing
   * an IAM password policy</a> in the <i>IAM User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateAccountPasswordPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::UpdateAccountPasswordPolicyOutcome UpdateAccountPasswordPolicy(
      const Model::UpdateAccountPasswordPolicyRequest& request = {}) const;

  /**
   * A Callable wrapper for UpdateAccountPasswordPolicy that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename UpdateAccountPasswordPolicyRequestT = Model::UpdateAccountPasswordPolicyRequest>
  Model::UpdateAccountPasswordPolicyOutcomeCallable UpdateAccountPasswordPolicyCallable(
      const UpdateAccountPasswordPolicyRequestT& request = {}) const {
    return SubmitCallable(&IAMClient::UpdateAccountPasswordPolicy, request);
  }

  /**
   * An Async wrapper for UpdateAccountPasswordPolicy that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Updates the policy that grants an IAM entity permission to assume a role.
   * This is typically referred to as the "role trust policy". For more information
   * about roles, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-toplevel.html">Using
   * roles to delegate permissions and federate identities</a>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateAssumeRolePolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::UpdateAssumeRolePolicyOutcome UpdateAssumeRolePolicy(const Model::UpdateAssumeRolePolicyRequest& request) const;

  /**
   * A Callable wrapper for UpdateAssumeRolePolicy that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename UpdateAssumeRolePolicyRequestT = Model::UpdateAssumeRolePolicyRequest>
  Model::UpdateAssumeRolePolicyOutcomeCallable UpdateAssumeRolePolicyCallable(const UpdateAssumeRolePolicyRequestT& request) const {
    return SubmitCallable(&IAMClient::UpdateAssumeRolePolicy, request);
  }

  /**
   * An Async wrapper for UpdateAssumeRolePolicy that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Updates an existing delegation request with additional information. When the
   * delegation request is updated, it reaches the <code>PENDING_APPROVAL</code>
   * state. </p> <p>Once a delegation request has an owner, that owner gets a default
   * permission to update the delegation request. For more details, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-temporary-delegation.html#temporary-delegation-managing-permissions">
   * Managing Permissions for Delegation Requests</a>. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateDelegationRequest">AWS
   * API Reference</a></p>
   */
  virtual Model::UpdateDelegationRequestOutcome UpdateDelegationRequest(const Model::UpdateDelegationRequestRequest& request) const;

  /**
   * A Callable wrapper for UpdateDelegationRequest that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename UpdateDelegationRequestRequestT = Model::UpdateDelegationRequestRequest>
  Model::UpdateDelegationRequestOutcomeCallable UpdateDelegationRequestCallable(const UpdateDelegationRequestRequestT& request) const {
    return SubmitCallable(&IAMClient::UpdateDelegationRequest, request);
  }

  /**
   * An Async wrapper for UpdateDelegationRequest that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Updates the name and/or the path of the specified IAM group.</p>
   * <p> You should understand the implications of changing a group's path or name.
   * For more information, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_WorkingWithGroupsAndUsers.html">Renaming
   * users and groups</a> in the <i>IAM User Guide</i>.</p>
   * <p>The person making the request (the principal), must have permission to change
   * the role group with the old name and the new name. For example, to change the
   * group named <code>Managers</code> to <code>MGRs</code>, the principal must have
   * a policy that allows them to update both groups. If the principal has permission
   * to update the <code>Managers</code> group, but not the <code>MGRs</code> group,
   * then the update fails. For more information about permissions, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html">Access
   * management</a>. </p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateGroup">AWS API
   * Reference</a></p>
   */
  virtual Model::UpdateGroupOutcome UpdateGroup(const Model::UpdateGroupRequest& request) const;

  /**
   * A Callable wrapper for UpdateGroup that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename UpdateGroupRequestT = Model::UpdateGroupRequest>
  Model::UpdateGroupOutcomeCallable UpdateGroupCallable(const UpdateGroupRequestT& request) const {
    return SubmitCallable(&IAMClient::UpdateGroup, request);
  }

  /**
   * An Async wrapper for UpdateGroup that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Changes the password for the specified IAM user. You can use the CLI, the
   * Amazon Web Services API, or the <b>Users</b> page in the IAM console to change
   * the password for any IAM user. Use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_ChangePassword.html">ChangePassword</a>
   * to change your own password in the <b>My Security Credentials</b> page in the
   * Amazon Web Services Management Console.</p> <p>For more information about
   * modifying passwords, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_ManagingLogins.html">Managing
   * passwords</a> in the <i>IAM User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateLoginProfile">AWS
   * API Reference</a></p>
   */
  virtual Model::UpdateLoginProfileOutcome UpdateLoginProfile(const Model::UpdateLoginProfileRequest& request) const;

  /**
   * A Callable wrapper for UpdateLoginProfile that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename UpdateLoginProfileRequestT = Model::UpdateLoginProfileRequest>
  Model::UpdateLoginProfileOutcomeCallable UpdateLoginProfileCallable(const UpdateLoginProfileRequestT& request) const {
    return SubmitCallable(&IAMClient::UpdateLoginProfile, request);
  }

  /**
   * An Async wrapper for UpdateLoginProfile that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Replaces the existing list of server certificate thumbprints associated with
   * an OpenID Connect (OIDC) provider resource object with a new list of
   * thumbprints.</p> <p>The list that you pass with this operation completely
   * replaces the existing list of thumbprints. (The lists are not merged.)</p>
   * <p>Typically, you need to update a thumbprint only when the identity provider
   * certificate changes, which occurs rarely. However, if the provider's certificate
   * <i>does</i> change, any attempt to assume an IAM role that specifies the OIDC
   * provider as a principal fails until the certificate thumbprint is updated.</p>
   *  <p>Amazon Web Services secures communication with OIDC identity providers
   * (IdPs) using our library of trusted root certificate authorities (CAs) to verify
   * the JSON Web Key Set (JWKS) endpoint's TLS certificate. If your OIDC IdP relies
   * on a certificate that is not signed by one of these trusted CAs, only then we
   * secure communication using the thumbprints set in the IdP's configuration.</p>
   *   <p>Trust for the OIDC provider is derived from the provider
   * certificate and is validated by the thumbprint. Therefore, it is best to limit
   * access to the <code>UpdateOpenIDConnectProviderThumbprint</code> operation to
   * highly privileged users.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateOpenIDConnectProviderThumbprint">AWS
   * API Reference</a></p>
   */
  virtual Model::UpdateOpenIDConnectProviderThumbprintOutcome UpdateOpenIDConnectProviderThumbprint(
      const Model::UpdateOpenIDConnectProviderThumbprintRequest& request) const;

  /**
   * A Callable wrapper for UpdateOpenIDConnectProviderThumbprint that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename UpdateOpenIDConnectProviderThumbprintRequestT = Model::UpdateOpenIDConnectProviderThumbprintRequest>
  Model::UpdateOpenIDConnectProviderThumbprintOutcomeCallable UpdateOpenIDConnectProviderThumbprintCallable(
      const UpdateOpenIDConnectProviderThumbprintRequestT& request) const {
    return SubmitCallable(&IAMClient::UpdateOpenIDConnectProviderThumbprint, request);
  }

  /**
   * An Async wrapper for UpdateOpenIDConnectProviderThumbprint that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  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);
  }

  /**
   * <p>Updates the description or maximum session duration setting of a
   * role.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateRole">AWS API
   * Reference</a></p>
   */
  virtual Model::UpdateRoleOutcome UpdateRole(const Model::UpdateRoleRequest& request) const;

  /**
   * A Callable wrapper for UpdateRole that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename UpdateRoleRequestT = Model::UpdateRoleRequest>
  Model::UpdateRoleOutcomeCallable UpdateRoleCallable(const UpdateRoleRequestT& request) const {
    return SubmitCallable(&IAMClient::UpdateRole, request);
  }

  /**
   * An Async wrapper for UpdateRole that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Use <a
   * href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateRole.html">UpdateRole</a>
   * instead.</p> <p>Modifies only the description of a role. This operation performs
   * the same function as the <code>Description</code> parameter in the
   * <code>UpdateRole</code> operation.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateRoleDescription">AWS
   * API Reference</a></p>
   */
  virtual Model::UpdateRoleDescriptionOutcome UpdateRoleDescription(const Model::UpdateRoleDescriptionRequest& request) const;

  /**
   * A Callable wrapper for UpdateRoleDescription that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename UpdateRoleDescriptionRequestT = Model::UpdateRoleDescriptionRequest>
  Model::UpdateRoleDescriptionOutcomeCallable UpdateRoleDescriptionCallable(const UpdateRoleDescriptionRequestT& request) const {
    return SubmitCallable(&IAMClient::UpdateRoleDescription, request);
  }

  /**
   * An Async wrapper for UpdateRoleDescription that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Updates the metadata document, SAML encryption settings, and private keys for
   * an existing SAML provider. To rotate private keys, add your new private key and
   * then remove the old key in a separate request.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateSAMLProvider">AWS
   * API Reference</a></p>
   */
  virtual Model::UpdateSAMLProviderOutcome UpdateSAMLProvider(const Model::UpdateSAMLProviderRequest& request) const;

  /**
   * A Callable wrapper for UpdateSAMLProvider that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename UpdateSAMLProviderRequestT = Model::UpdateSAMLProviderRequest>
  Model::UpdateSAMLProviderOutcomeCallable UpdateSAMLProviderCallable(const UpdateSAMLProviderRequestT& request) const {
    return SubmitCallable(&IAMClient::UpdateSAMLProvider, request);
  }

  /**
   * An Async wrapper for UpdateSAMLProvider that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Sets the status of an IAM user's SSH public key to active or inactive. SSH
   * public keys that are inactive cannot be used for authentication. This operation
   * can be used to disable a user's SSH public key as part of a key rotation work
   * flow.</p> <p>The SSH public key affected by this operation is used only for
   * authenticating the associated IAM user to an CodeCommit repository. For more
   * information about using SSH keys to authenticate to an CodeCommit repository,
   * see <a
   * href="https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up-credentials-ssh.html">Set
   * up CodeCommit for SSH connections</a> in the <i>CodeCommit User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateSSHPublicKey">AWS
   * API Reference</a></p>
   */
  virtual Model::UpdateSSHPublicKeyOutcome UpdateSSHPublicKey(const Model::UpdateSSHPublicKeyRequest& request) const;

  /**
   * A Callable wrapper for UpdateSSHPublicKey that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename UpdateSSHPublicKeyRequestT = Model::UpdateSSHPublicKeyRequest>
  Model::UpdateSSHPublicKeyOutcomeCallable UpdateSSHPublicKeyCallable(const UpdateSSHPublicKeyRequestT& request) const {
    return SubmitCallable(&IAMClient::UpdateSSHPublicKey, request);
  }

  /**
   * An Async wrapper for UpdateSSHPublicKey that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Updates the name and/or the path of the specified server certificate stored
   * in IAM.</p> <p>For more information about working with server certificates, see
   * <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html">Working
   * with server certificates</a> in the <i>IAM User Guide</i>. This topic also
   * includes a list of Amazon Web Services services that can use the server
   * certificates that you manage with IAM.</p>  <p>You should understand
   * the implications of changing a server certificate's path or name. For more
   * information, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs_manage.html#RenamingServerCerts">Renaming
   * a server certificate</a> in the <i>IAM User Guide</i>.</p>
   * <p>The person making the request (the principal), must have permission to change
   * the server certificate with the old name and the new name. For example, to
   * change the certificate named <code>ProductionCert</code> to
   * <code>ProdCert</code>, the principal must have a policy that allows them to
   * update both certificates. If the principal has permission to update the
   * <code>ProductionCert</code> group, but not the <code>ProdCert</code>
   * certificate, then the update fails. For more information about permissions, see
   * <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html">Access
   * management</a> in the <i>IAM User Guide</i>.</p> <p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateServerCertificate">AWS
   * API Reference</a></p>
   */
  virtual Model::UpdateServerCertificateOutcome UpdateServerCertificate(const Model::UpdateServerCertificateRequest& request) const;

  /**
   * A Callable wrapper for UpdateServerCertificate that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename UpdateServerCertificateRequestT = Model::UpdateServerCertificateRequest>
  Model::UpdateServerCertificateOutcomeCallable UpdateServerCertificateCallable(const UpdateServerCertificateRequestT& request) const {
    return SubmitCallable(&IAMClient::UpdateServerCertificate, request);
  }

  /**
   * An Async wrapper for UpdateServerCertificate that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Sets the status of a service-specific credential to <code>Active</code> or
   * <code>Inactive</code>. Service-specific credentials that are inactive cannot be
   * used for authentication to the service. This operation can be used to disable a
   * user's service-specific credential as part of a credential rotation work
   * flow.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateServiceSpecificCredential">AWS
   * API Reference</a></p>
   */
  virtual Model::UpdateServiceSpecificCredentialOutcome UpdateServiceSpecificCredential(
      const Model::UpdateServiceSpecificCredentialRequest& request) const;

  /**
   * A Callable wrapper for UpdateServiceSpecificCredential that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename UpdateServiceSpecificCredentialRequestT = Model::UpdateServiceSpecificCredentialRequest>
  Model::UpdateServiceSpecificCredentialOutcomeCallable UpdateServiceSpecificCredentialCallable(
      const UpdateServiceSpecificCredentialRequestT& request) const {
    return SubmitCallable(&IAMClient::UpdateServiceSpecificCredential, request);
  }

  /**
   * An Async wrapper for UpdateServiceSpecificCredential that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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);
  }

  /**
   * <p>Changes the status of the specified user signing certificate from active to
   * disabled, or vice versa. This operation can be used to disable an IAM user's
   * signing certificate as part of a certificate rotation work flow.</p> <p>If the
   * <code>UserName</code> field is not specified, the user name is determined
   * implicitly based on the Amazon Web Services access key ID used to sign the
   * request. This operation works for access keys under the Amazon Web Services
   * account. Consequently, you can use this operation to manage Amazon Web Services
   * account root user credentials even if the Amazon Web Services account has no
   * associated users.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateSigningCertificate">AWS
   * API Reference</a></p>
   */
  virtual Model::UpdateSigningCertificateOutcome UpdateSigningCertificate(const Model::UpdateSigningCertificateRequest& request) const;

  /**
   * A Callable wrapper for UpdateSigningCertificate that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename UpdateSigningCertificateRequestT = Model::UpdateSigningCertificateRequest>
  Model::UpdateSigningCertificateOutcomeCallable UpdateSigningCertificateCallable(const UpdateSigningCertificateRequestT& request) const {
    return SubmitCallable(&IAMClient::UpdateSigningCertificate, request);
  }

  /**
   * An Async wrapper for UpdateSigningCertificate that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Updates the name and/or the path of the specified IAM user.</p>
   * <p> You should understand the implications of changing an IAM user's path or
   * name. For more information, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_manage.html#id_users_renaming">Renaming
   * an IAM user</a> and <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups_manage_rename.html">Renaming
   * an IAM group</a> in the <i>IAM User Guide</i>.</p>   <p> To
   * change a user name, the requester must have appropriate permissions on both the
   * source object and the target object. For example, to change Bob to Robert, the
   * entity making the request must have permission on Bob and Robert, or must have
   * permission on all (*). For more information about permissions, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/PermissionsAndPolicies.html">Permissions
   * and policies</a>. </p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateUser">AWS API
   * Reference</a></p>
   */
  virtual Model::UpdateUserOutcome UpdateUser(const Model::UpdateUserRequest& request) const;

  /**
   * A Callable wrapper for UpdateUser that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename UpdateUserRequestT = Model::UpdateUserRequest>
  Model::UpdateUserOutcomeCallable UpdateUserCallable(const UpdateUserRequestT& request) const {
    return SubmitCallable(&IAMClient::UpdateUser, request);
  }

  /**
   * An Async wrapper for UpdateUser that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Uploads an SSH public key and associates it with the specified IAM user.</p>
   * <p>The SSH public key uploaded by this operation can be used only for
   * authenticating the associated IAM user to an CodeCommit repository. For more
   * information about using SSH keys to authenticate to an CodeCommit repository,
   * see <a
   * href="https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up-credentials-ssh.html">Set
   * up CodeCommit for SSH connections</a> in the <i>CodeCommit User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UploadSSHPublicKey">AWS
   * API Reference</a></p>
   */
  virtual Model::UploadSSHPublicKeyOutcome UploadSSHPublicKey(const Model::UploadSSHPublicKeyRequest& request) const;

  /**
   * A Callable wrapper for UploadSSHPublicKey that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename UploadSSHPublicKeyRequestT = Model::UploadSSHPublicKeyRequest>
  Model::UploadSSHPublicKeyOutcomeCallable UploadSSHPublicKeyCallable(const UploadSSHPublicKeyRequestT& request) const {
    return SubmitCallable(&IAMClient::UploadSSHPublicKey, request);
  }

  /**
   * An Async wrapper for UploadSSHPublicKey that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Uploads a server certificate entity for the Amazon Web Services account. The
   * server certificate entity includes a public key certificate, a private key, and
   * an optional certificate chain, which should all be PEM-encoded.</p> <p>We
   * recommend that you use <a href="https://docs.aws.amazon.com/acm/">Certificate
   * Manager</a> to provision, manage, and deploy your server certificates. With ACM
   * you can request a certificate, deploy it to Amazon Web Services resources, and
   * let ACM handle certificate renewals for you. Certificates provided by ACM are
   * free. For more information about using ACM, see the <a
   * href="https://docs.aws.amazon.com/acm/latest/userguide/">Certificate Manager
   * User Guide</a>.</p> <p>For more information about working with server
   * certificates, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html">Working
   * with server certificates</a> in the <i>IAM User Guide</i>. This topic includes a
   * list of Amazon Web Services services that can use the server certificates that
   * you manage with IAM.</p> <p>For information about the number of server
   * certificates you can upload, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html">IAM
   * and STS quotas</a> in the <i>IAM User Guide</i>.</p>  <p>Because the body
   * of the public key certificate, private key, and the certificate chain can be
   * large, you should use POST rather than GET when calling
   * <code>UploadServerCertificate</code>. For information about setting up
   * signatures and authorization through the API, see <a
   * href="https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html">Signing
   * Amazon Web Services API requests</a> in the <i>Amazon Web Services General
   * Reference</i>. For general information about using the Query API with IAM, see
   * <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/programming.html">Calling
   * the API by making HTTP query requests</a> in the <i>IAM User Guide</i>.</p>
   * <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UploadServerCertificate">AWS
   * API Reference</a></p>
   */
  virtual Model::UploadServerCertificateOutcome UploadServerCertificate(const Model::UploadServerCertificateRequest& request) const;

  /**
   * A Callable wrapper for UploadServerCertificate that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename UploadServerCertificateRequestT = Model::UploadServerCertificateRequest>
  Model::UploadServerCertificateOutcomeCallable UploadServerCertificateCallable(const UploadServerCertificateRequestT& request) const {
    return SubmitCallable(&IAMClient::UploadServerCertificate, request);
  }

  /**
   * An Async wrapper for UploadServerCertificate that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Uploads an X.509 signing certificate and associates it with the specified IAM
   * user. Some Amazon Web Services services require you to use certificates to
   * validate requests that are signed with a corresponding private key. When you
   * upload the certificate, its default status is <code>Active</code>.</p> <p>For
   * information about when you would use an X.509 signing certificate, see <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html">Managing
   * server certificates in IAM</a> in the <i>IAM User Guide</i>.</p> <p>If the
   * <code>UserName</code> is not specified, the IAM user name is determined
   * implicitly based on the Amazon Web Services access key ID used to sign the
   * request. This operation works for access keys under the Amazon Web Services
   * account. Consequently, you can use this operation to manage Amazon Web Services
   * account root user credentials even if the Amazon Web Services account has no
   * associated users.</p>  <p>Because the body of an X.509 certificate can be
   * large, you should use POST rather than GET when calling
   * <code>UploadSigningCertificate</code>. For information about setting up
   * signatures and authorization through the API, see <a
   * href="https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html">Signing
   * Amazon Web Services API requests</a> in the <i>Amazon Web Services General
   * Reference</i>. For general information about using the Query API with IAM, see
   * <a
   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/IAM_UsingQueryAPI.html">Making
   * query requests</a> in the <i>IAM User Guide</i>.</p> <p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UploadSigningCertificate">AWS
   * API Reference</a></p>
   */
  virtual Model::UploadSigningCertificateOutcome UploadSigningCertificate(const Model::UploadSigningCertificateRequest& request) const;

  /**
   * A Callable wrapper for UploadSigningCertificate that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename UploadSigningCertificateRequestT = Model::UploadSigningCertificateRequest>
  Model::UploadSigningCertificateOutcomeCallable UploadSigningCertificateCallable(const UploadSigningCertificateRequestT& request) const {
    return SubmitCallable(&IAMClient::UploadSigningCertificate, request);
  }

  /**
   * An Async wrapper for UploadSigningCertificate that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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
