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

#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/rolesanywhere/RolesAnywherePaginationBase.h>
#include <aws/rolesanywhere/RolesAnywhereServiceClientModel.h>
#include <aws/rolesanywhere/RolesAnywhereWaiter.h>
#include <aws/rolesanywhere/RolesAnywhere_EXPORTS.h>

namespace Aws {
namespace RolesAnywhere {
/**
 * <p>Identity and Access Management Roles Anywhere provides a secure way for your
 * workloads such as servers, containers, and applications that run outside of
 * Amazon Web Services to obtain temporary Amazon Web Services credentials. Your
 * workloads can use the same IAM policies and roles you have for native Amazon Web
 * Services applications to access Amazon Web Services resources. Using IAM Roles
 * Anywhere eliminates the need to manage long-term credentials for workloads
 * running outside of Amazon Web Services.</p> <p> To use IAM Roles Anywhere, your
 * workloads must use X.509 certificates issued by their certificate authority
 * (CA). You register the CA with IAM Roles Anywhere as a trust anchor to establish
 * trust between your public key infrastructure (PKI) and IAM Roles Anywhere. If
 * you don't manage your own PKI system, you can use Private Certificate Authority
 * to create a CA and then use that to establish trust with IAM Roles Anywhere.
 * </p> <p>This guide describes the IAM Roles Anywhere operations that you can call
 * programmatically. For more information about IAM Roles Anywhere, see the <a
 * href="https://docs.aws.amazon.com/rolesanywhere/latest/userguide/introduction.html">IAM
 * Roles Anywhere User Guide</a>.</p>
 */
class AWS_ROLESANYWHERE_API RolesAnywhereClient : public Aws::Client::AWSJsonClient,
                                                  public Aws::Client::ClientWithAsyncTemplateMethods<RolesAnywhereClient>,
                                                  public RolesAnywherePaginationBase<RolesAnywhereClient>,
                                                  public RolesAnywhereWaiter<RolesAnywhereClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();

  typedef RolesAnywhereClientConfiguration ClientConfigurationType;
  typedef RolesAnywhereEndpointProvider 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.
   */
  RolesAnywhereClient(const Aws::RolesAnywhere::RolesAnywhereClientConfiguration& clientConfiguration =
                          Aws::RolesAnywhere::RolesAnywhereClientConfiguration(),
                      std::shared_ptr<RolesAnywhereEndpointProviderBase> 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.
   */
  RolesAnywhereClient(const Aws::Auth::AWSCredentials& credentials,
                      std::shared_ptr<RolesAnywhereEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::RolesAnywhere::RolesAnywhereClientConfiguration& clientConfiguration =
                          Aws::RolesAnywhere::RolesAnywhereClientConfiguration());

  /**
   * 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
   */
  RolesAnywhereClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      std::shared_ptr<RolesAnywhereEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::RolesAnywhere::RolesAnywhereClientConfiguration& clientConfiguration =
                          Aws::RolesAnywhere::RolesAnywhereClientConfiguration());

