CognitoIdentityProviderClient.h

 
#pragma once
#include <aws/cognito-idp/CognitoIdentityProviderPaginationBase.h>
#include <aws/cognito-idp/CognitoIdentityProviderServiceClientModel.h>
#include <aws/cognito-idp/CognitoIdentityProviderWaiter.h>
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
#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>
 
namespace Aws {
namespace CognitoIdentityProvider {
class AWS_COGNITOIDENTITYPROVIDER_API CognitoIdentityProviderClient
    : public Aws::Client::AWSJsonClient,
      public Aws::Client::ClientWithAsyncTemplateMethods<CognitoIdentityProviderClient>,
      public CognitoIdentityProviderPaginationBase<CognitoIdentityProviderClient>,
      public CognitoIdentityProviderWaiter<CognitoIdentityProviderClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef CognitoIdentityProviderClientConfiguration ClientConfigurationType;
  typedef CognitoIdentityProviderEndpointProvider EndpointProviderType;
 
  CognitoIdentityProviderClient(const Aws::CognitoIdentityProvider::CognitoIdentityProviderClientConfiguration& clientConfiguration =
                                    Aws::CognitoIdentityProvider::CognitoIdentityProviderClientConfiguration(),
                                std::shared_ptr<CognitoIdentityProviderEndpointProviderBase> endpointProvider = nullptr);
 
  CognitoIdentityProviderClient(const Aws::Auth::AWSCredentials& credentials,
                                std::shared_ptr<CognitoIdentityProviderEndpointProviderBase> endpointProvider = nullptr,
                                const Aws::CognitoIdentityProvider::CognitoIdentityProviderClientConfiguration& clientConfiguration =
                                    Aws::CognitoIdentityProvider::CognitoIdentityProviderClientConfiguration());
 
  CognitoIdentityProviderClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                std::shared_ptr<CognitoIdentityProviderEndpointProviderBase> endpointProvider = nullptr,
                                const Aws::CognitoIdentityProvider::CognitoIdentityProviderClientConfiguration& clientConfiguration =
                                    Aws::CognitoIdentityProvider::CognitoIdentityProviderClientConfiguration());
 
  /* Legacy constructors due deprecation */
  CognitoIdentityProviderClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CognitoIdentityProviderClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CognitoIdentityProviderClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~CognitoIdentityProviderClient();
 
  virtual Model::AddCustomAttributesOutcome AddCustomAttributes(const Model::AddCustomAttributesRequest& request) const;
 