  /* 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.
   */
  RolesAnywhereClient(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.
   */
  RolesAnywhereClient(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
   */
  RolesAnywhereClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      const Aws::Client::ClientConfiguration& clientConfiguration);

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

  /**
   * <p>Creates a <i>profile</i>, a list of the roles that Roles Anywhere service is
   * trusted to assume. You use profiles to intersect permissions with IAM managed
   * policies.</p> <p> <b>Required permissions: </b>
   * <code>rolesanywhere:CreateProfile</code>. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/CreateProfile">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateProfileOutcome CreateProfile(const Model::CreateProfileRequest& request) const;

  /**
   * A Callable wrapper for CreateProfile that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename CreateProfileRequestT = Model::CreateProfileRequest>
  Model::CreateProfileOutcomeCallable CreateProfileCallable(const CreateProfileRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::CreateProfile, request);
  }

  /**
   * An Async wrapper for CreateProfile that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename CreateProfileRequestT = Model::CreateProfileRequest>
  void CreateProfileAsync(const CreateProfileRequestT& request, const CreateProfileResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::CreateProfile, request, handler, context);
  }

  /**
   * <p>Creates a trust anchor to establish trust between IAM Roles Anywhere and your
   * certificate authority (CA). You can define a trust anchor as a reference to an
   * Private Certificate Authority (Private CA) or by uploading a CA certificate.
   * Your Amazon Web Services workloads can authenticate with the trust anchor using
   * certificates issued by the CA in exchange for temporary Amazon Web Services
   * credentials.</p> <p> <b>Required permissions: </b>
   * <code>rolesanywhere:CreateTrustAnchor</code>. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/CreateTrustAnchor">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateTrustAnchorOutcome CreateTrustAnchor(const Model::CreateTrustAnchorRequest& request) const;

  /**
   * A Callable wrapper for CreateTrustAnchor that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename CreateTrustAnchorRequestT = Model::CreateTrustAnchorRequest>
  Model::CreateTrustAnchorOutcomeCallable CreateTrustAnchorCallable(const CreateTrustAnchorRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::CreateTrustAnchor, request);
  }

  /**
   * An Async wrapper for CreateTrustAnchor that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename CreateTrustAnchorRequestT = Model::CreateTrustAnchorRequest>
  void CreateTrustAnchorAsync(const CreateTrustAnchorRequestT& request, const CreateTrustAnchorResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::CreateTrustAnchor, request, handler, context);
  }

  /**
   * <p>Delete an entry from the attribute mapping rules enforced by a given
   * profile.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/DeleteAttributeMapping">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteAttributeMappingOutcome DeleteAttributeMapping(const Model::DeleteAttributeMappingRequest& request) const;

  /**
   * A Callable wrapper for DeleteAttributeMapping that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeleteAttributeMappingRequestT = Model::DeleteAttributeMappingRequest>
  Model::DeleteAttributeMappingOutcomeCallable DeleteAttributeMappingCallable(const DeleteAttributeMappingRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::DeleteAttributeMapping, request);
  }

  /**
   * An Async wrapper for DeleteAttributeMapping that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DeleteAttributeMappingRequestT = Model::DeleteAttributeMappingRequest>
  void DeleteAttributeMappingAsync(const DeleteAttributeMappingRequestT& request,
                                   const DeleteAttributeMappingResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::DeleteAttributeMapping, request, handler, context);
  }

  /**
   * <p>Deletes a certificate revocation list (CRL).</p> <p> <b>Required permissions:
   * </b> <code>rolesanywhere:DeleteCrl</code>. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/DeleteCrl">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteCrlOutcome DeleteCrl(const Model::DeleteCrlRequest& request) const;

  /**
   * A Callable wrapper for DeleteCrl that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename DeleteCrlRequestT = Model::DeleteCrlRequest>
  Model::DeleteCrlOutcomeCallable DeleteCrlCallable(const DeleteCrlRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::DeleteCrl, request);
  }

  /**
   * An Async wrapper for DeleteCrl that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename DeleteCrlRequestT = Model::DeleteCrlRequest>
  void DeleteCrlAsync(const DeleteCrlRequestT& request, const DeleteCrlResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::DeleteCrl, request, handler, context);
  }

  /**
   * <p>Deletes a profile.</p> <p> <b>Required permissions: </b>
   * <code>rolesanywhere:DeleteProfile</code>. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/DeleteProfile">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteProfileOutcome DeleteProfile(const Model::DeleteProfileRequest& request) const;

  /**
   * A Callable wrapper for DeleteProfile that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename DeleteProfileRequestT = Model::DeleteProfileRequest>
  Model::DeleteProfileOutcomeCallable DeleteProfileCallable(const DeleteProfileRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::DeleteProfile, request);
  }

  /**
   * An Async wrapper for DeleteProfile that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename DeleteProfileRequestT = Model::DeleteProfileRequest>
  void DeleteProfileAsync(const DeleteProfileRequestT& request, const DeleteProfileResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::DeleteProfile, request, handler, context);
  }

  /**
   * <p>Deletes a trust anchor.</p> <p> <b>Required permissions: </b>
   * <code>rolesanywhere:DeleteTrustAnchor</code>. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/DeleteTrustAnchor">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteTrustAnchorOutcome DeleteTrustAnchor(const Model::DeleteTrustAnchorRequest& request) const;

  /**
   * A Callable wrapper for DeleteTrustAnchor that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeleteTrustAnchorRequestT = Model::DeleteTrustAnchorRequest>
  Model::DeleteTrustAnchorOutcomeCallable DeleteTrustAnchorCallable(const DeleteTrustAnchorRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::DeleteTrustAnchor, request);
  }

  /**
   * An Async wrapper for DeleteTrustAnchor that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename DeleteTrustAnchorRequestT = Model::DeleteTrustAnchorRequest>
  void DeleteTrustAnchorAsync(const DeleteTrustAnchorRequestT& request, const DeleteTrustAnchorResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::DeleteTrustAnchor, request, handler, context);
  }

  /**
   * <p>Disables a certificate revocation list (CRL).</p> <p> <b>Required
   * permissions: </b> <code>rolesanywhere:DisableCrl</code>. </p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/DisableCrl">AWS
   * API Reference</a></p>
   */
  virtual Model::DisableCrlOutcome DisableCrl(const Model::DisableCrlRequest& request) const;

  /**
   * A Callable wrapper for DisableCrl that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename DisableCrlRequestT = Model::DisableCrlRequest>
  Model::DisableCrlOutcomeCallable DisableCrlCallable(const DisableCrlRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::DisableCrl, request);
  }

  /**
   * An Async wrapper for DisableCrl that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename DisableCrlRequestT = Model::DisableCrlRequest>
  void DisableCrlAsync(const DisableCrlRequestT& request, const DisableCrlResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::DisableCrl, request, handler, context);
  }

  /**
   * <p>Disables a profile. When disabled, temporary credential requests with this
   * profile fail.</p> <p> <b>Required permissions: </b>
   * <code>rolesanywhere:DisableProfile</code>. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/DisableProfile">AWS
   * API Reference</a></p>
   */
  virtual Model::DisableProfileOutcome DisableProfile(const Model::DisableProfileRequest& request) const;

  /**
   * A Callable wrapper for DisableProfile that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename DisableProfileRequestT = Model::DisableProfileRequest>
  Model::DisableProfileOutcomeCallable DisableProfileCallable(const DisableProfileRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::DisableProfile, request);
  }

  /**
   * An Async wrapper for DisableProfile that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename DisableProfileRequestT = Model::DisableProfileRequest>
  void DisableProfileAsync(const DisableProfileRequestT& request, const DisableProfileResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::DisableProfile, request, handler, context);
  }

  /**
   * <p>Disables a trust anchor. When disabled, temporary credential requests
   * specifying this trust anchor are unauthorized.</p> <p> <b>Required permissions:
   * </b> <code>rolesanywhere:DisableTrustAnchor</code>. </p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/DisableTrustAnchor">AWS
   * API Reference</a></p>
   */
  virtual Model::DisableTrustAnchorOutcome DisableTrustAnchor(const Model::DisableTrustAnchorRequest& request) const;

  /**
   * A Callable wrapper for DisableTrustAnchor that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DisableTrustAnchorRequestT = Model::DisableTrustAnchorRequest>
  Model::DisableTrustAnchorOutcomeCallable DisableTrustAnchorCallable(const DisableTrustAnchorRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::DisableTrustAnchor, request);
  }

  /**
   * An Async wrapper for DisableTrustAnchor that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename DisableTrustAnchorRequestT = Model::DisableTrustAnchorRequest>
  void DisableTrustAnchorAsync(const DisableTrustAnchorRequestT& request, const DisableTrustAnchorResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::DisableTrustAnchor, request, handler, context);
  }

  /**
   * <p>Enables a certificate revocation list (CRL). When enabled, certificates
   * stored in the CRL are unauthorized to receive session credentials.</p> <p>
   * <b>Required permissions: </b> <code>rolesanywhere:EnableCrl</code>.
   * </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/EnableCrl">AWS
   * API Reference</a></p>
   */
  virtual Model::EnableCrlOutcome EnableCrl(const Model::EnableCrlRequest& request) const;

  /**
   * A Callable wrapper for EnableCrl that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename EnableCrlRequestT = Model::EnableCrlRequest>
  Model::EnableCrlOutcomeCallable EnableCrlCallable(const EnableCrlRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::EnableCrl, request);
  }

  /**
   * An Async wrapper for EnableCrl that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename EnableCrlRequestT = Model::EnableCrlRequest>
  void EnableCrlAsync(const EnableCrlRequestT& request, const EnableCrlResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::EnableCrl, request, handler, context);
  }

  /**
   * <p>Enables temporary credential requests for a profile. </p> <p> <b>Required
   * permissions: </b> <code>rolesanywhere:EnableProfile</code>. </p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/EnableProfile">AWS
   * API Reference</a></p>
   */
  virtual Model::EnableProfileOutcome EnableProfile(const Model::EnableProfileRequest& request) const;

  /**
   * A Callable wrapper for EnableProfile that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename EnableProfileRequestT = Model::EnableProfileRequest>
  Model::EnableProfileOutcomeCallable EnableProfileCallable(const EnableProfileRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::EnableProfile, request);
  }

  /**
   * An Async wrapper for EnableProfile that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename EnableProfileRequestT = Model::EnableProfileRequest>
  void EnableProfileAsync(const EnableProfileRequestT& request, const EnableProfileResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::EnableProfile, request, handler, context);
  }

  /**
   * <p>Enables a trust anchor. When enabled, certificates in the trust anchor chain
   * are authorized for trust validation. </p> <p> <b>Required permissions: </b>
   * <code>rolesanywhere:EnableTrustAnchor</code>. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/EnableTrustAnchor">AWS
   * API Reference</a></p>
   */
  virtual Model::EnableTrustAnchorOutcome EnableTrustAnchor(const Model::EnableTrustAnchorRequest& request) const;

  /**
   * A Callable wrapper for EnableTrustAnchor that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename EnableTrustAnchorRequestT = Model::EnableTrustAnchorRequest>
  Model::EnableTrustAnchorOutcomeCallable EnableTrustAnchorCallable(const EnableTrustAnchorRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::EnableTrustAnchor, request);
  }

  /**
   * An Async wrapper for EnableTrustAnchor that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename EnableTrustAnchorRequestT = Model::EnableTrustAnchorRequest>
  void EnableTrustAnchorAsync(const EnableTrustAnchorRequestT& request, const EnableTrustAnchorResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::EnableTrustAnchor, request, handler, context);
  }

  /**
   * <p>Gets a certificate revocation list (CRL).</p> <p> <b>Required permissions:
   * </b> <code>rolesanywhere:GetCrl</code>. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/GetCrl">AWS
   * API Reference</a></p>
   */
  virtual Model::GetCrlOutcome GetCrl(const Model::GetCrlRequest& request) const;

  /**
   * A Callable wrapper for GetCrl that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename GetCrlRequestT = Model::GetCrlRequest>
  Model::GetCrlOutcomeCallable GetCrlCallable(const GetCrlRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::GetCrl, request);
  }

  /**
   * An Async wrapper for GetCrl that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename GetCrlRequestT = Model::GetCrlRequest>
  void GetCrlAsync(const GetCrlRequestT& request, const GetCrlResponseReceivedHandler& handler,
                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::GetCrl, request, handler, context);
  }

  /**
   * <p>Gets a profile.</p> <p> <b>Required permissions: </b>
   * <code>rolesanywhere:GetProfile</code>. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/GetProfile">AWS
   * API Reference</a></p>
   */
  virtual Model::GetProfileOutcome GetProfile(const Model::GetProfileRequest& request) const;

  /**
   * A Callable wrapper for GetProfile that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename GetProfileRequestT = Model::GetProfileRequest>
  Model::GetProfileOutcomeCallable GetProfileCallable(const GetProfileRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::GetProfile, request);
  }

  /**
   * An Async wrapper for GetProfile that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename GetProfileRequestT = Model::GetProfileRequest>
  void GetProfileAsync(const GetProfileRequestT& request, const GetProfileResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::GetProfile, request, handler, context);
  }

  /**
   * <p>Gets a <i>subject</i>, which associates a certificate identity with
   * authentication attempts. The subject stores auditing information such as the
   * status of the last authentication attempt, the certificate data used in the
   * attempt, and the last time the associated identity attempted authentication.
   * </p> <p> <b>Required permissions: </b> <code>rolesanywhere:GetSubject</code>.
   * </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/GetSubject">AWS
   * API Reference</a></p>
   */
  virtual Model::GetSubjectOutcome GetSubject(const Model::GetSubjectRequest& request) const;

  /**
   * A Callable wrapper for GetSubject that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename GetSubjectRequestT = Model::GetSubjectRequest>
  Model::GetSubjectOutcomeCallable GetSubjectCallable(const GetSubjectRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::GetSubject, request);
  }

  /**
   * An Async wrapper for GetSubject that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename GetSubjectRequestT = Model::GetSubjectRequest>
  void GetSubjectAsync(const GetSubjectRequestT& request, const GetSubjectResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::GetSubject, request, handler, context);
  }

  /**
   * <p>Gets a trust anchor.</p> <p> <b>Required permissions: </b>
   * <code>rolesanywhere:GetTrustAnchor</code>. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/GetTrustAnchor">AWS
   * API Reference</a></p>
   */
  virtual Model::GetTrustAnchorOutcome GetTrustAnchor(const Model::GetTrustAnchorRequest& request) const;

  /**
   * A Callable wrapper for GetTrustAnchor that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename GetTrustAnchorRequestT = Model::GetTrustAnchorRequest>
  Model::GetTrustAnchorOutcomeCallable GetTrustAnchorCallable(const GetTrustAnchorRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::GetTrustAnchor, request);
  }

  /**
   * An Async wrapper for GetTrustAnchor that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename GetTrustAnchorRequestT = Model::GetTrustAnchorRequest>
  void GetTrustAnchorAsync(const GetTrustAnchorRequestT& request, const GetTrustAnchorResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::GetTrustAnchor, request, handler, context);
  }

  /**
   * <p>Imports the certificate revocation list (CRL). A CRL is a list of
   * certificates that have been revoked by the issuing certificate Authority (CA).In
   * order to be properly imported, a CRL must be in PEM format. IAM Roles Anywhere
   * validates against the CRL before issuing credentials. </p> <p> <b>Required
   * permissions: </b> <code>rolesanywhere:ImportCrl</code>. </p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/ImportCrl">AWS
   * API Reference</a></p>
   */
  virtual Model::ImportCrlOutcome ImportCrl(const Model::ImportCrlRequest& request) const;

  /**
   * A Callable wrapper for ImportCrl that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename ImportCrlRequestT = Model::ImportCrlRequest>
  Model::ImportCrlOutcomeCallable ImportCrlCallable(const ImportCrlRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::ImportCrl, request);
  }

  /**
   * An Async wrapper for ImportCrl that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename ImportCrlRequestT = Model::ImportCrlRequest>
  void ImportCrlAsync(const ImportCrlRequestT& request, const ImportCrlResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::ImportCrl, request, handler, context);
  }

  /**
   * <p>Lists all certificate revocation lists (CRL) in the authenticated account and
   * Amazon Web Services Region.</p> <p> <b>Required permissions: </b>
   * <code>rolesanywhere:ListCrls</code>. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/ListCrls">AWS
   * API Reference</a></p>
   */
  virtual Model::ListCrlsOutcome ListCrls(const Model::ListCrlsRequest& request = {}) const;

  /**
   * A Callable wrapper for ListCrls that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename ListCrlsRequestT = Model::ListCrlsRequest>
  Model::ListCrlsOutcomeCallable ListCrlsCallable(const ListCrlsRequestT& request = {}) const {
    return SubmitCallable(&RolesAnywhereClient::ListCrls, request);
  }

  /**
   * An Async wrapper for ListCrls that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename ListCrlsRequestT = Model::ListCrlsRequest>
  void ListCrlsAsync(const ListCrlsResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                     const ListCrlsRequestT& request = {}) const {
    return SubmitAsync(&RolesAnywhereClient::ListCrls, request, handler, context);
  }

  /**
   * <p>Lists all profiles in the authenticated account and Amazon Web Services
   * Region.</p> <p> <b>Required permissions: </b>
   * <code>rolesanywhere:ListProfiles</code>. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/ListProfiles">AWS
   * API Reference</a></p>
   */
  virtual Model::ListProfilesOutcome ListProfiles(const Model::ListProfilesRequest& request = {}) const;

  /**
   * A Callable wrapper for ListProfiles that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename ListProfilesRequestT = Model::ListProfilesRequest>
  Model::ListProfilesOutcomeCallable ListProfilesCallable(const ListProfilesRequestT& request = {}) const {
    return SubmitCallable(&RolesAnywhereClient::ListProfiles, request);
  }

  /**
   * An Async wrapper for ListProfiles that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename ListProfilesRequestT = Model::ListProfilesRequest>
  void ListProfilesAsync(const ListProfilesResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListProfilesRequestT& request = {}) const {
    return SubmitAsync(&RolesAnywhereClient::ListProfiles, request, handler, context);
  }

  /**
   * <p>Lists the subjects in the authenticated account and Amazon Web Services
   * Region.</p> <p> <b>Required permissions: </b>
   * <code>rolesanywhere:ListSubjects</code>. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/ListSubjects">AWS
   * API Reference</a></p>
   */
  virtual Model::ListSubjectsOutcome ListSubjects(const Model::ListSubjectsRequest& request = {}) const;

  /**
   * A Callable wrapper for ListSubjects that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename ListSubjectsRequestT = Model::ListSubjectsRequest>
  Model::ListSubjectsOutcomeCallable ListSubjectsCallable(const ListSubjectsRequestT& request = {}) const {
    return SubmitCallable(&RolesAnywhereClient::ListSubjects, request);
  }

  /**
   * An Async wrapper for ListSubjects that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename ListSubjectsRequestT = Model::ListSubjectsRequest>
  void ListSubjectsAsync(const ListSubjectsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListSubjectsRequestT& request = {}) const {
    return SubmitAsync(&RolesAnywhereClient::ListSubjects, request, handler, context);
  }

  /**
   * <p>Lists the tags attached to the resource.</p> <p> <b>Required permissions:
   * </b> <code>rolesanywhere:ListTagsForResource</code>. </p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/ListTagsForResource">AWS
   * API Reference</a></p>
   */
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;

  /**
   * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::ListTagsForResource, request);
  }

  /**
   * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::ListTagsForResource, request, handler, context);
  }

  /**
   * <p>Lists the trust anchors in the authenticated account and Amazon Web Services
   * Region.</p> <p> <b>Required permissions: </b>
   * <code>rolesanywhere:ListTrustAnchors</code>. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/ListTrustAnchors">AWS
   * API Reference</a></p>
   */
  virtual Model::ListTrustAnchorsOutcome ListTrustAnchors(const Model::ListTrustAnchorsRequest& request = {}) const;

  /**
   * A Callable wrapper for ListTrustAnchors that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListTrustAnchorsRequestT = Model::ListTrustAnchorsRequest>
  Model::ListTrustAnchorsOutcomeCallable ListTrustAnchorsCallable(const ListTrustAnchorsRequestT& request = {}) const {
    return SubmitCallable(&RolesAnywhereClient::ListTrustAnchors, request);
  }

  /**
   * An Async wrapper for ListTrustAnchors that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename ListTrustAnchorsRequestT = Model::ListTrustAnchorsRequest>
  void ListTrustAnchorsAsync(const ListTrustAnchorsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListTrustAnchorsRequestT& request = {}) const {
    return SubmitAsync(&RolesAnywhereClient::ListTrustAnchors, request, handler, context);
  }

  /**
   * <p>Put an entry in the attribute mapping rules that will be enforced by a given
   * profile. A mapping specifies a certificate field and one or more specifiers that
   * have contextual meanings.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/PutAttributeMapping">AWS
   * API Reference</a></p>
   */
  virtual Model::PutAttributeMappingOutcome PutAttributeMapping(const Model::PutAttributeMappingRequest& request) const;

  /**
   * A Callable wrapper for PutAttributeMapping that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename PutAttributeMappingRequestT = Model::PutAttributeMappingRequest>
  Model::PutAttributeMappingOutcomeCallable PutAttributeMappingCallable(const PutAttributeMappingRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::PutAttributeMapping, request);
  }

  /**
   * An Async wrapper for PutAttributeMapping that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename PutAttributeMappingRequestT = Model::PutAttributeMappingRequest>
  void PutAttributeMappingAsync(const PutAttributeMappingRequestT& request, const PutAttributeMappingResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::PutAttributeMapping, request, handler, context);
  }

  /**
   * <p>Attaches a list of <i>notification settings</i> to a trust anchor.</p> <p>A
   * notification setting includes information such as event name, threshold, status
   * of the notification setting, and the channel to notify.</p> <p> <b>Required
   * permissions: </b> <code>rolesanywhere:PutNotificationSettings</code>.
   * </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/PutNotificationSettings">AWS
   * API Reference</a></p>
   */
  virtual Model::PutNotificationSettingsOutcome PutNotificationSettings(const Model::PutNotificationSettingsRequest& request) const;

  /**
   * A Callable wrapper for PutNotificationSettings that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename PutNotificationSettingsRequestT = Model::PutNotificationSettingsRequest>
  Model::PutNotificationSettingsOutcomeCallable PutNotificationSettingsCallable(const PutNotificationSettingsRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::PutNotificationSettings, request);
  }

  /**
   * An Async wrapper for PutNotificationSettings that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename PutNotificationSettingsRequestT = Model::PutNotificationSettingsRequest>
  void PutNotificationSettingsAsync(const PutNotificationSettingsRequestT& request,
                                    const PutNotificationSettingsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::PutNotificationSettings, request, handler, context);
  }

  /**
   * <p>Resets the <i>custom notification setting</i> to IAM Roles Anywhere default
   * setting. </p> <p> <b>Required permissions: </b>
   * <code>rolesanywhere:ResetNotificationSettings</code>. </p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/ResetNotificationSettings">AWS
   * API Reference</a></p>
   */
  virtual Model::ResetNotificationSettingsOutcome ResetNotificationSettings(const Model::ResetNotificationSettingsRequest& request) const;

  /**
   * A Callable wrapper for ResetNotificationSettings that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ResetNotificationSettingsRequestT = Model::ResetNotificationSettingsRequest>
  Model::ResetNotificationSettingsOutcomeCallable ResetNotificationSettingsCallable(
      const ResetNotificationSettingsRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::ResetNotificationSettings, request);
  }

  /**
   * An Async wrapper for ResetNotificationSettings that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename ResetNotificationSettingsRequestT = Model::ResetNotificationSettingsRequest>
  void ResetNotificationSettingsAsync(const ResetNotificationSettingsRequestT& request,
                                      const ResetNotificationSettingsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::ResetNotificationSettings, request, handler, context);
  }

  /**
   * <p>Attaches tags to a resource.</p> <p> <b>Required permissions: </b>
   * <code>rolesanywhere:TagResource</code>. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/TagResource">AWS
   * API Reference</a></p>
   */
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;

  /**
   * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::TagResource, request);
  }

  /**
   * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::TagResource, request, handler, context);
  }

  /**
   * <p>Removes tags from the resource.</p> <p> <b>Required permissions: </b>
   * <code>rolesanywhere:UntagResource</code>. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/UntagResource">AWS
   * API Reference</a></p>
   */
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;

  /**
   * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::UntagResource, request);
  }

  /**
   * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::UntagResource, request, handler, context);
  }

  /**
   * <p>Updates the certificate revocation list (CRL). A CRL is a list of
   * certificates that have been revoked by the issuing certificate authority (CA).
   * IAM Roles Anywhere validates against the CRL before issuing credentials.</p> <p>
   * <b>Required permissions: </b> <code>rolesanywhere:UpdateCrl</code>.
   * </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/UpdateCrl">AWS
   * API Reference</a></p>
   */
  virtual Model::UpdateCrlOutcome UpdateCrl(const Model::UpdateCrlRequest& request) const;

  /**
   * A Callable wrapper for UpdateCrl that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename UpdateCrlRequestT = Model::UpdateCrlRequest>
  Model::UpdateCrlOutcomeCallable UpdateCrlCallable(const UpdateCrlRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::UpdateCrl, request);
  }

  /**
   * An Async wrapper for UpdateCrl that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename UpdateCrlRequestT = Model::UpdateCrlRequest>
  void UpdateCrlAsync(const UpdateCrlRequestT& request, const UpdateCrlResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::UpdateCrl, request, handler, context);
  }

  /**
   * <p>Updates a <i>profile</i>, a list of the roles that IAM Roles Anywhere service
   * is trusted to assume. You use profiles to intersect permissions with IAM managed
   * policies.</p> <p> <b>Required permissions: </b>
   * <code>rolesanywhere:UpdateProfile</code>. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/UpdateProfile">AWS
   * API Reference</a></p>
   */
  virtual Model::UpdateProfileOutcome UpdateProfile(const Model::UpdateProfileRequest& request) const;

  /**
   * A Callable wrapper for UpdateProfile that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename UpdateProfileRequestT = Model::UpdateProfileRequest>
  Model::UpdateProfileOutcomeCallable UpdateProfileCallable(const UpdateProfileRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::UpdateProfile, request);
  }

  /**
   * An Async wrapper for UpdateProfile that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename UpdateProfileRequestT = Model::UpdateProfileRequest>
  void UpdateProfileAsync(const UpdateProfileRequestT& request, const UpdateProfileResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::UpdateProfile, request, handler, context);
  }

  /**
   * <p>Updates a trust anchor. You establish trust between IAM Roles Anywhere and
   * your certificate authority (CA) by configuring a trust anchor. You can define a
   * trust anchor as a reference to an Private Certificate Authority (Private CA) or
   * by uploading a CA certificate. Your Amazon Web Services workloads can
   * authenticate with the trust anchor using certificates issued by the CA in
   * exchange for temporary Amazon Web Services credentials.</p> <p> <b>Required
   * permissions: </b> <code>rolesanywhere:UpdateTrustAnchor</code>. </p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/rolesanywhere-2018-05-10/UpdateTrustAnchor">AWS
   * API Reference</a></p>
   */
  virtual Model::UpdateTrustAnchorOutcome UpdateTrustAnchor(const Model::UpdateTrustAnchorRequest& request) const;

  /**
   * A Callable wrapper for UpdateTrustAnchor that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename UpdateTrustAnchorRequestT = Model::UpdateTrustAnchorRequest>
  Model::UpdateTrustAnchorOutcomeCallable UpdateTrustAnchorCallable(const UpdateTrustAnchorRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::UpdateTrustAnchor, request);
  }

  /**
   * An Async wrapper for UpdateTrustAnchor that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename UpdateTrustAnchorRequestT = Model::UpdateTrustAnchorRequest>
  void UpdateTrustAnchorAsync(const UpdateTrustAnchorRequestT& request, const UpdateTrustAnchorResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::UpdateTrustAnchor, request, handler, context);
  }

  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<RolesAnywhereEndpointProviderBase>& accessEndpointProvider();

 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<RolesAnywhereClient>;
  void init(const RolesAnywhereClientConfiguration& clientConfiguration);

  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, RolesAnywhereError> InvokeOperationOutcome;

  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;

  RolesAnywhereClientConfiguration m_clientConfiguration;
  std::shared_ptr<RolesAnywhereEndpointProviderBase> m_endpointProvider;
};

}  // namespace RolesAnywhere
}  // namespace Aws