  template <typename AddCustomAttributesRequestT = Model::AddCustomAttributesRequest>
  Model::AddCustomAttributesOutcomeCallable AddCustomAttributesCallable(const AddCustomAttributesRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AddCustomAttributes, request);
  }
 
  template <typename AddCustomAttributesRequestT = Model::AddCustomAttributesRequest>
  void AddCustomAttributesAsync(const AddCustomAttributesRequestT& request, const AddCustomAttributesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AddCustomAttributes, request, handler, context);
  }
 
  virtual Model::AddUserPoolClientSecretOutcome AddUserPoolClientSecret(const Model::AddUserPoolClientSecretRequest& request) const;
 
  template <typename AddUserPoolClientSecretRequestT = Model::AddUserPoolClientSecretRequest>
  Model::AddUserPoolClientSecretOutcomeCallable AddUserPoolClientSecretCallable(const AddUserPoolClientSecretRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AddUserPoolClientSecret, request);
  }
 
  template <typename AddUserPoolClientSecretRequestT = Model::AddUserPoolClientSecretRequest>
  void AddUserPoolClientSecretAsync(const AddUserPoolClientSecretRequestT& request,
                                    const AddUserPoolClientSecretResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AddUserPoolClientSecret, request, handler, context);
  }
 
  virtual Model::AdminAddUserToGroupOutcome AdminAddUserToGroup(const Model::AdminAddUserToGroupRequest& request) const;
 
  template <typename AdminAddUserToGroupRequestT = Model::AdminAddUserToGroupRequest>
  Model::AdminAddUserToGroupOutcomeCallable AdminAddUserToGroupCallable(const AdminAddUserToGroupRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminAddUserToGroup, request);
  }
 
  template <typename AdminAddUserToGroupRequestT = Model::AdminAddUserToGroupRequest>
  void AdminAddUserToGroupAsync(const AdminAddUserToGroupRequestT& request, const AdminAddUserToGroupResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminAddUserToGroup, request, handler, context);
  }
 
  virtual Model::AdminConfirmSignUpOutcome AdminConfirmSignUp(const Model::AdminConfirmSignUpRequest& request) const;
 
  template <typename AdminConfirmSignUpRequestT = Model::AdminConfirmSignUpRequest>
  Model::AdminConfirmSignUpOutcomeCallable AdminConfirmSignUpCallable(const AdminConfirmSignUpRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminConfirmSignUp, request);
  }
 
  template <typename AdminConfirmSignUpRequestT = Model::AdminConfirmSignUpRequest>
  void AdminConfirmSignUpAsync(const AdminConfirmSignUpRequestT& request, const AdminConfirmSignUpResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminConfirmSignUp, request, handler, context);
  }
 
  virtual Model::AdminCreateUserOutcome AdminCreateUser(const Model::AdminCreateUserRequest& request) const;
 
  template <typename AdminCreateUserRequestT = Model::AdminCreateUserRequest>
  Model::AdminCreateUserOutcomeCallable AdminCreateUserCallable(const AdminCreateUserRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminCreateUser, request);
  }
 
  template <typename AdminCreateUserRequestT = Model::AdminCreateUserRequest>
  void AdminCreateUserAsync(const AdminCreateUserRequestT& request, const AdminCreateUserResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminCreateUser, request, handler, context);
  }
 
  virtual Model::AdminDeleteSoftwareTokenOutcome AdminDeleteSoftwareToken(const Model::AdminDeleteSoftwareTokenRequest& request) const;
 
  template <typename AdminDeleteSoftwareTokenRequestT = Model::AdminDeleteSoftwareTokenRequest>
  Model::AdminDeleteSoftwareTokenOutcomeCallable AdminDeleteSoftwareTokenCallable(const AdminDeleteSoftwareTokenRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminDeleteSoftwareToken, request);
  }
 
  template <typename AdminDeleteSoftwareTokenRequestT = Model::AdminDeleteSoftwareTokenRequest>
  void AdminDeleteSoftwareTokenAsync(const AdminDeleteSoftwareTokenRequestT& request,
                                     const AdminDeleteSoftwareTokenResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminDeleteSoftwareToken, request, handler, context);
  }
 
  virtual Model::AdminDeleteUserOutcome AdminDeleteUser(const Model::AdminDeleteUserRequest& request) const;
 
  template <typename AdminDeleteUserRequestT = Model::AdminDeleteUserRequest>
  Model::AdminDeleteUserOutcomeCallable AdminDeleteUserCallable(const AdminDeleteUserRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminDeleteUser, request);
  }
 
  template <typename AdminDeleteUserRequestT = Model::AdminDeleteUserRequest>
  void AdminDeleteUserAsync(const AdminDeleteUserRequestT& request, const AdminDeleteUserResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminDeleteUser, request, handler, context);
  }
 
  virtual Model::AdminDeleteUserAttributesOutcome AdminDeleteUserAttributes(const Model::AdminDeleteUserAttributesRequest& request) const;
 
  template <typename AdminDeleteUserAttributesRequestT = Model::AdminDeleteUserAttributesRequest>
  Model::AdminDeleteUserAttributesOutcomeCallable AdminDeleteUserAttributesCallable(
      const AdminDeleteUserAttributesRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminDeleteUserAttributes, request);
  }
 
  template <typename AdminDeleteUserAttributesRequestT = Model::AdminDeleteUserAttributesRequest>
  void AdminDeleteUserAttributesAsync(const AdminDeleteUserAttributesRequestT& request,
                                      const AdminDeleteUserAttributesResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminDeleteUserAttributes, request, handler, context);
  }
 
  virtual Model::AdminDisableProviderForUserOutcome AdminDisableProviderForUser(
      const Model::AdminDisableProviderForUserRequest& request) const;
 
  template <typename AdminDisableProviderForUserRequestT = Model::AdminDisableProviderForUserRequest>
  Model::AdminDisableProviderForUserOutcomeCallable AdminDisableProviderForUserCallable(
      const AdminDisableProviderForUserRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminDisableProviderForUser, request);
  }
 
  template <typename AdminDisableProviderForUserRequestT = Model::AdminDisableProviderForUserRequest>
  void AdminDisableProviderForUserAsync(const AdminDisableProviderForUserRequestT& request,
                                        const AdminDisableProviderForUserResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminDisableProviderForUser, request, handler, context);
  }
 
  virtual Model::AdminDisableUserOutcome AdminDisableUser(const Model::AdminDisableUserRequest& request) const;
 
  template <typename AdminDisableUserRequestT = Model::AdminDisableUserRequest>
  Model::AdminDisableUserOutcomeCallable AdminDisableUserCallable(const AdminDisableUserRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminDisableUser, request);
  }
 
  template <typename AdminDisableUserRequestT = Model::AdminDisableUserRequest>
  void AdminDisableUserAsync(const AdminDisableUserRequestT& request, const AdminDisableUserResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminDisableUser, request, handler, context);
  }
 
  virtual Model::AdminEnableUserOutcome AdminEnableUser(const Model::AdminEnableUserRequest& request) const;
 
  template <typename AdminEnableUserRequestT = Model::AdminEnableUserRequest>
  Model::AdminEnableUserOutcomeCallable AdminEnableUserCallable(const AdminEnableUserRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminEnableUser, request);
  }
 
  template <typename AdminEnableUserRequestT = Model::AdminEnableUserRequest>
  void AdminEnableUserAsync(const AdminEnableUserRequestT& request, const AdminEnableUserResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminEnableUser, request, handler, context);
  }
 
  virtual Model::AdminForgetDeviceOutcome AdminForgetDevice(const Model::AdminForgetDeviceRequest& request) const;
 
  template <typename AdminForgetDeviceRequestT = Model::AdminForgetDeviceRequest>
  Model::AdminForgetDeviceOutcomeCallable AdminForgetDeviceCallable(const AdminForgetDeviceRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminForgetDevice, request);
  }
 
  template <typename AdminForgetDeviceRequestT = Model::AdminForgetDeviceRequest>
  void AdminForgetDeviceAsync(const AdminForgetDeviceRequestT& request, const AdminForgetDeviceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminForgetDevice, request, handler, context);
  }
 
  virtual Model::AdminGetDeviceOutcome AdminGetDevice(const Model::AdminGetDeviceRequest& request) const;
 
  template <typename AdminGetDeviceRequestT = Model::AdminGetDeviceRequest>
  Model::AdminGetDeviceOutcomeCallable AdminGetDeviceCallable(const AdminGetDeviceRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminGetDevice, request);
  }
 
  template <typename AdminGetDeviceRequestT = Model::AdminGetDeviceRequest>
  void AdminGetDeviceAsync(const AdminGetDeviceRequestT& request, const AdminGetDeviceResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminGetDevice, request, handler, context);
  }
 
  virtual Model::AdminGetUserOutcome AdminGetUser(const Model::AdminGetUserRequest& request) const;
 
  template <typename AdminGetUserRequestT = Model::AdminGetUserRequest>
  Model::AdminGetUserOutcomeCallable AdminGetUserCallable(const AdminGetUserRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminGetUser, request);
  }
 
  template <typename AdminGetUserRequestT = Model::AdminGetUserRequest>
  void AdminGetUserAsync(const AdminGetUserRequestT& request, const AdminGetUserResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminGetUser, request, handler, context);
  }
 
  virtual Model::AdminGetUserAuthFactorsOutcome AdminGetUserAuthFactors(const Model::AdminGetUserAuthFactorsRequest& request) const;
 
  template <typename AdminGetUserAuthFactorsRequestT = Model::AdminGetUserAuthFactorsRequest>
  Model::AdminGetUserAuthFactorsOutcomeCallable AdminGetUserAuthFactorsCallable(const AdminGetUserAuthFactorsRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminGetUserAuthFactors, request);
  }
 
  template <typename AdminGetUserAuthFactorsRequestT = Model::AdminGetUserAuthFactorsRequest>
  void AdminGetUserAuthFactorsAsync(const AdminGetUserAuthFactorsRequestT& request,
                                    const AdminGetUserAuthFactorsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminGetUserAuthFactors, request, handler, context);
  }
 
  virtual Model::AdminInitiateAuthOutcome AdminInitiateAuth(const Model::AdminInitiateAuthRequest& request) const;
 
  template <typename AdminInitiateAuthRequestT = Model::AdminInitiateAuthRequest>
  Model::AdminInitiateAuthOutcomeCallable AdminInitiateAuthCallable(const AdminInitiateAuthRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminInitiateAuth, request);
  }
 
  template <typename AdminInitiateAuthRequestT = Model::AdminInitiateAuthRequest>
  void AdminInitiateAuthAsync(const AdminInitiateAuthRequestT& request, const AdminInitiateAuthResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminInitiateAuth, request, handler, context);
  }
 
  virtual Model::AdminLinkProviderForUserOutcome AdminLinkProviderForUser(const Model::AdminLinkProviderForUserRequest& request) const;
 
  template <typename AdminLinkProviderForUserRequestT = Model::AdminLinkProviderForUserRequest>
  Model::AdminLinkProviderForUserOutcomeCallable AdminLinkProviderForUserCallable(const AdminLinkProviderForUserRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminLinkProviderForUser, request);
  }
 
  template <typename AdminLinkProviderForUserRequestT = Model::AdminLinkProviderForUserRequest>
  void AdminLinkProviderForUserAsync(const AdminLinkProviderForUserRequestT& request,
                                     const AdminLinkProviderForUserResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminLinkProviderForUser, request, handler, context);
  }
 
  virtual Model::AdminListDevicesOutcome AdminListDevices(const Model::AdminListDevicesRequest& request) const;
 
  template <typename AdminListDevicesRequestT = Model::AdminListDevicesRequest>
  Model::AdminListDevicesOutcomeCallable AdminListDevicesCallable(const AdminListDevicesRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminListDevices, request);
  }
 
  template <typename AdminListDevicesRequestT = Model::AdminListDevicesRequest>
  void AdminListDevicesAsync(const AdminListDevicesRequestT& request, const AdminListDevicesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminListDevices, request, handler, context);
  }
 
  virtual Model::AdminListGroupsForUserOutcome AdminListGroupsForUser(const Model::AdminListGroupsForUserRequest& request) const;
 
  template <typename AdminListGroupsForUserRequestT = Model::AdminListGroupsForUserRequest>
  Model::AdminListGroupsForUserOutcomeCallable AdminListGroupsForUserCallable(const AdminListGroupsForUserRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminListGroupsForUser, request);
  }
 
  template <typename AdminListGroupsForUserRequestT = Model::AdminListGroupsForUserRequest>
  void AdminListGroupsForUserAsync(const AdminListGroupsForUserRequestT& request,
                                   const AdminListGroupsForUserResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminListGroupsForUser, request, handler, context);
  }
 
  virtual Model::AdminListUserAuthEventsOutcome AdminListUserAuthEvents(const Model::AdminListUserAuthEventsRequest& request) const;
 
  template <typename AdminListUserAuthEventsRequestT = Model::AdminListUserAuthEventsRequest>
  Model::AdminListUserAuthEventsOutcomeCallable AdminListUserAuthEventsCallable(const AdminListUserAuthEventsRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminListUserAuthEvents, request);
  }
 
  template <typename AdminListUserAuthEventsRequestT = Model::AdminListUserAuthEventsRequest>
  void AdminListUserAuthEventsAsync(const AdminListUserAuthEventsRequestT& request,
                                    const AdminListUserAuthEventsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminListUserAuthEvents, request, handler, context);
  }
 
  virtual Model::AdminRemoveUserFromGroupOutcome AdminRemoveUserFromGroup(const Model::AdminRemoveUserFromGroupRequest& request) const;
 
  template <typename AdminRemoveUserFromGroupRequestT = Model::AdminRemoveUserFromGroupRequest>
  Model::AdminRemoveUserFromGroupOutcomeCallable AdminRemoveUserFromGroupCallable(const AdminRemoveUserFromGroupRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminRemoveUserFromGroup, request);
  }
 
  template <typename AdminRemoveUserFromGroupRequestT = Model::AdminRemoveUserFromGroupRequest>
  void AdminRemoveUserFromGroupAsync(const AdminRemoveUserFromGroupRequestT& request,
                                     const AdminRemoveUserFromGroupResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminRemoveUserFromGroup, request, handler, context);
  }
 
  virtual Model::AdminResetUserPasswordOutcome AdminResetUserPassword(const Model::AdminResetUserPasswordRequest& request) const;
 
  template <typename AdminResetUserPasswordRequestT = Model::AdminResetUserPasswordRequest>
  Model::AdminResetUserPasswordOutcomeCallable AdminResetUserPasswordCallable(const AdminResetUserPasswordRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminResetUserPassword, request);
  }
 
  template <typename AdminResetUserPasswordRequestT = Model::AdminResetUserPasswordRequest>
  void AdminResetUserPasswordAsync(const AdminResetUserPasswordRequestT& request,
                                   const AdminResetUserPasswordResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminResetUserPassword, request, handler, context);
  }
 
  virtual Model::AdminRespondToAuthChallengeOutcome AdminRespondToAuthChallenge(
      const Model::AdminRespondToAuthChallengeRequest& request) const;
 
  template <typename AdminRespondToAuthChallengeRequestT = Model::AdminRespondToAuthChallengeRequest>
  Model::AdminRespondToAuthChallengeOutcomeCallable AdminRespondToAuthChallengeCallable(
      const AdminRespondToAuthChallengeRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminRespondToAuthChallenge, request);
  }
 
  template <typename AdminRespondToAuthChallengeRequestT = Model::AdminRespondToAuthChallengeRequest>
  void AdminRespondToAuthChallengeAsync(const AdminRespondToAuthChallengeRequestT& request,
                                        const AdminRespondToAuthChallengeResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminRespondToAuthChallenge, request, handler, context);
  }
 
  virtual Model::AdminSetUserMFAPreferenceOutcome AdminSetUserMFAPreference(const Model::AdminSetUserMFAPreferenceRequest& request) const;
 
  template <typename AdminSetUserMFAPreferenceRequestT = Model::AdminSetUserMFAPreferenceRequest>
  Model::AdminSetUserMFAPreferenceOutcomeCallable AdminSetUserMFAPreferenceCallable(
      const AdminSetUserMFAPreferenceRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminSetUserMFAPreference, request);
  }
 
  template <typename AdminSetUserMFAPreferenceRequestT = Model::AdminSetUserMFAPreferenceRequest>
  void AdminSetUserMFAPreferenceAsync(const AdminSetUserMFAPreferenceRequestT& request,
                                      const AdminSetUserMFAPreferenceResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminSetUserMFAPreference, request, handler, context);
  }
 
  virtual Model::AdminSetUserPasswordOutcome AdminSetUserPassword(const Model::AdminSetUserPasswordRequest& request) const;
 
  template <typename AdminSetUserPasswordRequestT = Model::AdminSetUserPasswordRequest>
  Model::AdminSetUserPasswordOutcomeCallable AdminSetUserPasswordCallable(const AdminSetUserPasswordRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminSetUserPassword, request);
  }
 
  template <typename AdminSetUserPasswordRequestT = Model::AdminSetUserPasswordRequest>
  void AdminSetUserPasswordAsync(const AdminSetUserPasswordRequestT& request, const AdminSetUserPasswordResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminSetUserPassword, request, handler, context);
  }
 
  virtual Model::AdminSetUserSettingsOutcome AdminSetUserSettings(const Model::AdminSetUserSettingsRequest& request) const;
 
  template <typename AdminSetUserSettingsRequestT = Model::AdminSetUserSettingsRequest>
  Model::AdminSetUserSettingsOutcomeCallable AdminSetUserSettingsCallable(const AdminSetUserSettingsRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminSetUserSettings, request);
  }
 
  template <typename AdminSetUserSettingsRequestT = Model::AdminSetUserSettingsRequest>
  void AdminSetUserSettingsAsync(const AdminSetUserSettingsRequestT& request, const AdminSetUserSettingsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminSetUserSettings, request, handler, context);
  }
 
  virtual Model::AdminUpdateAuthEventFeedbackOutcome AdminUpdateAuthEventFeedback(
      const Model::AdminUpdateAuthEventFeedbackRequest& request) const;
 
  template <typename AdminUpdateAuthEventFeedbackRequestT = Model::AdminUpdateAuthEventFeedbackRequest>
  Model::AdminUpdateAuthEventFeedbackOutcomeCallable AdminUpdateAuthEventFeedbackCallable(
      const AdminUpdateAuthEventFeedbackRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminUpdateAuthEventFeedback, request);
  }
 
  template <typename AdminUpdateAuthEventFeedbackRequestT = Model::AdminUpdateAuthEventFeedbackRequest>
  void AdminUpdateAuthEventFeedbackAsync(const AdminUpdateAuthEventFeedbackRequestT& request,
                                         const AdminUpdateAuthEventFeedbackResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminUpdateAuthEventFeedback, request, handler, context);
  }
 
  virtual Model::AdminUpdateDeviceStatusOutcome AdminUpdateDeviceStatus(const Model::AdminUpdateDeviceStatusRequest& request) const;
 
  template <typename AdminUpdateDeviceStatusRequestT = Model::AdminUpdateDeviceStatusRequest>
  Model::AdminUpdateDeviceStatusOutcomeCallable AdminUpdateDeviceStatusCallable(const AdminUpdateDeviceStatusRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminUpdateDeviceStatus, request);
  }
 
  template <typename AdminUpdateDeviceStatusRequestT = Model::AdminUpdateDeviceStatusRequest>
  void AdminUpdateDeviceStatusAsync(const AdminUpdateDeviceStatusRequestT& request,
                                    const AdminUpdateDeviceStatusResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminUpdateDeviceStatus, request, handler, context);
  }
 
  virtual Model::AdminUpdateUserAttributesOutcome AdminUpdateUserAttributes(const Model::AdminUpdateUserAttributesRequest& request) const;
 
  template <typename AdminUpdateUserAttributesRequestT = Model::AdminUpdateUserAttributesRequest>
  Model::AdminUpdateUserAttributesOutcomeCallable AdminUpdateUserAttributesCallable(
      const AdminUpdateUserAttributesRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminUpdateUserAttributes, request);
  }
 
  template <typename AdminUpdateUserAttributesRequestT = Model::AdminUpdateUserAttributesRequest>
  void AdminUpdateUserAttributesAsync(const AdminUpdateUserAttributesRequestT& request,
                                      const AdminUpdateUserAttributesResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminUpdateUserAttributes, request, handler, context);
  }
 
  virtual Model::AdminUserGlobalSignOutOutcome AdminUserGlobalSignOut(const Model::AdminUserGlobalSignOutRequest& request) const;
 
  template <typename AdminUserGlobalSignOutRequestT = Model::AdminUserGlobalSignOutRequest>
  Model::AdminUserGlobalSignOutOutcomeCallable AdminUserGlobalSignOutCallable(const AdminUserGlobalSignOutRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AdminUserGlobalSignOut, request);
  }
 
  template <typename AdminUserGlobalSignOutRequestT = Model::AdminUserGlobalSignOutRequest>
  void AdminUserGlobalSignOutAsync(const AdminUserGlobalSignOutRequestT& request,
                                   const AdminUserGlobalSignOutResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AdminUserGlobalSignOut, request, handler, context);
  }
 
  virtual Model::AssociateSoftwareTokenOutcome AssociateSoftwareToken(const Model::AssociateSoftwareTokenRequest& request = {}) const;
 
  template <typename AssociateSoftwareTokenRequestT = Model::AssociateSoftwareTokenRequest>
  Model::AssociateSoftwareTokenOutcomeCallable AssociateSoftwareTokenCallable(const AssociateSoftwareTokenRequestT& request = {}) const {
    return SubmitCallable(&CognitoIdentityProviderClient::AssociateSoftwareToken, request);
  }
 
  template <typename AssociateSoftwareTokenRequestT = Model::AssociateSoftwareTokenRequest>
  void AssociateSoftwareTokenAsync(const AssociateSoftwareTokenResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const AssociateSoftwareTokenRequestT& request = {}) const {
    return SubmitAsync(&CognitoIdentityProviderClient::AssociateSoftwareToken, request, handler, context);
  }
 
  virtual Model::ChangePasswordOutcome ChangePassword(const Model::ChangePasswordRequest& request) const;
 
  template <typename ChangePasswordRequestT = Model::ChangePasswordRequest>
  Model::ChangePasswordOutcomeCallable ChangePasswordCallable(const ChangePasswordRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::ChangePassword, request);
  }
 
  template <typename ChangePasswordRequestT = Model::ChangePasswordRequest>
  void ChangePasswordAsync(const ChangePasswordRequestT& request, const ChangePasswordResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::ChangePassword, request, handler, context);
  }
 
  virtual Model::CompleteWebAuthnRegistrationOutcome CompleteWebAuthnRegistration(
      const Model::CompleteWebAuthnRegistrationRequest& request) const;
 
  template <typename CompleteWebAuthnRegistrationRequestT = Model::CompleteWebAuthnRegistrationRequest>
  Model::CompleteWebAuthnRegistrationOutcomeCallable CompleteWebAuthnRegistrationCallable(
      const CompleteWebAuthnRegistrationRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::CompleteWebAuthnRegistration, request);
  }
 
  template <typename CompleteWebAuthnRegistrationRequestT = Model::CompleteWebAuthnRegistrationRequest>
  void CompleteWebAuthnRegistrationAsync(const CompleteWebAuthnRegistrationRequestT& request,
                                         const CompleteWebAuthnRegistrationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::CompleteWebAuthnRegistration, request, handler, context);
  }
 
  virtual Model::ConfirmDeviceOutcome ConfirmDevice(const Model::ConfirmDeviceRequest& request) const;
 
  template <typename ConfirmDeviceRequestT = Model::ConfirmDeviceRequest>
  Model::ConfirmDeviceOutcomeCallable ConfirmDeviceCallable(const ConfirmDeviceRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::ConfirmDevice, request);
  }
 
  template <typename ConfirmDeviceRequestT = Model::ConfirmDeviceRequest>
  void ConfirmDeviceAsync(const ConfirmDeviceRequestT& request, const ConfirmDeviceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::ConfirmDevice, request, handler, context);
  }
 
  virtual Model::ConfirmForgotPasswordOutcome ConfirmForgotPassword(const Model::ConfirmForgotPasswordRequest& request) const;
 
  template <typename ConfirmForgotPasswordRequestT = Model::ConfirmForgotPasswordRequest>
  Model::ConfirmForgotPasswordOutcomeCallable ConfirmForgotPasswordCallable(const ConfirmForgotPasswordRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::ConfirmForgotPassword, request);
  }
 
  template <typename ConfirmForgotPasswordRequestT = Model::ConfirmForgotPasswordRequest>
  void ConfirmForgotPasswordAsync(const ConfirmForgotPasswordRequestT& request, const ConfirmForgotPasswordResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::ConfirmForgotPassword, request, handler, context);
  }
 
  virtual Model::ConfirmSignUpOutcome ConfirmSignUp(const Model::ConfirmSignUpRequest& request) const;
 
  template <typename ConfirmSignUpRequestT = Model::ConfirmSignUpRequest>
  Model::ConfirmSignUpOutcomeCallable ConfirmSignUpCallable(const ConfirmSignUpRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::ConfirmSignUp, request);
  }
 
  template <typename ConfirmSignUpRequestT = Model::ConfirmSignUpRequest>
  void ConfirmSignUpAsync(const ConfirmSignUpRequestT& request, const ConfirmSignUpResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::ConfirmSignUp, request, handler, context);
  }
 
  virtual Model::CreateGroupOutcome CreateGroup(const Model::CreateGroupRequest& request) const;
 
  template <typename CreateGroupRequestT = Model::CreateGroupRequest>
  Model::CreateGroupOutcomeCallable CreateGroupCallable(const CreateGroupRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::CreateGroup, request);
  }
 
  template <typename CreateGroupRequestT = Model::CreateGroupRequest>
  void CreateGroupAsync(const CreateGroupRequestT& request, const CreateGroupResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::CreateGroup, request, handler, context);
  }
 
  virtual Model::CreateIdentityProviderOutcome CreateIdentityProvider(const Model::CreateIdentityProviderRequest& request) const;
 
  template <typename CreateIdentityProviderRequestT = Model::CreateIdentityProviderRequest>
  Model::CreateIdentityProviderOutcomeCallable CreateIdentityProviderCallable(const CreateIdentityProviderRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::CreateIdentityProvider, request);
  }
 
  template <typename CreateIdentityProviderRequestT = Model::CreateIdentityProviderRequest>
  void CreateIdentityProviderAsync(const CreateIdentityProviderRequestT& request,
                                   const CreateIdentityProviderResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::CreateIdentityProvider, request, handler, context);
  }
 
  virtual Model::CreateManagedLoginBrandingOutcome CreateManagedLoginBranding(
      const Model::CreateManagedLoginBrandingRequest& request) const;
 
  template <typename CreateManagedLoginBrandingRequestT = Model::CreateManagedLoginBrandingRequest>
  Model::CreateManagedLoginBrandingOutcomeCallable CreateManagedLoginBrandingCallable(
      const CreateManagedLoginBrandingRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::CreateManagedLoginBranding, request);
  }
 
  template <typename CreateManagedLoginBrandingRequestT = Model::CreateManagedLoginBrandingRequest>
  void CreateManagedLoginBrandingAsync(const CreateManagedLoginBrandingRequestT& request,
                                       const CreateManagedLoginBrandingResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::CreateManagedLoginBranding, request, handler, context);
  }
 
  virtual Model::CreateResourceServerOutcome CreateResourceServer(const Model::CreateResourceServerRequest& request) const;
 
  template <typename CreateResourceServerRequestT = Model::CreateResourceServerRequest>
  Model::CreateResourceServerOutcomeCallable CreateResourceServerCallable(const CreateResourceServerRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::CreateResourceServer, request);
  }
 
  template <typename CreateResourceServerRequestT = Model::CreateResourceServerRequest>
  void CreateResourceServerAsync(const CreateResourceServerRequestT& request, const CreateResourceServerResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::CreateResourceServer, request, handler, context);
  }
 
  virtual Model::CreateTermsOutcome CreateTerms(const Model::CreateTermsRequest& request) const;
 
  template <typename CreateTermsRequestT = Model::CreateTermsRequest>
  Model::CreateTermsOutcomeCallable CreateTermsCallable(const CreateTermsRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::CreateTerms, request);
  }
 
  template <typename CreateTermsRequestT = Model::CreateTermsRequest>
  void CreateTermsAsync(const CreateTermsRequestT& request, const CreateTermsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::CreateTerms, request, handler, context);
  }
 
  virtual Model::CreateUserImportJobOutcome CreateUserImportJob(const Model::CreateUserImportJobRequest& request) const;
 
  template <typename CreateUserImportJobRequestT = Model::CreateUserImportJobRequest>
  Model::CreateUserImportJobOutcomeCallable CreateUserImportJobCallable(const CreateUserImportJobRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::CreateUserImportJob, request);
  }
 
  template <typename CreateUserImportJobRequestT = Model::CreateUserImportJobRequest>
  void CreateUserImportJobAsync(const CreateUserImportJobRequestT& request, const CreateUserImportJobResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::CreateUserImportJob, request, handler, context);
  }
 
  virtual Model::CreateUserPoolOutcome CreateUserPool(const Model::CreateUserPoolRequest& request) const;
 
  template <typename CreateUserPoolRequestT = Model::CreateUserPoolRequest>
  Model::CreateUserPoolOutcomeCallable CreateUserPoolCallable(const CreateUserPoolRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::CreateUserPool, request);
  }
 
  template <typename CreateUserPoolRequestT = Model::CreateUserPoolRequest>
  void CreateUserPoolAsync(const CreateUserPoolRequestT& request, const CreateUserPoolResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::CreateUserPool, request, handler, context);
  }
 
  virtual Model::CreateUserPoolClientOutcome CreateUserPoolClient(const Model::CreateUserPoolClientRequest& request) const;
 
  template <typename CreateUserPoolClientRequestT = Model::CreateUserPoolClientRequest>
  Model::CreateUserPoolClientOutcomeCallable CreateUserPoolClientCallable(const CreateUserPoolClientRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::CreateUserPoolClient, request);
  }
 
  template <typename CreateUserPoolClientRequestT = Model::CreateUserPoolClientRequest>
  void CreateUserPoolClientAsync(const CreateUserPoolClientRequestT& request, const CreateUserPoolClientResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::CreateUserPoolClient, request, handler, context);
  }
 
  virtual Model::CreateUserPoolDomainOutcome CreateUserPoolDomain(const Model::CreateUserPoolDomainRequest& request) const;
 
  template <typename CreateUserPoolDomainRequestT = Model::CreateUserPoolDomainRequest>
  Model::CreateUserPoolDomainOutcomeCallable CreateUserPoolDomainCallable(const CreateUserPoolDomainRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::CreateUserPoolDomain, request);
  }
 
  template <typename CreateUserPoolDomainRequestT = Model::CreateUserPoolDomainRequest>
  void CreateUserPoolDomainAsync(const CreateUserPoolDomainRequestT& request, const CreateUserPoolDomainResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::CreateUserPoolDomain, request, handler, context);
  }
 
  virtual Model::CreateUserPoolReplicaOutcome CreateUserPoolReplica(const Model::CreateUserPoolReplicaRequest& request) const;
 
  template <typename CreateUserPoolReplicaRequestT = Model::CreateUserPoolReplicaRequest>
  Model::CreateUserPoolReplicaOutcomeCallable CreateUserPoolReplicaCallable(const CreateUserPoolReplicaRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::CreateUserPoolReplica, request);
  }
 
  template <typename CreateUserPoolReplicaRequestT = Model::CreateUserPoolReplicaRequest>
  void CreateUserPoolReplicaAsync(const CreateUserPoolReplicaRequestT& request, const CreateUserPoolReplicaResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::CreateUserPoolReplica, request, handler, context);
  }
 
  virtual Model::DeleteGroupOutcome DeleteGroup(const Model::DeleteGroupRequest& request) const;
 
  template <typename DeleteGroupRequestT = Model::DeleteGroupRequest>
  Model::DeleteGroupOutcomeCallable DeleteGroupCallable(const DeleteGroupRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::DeleteGroup, request);
  }
 
  template <typename DeleteGroupRequestT = Model::DeleteGroupRequest>
  void DeleteGroupAsync(const DeleteGroupRequestT& request, const DeleteGroupResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::DeleteGroup, request, handler, context);
  }
 
  virtual Model::DeleteIdentityProviderOutcome DeleteIdentityProvider(const Model::DeleteIdentityProviderRequest& request) const;
 
  template <typename DeleteIdentityProviderRequestT = Model::DeleteIdentityProviderRequest>
  Model::DeleteIdentityProviderOutcomeCallable DeleteIdentityProviderCallable(const DeleteIdentityProviderRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::DeleteIdentityProvider, request);
  }
 
  template <typename DeleteIdentityProviderRequestT = Model::DeleteIdentityProviderRequest>
  void DeleteIdentityProviderAsync(const DeleteIdentityProviderRequestT& request,
                                   const DeleteIdentityProviderResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::DeleteIdentityProvider, request, handler, context);
  }
 
  virtual Model::DeleteManagedLoginBrandingOutcome DeleteManagedLoginBranding(
      const Model::DeleteManagedLoginBrandingRequest& request) const;
 
  template <typename DeleteManagedLoginBrandingRequestT = Model::DeleteManagedLoginBrandingRequest>
  Model::DeleteManagedLoginBrandingOutcomeCallable DeleteManagedLoginBrandingCallable(
      const DeleteManagedLoginBrandingRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::DeleteManagedLoginBranding, request);
  }
 
  template <typename DeleteManagedLoginBrandingRequestT = Model::DeleteManagedLoginBrandingRequest>
  void DeleteManagedLoginBrandingAsync(const DeleteManagedLoginBrandingRequestT& request,
                                       const DeleteManagedLoginBrandingResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::DeleteManagedLoginBranding, request, handler, context);
  }
 
  virtual Model::DeleteResourceServerOutcome DeleteResourceServer(const Model::DeleteResourceServerRequest& request) const;
 
  template <typename DeleteResourceServerRequestT = Model::DeleteResourceServerRequest>
  Model::DeleteResourceServerOutcomeCallable DeleteResourceServerCallable(const DeleteResourceServerRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::DeleteResourceServer, request);
  }
 
  template <typename DeleteResourceServerRequestT = Model::DeleteResourceServerRequest>
  void DeleteResourceServerAsync(const DeleteResourceServerRequestT& request, const DeleteResourceServerResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::DeleteResourceServer, request, handler, context);
  }
 
  virtual Model::DeleteTermsOutcome DeleteTerms(const Model::DeleteTermsRequest& request) const;
 
  template <typename DeleteTermsRequestT = Model::DeleteTermsRequest>
  Model::DeleteTermsOutcomeCallable DeleteTermsCallable(const DeleteTermsRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::DeleteTerms, request);
  }
 
  template <typename DeleteTermsRequestT = Model::DeleteTermsRequest>
  void DeleteTermsAsync(const DeleteTermsRequestT& request, const DeleteTermsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::DeleteTerms, request, handler, context);
  }
 
  virtual Model::DeleteUserOutcome DeleteUser(const Model::DeleteUserRequest& request) const;
 
  template <typename DeleteUserRequestT = Model::DeleteUserRequest>
  Model::DeleteUserOutcomeCallable DeleteUserCallable(const DeleteUserRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::DeleteUser, request);
  }
 
  template <typename DeleteUserRequestT = Model::DeleteUserRequest>
  void DeleteUserAsync(const DeleteUserRequestT& request, const DeleteUserResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::DeleteUser, request, handler, context);
  }
 
  virtual Model::DeleteUserAttributesOutcome DeleteUserAttributes(const Model::DeleteUserAttributesRequest& request) const;
 
  template <typename DeleteUserAttributesRequestT = Model::DeleteUserAttributesRequest>
  Model::DeleteUserAttributesOutcomeCallable DeleteUserAttributesCallable(const DeleteUserAttributesRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::DeleteUserAttributes, request);
  }
 
  template <typename DeleteUserAttributesRequestT = Model::DeleteUserAttributesRequest>
  void DeleteUserAttributesAsync(const DeleteUserAttributesRequestT& request, const DeleteUserAttributesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::DeleteUserAttributes, request, handler, context);
  }
 
  virtual Model::DeleteUserPoolOutcome DeleteUserPool(const Model::DeleteUserPoolRequest& request) const;
 
  template <typename DeleteUserPoolRequestT = Model::DeleteUserPoolRequest>
  Model::DeleteUserPoolOutcomeCallable DeleteUserPoolCallable(const DeleteUserPoolRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::DeleteUserPool, request);
  }
 
  template <typename DeleteUserPoolRequestT = Model::DeleteUserPoolRequest>
  void DeleteUserPoolAsync(const DeleteUserPoolRequestT& request, const DeleteUserPoolResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::DeleteUserPool, request, handler, context);
  }
 
  virtual Model::DeleteUserPoolClientOutcome DeleteUserPoolClient(const Model::DeleteUserPoolClientRequest& request) const;
 
  template <typename DeleteUserPoolClientRequestT = Model::DeleteUserPoolClientRequest>
  Model::DeleteUserPoolClientOutcomeCallable DeleteUserPoolClientCallable(const DeleteUserPoolClientRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::DeleteUserPoolClient, request);
  }
 
  template <typename DeleteUserPoolClientRequestT = Model::DeleteUserPoolClientRequest>
  void DeleteUserPoolClientAsync(const DeleteUserPoolClientRequestT& request, const DeleteUserPoolClientResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::DeleteUserPoolClient, request, handler, context);
  }
 
  virtual Model::DeleteUserPoolClientSecretOutcome DeleteUserPoolClientSecret(
      const Model::DeleteUserPoolClientSecretRequest& request) const;
 
  template <typename DeleteUserPoolClientSecretRequestT = Model::DeleteUserPoolClientSecretRequest>
  Model::DeleteUserPoolClientSecretOutcomeCallable DeleteUserPoolClientSecretCallable(
      const DeleteUserPoolClientSecretRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::DeleteUserPoolClientSecret, request);
  }
 
  template <typename DeleteUserPoolClientSecretRequestT = Model::DeleteUserPoolClientSecretRequest>
  void DeleteUserPoolClientSecretAsync(const DeleteUserPoolClientSecretRequestT& request,
                                       const DeleteUserPoolClientSecretResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::DeleteUserPoolClientSecret, request, handler, context);
  }
 
  virtual Model::DeleteUserPoolDomainOutcome DeleteUserPoolDomain(const Model::DeleteUserPoolDomainRequest& request) const;
 
  template <typename DeleteUserPoolDomainRequestT = Model::DeleteUserPoolDomainRequest>
  Model::DeleteUserPoolDomainOutcomeCallable DeleteUserPoolDomainCallable(const DeleteUserPoolDomainRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::DeleteUserPoolDomain, request);
  }
 
  template <typename DeleteUserPoolDomainRequestT = Model::DeleteUserPoolDomainRequest>
  void DeleteUserPoolDomainAsync(const DeleteUserPoolDomainRequestT& request, const DeleteUserPoolDomainResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::DeleteUserPoolDomain, request, handler, context);
  }
 
  virtual Model::DeleteUserPoolReplicaOutcome DeleteUserPoolReplica(const Model::DeleteUserPoolReplicaRequest& request) const;
 
  template <typename DeleteUserPoolReplicaRequestT = Model::DeleteUserPoolReplicaRequest>
  Model::DeleteUserPoolReplicaOutcomeCallable DeleteUserPoolReplicaCallable(const DeleteUserPoolReplicaRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::DeleteUserPoolReplica, request);
  }
 
  template <typename DeleteUserPoolReplicaRequestT = Model::DeleteUserPoolReplicaRequest>
  void DeleteUserPoolReplicaAsync(const DeleteUserPoolReplicaRequestT& request, const DeleteUserPoolReplicaResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::DeleteUserPoolReplica, request, handler, context);
  }
 
  virtual Model::DeleteWebAuthnCredentialOutcome DeleteWebAuthnCredential(const Model::DeleteWebAuthnCredentialRequest& request) const;
 
  template <typename DeleteWebAuthnCredentialRequestT = Model::DeleteWebAuthnCredentialRequest>
  Model::DeleteWebAuthnCredentialOutcomeCallable DeleteWebAuthnCredentialCallable(const DeleteWebAuthnCredentialRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::DeleteWebAuthnCredential, request);
  }
 
  template <typename DeleteWebAuthnCredentialRequestT = Model::DeleteWebAuthnCredentialRequest>
  void DeleteWebAuthnCredentialAsync(const DeleteWebAuthnCredentialRequestT& request,
                                     const DeleteWebAuthnCredentialResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::DeleteWebAuthnCredential, request, handler, context);
  }
 
  virtual Model::DescribeIdentityProviderOutcome DescribeIdentityProvider(const Model::DescribeIdentityProviderRequest& request) const;
 
  template <typename DescribeIdentityProviderRequestT = Model::DescribeIdentityProviderRequest>
  Model::DescribeIdentityProviderOutcomeCallable DescribeIdentityProviderCallable(const DescribeIdentityProviderRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::DescribeIdentityProvider, request);
  }
 
  template <typename DescribeIdentityProviderRequestT = Model::DescribeIdentityProviderRequest>
  void DescribeIdentityProviderAsync(const DescribeIdentityProviderRequestT& request,
                                     const DescribeIdentityProviderResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::DescribeIdentityProvider, request, handler, context);
  }
 
  virtual Model::DescribeManagedLoginBrandingOutcome DescribeManagedLoginBranding(
      const Model::DescribeManagedLoginBrandingRequest& request) const;
 
  template <typename DescribeManagedLoginBrandingRequestT = Model::DescribeManagedLoginBrandingRequest>
  Model::DescribeManagedLoginBrandingOutcomeCallable DescribeManagedLoginBrandingCallable(
      const DescribeManagedLoginBrandingRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::DescribeManagedLoginBranding, request);
  }
 
  template <typename DescribeManagedLoginBrandingRequestT = Model::DescribeManagedLoginBrandingRequest>
  void DescribeManagedLoginBrandingAsync(const DescribeManagedLoginBrandingRequestT& request,
                                         const DescribeManagedLoginBrandingResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::DescribeManagedLoginBranding, request, handler, context);
  }
 
  virtual Model::DescribeManagedLoginBrandingByClientOutcome DescribeManagedLoginBrandingByClient(
      const Model::DescribeManagedLoginBrandingByClientRequest& request) const;
 
  template <typename DescribeManagedLoginBrandingByClientRequestT = Model::DescribeManagedLoginBrandingByClientRequest>
  Model::DescribeManagedLoginBrandingByClientOutcomeCallable DescribeManagedLoginBrandingByClientCallable(
      const DescribeManagedLoginBrandingByClientRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::DescribeManagedLoginBrandingByClient, request);
  }
 
  template <typename DescribeManagedLoginBrandingByClientRequestT = Model::DescribeManagedLoginBrandingByClientRequest>
  void DescribeManagedLoginBrandingByClientAsync(const DescribeManagedLoginBrandingByClientRequestT& request,
                                                 const DescribeManagedLoginBrandingByClientResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::DescribeManagedLoginBrandingByClient, request, handler, context);
  }
 
  virtual Model::DescribeResourceServerOutcome DescribeResourceServer(const Model::DescribeResourceServerRequest& request) const;
 
  template <typename DescribeResourceServerRequestT = Model::DescribeResourceServerRequest>
  Model::DescribeResourceServerOutcomeCallable DescribeResourceServerCallable(const DescribeResourceServerRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::DescribeResourceServer, request);
  }
 
  template <typename DescribeResourceServerRequestT = Model::DescribeResourceServerRequest>
  void DescribeResourceServerAsync(const DescribeResourceServerRequestT& request,
                                   const DescribeResourceServerResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::DescribeResourceServer, request, handler, context);
  }
 
  virtual Model::DescribeRiskConfigurationOutcome DescribeRiskConfiguration(const Model::DescribeRiskConfigurationRequest& request) const;
 
  template <typename DescribeRiskConfigurationRequestT = Model::DescribeRiskConfigurationRequest>
  Model::DescribeRiskConfigurationOutcomeCallable DescribeRiskConfigurationCallable(
      const DescribeRiskConfigurationRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::DescribeRiskConfiguration, request);
  }
 
  template <typename DescribeRiskConfigurationRequestT = Model::DescribeRiskConfigurationRequest>
  void DescribeRiskConfigurationAsync(const DescribeRiskConfigurationRequestT& request,
                                      const DescribeRiskConfigurationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::DescribeRiskConfiguration, request, handler, context);
  }
 
  virtual Model::DescribeTermsOutcome DescribeTerms(const Model::DescribeTermsRequest& request) const;
 
  template <typename DescribeTermsRequestT = Model::DescribeTermsRequest>
  Model::DescribeTermsOutcomeCallable DescribeTermsCallable(const DescribeTermsRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::DescribeTerms, request);
  }
 
  template <typename DescribeTermsRequestT = Model::DescribeTermsRequest>
  void DescribeTermsAsync(const DescribeTermsRequestT& request, const DescribeTermsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::DescribeTerms, request, handler, context);
  }
 
  virtual Model::DescribeTermsByClientOutcome DescribeTermsByClient(const Model::DescribeTermsByClientRequest& request) const;
 
  template <typename DescribeTermsByClientRequestT = Model::DescribeTermsByClientRequest>
  Model::DescribeTermsByClientOutcomeCallable DescribeTermsByClientCallable(const DescribeTermsByClientRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::DescribeTermsByClient, request);
  }
 
  template <typename DescribeTermsByClientRequestT = Model::DescribeTermsByClientRequest>
  void DescribeTermsByClientAsync(const DescribeTermsByClientRequestT& request, const DescribeTermsByClientResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::DescribeTermsByClient, request, handler, context);
  }
 
  virtual Model::DescribeUserImportJobOutcome DescribeUserImportJob(const Model::DescribeUserImportJobRequest& request) const;
 
  template <typename DescribeUserImportJobRequestT = Model::DescribeUserImportJobRequest>
  Model::DescribeUserImportJobOutcomeCallable DescribeUserImportJobCallable(const DescribeUserImportJobRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::DescribeUserImportJob, request);
  }
 
  template <typename DescribeUserImportJobRequestT = Model::DescribeUserImportJobRequest>
  void DescribeUserImportJobAsync(const DescribeUserImportJobRequestT& request, const DescribeUserImportJobResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::DescribeUserImportJob, request, handler, context);
  }
 
  virtual Model::DescribeUserPoolOutcome DescribeUserPool(const Model::DescribeUserPoolRequest& request) const;
 
  template <typename DescribeUserPoolRequestT = Model::DescribeUserPoolRequest>
  Model::DescribeUserPoolOutcomeCallable DescribeUserPoolCallable(const DescribeUserPoolRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::DescribeUserPool, request);
  }
 
  template <typename DescribeUserPoolRequestT = Model::DescribeUserPoolRequest>
  void DescribeUserPoolAsync(const DescribeUserPoolRequestT& request, const DescribeUserPoolResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::DescribeUserPool, request, handler, context);
  }
 
  virtual Model::DescribeUserPoolClientOutcome DescribeUserPoolClient(const Model::DescribeUserPoolClientRequest& request) const;
 
  template <typename DescribeUserPoolClientRequestT = Model::DescribeUserPoolClientRequest>
  Model::DescribeUserPoolClientOutcomeCallable DescribeUserPoolClientCallable(const DescribeUserPoolClientRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::DescribeUserPoolClient, request);
  }
 
  template <typename DescribeUserPoolClientRequestT = Model::DescribeUserPoolClientRequest>
  void DescribeUserPoolClientAsync(const DescribeUserPoolClientRequestT& request,
                                   const DescribeUserPoolClientResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::DescribeUserPoolClient, request, handler, context);
  }
 
  virtual Model::DescribeUserPoolDomainOutcome DescribeUserPoolDomain(const Model::DescribeUserPoolDomainRequest& request) const;
 
  template <typename DescribeUserPoolDomainRequestT = Model::DescribeUserPoolDomainRequest>
  Model::DescribeUserPoolDomainOutcomeCallable DescribeUserPoolDomainCallable(const DescribeUserPoolDomainRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::DescribeUserPoolDomain, request);
  }
 
  template <typename DescribeUserPoolDomainRequestT = Model::DescribeUserPoolDomainRequest>
  void DescribeUserPoolDomainAsync(const DescribeUserPoolDomainRequestT& request,
                                   const DescribeUserPoolDomainResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::DescribeUserPoolDomain, request, handler, context);
  }
 
  virtual Model::ForgetDeviceOutcome ForgetDevice(const Model::ForgetDeviceRequest& request) const;
 
  template <typename ForgetDeviceRequestT = Model::ForgetDeviceRequest>
  Model::ForgetDeviceOutcomeCallable ForgetDeviceCallable(const ForgetDeviceRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::ForgetDevice, request);
  }
 
  template <typename ForgetDeviceRequestT = Model::ForgetDeviceRequest>
  void ForgetDeviceAsync(const ForgetDeviceRequestT& request, const ForgetDeviceResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::ForgetDevice, request, handler, context);
  }
 
  virtual Model::ForgotPasswordOutcome ForgotPassword(const Model::ForgotPasswordRequest& request) const;
 
  template <typename ForgotPasswordRequestT = Model::ForgotPasswordRequest>
  Model::ForgotPasswordOutcomeCallable ForgotPasswordCallable(const ForgotPasswordRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::ForgotPassword, request);
  }
 
  template <typename ForgotPasswordRequestT = Model::ForgotPasswordRequest>
  void ForgotPasswordAsync(const ForgotPasswordRequestT& request, const ForgotPasswordResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::ForgotPassword, request, handler, context);
  }
 
  virtual Model::GetCSVHeaderOutcome GetCSVHeader(const Model::GetCSVHeaderRequest& request) const;
 
  template <typename GetCSVHeaderRequestT = Model::GetCSVHeaderRequest>
  Model::GetCSVHeaderOutcomeCallable GetCSVHeaderCallable(const GetCSVHeaderRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::GetCSVHeader, request);
  }
 
  template <typename GetCSVHeaderRequestT = Model::GetCSVHeaderRequest>
  void GetCSVHeaderAsync(const GetCSVHeaderRequestT& request, const GetCSVHeaderResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::GetCSVHeader, request, handler, context);
  }
 
  virtual Model::GetClientTokenOutcome GetClientToken(const Model::GetClientTokenRequest& request) const;
 
  template <typename GetClientTokenRequestT = Model::GetClientTokenRequest>
  Model::GetClientTokenOutcomeCallable GetClientTokenCallable(const GetClientTokenRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::GetClientToken, request);
  }
 
  template <typename GetClientTokenRequestT = Model::GetClientTokenRequest>
  void GetClientTokenAsync(const GetClientTokenRequestT& request, const GetClientTokenResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::GetClientToken, request, handler, context);
  }
 
  virtual Model::GetDeviceOutcome GetDevice(const Model::GetDeviceRequest& request) const;
 
  template <typename GetDeviceRequestT = Model::GetDeviceRequest>
  Model::GetDeviceOutcomeCallable GetDeviceCallable(const GetDeviceRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::GetDevice, request);
  }
 
  template <typename GetDeviceRequestT = Model::GetDeviceRequest>
  void GetDeviceAsync(const GetDeviceRequestT& request, const GetDeviceResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::GetDevice, request, handler, context);
  }
 
  virtual Model::GetGroupOutcome GetGroup(const Model::GetGroupRequest& request) const;
 
  template <typename GetGroupRequestT = Model::GetGroupRequest>
  Model::GetGroupOutcomeCallable GetGroupCallable(const GetGroupRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::GetGroup, request);
  }
 
  template <typename GetGroupRequestT = Model::GetGroupRequest>
  void GetGroupAsync(const GetGroupRequestT& request, const GetGroupResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::GetGroup, request, handler, context);
  }
 
  virtual Model::GetIdentityProviderByIdentifierOutcome GetIdentityProviderByIdentifier(
      const Model::GetIdentityProviderByIdentifierRequest& request) const;
 
  template <typename GetIdentityProviderByIdentifierRequestT = Model::GetIdentityProviderByIdentifierRequest>
  Model::GetIdentityProviderByIdentifierOutcomeCallable GetIdentityProviderByIdentifierCallable(
      const GetIdentityProviderByIdentifierRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::GetIdentityProviderByIdentifier, request);
  }
 
  template <typename GetIdentityProviderByIdentifierRequestT = Model::GetIdentityProviderByIdentifierRequest>
  void GetIdentityProviderByIdentifierAsync(const GetIdentityProviderByIdentifierRequestT& request,
                                            const GetIdentityProviderByIdentifierResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::GetIdentityProviderByIdentifier, request, handler, context);
  }
 
  virtual Model::GetLogDeliveryConfigurationOutcome GetLogDeliveryConfiguration(
      const Model::GetLogDeliveryConfigurationRequest& request) const;
 
  template <typename GetLogDeliveryConfigurationRequestT = Model::GetLogDeliveryConfigurationRequest>
  Model::GetLogDeliveryConfigurationOutcomeCallable GetLogDeliveryConfigurationCallable(
      const GetLogDeliveryConfigurationRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::GetLogDeliveryConfiguration, request);
  }
 
  template <typename GetLogDeliveryConfigurationRequestT = Model::GetLogDeliveryConfigurationRequest>
  void GetLogDeliveryConfigurationAsync(const GetLogDeliveryConfigurationRequestT& request,
                                        const GetLogDeliveryConfigurationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::GetLogDeliveryConfiguration, request, handler, context);
  }
 
  virtual Model::GetProvisionedLimitOutcome GetProvisionedLimit(const Model::GetProvisionedLimitRequest& request) const;
 
  template <typename GetProvisionedLimitRequestT = Model::GetProvisionedLimitRequest>
  Model::GetProvisionedLimitOutcomeCallable GetProvisionedLimitCallable(const GetProvisionedLimitRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::GetProvisionedLimit, request);
  }
 
  template <typename GetProvisionedLimitRequestT = Model::GetProvisionedLimitRequest>
  void GetProvisionedLimitAsync(const GetProvisionedLimitRequestT& request, const GetProvisionedLimitResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::GetProvisionedLimit, request, handler, context);
  }
 
  virtual Model::GetSigningCertificateOutcome GetSigningCertificate(const Model::GetSigningCertificateRequest& request) const;
 
  template <typename GetSigningCertificateRequestT = Model::GetSigningCertificateRequest>
  Model::GetSigningCertificateOutcomeCallable GetSigningCertificateCallable(const GetSigningCertificateRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::GetSigningCertificate, request);
  }
 
  template <typename GetSigningCertificateRequestT = Model::GetSigningCertificateRequest>
  void GetSigningCertificateAsync(const GetSigningCertificateRequestT& request, const GetSigningCertificateResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::GetSigningCertificate, request, handler, context);
  }
 
  virtual Model::GetTokensFromRefreshTokenOutcome GetTokensFromRefreshToken(const Model::GetTokensFromRefreshTokenRequest& request) const;
 
  template <typename GetTokensFromRefreshTokenRequestT = Model::GetTokensFromRefreshTokenRequest>
  Model::GetTokensFromRefreshTokenOutcomeCallable GetTokensFromRefreshTokenCallable(
      const GetTokensFromRefreshTokenRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::GetTokensFromRefreshToken, request);
  }
 
  template <typename GetTokensFromRefreshTokenRequestT = Model::GetTokensFromRefreshTokenRequest>
  void GetTokensFromRefreshTokenAsync(const GetTokensFromRefreshTokenRequestT& request,
                                      const GetTokensFromRefreshTokenResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::GetTokensFromRefreshToken, request, handler, context);
  }
 
  virtual Model::GetUICustomizationOutcome GetUICustomization(const Model::GetUICustomizationRequest& request) const;
 
  template <typename GetUICustomizationRequestT = Model::GetUICustomizationRequest>
  Model::GetUICustomizationOutcomeCallable GetUICustomizationCallable(const GetUICustomizationRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::GetUICustomization, request);
  }
 
  template <typename GetUICustomizationRequestT = Model::GetUICustomizationRequest>
  void GetUICustomizationAsync(const GetUICustomizationRequestT& request, const GetUICustomizationResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::GetUICustomization, request, handler, context);
  }
 
  virtual Model::GetUserOutcome GetUser(const Model::GetUserRequest& request) const;
 
  template <typename GetUserRequestT = Model::GetUserRequest>
  Model::GetUserOutcomeCallable GetUserCallable(const GetUserRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::GetUser, request);
  }
 
  template <typename GetUserRequestT = Model::GetUserRequest>
  void GetUserAsync(const GetUserRequestT& request, const GetUserResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::GetUser, request, handler, context);
  }
 
  virtual Model::GetUserAttributeVerificationCodeOutcome GetUserAttributeVerificationCode(
      const Model::GetUserAttributeVerificationCodeRequest& request) const;
 
  template <typename GetUserAttributeVerificationCodeRequestT = Model::GetUserAttributeVerificationCodeRequest>
  Model::GetUserAttributeVerificationCodeOutcomeCallable GetUserAttributeVerificationCodeCallable(
      const GetUserAttributeVerificationCodeRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::GetUserAttributeVerificationCode, request);
  }
 
  template <typename GetUserAttributeVerificationCodeRequestT = Model::GetUserAttributeVerificationCodeRequest>
  void GetUserAttributeVerificationCodeAsync(const GetUserAttributeVerificationCodeRequestT& request,
                                             const GetUserAttributeVerificationCodeResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::GetUserAttributeVerificationCode, request, handler, context);
  }
 
  virtual Model::GetUserAuthFactorsOutcome GetUserAuthFactors(const Model::GetUserAuthFactorsRequest& request) const;
 
  template <typename GetUserAuthFactorsRequestT = Model::GetUserAuthFactorsRequest>
  Model::GetUserAuthFactorsOutcomeCallable GetUserAuthFactorsCallable(const GetUserAuthFactorsRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::GetUserAuthFactors, request);
  }
 
  template <typename GetUserAuthFactorsRequestT = Model::GetUserAuthFactorsRequest>
  void GetUserAuthFactorsAsync(const GetUserAuthFactorsRequestT& request, const GetUserAuthFactorsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::GetUserAuthFactors, request, handler, context);
  }
 
  virtual Model::GetUserPoolMfaConfigOutcome GetUserPoolMfaConfig(const Model::GetUserPoolMfaConfigRequest& request) const;
 
  template <typename GetUserPoolMfaConfigRequestT = Model::GetUserPoolMfaConfigRequest>
  Model::GetUserPoolMfaConfigOutcomeCallable GetUserPoolMfaConfigCallable(const GetUserPoolMfaConfigRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::GetUserPoolMfaConfig, request);
  }
 
  template <typename GetUserPoolMfaConfigRequestT = Model::GetUserPoolMfaConfigRequest>
  void GetUserPoolMfaConfigAsync(const GetUserPoolMfaConfigRequestT& request, const GetUserPoolMfaConfigResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::GetUserPoolMfaConfig, request, handler, context);
  }
 
  virtual Model::GlobalSignOutOutcome GlobalSignOut(const Model::GlobalSignOutRequest& request) const;
 
  template <typename GlobalSignOutRequestT = Model::GlobalSignOutRequest>
  Model::GlobalSignOutOutcomeCallable GlobalSignOutCallable(const GlobalSignOutRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::GlobalSignOut, request);
  }
 
  template <typename GlobalSignOutRequestT = Model::GlobalSignOutRequest>
  void GlobalSignOutAsync(const GlobalSignOutRequestT& request, const GlobalSignOutResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::GlobalSignOut, request, handler, context);
  }
 
  virtual Model::InitiateAuthOutcome InitiateAuth(const Model::InitiateAuthRequest& request) const;
 
  template <typename InitiateAuthRequestT = Model::InitiateAuthRequest>
  Model::InitiateAuthOutcomeCallable InitiateAuthCallable(const InitiateAuthRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::InitiateAuth, request);
  }
 
  template <typename InitiateAuthRequestT = Model::InitiateAuthRequest>
  void InitiateAuthAsync(const InitiateAuthRequestT& request, const InitiateAuthResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::InitiateAuth, request, handler, context);
  }
 
  virtual Model::ListDevicesOutcome ListDevices(const Model::ListDevicesRequest& request) const;
 
  template <typename ListDevicesRequestT = Model::ListDevicesRequest>
  Model::ListDevicesOutcomeCallable ListDevicesCallable(const ListDevicesRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::ListDevices, request);
  }
 
  template <typename ListDevicesRequestT = Model::ListDevicesRequest>
  void ListDevicesAsync(const ListDevicesRequestT& request, const ListDevicesResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::ListDevices, request, handler, context);
  }
 
  virtual Model::ListGroupsOutcome ListGroups(const Model::ListGroupsRequest& request) const;
 
  template <typename ListGroupsRequestT = Model::ListGroupsRequest>
  Model::ListGroupsOutcomeCallable ListGroupsCallable(const ListGroupsRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::ListGroups, request);
  }
 
  template <typename ListGroupsRequestT = Model::ListGroupsRequest>
  void ListGroupsAsync(const ListGroupsRequestT& request, const ListGroupsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::ListGroups, request, handler, context);
  }
 
  virtual Model::ListIdentityProvidersOutcome ListIdentityProviders(const Model::ListIdentityProvidersRequest& request) const;
 
  template <typename ListIdentityProvidersRequestT = Model::ListIdentityProvidersRequest>
  Model::ListIdentityProvidersOutcomeCallable ListIdentityProvidersCallable(const ListIdentityProvidersRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::ListIdentityProviders, request);
  }
 
  template <typename ListIdentityProvidersRequestT = Model::ListIdentityProvidersRequest>
  void ListIdentityProvidersAsync(const ListIdentityProvidersRequestT& request, const ListIdentityProvidersResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::ListIdentityProviders, request, handler, context);
  }
 
  virtual Model::ListResourceServersOutcome ListResourceServers(const Model::ListResourceServersRequest& request) const;
 
  template <typename ListResourceServersRequestT = Model::ListResourceServersRequest>
  Model::ListResourceServersOutcomeCallable ListResourceServersCallable(const ListResourceServersRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::ListResourceServers, request);
  }
 
  template <typename ListResourceServersRequestT = Model::ListResourceServersRequest>
  void ListResourceServersAsync(const ListResourceServersRequestT& request, const ListResourceServersResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::ListResourceServers, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::ListTagsForResource, request);
  }
 
  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(&CognitoIdentityProviderClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTermsOutcome ListTerms(const Model::ListTermsRequest& request) const;
 
  template <typename ListTermsRequestT = Model::ListTermsRequest>
  Model::ListTermsOutcomeCallable ListTermsCallable(const ListTermsRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::ListTerms, request);
  }
 
  template <typename ListTermsRequestT = Model::ListTermsRequest>
  void ListTermsAsync(const ListTermsRequestT& request, const ListTermsResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::ListTerms, request, handler, context);
  }
 
  virtual Model::ListUserImportJobsOutcome ListUserImportJobs(const Model::ListUserImportJobsRequest& request) const;
 
  template <typename ListUserImportJobsRequestT = Model::ListUserImportJobsRequest>
  Model::ListUserImportJobsOutcomeCallable ListUserImportJobsCallable(const ListUserImportJobsRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::ListUserImportJobs, request);
  }
 
  template <typename ListUserImportJobsRequestT = Model::ListUserImportJobsRequest>
  void ListUserImportJobsAsync(const ListUserImportJobsRequestT& request, const ListUserImportJobsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::ListUserImportJobs, request, handler, context);
  }
 
  virtual Model::ListUserPoolClientSecretsOutcome ListUserPoolClientSecrets(const Model::ListUserPoolClientSecretsRequest& request) const;
 
  template <typename ListUserPoolClientSecretsRequestT = Model::ListUserPoolClientSecretsRequest>
  Model::ListUserPoolClientSecretsOutcomeCallable ListUserPoolClientSecretsCallable(
      const ListUserPoolClientSecretsRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::ListUserPoolClientSecrets, request);
  }
 
  template <typename ListUserPoolClientSecretsRequestT = Model::ListUserPoolClientSecretsRequest>
  void ListUserPoolClientSecretsAsync(const ListUserPoolClientSecretsRequestT& request,
                                      const ListUserPoolClientSecretsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::ListUserPoolClientSecrets, request, handler, context);
  }
 
  virtual Model::ListUserPoolClientsOutcome ListUserPoolClients(const Model::ListUserPoolClientsRequest& request) const;
 
  template <typename ListUserPoolClientsRequestT = Model::ListUserPoolClientsRequest>
  Model::ListUserPoolClientsOutcomeCallable ListUserPoolClientsCallable(const ListUserPoolClientsRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::ListUserPoolClients, request);
  }
 
  template <typename ListUserPoolClientsRequestT = Model::ListUserPoolClientsRequest>
  void ListUserPoolClientsAsync(const ListUserPoolClientsRequestT& request, const ListUserPoolClientsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::ListUserPoolClients, request, handler, context);
  }
 
  virtual Model::ListUserPoolReplicasOutcome ListUserPoolReplicas(const Model::ListUserPoolReplicasRequest& request) const;
 
  template <typename ListUserPoolReplicasRequestT = Model::ListUserPoolReplicasRequest>
  Model::ListUserPoolReplicasOutcomeCallable ListUserPoolReplicasCallable(const ListUserPoolReplicasRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::ListUserPoolReplicas, request);
  }
 
  template <typename ListUserPoolReplicasRequestT = Model::ListUserPoolReplicasRequest>
  void ListUserPoolReplicasAsync(const ListUserPoolReplicasRequestT& request, const ListUserPoolReplicasResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::ListUserPoolReplicas, request, handler, context);
  }
 
  virtual Model::ListUserPoolsOutcome ListUserPools(const Model::ListUserPoolsRequest& request) const;
 
  template <typename ListUserPoolsRequestT = Model::ListUserPoolsRequest>
  Model::ListUserPoolsOutcomeCallable ListUserPoolsCallable(const ListUserPoolsRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::ListUserPools, request);
  }
 
  template <typename ListUserPoolsRequestT = Model::ListUserPoolsRequest>
  void ListUserPoolsAsync(const ListUserPoolsRequestT& request, const ListUserPoolsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::ListUserPools, request, handler, context);
  }
 
  virtual Model::ListUsersOutcome ListUsers(const Model::ListUsersRequest& request) const;
 
  template <typename ListUsersRequestT = Model::ListUsersRequest>
  Model::ListUsersOutcomeCallable ListUsersCallable(const ListUsersRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::ListUsers, request);
  }
 
  template <typename ListUsersRequestT = Model::ListUsersRequest>
  void ListUsersAsync(const ListUsersRequestT& request, const ListUsersResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::ListUsers, request, handler, context);
  }
 
  virtual Model::ListUsersInGroupOutcome ListUsersInGroup(const Model::ListUsersInGroupRequest& request) const;
 
  template <typename ListUsersInGroupRequestT = Model::ListUsersInGroupRequest>
  Model::ListUsersInGroupOutcomeCallable ListUsersInGroupCallable(const ListUsersInGroupRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::ListUsersInGroup, request);
  }
 
  template <typename ListUsersInGroupRequestT = Model::ListUsersInGroupRequest>
  void ListUsersInGroupAsync(const ListUsersInGroupRequestT& request, const ListUsersInGroupResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::ListUsersInGroup, request, handler, context);
  }
 
  virtual Model::ListWebAuthnCredentialsOutcome ListWebAuthnCredentials(const Model::ListWebAuthnCredentialsRequest& request) const;
 
  template <typename ListWebAuthnCredentialsRequestT = Model::ListWebAuthnCredentialsRequest>
  Model::ListWebAuthnCredentialsOutcomeCallable ListWebAuthnCredentialsCallable(const ListWebAuthnCredentialsRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::ListWebAuthnCredentials, request);
  }
 
  template <typename ListWebAuthnCredentialsRequestT = Model::ListWebAuthnCredentialsRequest>
  void ListWebAuthnCredentialsAsync(const ListWebAuthnCredentialsRequestT& request,
                                    const ListWebAuthnCredentialsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::ListWebAuthnCredentials, request, handler, context);
  }
 
  virtual Model::ResendConfirmationCodeOutcome ResendConfirmationCode(const Model::ResendConfirmationCodeRequest& request) const;
 
  template <typename ResendConfirmationCodeRequestT = Model::ResendConfirmationCodeRequest>
  Model::ResendConfirmationCodeOutcomeCallable ResendConfirmationCodeCallable(const ResendConfirmationCodeRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::ResendConfirmationCode, request);
  }
 
  template <typename ResendConfirmationCodeRequestT = Model::ResendConfirmationCodeRequest>
  void ResendConfirmationCodeAsync(const ResendConfirmationCodeRequestT& request,
                                   const ResendConfirmationCodeResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::ResendConfirmationCode, request, handler, context);
  }
 
  virtual Model::RespondToAuthChallengeOutcome RespondToAuthChallenge(const Model::RespondToAuthChallengeRequest& request) const;
 
  template <typename RespondToAuthChallengeRequestT = Model::RespondToAuthChallengeRequest>
  Model::RespondToAuthChallengeOutcomeCallable RespondToAuthChallengeCallable(const RespondToAuthChallengeRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::RespondToAuthChallenge, request);
  }
 
  template <typename RespondToAuthChallengeRequestT = Model::RespondToAuthChallengeRequest>
  void RespondToAuthChallengeAsync(const RespondToAuthChallengeRequestT& request,
                                   const RespondToAuthChallengeResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::RespondToAuthChallenge, request, handler, context);
  }
 
  virtual Model::RevokeTokenOutcome RevokeToken(const Model::RevokeTokenRequest& request) const;
 
  template <typename RevokeTokenRequestT = Model::RevokeTokenRequest>
  Model::RevokeTokenOutcomeCallable RevokeTokenCallable(const RevokeTokenRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::RevokeToken, request);
  }
 
  template <typename RevokeTokenRequestT = Model::RevokeTokenRequest>
  void RevokeTokenAsync(const RevokeTokenRequestT& request, const RevokeTokenResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::RevokeToken, request, handler, context);
  }
 
  virtual Model::SetLogDeliveryConfigurationOutcome SetLogDeliveryConfiguration(
      const Model::SetLogDeliveryConfigurationRequest& request) const;
 
  template <typename SetLogDeliveryConfigurationRequestT = Model::SetLogDeliveryConfigurationRequest>
  Model::SetLogDeliveryConfigurationOutcomeCallable SetLogDeliveryConfigurationCallable(
      const SetLogDeliveryConfigurationRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::SetLogDeliveryConfiguration, request);
  }
 
  template <typename SetLogDeliveryConfigurationRequestT = Model::SetLogDeliveryConfigurationRequest>
  void SetLogDeliveryConfigurationAsync(const SetLogDeliveryConfigurationRequestT& request,
                                        const SetLogDeliveryConfigurationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::SetLogDeliveryConfiguration, request, handler, context);
  }
 
  virtual Model::SetRiskConfigurationOutcome SetRiskConfiguration(const Model::SetRiskConfigurationRequest& request) const;
 
  template <typename SetRiskConfigurationRequestT = Model::SetRiskConfigurationRequest>
  Model::SetRiskConfigurationOutcomeCallable SetRiskConfigurationCallable(const SetRiskConfigurationRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::SetRiskConfiguration, request);
  }
 
  template <typename SetRiskConfigurationRequestT = Model::SetRiskConfigurationRequest>
  void SetRiskConfigurationAsync(const SetRiskConfigurationRequestT& request, const SetRiskConfigurationResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::SetRiskConfiguration, request, handler, context);
  }
 
  virtual Model::SetUICustomizationOutcome SetUICustomization(const Model::SetUICustomizationRequest& request) const;
 
  template <typename SetUICustomizationRequestT = Model::SetUICustomizationRequest>
  Model::SetUICustomizationOutcomeCallable SetUICustomizationCallable(const SetUICustomizationRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::SetUICustomization, request);
  }
 
  template <typename SetUICustomizationRequestT = Model::SetUICustomizationRequest>
  void SetUICustomizationAsync(const SetUICustomizationRequestT& request, const SetUICustomizationResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::SetUICustomization, request, handler, context);
  }
 
  virtual Model::SetUserMFAPreferenceOutcome SetUserMFAPreference(const Model::SetUserMFAPreferenceRequest& request) const;
 
  template <typename SetUserMFAPreferenceRequestT = Model::SetUserMFAPreferenceRequest>
  Model::SetUserMFAPreferenceOutcomeCallable SetUserMFAPreferenceCallable(const SetUserMFAPreferenceRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::SetUserMFAPreference, request);
  }
 
  template <typename SetUserMFAPreferenceRequestT = Model::SetUserMFAPreferenceRequest>
  void SetUserMFAPreferenceAsync(const SetUserMFAPreferenceRequestT& request, const SetUserMFAPreferenceResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::SetUserMFAPreference, request, handler, context);
  }
 
  virtual Model::SetUserPoolMfaConfigOutcome SetUserPoolMfaConfig(const Model::SetUserPoolMfaConfigRequest& request) const;
 
  template <typename SetUserPoolMfaConfigRequestT = Model::SetUserPoolMfaConfigRequest>
  Model::SetUserPoolMfaConfigOutcomeCallable SetUserPoolMfaConfigCallable(const SetUserPoolMfaConfigRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::SetUserPoolMfaConfig, request);
  }
 
  template <typename SetUserPoolMfaConfigRequestT = Model::SetUserPoolMfaConfigRequest>
  void SetUserPoolMfaConfigAsync(const SetUserPoolMfaConfigRequestT& request, const SetUserPoolMfaConfigResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::SetUserPoolMfaConfig, request, handler, context);
  }
 
  virtual Model::SetUserSettingsOutcome SetUserSettings(const Model::SetUserSettingsRequest& request) const;
 
  template <typename SetUserSettingsRequestT = Model::SetUserSettingsRequest>
  Model::SetUserSettingsOutcomeCallable SetUserSettingsCallable(const SetUserSettingsRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::SetUserSettings, request);
  }
 
  template <typename SetUserSettingsRequestT = Model::SetUserSettingsRequest>
  void SetUserSettingsAsync(const SetUserSettingsRequestT& request, const SetUserSettingsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::SetUserSettings, request, handler, context);
  }
 
  virtual Model::SignUpOutcome SignUp(const Model::SignUpRequest& request) const;
 
  template <typename SignUpRequestT = Model::SignUpRequest>
  Model::SignUpOutcomeCallable SignUpCallable(const SignUpRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::SignUp, request);
  }
 
  template <typename SignUpRequestT = Model::SignUpRequest>
  void SignUpAsync(const SignUpRequestT& request, const SignUpResponseReceivedHandler& handler,
                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::SignUp, request, handler, context);
  }
 
  virtual Model::StartUserImportJobOutcome StartUserImportJob(const Model::StartUserImportJobRequest& request) const;
 
  template <typename StartUserImportJobRequestT = Model::StartUserImportJobRequest>
  Model::StartUserImportJobOutcomeCallable StartUserImportJobCallable(const StartUserImportJobRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::StartUserImportJob, request);
  }
 
  template <typename StartUserImportJobRequestT = Model::StartUserImportJobRequest>
  void StartUserImportJobAsync(const StartUserImportJobRequestT& request, const StartUserImportJobResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::StartUserImportJob, request, handler, context);
  }
 
  virtual Model::StartWebAuthnRegistrationOutcome StartWebAuthnRegistration(const Model::StartWebAuthnRegistrationRequest& request) const;
 
  template <typename StartWebAuthnRegistrationRequestT = Model::StartWebAuthnRegistrationRequest>
  Model::StartWebAuthnRegistrationOutcomeCallable StartWebAuthnRegistrationCallable(
      const StartWebAuthnRegistrationRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::StartWebAuthnRegistration, request);
  }
 
  template <typename StartWebAuthnRegistrationRequestT = Model::StartWebAuthnRegistrationRequest>
  void StartWebAuthnRegistrationAsync(const StartWebAuthnRegistrationRequestT& request,
                                      const StartWebAuthnRegistrationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::StartWebAuthnRegistration, request, handler, context);
  }
 
  virtual Model::StopUserImportJobOutcome StopUserImportJob(const Model::StopUserImportJobRequest& request) const;
 
  template <typename StopUserImportJobRequestT = Model::StopUserImportJobRequest>
  Model::StopUserImportJobOutcomeCallable StopUserImportJobCallable(const StopUserImportJobRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::StopUserImportJob, request);
  }
 
  template <typename StopUserImportJobRequestT = Model::StopUserImportJobRequest>
  void StopUserImportJobAsync(const StopUserImportJobRequestT& request, const StopUserImportJobResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::StopUserImportJob, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::TagResource, request);
  }
 
  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(&CognitoIdentityProviderClient::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::UntagResource, request);
  }
 
  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(&CognitoIdentityProviderClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateAuthEventFeedbackOutcome UpdateAuthEventFeedback(const Model::UpdateAuthEventFeedbackRequest& request) const;
 
  template <typename UpdateAuthEventFeedbackRequestT = Model::UpdateAuthEventFeedbackRequest>
  Model::UpdateAuthEventFeedbackOutcomeCallable UpdateAuthEventFeedbackCallable(const UpdateAuthEventFeedbackRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::UpdateAuthEventFeedback, request);
  }
 
  template <typename UpdateAuthEventFeedbackRequestT = Model::UpdateAuthEventFeedbackRequest>
  void UpdateAuthEventFeedbackAsync(const UpdateAuthEventFeedbackRequestT& request,
                                    const UpdateAuthEventFeedbackResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::UpdateAuthEventFeedback, request, handler, context);
  }
 
  virtual Model::UpdateDeviceStatusOutcome UpdateDeviceStatus(const Model::UpdateDeviceStatusRequest& request) const;
 
  template <typename UpdateDeviceStatusRequestT = Model::UpdateDeviceStatusRequest>
  Model::UpdateDeviceStatusOutcomeCallable UpdateDeviceStatusCallable(const UpdateDeviceStatusRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::UpdateDeviceStatus, request);
  }
 
  template <typename UpdateDeviceStatusRequestT = Model::UpdateDeviceStatusRequest>
  void UpdateDeviceStatusAsync(const UpdateDeviceStatusRequestT& request, const UpdateDeviceStatusResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::UpdateDeviceStatus, request, handler, context);
  }
 
  virtual Model::UpdateGroupOutcome UpdateGroup(const Model::UpdateGroupRequest& request) const;
 
  template <typename UpdateGroupRequestT = Model::UpdateGroupRequest>
  Model::UpdateGroupOutcomeCallable UpdateGroupCallable(const UpdateGroupRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::UpdateGroup, request);
  }
 
  template <typename UpdateGroupRequestT = Model::UpdateGroupRequest>
  void UpdateGroupAsync(const UpdateGroupRequestT& request, const UpdateGroupResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::UpdateGroup, request, handler, context);
  }
 
  virtual Model::UpdateIdentityProviderOutcome UpdateIdentityProvider(const Model::UpdateIdentityProviderRequest& request) const;
 
  template <typename UpdateIdentityProviderRequestT = Model::UpdateIdentityProviderRequest>
  Model::UpdateIdentityProviderOutcomeCallable UpdateIdentityProviderCallable(const UpdateIdentityProviderRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::UpdateIdentityProvider, request);
  }
 
  template <typename UpdateIdentityProviderRequestT = Model::UpdateIdentityProviderRequest>
  void UpdateIdentityProviderAsync(const UpdateIdentityProviderRequestT& request,
                                   const UpdateIdentityProviderResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::UpdateIdentityProvider, request, handler, context);
  }
 
  virtual Model::UpdateManagedLoginBrandingOutcome UpdateManagedLoginBranding(
      const Model::UpdateManagedLoginBrandingRequest& request = {}) const;
 
  template <typename UpdateManagedLoginBrandingRequestT = Model::UpdateManagedLoginBrandingRequest>
  Model::UpdateManagedLoginBrandingOutcomeCallable UpdateManagedLoginBrandingCallable(
      const UpdateManagedLoginBrandingRequestT& request = {}) const {
    return SubmitCallable(&CognitoIdentityProviderClient::UpdateManagedLoginBranding, request);
  }
 
  template <typename UpdateManagedLoginBrandingRequestT = Model::UpdateManagedLoginBrandingRequest>
  void UpdateManagedLoginBrandingAsync(const UpdateManagedLoginBrandingResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const UpdateManagedLoginBrandingRequestT& request = {}) const {
    return SubmitAsync(&CognitoIdentityProviderClient::UpdateManagedLoginBranding, request, handler, context);
  }
 
  virtual Model::UpdateProvisionedLimitOutcome UpdateProvisionedLimit(const Model::UpdateProvisionedLimitRequest& request) const;
 
  template <typename UpdateProvisionedLimitRequestT = Model::UpdateProvisionedLimitRequest>
  Model::UpdateProvisionedLimitOutcomeCallable UpdateProvisionedLimitCallable(const UpdateProvisionedLimitRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::UpdateProvisionedLimit, request);
  }
 
  template <typename UpdateProvisionedLimitRequestT = Model::UpdateProvisionedLimitRequest>
  void UpdateProvisionedLimitAsync(const UpdateProvisionedLimitRequestT& request,
                                   const UpdateProvisionedLimitResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::UpdateProvisionedLimit, request, handler, context);
  }
 
  virtual Model::UpdateResourceServerOutcome UpdateResourceServer(const Model::UpdateResourceServerRequest& request) const;
 
  template <typename UpdateResourceServerRequestT = Model::UpdateResourceServerRequest>
  Model::UpdateResourceServerOutcomeCallable UpdateResourceServerCallable(const UpdateResourceServerRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::UpdateResourceServer, request);
  }
 
  template <typename UpdateResourceServerRequestT = Model::UpdateResourceServerRequest>
  void UpdateResourceServerAsync(const UpdateResourceServerRequestT& request, const UpdateResourceServerResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::UpdateResourceServer, request, handler, context);
  }
 
  virtual Model::UpdateTermsOutcome UpdateTerms(const Model::UpdateTermsRequest& request) const;
 
  template <typename UpdateTermsRequestT = Model::UpdateTermsRequest>
  Model::UpdateTermsOutcomeCallable UpdateTermsCallable(const UpdateTermsRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::UpdateTerms, request);
  }
 
  template <typename UpdateTermsRequestT = Model::UpdateTermsRequest>
  void UpdateTermsAsync(const UpdateTermsRequestT& request, const UpdateTermsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::UpdateTerms, request, handler, context);
  }
 
  virtual Model::UpdateUserAttributesOutcome UpdateUserAttributes(const Model::UpdateUserAttributesRequest& request) const;
 
  template <typename UpdateUserAttributesRequestT = Model::UpdateUserAttributesRequest>
  Model::UpdateUserAttributesOutcomeCallable UpdateUserAttributesCallable(const UpdateUserAttributesRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::UpdateUserAttributes, request);
  }
 
  template <typename UpdateUserAttributesRequestT = Model::UpdateUserAttributesRequest>
  void UpdateUserAttributesAsync(const UpdateUserAttributesRequestT& request, const UpdateUserAttributesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::UpdateUserAttributes, request, handler, context);
  }
 
  virtual Model::UpdateUserPoolOutcome UpdateUserPool(const Model::UpdateUserPoolRequest& request) const;
 
  template <typename UpdateUserPoolRequestT = Model::UpdateUserPoolRequest>
  Model::UpdateUserPoolOutcomeCallable UpdateUserPoolCallable(const UpdateUserPoolRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::UpdateUserPool, request);
  }
 
  template <typename UpdateUserPoolRequestT = Model::UpdateUserPoolRequest>
  void UpdateUserPoolAsync(const UpdateUserPoolRequestT& request, const UpdateUserPoolResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::UpdateUserPool, request, handler, context);
  }
 
  virtual Model::UpdateUserPoolClientOutcome UpdateUserPoolClient(const Model::UpdateUserPoolClientRequest& request) const;
 
  template <typename UpdateUserPoolClientRequestT = Model::UpdateUserPoolClientRequest>
  Model::UpdateUserPoolClientOutcomeCallable UpdateUserPoolClientCallable(const UpdateUserPoolClientRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::UpdateUserPoolClient, request);
  }
 
  template <typename UpdateUserPoolClientRequestT = Model::UpdateUserPoolClientRequest>
  void UpdateUserPoolClientAsync(const UpdateUserPoolClientRequestT& request, const UpdateUserPoolClientResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::UpdateUserPoolClient, request, handler, context);
  }
 
  virtual Model::UpdateUserPoolDomainOutcome UpdateUserPoolDomain(const Model::UpdateUserPoolDomainRequest& request) const;
 
  template <typename UpdateUserPoolDomainRequestT = Model::UpdateUserPoolDomainRequest>
  Model::UpdateUserPoolDomainOutcomeCallable UpdateUserPoolDomainCallable(const UpdateUserPoolDomainRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::UpdateUserPoolDomain, request);
  }
 
  template <typename UpdateUserPoolDomainRequestT = Model::UpdateUserPoolDomainRequest>
  void UpdateUserPoolDomainAsync(const UpdateUserPoolDomainRequestT& request, const UpdateUserPoolDomainResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::UpdateUserPoolDomain, request, handler, context);
  }
 
  virtual Model::UpdateUserPoolReplicaOutcome UpdateUserPoolReplica(const Model::UpdateUserPoolReplicaRequest& request) const;
 
  template <typename UpdateUserPoolReplicaRequestT = Model::UpdateUserPoolReplicaRequest>
  Model::UpdateUserPoolReplicaOutcomeCallable UpdateUserPoolReplicaCallable(const UpdateUserPoolReplicaRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::UpdateUserPoolReplica, request);
  }
 
  template <typename UpdateUserPoolReplicaRequestT = Model::UpdateUserPoolReplicaRequest>
  void UpdateUserPoolReplicaAsync(const UpdateUserPoolReplicaRequestT& request, const UpdateUserPoolReplicaResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::UpdateUserPoolReplica, request, handler, context);
  }
 
  virtual Model::VerifySoftwareTokenOutcome VerifySoftwareToken(const Model::VerifySoftwareTokenRequest& request) const;
 
  template <typename VerifySoftwareTokenRequestT = Model::VerifySoftwareTokenRequest>
  Model::VerifySoftwareTokenOutcomeCallable VerifySoftwareTokenCallable(const VerifySoftwareTokenRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::VerifySoftwareToken, request);
  }
 
  template <typename VerifySoftwareTokenRequestT = Model::VerifySoftwareTokenRequest>
  void VerifySoftwareTokenAsync(const VerifySoftwareTokenRequestT& request, const VerifySoftwareTokenResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::VerifySoftwareToken, request, handler, context);
  }
 
  virtual Model::VerifyUserAttributeOutcome VerifyUserAttribute(const Model::VerifyUserAttributeRequest& request) const;
 
  template <typename VerifyUserAttributeRequestT = Model::VerifyUserAttributeRequest>
  Model::VerifyUserAttributeOutcomeCallable VerifyUserAttributeCallable(const VerifyUserAttributeRequestT& request) const {
    return SubmitCallable(&CognitoIdentityProviderClient::VerifyUserAttribute, request);
  }
 
  template <typename VerifyUserAttributeRequestT = Model::VerifyUserAttributeRequest>
  void VerifyUserAttributeAsync(const VerifyUserAttributeRequestT& request, const VerifyUserAttributeResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CognitoIdentityProviderClient::VerifyUserAttribute, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<CognitoIdentityProviderEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<CognitoIdentityProviderClient>;
  void init(const CognitoIdentityProviderClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, CognitoIdentityProviderError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  CognitoIdentityProviderClientConfiguration m_clientConfiguration;
  std::shared_ptr<CognitoIdentityProviderEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace CognitoIdentityProvider
}  // namespace Aws