AWS SDK for C++

AWS SDK for C++ Version 1.11.605

Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Member Functions | Friends | List of all members
Aws::CognitoIdentityProvider::CognitoIdentityProviderClient Class Reference

#include <CognitoIdentityProviderClient.h>

Inheritance diagram for Aws::CognitoIdentityProvider::CognitoIdentityProviderClient:
[legend]

Public Types

 
 
 

Public Types inherited from Aws::Client::AWSJsonClient

 

Public Member Functions

 
 
 
 
 
 CognitoIdentityProviderClient (const std::shared_ptr< Aws::Auth::AWSCredentialsProvider > &credentialsProvider, const Aws::Client::ClientConfiguration &clientConfiguration)
 
 
 
template<typename AddCustomAttributesRequestT = Model::AddCustomAttributesRequest>
Model::AddCustomAttributesOutcomeCallable AddCustomAttributesCallable (const AddCustomAttributesRequestT &request) const
 
template<typename AddCustomAttributesRequestT = Model::AddCustomAttributesRequest>
void AddCustomAttributesAsync (const AddCustomAttributesRequestT &request, const AddCustomAttributesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AdminAddUserToGroupRequestT = Model::AdminAddUserToGroupRequest>
Model::AdminAddUserToGroupOutcomeCallable AdminAddUserToGroupCallable (const AdminAddUserToGroupRequestT &request) const
 
template<typename AdminAddUserToGroupRequestT = Model::AdminAddUserToGroupRequest>
void AdminAddUserToGroupAsync (const AdminAddUserToGroupRequestT &request, const AdminAddUserToGroupResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AdminConfirmSignUpRequestT = Model::AdminConfirmSignUpRequest>
Model::AdminConfirmSignUpOutcomeCallable AdminConfirmSignUpCallable (const AdminConfirmSignUpRequestT &request) const
 
template<typename AdminConfirmSignUpRequestT = Model::AdminConfirmSignUpRequest>
void AdminConfirmSignUpAsync (const AdminConfirmSignUpRequestT &request, const AdminConfirmSignUpResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AdminCreateUserRequestT = Model::AdminCreateUserRequest>
Model::AdminCreateUserOutcomeCallable AdminCreateUserCallable (const AdminCreateUserRequestT &request) const
 
template<typename AdminCreateUserRequestT = Model::AdminCreateUserRequest>
void AdminCreateUserAsync (const AdminCreateUserRequestT &request, const AdminCreateUserResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AdminDeleteUserRequestT = Model::AdminDeleteUserRequest>
Model::AdminDeleteUserOutcomeCallable AdminDeleteUserCallable (const AdminDeleteUserRequestT &request) const
 
template<typename AdminDeleteUserRequestT = Model::AdminDeleteUserRequest>
void AdminDeleteUserAsync (const AdminDeleteUserRequestT &request, const AdminDeleteUserResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AdminDeleteUserAttributesRequestT = Model::AdminDeleteUserAttributesRequest>
Model::AdminDeleteUserAttributesOutcomeCallable AdminDeleteUserAttributesCallable (const AdminDeleteUserAttributesRequestT &request) const
 
template<typename AdminDeleteUserAttributesRequestT = Model::AdminDeleteUserAttributesRequest>
void AdminDeleteUserAttributesAsync (const AdminDeleteUserAttributesRequestT &request, const AdminDeleteUserAttributesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AdminDisableProviderForUserRequestT = Model::AdminDisableProviderForUserRequest>
Model::AdminDisableProviderForUserOutcomeCallable AdminDisableProviderForUserCallable (const AdminDisableProviderForUserRequestT &request) const
 
template<typename AdminDisableProviderForUserRequestT = Model::AdminDisableProviderForUserRequest>
void AdminDisableProviderForUserAsync (const AdminDisableProviderForUserRequestT &request, const AdminDisableProviderForUserResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AdminDisableUserRequestT = Model::AdminDisableUserRequest>
Model::AdminDisableUserOutcomeCallable AdminDisableUserCallable (const AdminDisableUserRequestT &request) const
 
template<typename AdminDisableUserRequestT = Model::AdminDisableUserRequest>
void AdminDisableUserAsync (const AdminDisableUserRequestT &request, const AdminDisableUserResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AdminEnableUserRequestT = Model::AdminEnableUserRequest>
Model::AdminEnableUserOutcomeCallable AdminEnableUserCallable (const AdminEnableUserRequestT &request) const
 
template<typename AdminEnableUserRequestT = Model::AdminEnableUserRequest>
void AdminEnableUserAsync (const AdminEnableUserRequestT &request, const AdminEnableUserResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AdminForgetDeviceRequestT = Model::AdminForgetDeviceRequest>
Model::AdminForgetDeviceOutcomeCallable AdminForgetDeviceCallable (const AdminForgetDeviceRequestT &request) const
 
template<typename AdminForgetDeviceRequestT = Model::AdminForgetDeviceRequest>
void AdminForgetDeviceAsync (const AdminForgetDeviceRequestT &request, const AdminForgetDeviceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AdminGetDeviceRequestT = Model::AdminGetDeviceRequest>
Model::AdminGetDeviceOutcomeCallable AdminGetDeviceCallable (const AdminGetDeviceRequestT &request) const
 
template<typename AdminGetDeviceRequestT = Model::AdminGetDeviceRequest>
void AdminGetDeviceAsync (const AdminGetDeviceRequestT &request, const AdminGetDeviceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AdminGetUserRequestT = Model::AdminGetUserRequest>
Model::AdminGetUserOutcomeCallable AdminGetUserCallable (const AdminGetUserRequestT &request) const
 
template<typename AdminGetUserRequestT = Model::AdminGetUserRequest>
void AdminGetUserAsync (const AdminGetUserRequestT &request, const AdminGetUserResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AdminInitiateAuthRequestT = Model::AdminInitiateAuthRequest>
Model::AdminInitiateAuthOutcomeCallable AdminInitiateAuthCallable (const AdminInitiateAuthRequestT &request) const
 
template<typename AdminInitiateAuthRequestT = Model::AdminInitiateAuthRequest>
void AdminInitiateAuthAsync (const AdminInitiateAuthRequestT &request, const AdminInitiateAuthResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AdminLinkProviderForUserRequestT = Model::AdminLinkProviderForUserRequest>
Model::AdminLinkProviderForUserOutcomeCallable AdminLinkProviderForUserCallable (const AdminLinkProviderForUserRequestT &request) const
 
template<typename AdminLinkProviderForUserRequestT = Model::AdminLinkProviderForUserRequest>
void AdminLinkProviderForUserAsync (const AdminLinkProviderForUserRequestT &request, const AdminLinkProviderForUserResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AdminListDevicesRequestT = Model::AdminListDevicesRequest>
Model::AdminListDevicesOutcomeCallable AdminListDevicesCallable (const AdminListDevicesRequestT &request) const
 
template<typename AdminListDevicesRequestT = Model::AdminListDevicesRequest>
void AdminListDevicesAsync (const AdminListDevicesRequestT &request, const AdminListDevicesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AdminListGroupsForUserRequestT = Model::AdminListGroupsForUserRequest>
Model::AdminListGroupsForUserOutcomeCallable AdminListGroupsForUserCallable (const AdminListGroupsForUserRequestT &request) const
 
template<typename AdminListGroupsForUserRequestT = Model::AdminListGroupsForUserRequest>
void AdminListGroupsForUserAsync (const AdminListGroupsForUserRequestT &request, const AdminListGroupsForUserResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AdminListUserAuthEventsRequestT = Model::AdminListUserAuthEventsRequest>
Model::AdminListUserAuthEventsOutcomeCallable AdminListUserAuthEventsCallable (const AdminListUserAuthEventsRequestT &request) const
 
template<typename AdminListUserAuthEventsRequestT = Model::AdminListUserAuthEventsRequest>
void AdminListUserAuthEventsAsync (const AdminListUserAuthEventsRequestT &request, const AdminListUserAuthEventsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AdminRemoveUserFromGroupRequestT = Model::AdminRemoveUserFromGroupRequest>
Model::AdminRemoveUserFromGroupOutcomeCallable AdminRemoveUserFromGroupCallable (const AdminRemoveUserFromGroupRequestT &request) const
 
template<typename AdminRemoveUserFromGroupRequestT = Model::AdminRemoveUserFromGroupRequest>
void AdminRemoveUserFromGroupAsync (const AdminRemoveUserFromGroupRequestT &request, const AdminRemoveUserFromGroupResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AdminResetUserPasswordRequestT = Model::AdminResetUserPasswordRequest>
Model::AdminResetUserPasswordOutcomeCallable AdminResetUserPasswordCallable (const AdminResetUserPasswordRequestT &request) const
 
template<typename AdminResetUserPasswordRequestT = Model::AdminResetUserPasswordRequest>
void AdminResetUserPasswordAsync (const AdminResetUserPasswordRequestT &request, const AdminResetUserPasswordResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AdminRespondToAuthChallengeRequestT = Model::AdminRespondToAuthChallengeRequest>
Model::AdminRespondToAuthChallengeOutcomeCallable AdminRespondToAuthChallengeCallable (const AdminRespondToAuthChallengeRequestT &request) const
 
template<typename AdminRespondToAuthChallengeRequestT = Model::AdminRespondToAuthChallengeRequest>
void AdminRespondToAuthChallengeAsync (const AdminRespondToAuthChallengeRequestT &request, const AdminRespondToAuthChallengeResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AdminSetUserMFAPreferenceRequestT = Model::AdminSetUserMFAPreferenceRequest>
Model::AdminSetUserMFAPreferenceOutcomeCallable AdminSetUserMFAPreferenceCallable (const AdminSetUserMFAPreferenceRequestT &request) const
 
template<typename AdminSetUserMFAPreferenceRequestT = Model::AdminSetUserMFAPreferenceRequest>
void AdminSetUserMFAPreferenceAsync (const AdminSetUserMFAPreferenceRequestT &request, const AdminSetUserMFAPreferenceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AdminSetUserPasswordRequestT = Model::AdminSetUserPasswordRequest>
Model::AdminSetUserPasswordOutcomeCallable AdminSetUserPasswordCallable (const AdminSetUserPasswordRequestT &request) const
 
template<typename AdminSetUserPasswordRequestT = Model::AdminSetUserPasswordRequest>
void AdminSetUserPasswordAsync (const AdminSetUserPasswordRequestT &request, const AdminSetUserPasswordResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AdminSetUserSettingsRequestT = Model::AdminSetUserSettingsRequest>
Model::AdminSetUserSettingsOutcomeCallable AdminSetUserSettingsCallable (const AdminSetUserSettingsRequestT &request) const
 
template<typename AdminSetUserSettingsRequestT = Model::AdminSetUserSettingsRequest>
void AdminSetUserSettingsAsync (const AdminSetUserSettingsRequestT &request, const AdminSetUserSettingsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AdminUpdateAuthEventFeedbackRequestT = Model::AdminUpdateAuthEventFeedbackRequest>
Model::AdminUpdateAuthEventFeedbackOutcomeCallable AdminUpdateAuthEventFeedbackCallable (const AdminUpdateAuthEventFeedbackRequestT &request) const
 
template<typename AdminUpdateAuthEventFeedbackRequestT = Model::AdminUpdateAuthEventFeedbackRequest>
void AdminUpdateAuthEventFeedbackAsync (const AdminUpdateAuthEventFeedbackRequestT &request, const AdminUpdateAuthEventFeedbackResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AdminUpdateDeviceStatusRequestT = Model::AdminUpdateDeviceStatusRequest>
Model::AdminUpdateDeviceStatusOutcomeCallable AdminUpdateDeviceStatusCallable (const AdminUpdateDeviceStatusRequestT &request) const
 
template<typename AdminUpdateDeviceStatusRequestT = Model::AdminUpdateDeviceStatusRequest>
void AdminUpdateDeviceStatusAsync (const AdminUpdateDeviceStatusRequestT &request, const AdminUpdateDeviceStatusResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AdminUpdateUserAttributesRequestT = Model::AdminUpdateUserAttributesRequest>
Model::AdminUpdateUserAttributesOutcomeCallable AdminUpdateUserAttributesCallable (const AdminUpdateUserAttributesRequestT &request) const
 
template<typename AdminUpdateUserAttributesRequestT = Model::AdminUpdateUserAttributesRequest>
void AdminUpdateUserAttributesAsync (const AdminUpdateUserAttributesRequestT &request, const AdminUpdateUserAttributesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AdminUserGlobalSignOutRequestT = Model::AdminUserGlobalSignOutRequest>
Model::AdminUserGlobalSignOutOutcomeCallable AdminUserGlobalSignOutCallable (const AdminUserGlobalSignOutRequestT &request) const
 
template<typename AdminUserGlobalSignOutRequestT = Model::AdminUserGlobalSignOutRequest>
void AdminUserGlobalSignOutAsync (const AdminUserGlobalSignOutRequestT &request, const AdminUserGlobalSignOutResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename AssociateSoftwareTokenRequestT = Model::AssociateSoftwareTokenRequest>
Model::AssociateSoftwareTokenOutcomeCallable AssociateSoftwareTokenCallable (const AssociateSoftwareTokenRequestT &request={}) const
 
template<typename AssociateSoftwareTokenRequestT = Model::AssociateSoftwareTokenRequest>
void AssociateSoftwareTokenAsync (const AssociateSoftwareTokenResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const AssociateSoftwareTokenRequestT &request={}) const
 
 
template<typename ChangePasswordRequestT = Model::ChangePasswordRequest>
Model::ChangePasswordOutcomeCallable ChangePasswordCallable (const ChangePasswordRequestT &request) const
 
template<typename ChangePasswordRequestT = Model::ChangePasswordRequest>
void ChangePasswordAsync (const ChangePasswordRequestT &request, const ChangePasswordResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CompleteWebAuthnRegistrationRequestT = Model::CompleteWebAuthnRegistrationRequest>
Model::CompleteWebAuthnRegistrationOutcomeCallable CompleteWebAuthnRegistrationCallable (const CompleteWebAuthnRegistrationRequestT &request) const
 
template<typename CompleteWebAuthnRegistrationRequestT = Model::CompleteWebAuthnRegistrationRequest>
void CompleteWebAuthnRegistrationAsync (const CompleteWebAuthnRegistrationRequestT &request, const CompleteWebAuthnRegistrationResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ConfirmDeviceRequestT = Model::ConfirmDeviceRequest>
Model::ConfirmDeviceOutcomeCallable ConfirmDeviceCallable (const ConfirmDeviceRequestT &request) const
 
template<typename ConfirmDeviceRequestT = Model::ConfirmDeviceRequest>
void ConfirmDeviceAsync (const ConfirmDeviceRequestT &request, const ConfirmDeviceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ConfirmForgotPasswordRequestT = Model::ConfirmForgotPasswordRequest>
Model::ConfirmForgotPasswordOutcomeCallable ConfirmForgotPasswordCallable (const ConfirmForgotPasswordRequestT &request) const
 
template<typename ConfirmForgotPasswordRequestT = Model::ConfirmForgotPasswordRequest>
void ConfirmForgotPasswordAsync (const ConfirmForgotPasswordRequestT &request, const ConfirmForgotPasswordResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ConfirmSignUpRequestT = Model::ConfirmSignUpRequest>
Model::ConfirmSignUpOutcomeCallable ConfirmSignUpCallable (const ConfirmSignUpRequestT &request) const
 
template<typename ConfirmSignUpRequestT = Model::ConfirmSignUpRequest>
void ConfirmSignUpAsync (const ConfirmSignUpRequestT &request, const ConfirmSignUpResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateGroupRequestT = Model::CreateGroupRequest>
Model::CreateGroupOutcomeCallable CreateGroupCallable (const CreateGroupRequestT &request) const
 
template<typename CreateGroupRequestT = Model::CreateGroupRequest>
void CreateGroupAsync (const CreateGroupRequestT &request, const CreateGroupResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateIdentityProviderRequestT = Model::CreateIdentityProviderRequest>
Model::CreateIdentityProviderOutcomeCallable CreateIdentityProviderCallable (const CreateIdentityProviderRequestT &request) const
 
template<typename CreateIdentityProviderRequestT = Model::CreateIdentityProviderRequest>
void CreateIdentityProviderAsync (const CreateIdentityProviderRequestT &request, const CreateIdentityProviderResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateManagedLoginBrandingRequestT = Model::CreateManagedLoginBrandingRequest>
Model::CreateManagedLoginBrandingOutcomeCallable CreateManagedLoginBrandingCallable (const CreateManagedLoginBrandingRequestT &request) const
 
template<typename CreateManagedLoginBrandingRequestT = Model::CreateManagedLoginBrandingRequest>
void CreateManagedLoginBrandingAsync (const CreateManagedLoginBrandingRequestT &request, const CreateManagedLoginBrandingResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateResourceServerRequestT = Model::CreateResourceServerRequest>
Model::CreateResourceServerOutcomeCallable CreateResourceServerCallable (const CreateResourceServerRequestT &request) const
 
template<typename CreateResourceServerRequestT = Model::CreateResourceServerRequest>
void CreateResourceServerAsync (const CreateResourceServerRequestT &request, const CreateResourceServerResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateUserImportJobRequestT = Model::CreateUserImportJobRequest>
Model::CreateUserImportJobOutcomeCallable CreateUserImportJobCallable (const CreateUserImportJobRequestT &request) const
 
template<typename CreateUserImportJobRequestT = Model::CreateUserImportJobRequest>
void CreateUserImportJobAsync (const CreateUserImportJobRequestT &request, const CreateUserImportJobResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateUserPoolRequestT = Model::CreateUserPoolRequest>
Model::CreateUserPoolOutcomeCallable CreateUserPoolCallable (const CreateUserPoolRequestT &request) const
 
template<typename CreateUserPoolRequestT = Model::CreateUserPoolRequest>
void CreateUserPoolAsync (const CreateUserPoolRequestT &request, const CreateUserPoolResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateUserPoolClientRequestT = Model::CreateUserPoolClientRequest>
Model::CreateUserPoolClientOutcomeCallable CreateUserPoolClientCallable (const CreateUserPoolClientRequestT &request) const
 
template<typename CreateUserPoolClientRequestT = Model::CreateUserPoolClientRequest>
void CreateUserPoolClientAsync (const CreateUserPoolClientRequestT &request, const CreateUserPoolClientResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateUserPoolDomainRequestT = Model::CreateUserPoolDomainRequest>
Model::CreateUserPoolDomainOutcomeCallable CreateUserPoolDomainCallable (const CreateUserPoolDomainRequestT &request) const
 
template<typename CreateUserPoolDomainRequestT = Model::CreateUserPoolDomainRequest>
void CreateUserPoolDomainAsync (const CreateUserPoolDomainRequestT &request, const CreateUserPoolDomainResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteGroupRequestT = Model::DeleteGroupRequest>
Model::DeleteGroupOutcomeCallable DeleteGroupCallable (const DeleteGroupRequestT &request) const
 
template<typename DeleteGroupRequestT = Model::DeleteGroupRequest>
void DeleteGroupAsync (const DeleteGroupRequestT &request, const DeleteGroupResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteIdentityProviderRequestT = Model::DeleteIdentityProviderRequest>
Model::DeleteIdentityProviderOutcomeCallable DeleteIdentityProviderCallable (const DeleteIdentityProviderRequestT &request) const
 
template<typename DeleteIdentityProviderRequestT = Model::DeleteIdentityProviderRequest>
void DeleteIdentityProviderAsync (const DeleteIdentityProviderRequestT &request, const DeleteIdentityProviderResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteManagedLoginBrandingRequestT = Model::DeleteManagedLoginBrandingRequest>
Model::DeleteManagedLoginBrandingOutcomeCallable DeleteManagedLoginBrandingCallable (const DeleteManagedLoginBrandingRequestT &request) const
 
template<typename DeleteManagedLoginBrandingRequestT = Model::DeleteManagedLoginBrandingRequest>
void DeleteManagedLoginBrandingAsync (const DeleteManagedLoginBrandingRequestT &request, const DeleteManagedLoginBrandingResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteResourceServerRequestT = Model::DeleteResourceServerRequest>
Model::DeleteResourceServerOutcomeCallable DeleteResourceServerCallable (const DeleteResourceServerRequestT &request) const
 
template<typename DeleteResourceServerRequestT = Model::DeleteResourceServerRequest>
void DeleteResourceServerAsync (const DeleteResourceServerRequestT &request, const DeleteResourceServerResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteUserRequestT = Model::DeleteUserRequest>
Model::DeleteUserOutcomeCallable DeleteUserCallable (const DeleteUserRequestT &request) const
 
template<typename DeleteUserRequestT = Model::DeleteUserRequest>
void DeleteUserAsync (const DeleteUserRequestT &request, const DeleteUserResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteUserAttributesRequestT = Model::DeleteUserAttributesRequest>
Model::DeleteUserAttributesOutcomeCallable DeleteUserAttributesCallable (const DeleteUserAttributesRequestT &request) const
 
template<typename DeleteUserAttributesRequestT = Model::DeleteUserAttributesRequest>
void DeleteUserAttributesAsync (const DeleteUserAttributesRequestT &request, const DeleteUserAttributesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteUserPoolRequestT = Model::DeleteUserPoolRequest>
Model::DeleteUserPoolOutcomeCallable DeleteUserPoolCallable (const DeleteUserPoolRequestT &request) const
 
template<typename DeleteUserPoolRequestT = Model::DeleteUserPoolRequest>
void DeleteUserPoolAsync (const DeleteUserPoolRequestT &request, const DeleteUserPoolResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteUserPoolClientRequestT = Model::DeleteUserPoolClientRequest>
Model::DeleteUserPoolClientOutcomeCallable DeleteUserPoolClientCallable (const DeleteUserPoolClientRequestT &request) const
 
template<typename DeleteUserPoolClientRequestT = Model::DeleteUserPoolClientRequest>
void DeleteUserPoolClientAsync (const DeleteUserPoolClientRequestT &request, const DeleteUserPoolClientResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteUserPoolDomainRequestT = Model::DeleteUserPoolDomainRequest>
Model::DeleteUserPoolDomainOutcomeCallable DeleteUserPoolDomainCallable (const DeleteUserPoolDomainRequestT &request) const
 
template<typename DeleteUserPoolDomainRequestT = Model::DeleteUserPoolDomainRequest>
void DeleteUserPoolDomainAsync (const DeleteUserPoolDomainRequestT &request, const DeleteUserPoolDomainResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteWebAuthnCredentialRequestT = Model::DeleteWebAuthnCredentialRequest>
Model::DeleteWebAuthnCredentialOutcomeCallable DeleteWebAuthnCredentialCallable (const DeleteWebAuthnCredentialRequestT &request) const
 
template<typename DeleteWebAuthnCredentialRequestT = Model::DeleteWebAuthnCredentialRequest>
void DeleteWebAuthnCredentialAsync (const DeleteWebAuthnCredentialRequestT &request, const DeleteWebAuthnCredentialResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DescribeIdentityProviderRequestT = Model::DescribeIdentityProviderRequest>
Model::DescribeIdentityProviderOutcomeCallable DescribeIdentityProviderCallable (const DescribeIdentityProviderRequestT &request) const
 
template<typename DescribeIdentityProviderRequestT = Model::DescribeIdentityProviderRequest>
void DescribeIdentityProviderAsync (const DescribeIdentityProviderRequestT &request, const DescribeIdentityProviderResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DescribeManagedLoginBrandingRequestT = Model::DescribeManagedLoginBrandingRequest>
Model::DescribeManagedLoginBrandingOutcomeCallable DescribeManagedLoginBrandingCallable (const DescribeManagedLoginBrandingRequestT &request) const
 
template<typename DescribeManagedLoginBrandingRequestT = Model::DescribeManagedLoginBrandingRequest>
void DescribeManagedLoginBrandingAsync (const DescribeManagedLoginBrandingRequestT &request, const DescribeManagedLoginBrandingResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DescribeManagedLoginBrandingByClientRequestT = Model::DescribeManagedLoginBrandingByClientRequest>
Model::DescribeManagedLoginBrandingByClientOutcomeCallable DescribeManagedLoginBrandingByClientCallable (const DescribeManagedLoginBrandingByClientRequestT &request) const
 
template<typename DescribeManagedLoginBrandingByClientRequestT = Model::DescribeManagedLoginBrandingByClientRequest>
void DescribeManagedLoginBrandingByClientAsync (const DescribeManagedLoginBrandingByClientRequestT &request, const DescribeManagedLoginBrandingByClientResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DescribeResourceServerRequestT = Model::DescribeResourceServerRequest>
Model::DescribeResourceServerOutcomeCallable DescribeResourceServerCallable (const DescribeResourceServerRequestT &request) const
 
template<typename DescribeResourceServerRequestT = Model::DescribeResourceServerRequest>
void DescribeResourceServerAsync (const DescribeResourceServerRequestT &request, const DescribeResourceServerResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DescribeRiskConfigurationRequestT = Model::DescribeRiskConfigurationRequest>
Model::DescribeRiskConfigurationOutcomeCallable DescribeRiskConfigurationCallable (const DescribeRiskConfigurationRequestT &request) const
 
template<typename DescribeRiskConfigurationRequestT = Model::DescribeRiskConfigurationRequest>
void DescribeRiskConfigurationAsync (const DescribeRiskConfigurationRequestT &request, const DescribeRiskConfigurationResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DescribeUserImportJobRequestT = Model::DescribeUserImportJobRequest>
Model::DescribeUserImportJobOutcomeCallable DescribeUserImportJobCallable (const DescribeUserImportJobRequestT &request) const
 
template<typename DescribeUserImportJobRequestT = Model::DescribeUserImportJobRequest>
void DescribeUserImportJobAsync (const DescribeUserImportJobRequestT &request, const DescribeUserImportJobResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DescribeUserPoolRequestT = Model::DescribeUserPoolRequest>
Model::DescribeUserPoolOutcomeCallable DescribeUserPoolCallable (const DescribeUserPoolRequestT &request) const
 
template<typename DescribeUserPoolRequestT = Model::DescribeUserPoolRequest>
void DescribeUserPoolAsync (const DescribeUserPoolRequestT &request, const DescribeUserPoolResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DescribeUserPoolClientRequestT = Model::DescribeUserPoolClientRequest>
Model::DescribeUserPoolClientOutcomeCallable DescribeUserPoolClientCallable (const DescribeUserPoolClientRequestT &request) const
 
template<typename DescribeUserPoolClientRequestT = Model::DescribeUserPoolClientRequest>
void DescribeUserPoolClientAsync (const DescribeUserPoolClientRequestT &request, const DescribeUserPoolClientResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DescribeUserPoolDomainRequestT = Model::DescribeUserPoolDomainRequest>
Model::DescribeUserPoolDomainOutcomeCallable DescribeUserPoolDomainCallable (const DescribeUserPoolDomainRequestT &request) const
 
template<typename DescribeUserPoolDomainRequestT = Model::DescribeUserPoolDomainRequest>
void DescribeUserPoolDomainAsync (const DescribeUserPoolDomainRequestT &request, const DescribeUserPoolDomainResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ForgetDeviceRequestT = Model::ForgetDeviceRequest>
Model::ForgetDeviceOutcomeCallable ForgetDeviceCallable (const ForgetDeviceRequestT &request) const
 
template<typename ForgetDeviceRequestT = Model::ForgetDeviceRequest>
void ForgetDeviceAsync (const ForgetDeviceRequestT &request, const ForgetDeviceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ForgotPasswordRequestT = Model::ForgotPasswordRequest>
Model::ForgotPasswordOutcomeCallable ForgotPasswordCallable (const ForgotPasswordRequestT &request) const
 
template<typename ForgotPasswordRequestT = Model::ForgotPasswordRequest>
void ForgotPasswordAsync (const ForgotPasswordRequestT &request, const ForgotPasswordResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetCSVHeaderRequestT = Model::GetCSVHeaderRequest>
Model::GetCSVHeaderOutcomeCallable GetCSVHeaderCallable (const GetCSVHeaderRequestT &request) const
 
template<typename GetCSVHeaderRequestT = Model::GetCSVHeaderRequest>
void GetCSVHeaderAsync (const GetCSVHeaderRequestT &request, const GetCSVHeaderResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetDeviceRequestT = Model::GetDeviceRequest>
Model::GetDeviceOutcomeCallable GetDeviceCallable (const GetDeviceRequestT &request) const
 
template<typename GetDeviceRequestT = Model::GetDeviceRequest>
void GetDeviceAsync (const GetDeviceRequestT &request, const GetDeviceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetGroupRequestT = Model::GetGroupRequest>
Model::GetGroupOutcomeCallable GetGroupCallable (const GetGroupRequestT &request) const
 
template<typename GetGroupRequestT = Model::GetGroupRequest>
void GetGroupAsync (const GetGroupRequestT &request, const GetGroupResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetIdentityProviderByIdentifierRequestT = Model::GetIdentityProviderByIdentifierRequest>
Model::GetIdentityProviderByIdentifierOutcomeCallable GetIdentityProviderByIdentifierCallable (const GetIdentityProviderByIdentifierRequestT &request) const
 
template<typename GetIdentityProviderByIdentifierRequestT = Model::GetIdentityProviderByIdentifierRequest>
void GetIdentityProviderByIdentifierAsync (const GetIdentityProviderByIdentifierRequestT &request, const GetIdentityProviderByIdentifierResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetLogDeliveryConfigurationRequestT = Model::GetLogDeliveryConfigurationRequest>
Model::GetLogDeliveryConfigurationOutcomeCallable GetLogDeliveryConfigurationCallable (const GetLogDeliveryConfigurationRequestT &request) const
 
template<typename GetLogDeliveryConfigurationRequestT = Model::GetLogDeliveryConfigurationRequest>
void GetLogDeliveryConfigurationAsync (const GetLogDeliveryConfigurationRequestT &request, const GetLogDeliveryConfigurationResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetSigningCertificateRequestT = Model::GetSigningCertificateRequest>
Model::GetSigningCertificateOutcomeCallable GetSigningCertificateCallable (const GetSigningCertificateRequestT &request) const
 
template<typename GetSigningCertificateRequestT = Model::GetSigningCertificateRequest>
void GetSigningCertificateAsync (const GetSigningCertificateRequestT &request, const GetSigningCertificateResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetTokensFromRefreshTokenRequestT = Model::GetTokensFromRefreshTokenRequest>
Model::GetTokensFromRefreshTokenOutcomeCallable GetTokensFromRefreshTokenCallable (const GetTokensFromRefreshTokenRequestT &request) const
 
template<typename GetTokensFromRefreshTokenRequestT = Model::GetTokensFromRefreshTokenRequest>
void GetTokensFromRefreshTokenAsync (const GetTokensFromRefreshTokenRequestT &request, const GetTokensFromRefreshTokenResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetUICustomizationRequestT = Model::GetUICustomizationRequest>
Model::GetUICustomizationOutcomeCallable GetUICustomizationCallable (const GetUICustomizationRequestT &request) const
 
template<typename GetUICustomizationRequestT = Model::GetUICustomizationRequest>
void GetUICustomizationAsync (const GetUICustomizationRequestT &request, const GetUICustomizationResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
virtual Model::GetUserOutcome GetUser (const Model::GetUserRequest &request) const
 
template<typename GetUserRequestT = Model::GetUserRequest>
Model::GetUserOutcomeCallable GetUserCallable (const GetUserRequestT &request) const
 
template<typename GetUserRequestT = Model::GetUserRequest>
void GetUserAsync (const GetUserRequestT &request, const GetUserResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetUserAttributeVerificationCodeRequestT = Model::GetUserAttributeVerificationCodeRequest>
Model::GetUserAttributeVerificationCodeOutcomeCallable GetUserAttributeVerificationCodeCallable (const GetUserAttributeVerificationCodeRequestT &request) const
 
template<typename GetUserAttributeVerificationCodeRequestT = Model::GetUserAttributeVerificationCodeRequest>
void GetUserAttributeVerificationCodeAsync (const GetUserAttributeVerificationCodeRequestT &request, const GetUserAttributeVerificationCodeResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetUserAuthFactorsRequestT = Model::GetUserAuthFactorsRequest>
Model::GetUserAuthFactorsOutcomeCallable GetUserAuthFactorsCallable (const GetUserAuthFactorsRequestT &request) const
 
template<typename GetUserAuthFactorsRequestT = Model::GetUserAuthFactorsRequest>
void GetUserAuthFactorsAsync (const GetUserAuthFactorsRequestT &request, const GetUserAuthFactorsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetUserPoolMfaConfigRequestT = Model::GetUserPoolMfaConfigRequest>
Model::GetUserPoolMfaConfigOutcomeCallable GetUserPoolMfaConfigCallable (const GetUserPoolMfaConfigRequestT &request) const
 
template<typename GetUserPoolMfaConfigRequestT = Model::GetUserPoolMfaConfigRequest>
void GetUserPoolMfaConfigAsync (const GetUserPoolMfaConfigRequestT &request, const GetUserPoolMfaConfigResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GlobalSignOutRequestT = Model::GlobalSignOutRequest>
Model::GlobalSignOutOutcomeCallable GlobalSignOutCallable (const GlobalSignOutRequestT &request) const
 
template<typename GlobalSignOutRequestT = Model::GlobalSignOutRequest>
void GlobalSignOutAsync (const GlobalSignOutRequestT &request, const GlobalSignOutResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename InitiateAuthRequestT = Model::InitiateAuthRequest>
Model::InitiateAuthOutcomeCallable InitiateAuthCallable (const InitiateAuthRequestT &request) const
 
template<typename InitiateAuthRequestT = Model::InitiateAuthRequest>
void InitiateAuthAsync (const InitiateAuthRequestT &request, const InitiateAuthResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ListDevicesRequestT = Model::ListDevicesRequest>
Model::ListDevicesOutcomeCallable ListDevicesCallable (const ListDevicesRequestT &request) const
 
template<typename ListDevicesRequestT = Model::ListDevicesRequest>
void ListDevicesAsync (const ListDevicesRequestT &request, const ListDevicesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ListGroupsRequestT = Model::ListGroupsRequest>
Model::ListGroupsOutcomeCallable ListGroupsCallable (const ListGroupsRequestT &request) const
 
template<typename ListGroupsRequestT = Model::ListGroupsRequest>
void ListGroupsAsync (const ListGroupsRequestT &request, const ListGroupsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ListIdentityProvidersRequestT = Model::ListIdentityProvidersRequest>
Model::ListIdentityProvidersOutcomeCallable ListIdentityProvidersCallable (const ListIdentityProvidersRequestT &request) const
 
template<typename ListIdentityProvidersRequestT = Model::ListIdentityProvidersRequest>
void ListIdentityProvidersAsync (const ListIdentityProvidersRequestT &request, const ListIdentityProvidersResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ListResourceServersRequestT = Model::ListResourceServersRequest>
Model::ListResourceServersOutcomeCallable ListResourceServersCallable (const ListResourceServersRequestT &request) const
 
template<typename ListResourceServersRequestT = Model::ListResourceServersRequest>
void ListResourceServersAsync (const ListResourceServersRequestT &request, const ListResourceServersResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable (const ListTagsForResourceRequestT &request) const
 
template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
void ListTagsForResourceAsync (const ListTagsForResourceRequestT &request, const ListTagsForResourceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ListUserImportJobsRequestT = Model::ListUserImportJobsRequest>
Model::ListUserImportJobsOutcomeCallable ListUserImportJobsCallable (const ListUserImportJobsRequestT &request) const
 
template<typename ListUserImportJobsRequestT = Model::ListUserImportJobsRequest>
void ListUserImportJobsAsync (const ListUserImportJobsRequestT &request, const ListUserImportJobsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ListUserPoolClientsRequestT = Model::ListUserPoolClientsRequest>
Model::ListUserPoolClientsOutcomeCallable ListUserPoolClientsCallable (const ListUserPoolClientsRequestT &request) const
 
template<typename ListUserPoolClientsRequestT = Model::ListUserPoolClientsRequest>
void ListUserPoolClientsAsync (const ListUserPoolClientsRequestT &request, const ListUserPoolClientsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ListUserPoolsRequestT = Model::ListUserPoolsRequest>
Model::ListUserPoolsOutcomeCallable ListUserPoolsCallable (const ListUserPoolsRequestT &request) const
 
template<typename ListUserPoolsRequestT = Model::ListUserPoolsRequest>
void ListUserPoolsAsync (const ListUserPoolsRequestT &request, const ListUserPoolsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ListUsersRequestT = Model::ListUsersRequest>
Model::ListUsersOutcomeCallable ListUsersCallable (const ListUsersRequestT &request) const
 
template<typename ListUsersRequestT = Model::ListUsersRequest>
void ListUsersAsync (const ListUsersRequestT &request, const ListUsersResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ListUsersInGroupRequestT = Model::ListUsersInGroupRequest>
Model::ListUsersInGroupOutcomeCallable ListUsersInGroupCallable (const ListUsersInGroupRequestT &request) const
 
template<typename ListUsersInGroupRequestT = Model::ListUsersInGroupRequest>
void ListUsersInGroupAsync (const ListUsersInGroupRequestT &request, const ListUsersInGroupResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ListWebAuthnCredentialsRequestT = Model::ListWebAuthnCredentialsRequest>
Model::ListWebAuthnCredentialsOutcomeCallable ListWebAuthnCredentialsCallable (const ListWebAuthnCredentialsRequestT &request) const
 
template<typename ListWebAuthnCredentialsRequestT = Model::ListWebAuthnCredentialsRequest>
void ListWebAuthnCredentialsAsync (const ListWebAuthnCredentialsRequestT &request, const ListWebAuthnCredentialsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ResendConfirmationCodeRequestT = Model::ResendConfirmationCodeRequest>
Model::ResendConfirmationCodeOutcomeCallable ResendConfirmationCodeCallable (const ResendConfirmationCodeRequestT &request) const
 
template<typename ResendConfirmationCodeRequestT = Model::ResendConfirmationCodeRequest>
void ResendConfirmationCodeAsync (const ResendConfirmationCodeRequestT &request, const ResendConfirmationCodeResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename RespondToAuthChallengeRequestT = Model::RespondToAuthChallengeRequest>
Model::RespondToAuthChallengeOutcomeCallable RespondToAuthChallengeCallable (const RespondToAuthChallengeRequestT &request) const
 
template<typename RespondToAuthChallengeRequestT = Model::RespondToAuthChallengeRequest>
void RespondToAuthChallengeAsync (const RespondToAuthChallengeRequestT &request, const RespondToAuthChallengeResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename RevokeTokenRequestT = Model::RevokeTokenRequest>
Model::RevokeTokenOutcomeCallable RevokeTokenCallable (const RevokeTokenRequestT &request) const
 
template<typename RevokeTokenRequestT = Model::RevokeTokenRequest>
void RevokeTokenAsync (const RevokeTokenRequestT &request, const RevokeTokenResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename SetLogDeliveryConfigurationRequestT = Model::SetLogDeliveryConfigurationRequest>
Model::SetLogDeliveryConfigurationOutcomeCallable SetLogDeliveryConfigurationCallable (const SetLogDeliveryConfigurationRequestT &request) const
 
template<typename SetLogDeliveryConfigurationRequestT = Model::SetLogDeliveryConfigurationRequest>
void SetLogDeliveryConfigurationAsync (const SetLogDeliveryConfigurationRequestT &request, const SetLogDeliveryConfigurationResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename SetRiskConfigurationRequestT = Model::SetRiskConfigurationRequest>
Model::SetRiskConfigurationOutcomeCallable SetRiskConfigurationCallable (const SetRiskConfigurationRequestT &request) const
 
template<typename SetRiskConfigurationRequestT = Model::SetRiskConfigurationRequest>
void SetRiskConfigurationAsync (const SetRiskConfigurationRequestT &request, const SetRiskConfigurationResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename SetUICustomizationRequestT = Model::SetUICustomizationRequest>
Model::SetUICustomizationOutcomeCallable SetUICustomizationCallable (const SetUICustomizationRequestT &request) const
 
template<typename SetUICustomizationRequestT = Model::SetUICustomizationRequest>
void SetUICustomizationAsync (const SetUICustomizationRequestT &request, const SetUICustomizationResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename SetUserMFAPreferenceRequestT = Model::SetUserMFAPreferenceRequest>
Model::SetUserMFAPreferenceOutcomeCallable SetUserMFAPreferenceCallable (const SetUserMFAPreferenceRequestT &request) const
 
template<typename SetUserMFAPreferenceRequestT = Model::SetUserMFAPreferenceRequest>
void SetUserMFAPreferenceAsync (const SetUserMFAPreferenceRequestT &request, const SetUserMFAPreferenceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename SetUserPoolMfaConfigRequestT = Model::SetUserPoolMfaConfigRequest>
Model::SetUserPoolMfaConfigOutcomeCallable SetUserPoolMfaConfigCallable (const SetUserPoolMfaConfigRequestT &request) const
 
template<typename SetUserPoolMfaConfigRequestT = Model::SetUserPoolMfaConfigRequest>
void SetUserPoolMfaConfigAsync (const SetUserPoolMfaConfigRequestT &request, const SetUserPoolMfaConfigResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename SetUserSettingsRequestT = Model::SetUserSettingsRequest>
Model::SetUserSettingsOutcomeCallable SetUserSettingsCallable (const SetUserSettingsRequestT &request) const
 
template<typename SetUserSettingsRequestT = Model::SetUserSettingsRequest>
void SetUserSettingsAsync (const SetUserSettingsRequestT &request, const SetUserSettingsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
virtual Model::SignUpOutcome SignUp (const Model::SignUpRequest &request) const
 
template<typename SignUpRequestT = Model::SignUpRequest>
Model::SignUpOutcomeCallable SignUpCallable (const SignUpRequestT &request) const
 
template<typename SignUpRequestT = Model::SignUpRequest>
void SignUpAsync (const SignUpRequestT &request, const SignUpResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename StartUserImportJobRequestT = Model::StartUserImportJobRequest>
Model::StartUserImportJobOutcomeCallable StartUserImportJobCallable (const StartUserImportJobRequestT &request) const
 
template<typename StartUserImportJobRequestT = Model::StartUserImportJobRequest>
void StartUserImportJobAsync (const StartUserImportJobRequestT &request, const StartUserImportJobResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename StartWebAuthnRegistrationRequestT = Model::StartWebAuthnRegistrationRequest>
Model::StartWebAuthnRegistrationOutcomeCallable StartWebAuthnRegistrationCallable (const StartWebAuthnRegistrationRequestT &request) const
 
template<typename StartWebAuthnRegistrationRequestT = Model::StartWebAuthnRegistrationRequest>
void StartWebAuthnRegistrationAsync (const StartWebAuthnRegistrationRequestT &request, const StartWebAuthnRegistrationResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename StopUserImportJobRequestT = Model::StopUserImportJobRequest>
Model::StopUserImportJobOutcomeCallable StopUserImportJobCallable (const StopUserImportJobRequestT &request) const
 
template<typename StopUserImportJobRequestT = Model::StopUserImportJobRequest>
void StopUserImportJobAsync (const StopUserImportJobRequestT &request, const StopUserImportJobResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename TagResourceRequestT = Model::TagResourceRequest>
Model::TagResourceOutcomeCallable TagResourceCallable (const TagResourceRequestT &request) const
 
template<typename TagResourceRequestT = Model::TagResourceRequest>
void TagResourceAsync (const TagResourceRequestT &request, const TagResourceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UntagResourceRequestT = Model::UntagResourceRequest>
Model::UntagResourceOutcomeCallable UntagResourceCallable (const UntagResourceRequestT &request) const
 
template<typename UntagResourceRequestT = Model::UntagResourceRequest>
void UntagResourceAsync (const UntagResourceRequestT &request, const UntagResourceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateAuthEventFeedbackRequestT = Model::UpdateAuthEventFeedbackRequest>
Model::UpdateAuthEventFeedbackOutcomeCallable UpdateAuthEventFeedbackCallable (const UpdateAuthEventFeedbackRequestT &request) const
 
template<typename UpdateAuthEventFeedbackRequestT = Model::UpdateAuthEventFeedbackRequest>
void UpdateAuthEventFeedbackAsync (const UpdateAuthEventFeedbackRequestT &request, const UpdateAuthEventFeedbackResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateDeviceStatusRequestT = Model::UpdateDeviceStatusRequest>
Model::UpdateDeviceStatusOutcomeCallable UpdateDeviceStatusCallable (const UpdateDeviceStatusRequestT &request) const
 
template<typename UpdateDeviceStatusRequestT = Model::UpdateDeviceStatusRequest>
void UpdateDeviceStatusAsync (const UpdateDeviceStatusRequestT &request, const UpdateDeviceStatusResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateGroupRequestT = Model::UpdateGroupRequest>
Model::UpdateGroupOutcomeCallable UpdateGroupCallable (const UpdateGroupRequestT &request) const
 
template<typename UpdateGroupRequestT = Model::UpdateGroupRequest>
void UpdateGroupAsync (const UpdateGroupRequestT &request, const UpdateGroupResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateIdentityProviderRequestT = Model::UpdateIdentityProviderRequest>
Model::UpdateIdentityProviderOutcomeCallable UpdateIdentityProviderCallable (const UpdateIdentityProviderRequestT &request) const
 
template<typename UpdateIdentityProviderRequestT = Model::UpdateIdentityProviderRequest>
void UpdateIdentityProviderAsync (const UpdateIdentityProviderRequestT &request, const UpdateIdentityProviderResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateManagedLoginBrandingRequestT = Model::UpdateManagedLoginBrandingRequest>
Model::UpdateManagedLoginBrandingOutcomeCallable UpdateManagedLoginBrandingCallable (const UpdateManagedLoginBrandingRequestT &request={}) const
 
template<typename UpdateManagedLoginBrandingRequestT = Model::UpdateManagedLoginBrandingRequest>
void UpdateManagedLoginBrandingAsync (const UpdateManagedLoginBrandingResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const UpdateManagedLoginBrandingRequestT &request={}) const
 
 
template<typename UpdateResourceServerRequestT = Model::UpdateResourceServerRequest>
Model::UpdateResourceServerOutcomeCallable UpdateResourceServerCallable (const UpdateResourceServerRequestT &request) const
 
template<typename UpdateResourceServerRequestT = Model::UpdateResourceServerRequest>
void UpdateResourceServerAsync (const UpdateResourceServerRequestT &request, const UpdateResourceServerResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateUserAttributesRequestT = Model::UpdateUserAttributesRequest>
Model::UpdateUserAttributesOutcomeCallable UpdateUserAttributesCallable (const UpdateUserAttributesRequestT &request) const
 
template<typename UpdateUserAttributesRequestT = Model::UpdateUserAttributesRequest>
void UpdateUserAttributesAsync (const UpdateUserAttributesRequestT &request, const UpdateUserAttributesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateUserPoolRequestT = Model::UpdateUserPoolRequest>
Model::UpdateUserPoolOutcomeCallable UpdateUserPoolCallable (const UpdateUserPoolRequestT &request) const
 
template<typename UpdateUserPoolRequestT = Model::UpdateUserPoolRequest>
void UpdateUserPoolAsync (const UpdateUserPoolRequestT &request, const UpdateUserPoolResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateUserPoolClientRequestT = Model::UpdateUserPoolClientRequest>
Model::UpdateUserPoolClientOutcomeCallable UpdateUserPoolClientCallable (const UpdateUserPoolClientRequestT &request) const
 
template<typename UpdateUserPoolClientRequestT = Model::UpdateUserPoolClientRequest>
void UpdateUserPoolClientAsync (const UpdateUserPoolClientRequestT &request, const UpdateUserPoolClientResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateUserPoolDomainRequestT = Model::UpdateUserPoolDomainRequest>
Model::UpdateUserPoolDomainOutcomeCallable UpdateUserPoolDomainCallable (const UpdateUserPoolDomainRequestT &request) const
 
template<typename UpdateUserPoolDomainRequestT = Model::UpdateUserPoolDomainRequest>
void UpdateUserPoolDomainAsync (const UpdateUserPoolDomainRequestT &request, const UpdateUserPoolDomainResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename VerifySoftwareTokenRequestT = Model::VerifySoftwareTokenRequest>
Model::VerifySoftwareTokenOutcomeCallable VerifySoftwareTokenCallable (const VerifySoftwareTokenRequestT &request) const
 
template<typename VerifySoftwareTokenRequestT = Model::VerifySoftwareTokenRequest>
void VerifySoftwareTokenAsync (const VerifySoftwareTokenRequestT &request, const VerifySoftwareTokenResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename VerifyUserAttributeRequestT = Model::VerifyUserAttributeRequest>
Model::VerifyUserAttributeOutcomeCallable VerifyUserAttributeCallable (const VerifyUserAttributeRequestT &request) const
 
template<typename VerifyUserAttributeRequestT = Model::VerifyUserAttributeRequest>
void VerifyUserAttributeAsync (const VerifyUserAttributeRequestT &request, const VerifyUserAttributeResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
void OverrideEndpoint (const Aws::String &endpoint)
 
 

Public Member Functions inherited from Aws::Client::AWSJsonClient

 AWSJsonClient (const Aws::Client::ClientConfiguration &configuration, const std::shared_ptr< Aws::Client::AWSAuthSigner > &signer, const std::shared_ptr< AWSErrorMarshaller > &errorMarshaller)
 
 AWSJsonClient (const Aws::Client::ClientConfiguration &configuration, const std::shared_ptr< Aws::Auth::AWSAuthSignerProvider > &signerProvider, const std::shared_ptr< AWSErrorMarshaller > &errorMarshaller)
 
virtual ~AWSJsonClient ()=default
 

Public Member Functions inherited from Aws::Client::AWSClient

 AWSClient (const Aws::Client::ClientConfiguration &configuration, const std::shared_ptr< Aws::Client::AWSAuthSigner > &signer, const std::shared_ptr< AWSErrorMarshaller > &errorMarshaller)
 
 AWSClient (const Aws::Client::ClientConfiguration &configuration, const std::shared_ptr< Aws::Auth::AWSAuthSignerProvider > &signerProvider, const std::shared_ptr< AWSErrorMarshaller > &errorMarshaller)
 
virtual ~AWSClient ()
 
Aws::String GeneratePresignedUrl (const Aws::Http::URI &uri, Aws::Http::HttpMethod method, long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={})
 
Aws::String GeneratePresignedUrl (const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const Aws::Http::HeaderValueCollection &customizedHeaders, long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={})
 
Aws::String GeneratePresignedUrl (const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={}) const
 
Aws::String GeneratePresignedUrl (const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, const Aws::Http::HeaderValueCollection &customizedHeaders, long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={})
 
Aws::String GeneratePresignedUrl (const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, const char *serviceName, long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={}) const
 
Aws::String GeneratePresignedUrl (const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, const char *serviceName, const Aws::Http::HeaderValueCollection &customizedHeaders, long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={})
 
Aws::String GeneratePresignedUrl (const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, const char *serviceName, const char *signerName, long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={}) const
 
Aws::String GeneratePresignedUrl (const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, const char *serviceName, const char *signerName, const Aws::Http::HeaderValueCollection &customizedHeaders, long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={})
 
Aws::String GeneratePresignedUrl (const Aws::Endpoint::AWSEndpoint &endpoint, Aws::Http::HttpMethod method=Http::HttpMethod::HTTP_POST, const Aws::Http::HeaderValueCollection &customizedHeaders={}, uint64_t expirationInSeconds=0, const char *signerName=Aws::Auth::SIGV4_SIGNER, const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={})
 
Aws::String GeneratePresignedUrl (const Aws::AmazonWebServiceRequest &request, const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const Aws::Http::QueryStringParameterCollection &extraParams=Aws::Http::QueryStringParameterCollection(), long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={}) const
 
Aws::String GeneratePresignedUrl (const Aws::AmazonWebServiceRequest &request, const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, const char *serviceName, const char *signerName, const Aws::Http::QueryStringParameterCollection &extraParams=Aws::Http::QueryStringParameterCollection(), long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={}) const
 
Aws::String GeneratePresignedUrl (const Aws::AmazonWebServiceRequest &request, const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, const char *serviceName, const Aws::Http::QueryStringParameterCollection &extraParams=Aws::Http::QueryStringParameterCollection(), long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={}) const
 
Aws::String GeneratePresignedUrl (const Aws::AmazonWebServiceRequest &request, const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, const Aws::Http::QueryStringParameterCollection &extraParams=Aws::Http::QueryStringParameterCollection(), long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={}) const
 
const std::shared_ptr< Aws::Http::HttpClient > & GetHttpClient () const
 
 
 
virtual const char * GetServiceClientName () const
 
virtual void SetServiceClientName (const Aws::String &name)
 
void AppendToUserAgent (const Aws::String &valueToAppend)
 
 
 
 
 
void SubmitAsync (OperationFuncT operationFunc, const RequestT &request, const HandlerT &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
void SubmitAsync (OperationFuncT operationFunc, RequestT &request, const HandlerT &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
void SubmitAsync (OperationFuncT operationFunc, const HandlerT &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
auto SubmitCallable (OperationFuncT operationFunc, const RequestT &request) const -> std::future< decltype((static_cast< const AwsServiceClientT * >(nullptr) -> *operationFunc)(request))>
 
auto SubmitCallable (OperationFuncT operationFunc, RequestT &request) const -> std::future< decltype((static_cast< const AwsServiceClientT * >(nullptr) -> *operationFunc)(request))>
 
auto SubmitCallable (OperationFuncT operationFunc) const -> std::future< decltype((static_cast< const AwsServiceClientT * >(nullptr) -> *operationFunc)())>
 

Static Public Member Functions

static const char * GetServiceName ()
 
static const char * GetAllocationTag ()
 
static void ShutdownSdkClient (void *pThis, int64_t timeoutMs=-1)
 

Friends

 

Additional Inherited Members

Protected Member Functions inherited from Aws::Client::AWSJsonClient

virtual AWSError< CoreErrorsBuildAWSError (const std::shared_ptr< Aws::Http::HttpResponse > &response) const override
 
JsonOutcome MakeRequest (const Aws::AmazonWebServiceRequest &request, const Aws::Endpoint::AWSEndpoint &endpoint, Http::HttpMethod method=Http::HttpMethod::HTTP_POST, const char *signerName=Aws::Auth::SIGV4_SIGNER, const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
JsonOutcome MakeRequest (const Aws::Endpoint::AWSEndpoint &endpoint, Http::HttpMethod method=Http::HttpMethod::HTTP_POST, const char *signerName=Aws::Auth::SIGV4_SIGNER, const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
JsonOutcome MakeRequest (const Aws::Http::URI &uri, const Aws::AmazonWebServiceRequest &request, Http::HttpMethod method=Http::HttpMethod::HTTP_POST, const char *signerName=Aws::Auth::SIGV4_SIGNER, const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
JsonOutcome MakeRequest (const Aws::Http::URI &uri, Http::HttpMethod method=Http::HttpMethod::HTTP_POST, const char *signerName=Aws::Auth::SIGV4_SIGNER, const char *requestName="", const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
JsonOutcome MakeEventStreamRequest (std::shared_ptr< Aws::Http::HttpRequest > &request) const
 

Protected Member Functions inherited from Aws::Client::AWSClient

HttpResponseOutcome AttemptExhaustively (const Aws::Http::URI &uri, const Aws::AmazonWebServiceRequest &request, Http::HttpMethod httpMethod, const char *signerName, const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
HttpResponseOutcome AttemptExhaustively (const Aws::Http::URI &uri, Http::HttpMethod httpMethod, const char *signerName, const char *requestName="", const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
HttpResponseOutcome AttemptOneRequest (const std::shared_ptr< Http::HttpRequest > &httpRequest, const Aws::AmazonWebServiceRequest &request, const char *signerName, const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
HttpResponseOutcome AttemptOneRequest (const std::shared_ptr< Http::HttpRequest > &httpRequest, const char *signerName, const char *requestName="", const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
StreamOutcome MakeRequestWithUnparsedResponse (const Aws::Http::URI &uri, const Aws::AmazonWebServiceRequest &request, Http::HttpMethod method=Http::HttpMethod::HTTP_POST, const char *signerName=Aws::Auth::SIGV4_SIGNER, const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
StreamOutcome MakeRequestWithUnparsedResponse (const Aws::Http::URI &uri, Http::HttpMethod method=Http::HttpMethod::HTTP_POST, const char *signerName=Aws::Auth::SIGV4_SIGNER, const char *requestName="", const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
StreamOutcome MakeRequestWithUnparsedResponse (const Aws::AmazonWebServiceRequest &request, const Aws::Endpoint::AWSEndpoint &endpoint, Http::HttpMethod method=Http::HttpMethod::HTTP_POST, const char *signerName=Aws::Auth::SIGV4_SIGNER, const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
virtual void BuildHttpRequest (const Aws::AmazonWebServiceRequest &request, const std::shared_ptr< Aws::Http::HttpRequest > &httpRequest) const
 
virtual void AddContentLengthToRequest (const std::shared_ptr< Aws::Http::HttpRequest > &httpRequest, const std::shared_ptr< Aws::IOStream > &body, bool isChunked) const
 
const std::shared_ptr< AWSErrorMarshaller > & GetErrorMarshaller () const
 
Aws::Client::AWSAuthSignerGetSignerByName (const char *name) const
 
 
std::shared_ptr< Aws::Http::HttpRequestBuildAndSignHttpRequest (const Aws::Http::URI &uri, const Aws::AmazonWebServiceRequest &request, Http::HttpMethod method, const char *signerName) const
 
std::shared_ptr< Aws::Http::HttpResponseMakeHttpRequest (std::shared_ptr< Aws::Http::HttpRequest > &request) const
 

Static Protected Member Functions inherited from Aws::Client::AWSClient

static void AppendRecursionDetectionHeader (std::shared_ptr< Aws::Http::HttpRequest > ioRequest)
 
 
static bool DoesResponseGenerateError (const std::shared_ptr< Aws::Http::HttpResponse > &response)
 

Protected Attributes inherited from Aws::Client::AWSClient

 
 
 
std::atomic< bool > m_isInitialized
 
std::atomic< size_t > m_operationsProcessed
 
std::condition_variable m_shutdownSignal
 
std::mutex m_shutdownMutex
 

Detailed Description

With the Amazon Cognito user pools API, you can configure user pools and authenticate users. To authenticate users from third-party identity providers (IdPs) in this API, you can link IdP users to native user profiles. Learn more about the authentication and authorization of federated users at Adding user pool sign-in through a third party and in the User pool federation endpoints and managed login reference.

This API reference provides detailed information about API operations and object types in Amazon Cognito.

Along with resource management operations, the Amazon Cognito user pools API includes classes of operations and authorization models for client-side and server-side authentication of users. You can interact with operations in the Amazon Cognito user pools API as any of the following subjects.

  1. An administrator who wants to configure user pools, app clients, users, groups, or other user pool functions.

  2. A server-side app, like a web application, that wants to use its Amazon Web Services privileges to manage, authenticate, or authorize a user.

  3. A client-side app, like a mobile app, that wants to make unauthenticated requests to manage, authenticate, or authorize a user.

For more information, see Understanding API, OIDC, and managed login pages authentication in the Amazon Cognito Developer Guide.

With your Amazon Web Services SDK, you can build the logic to support operational flows in every use case for this API. You can also make direct REST API requests to Amazon Cognito user pools service endpoints. The following links can get you started with the CognitoIdentityProvider client in supported Amazon Web Services SDKs.

To get started with an Amazon Web Services SDK, see Tools to Build on Amazon Web Services. For example actions and scenarios, see Code examples for Amazon Cognito Identity Provider using Amazon Web Services SDKs.

Definition at line 56 of file CognitoIdentityProviderClient.h.

Member Typedef Documentation

◆ BASECLASS

Definition at line 59 of file CognitoIdentityProviderClient.h.

◆ ClientConfigurationType

Definition at line 63 of file CognitoIdentityProviderClient.h.

◆ EndpointProviderType

Definition at line 64 of file CognitoIdentityProviderClient.h.

Constructor & Destructor Documentation

◆ CognitoIdentityProviderClient() [1/6]

Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CognitoIdentityProviderClient ( const Aws::CognitoIdentityProvider::CognitoIdentityProviderClientConfiguration clientConfiguration = Aws::CognitoIdentityProvider::CognitoIdentityProviderClientConfiguration(),
std::shared_ptr< CognitoIdentityProviderEndpointProviderBase endpointProvider = nullptr 
)

Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config is not specified, it will be initialized to default values.

◆ CognitoIdentityProviderClient() [2/6]

Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CognitoIdentityProviderClient ( const Aws::Auth::AWSCredentials credentials,
std::shared_ptr< CognitoIdentityProviderEndpointProviderBase endpointProvider = nullptr,
const Aws::CognitoIdentityProvider::CognitoIdentityProviderClientConfiguration clientConfiguration = Aws::CognitoIdentityProvider::CognitoIdentityProviderClientConfiguration() 
)

Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config is not specified, it will be initialized to default values.

◆ CognitoIdentityProviderClient() [3/6]

Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CognitoIdentityProviderClient ( const std::shared_ptr< Aws::Auth::AWSCredentialsProvider > &  credentialsProvider,
std::shared_ptr< CognitoIdentityProviderEndpointProviderBase endpointProvider = nullptr,
const Aws::CognitoIdentityProvider::CognitoIdentityProviderClientConfiguration clientConfiguration = Aws::CognitoIdentityProvider::CognitoIdentityProviderClientConfiguration() 
)

Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, the default http client factory will be used

◆ CognitoIdentityProviderClient() [4/6]

Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CognitoIdentityProviderClient ( const Aws::Client::ClientConfiguration clientConfiguration)

Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config is not specified, it will be initialized to default values.

◆ CognitoIdentityProviderClient() [5/6]

Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CognitoIdentityProviderClient ( const Aws::Auth::AWSCredentials credentials,
const Aws::Client::ClientConfiguration clientConfiguration 
)

Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config is not specified, it will be initialized to default values.

◆ CognitoIdentityProviderClient() [6/6]

Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CognitoIdentityProviderClient ( const std::shared_ptr< Aws::Auth::AWSCredentialsProvider > &  credentialsProvider,
const Aws::Client::ClientConfiguration clientConfiguration 
)

Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, the default http client factory will be used

◆ ~CognitoIdentityProviderClient()

virtual Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::~CognitoIdentityProviderClient ( )
virtual

Member Function Documentation

◆ accessEndpointProvider()

std::shared_ptr< CognitoIdentityProviderEndpointProviderBase > & Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::accessEndpointProvider ( )

◆ AddCustomAttributes()

virtual Model::AddCustomAttributesOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AddCustomAttributes ( const Model::AddCustomAttributesRequest request) const
virtual

Adds additional user attributes to the user pool schema. Custom attributes can be mutable or immutable and have a custom: or dev: prefix. For more information, see Custom attributes.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ AddCustomAttributesAsync()

template<typename AddCustomAttributesRequestT = Model::AddCustomAttributesRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AddCustomAttributesAsync ( const AddCustomAttributesRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AddCustomAttributes that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 147 of file CognitoIdentityProviderClient.h.

◆ AddCustomAttributesCallable()

template<typename AddCustomAttributesRequestT = Model::AddCustomAttributesRequest>
Model::AddCustomAttributesOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AddCustomAttributesCallable ( const AddCustomAttributesRequestT &  request) const
inline

A Callable wrapper for AddCustomAttributes that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 138 of file CognitoIdentityProviderClient.h.

◆ AdminAddUserToGroup()

virtual Model::AdminAddUserToGroupOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminAddUserToGroup ( const Model::AdminAddUserToGroupRequest request) const
virtual

Adds a user to a group. A user who is in a group can present a preferred-role claim to an identity pool, and populates a cognito:groups claim to their access and identity tokens.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ AdminAddUserToGroupAsync()

template<typename AdminAddUserToGroupRequestT = Model::AdminAddUserToGroupRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminAddUserToGroupAsync ( const AdminAddUserToGroupRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AdminAddUserToGroup that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 183 of file CognitoIdentityProviderClient.h.

◆ AdminAddUserToGroupCallable()

template<typename AdminAddUserToGroupRequestT = Model::AdminAddUserToGroupRequest>
Model::AdminAddUserToGroupOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminAddUserToGroupCallable ( const AdminAddUserToGroupRequestT &  request) const
inline

A Callable wrapper for AdminAddUserToGroup that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 174 of file CognitoIdentityProviderClient.h.

◆ AdminConfirmSignUp()

virtual Model::AdminConfirmSignUpOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminConfirmSignUp ( const Model::AdminConfirmSignUpRequest request) const
virtual

Confirms user sign-up as an administrator.

This request sets a user account active in a user pool that requires confirmation of new user accounts before they can sign in. You can configure your user pool to not send confirmation codes to new users and instead confirm them with this API operation on the back end.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

To configure your user pool to require administrative confirmation of users, set AllowAdminCreateUserOnly to true in a CreateUserPool or UpdateUserPool request.

See Also:

AWS API Reference

◆ AdminConfirmSignUpAsync()

template<typename AdminConfirmSignUpRequestT = Model::AdminConfirmSignUpRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminConfirmSignUpAsync ( const AdminConfirmSignUpRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AdminConfirmSignUp that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 225 of file CognitoIdentityProviderClient.h.

◆ AdminConfirmSignUpCallable()

template<typename AdminConfirmSignUpRequestT = Model::AdminConfirmSignUpRequest>
Model::AdminConfirmSignUpOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminConfirmSignUpCallable ( const AdminConfirmSignUpRequestT &  request) const
inline

A Callable wrapper for AdminConfirmSignUp that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 216 of file CognitoIdentityProviderClient.h.

◆ AdminCreateUser()

virtual Model::AdminCreateUserOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminCreateUser ( const Model::AdminCreateUserRequest request) const
virtual

Creates a new user in the specified user pool.

If MessageAction isn't set, the default is to send a welcome message via email or phone (SMS).

This message is based on a template that you configured in your call to create or update a user pool. This template includes your custom sign-up instructions and placeholders for user name and temporary password.

Alternatively, you can call AdminCreateUser with SUPPRESS for the MessageAction parameter, and Amazon Cognito won't send any email.

In either case, if the user has a password, they will be in the FORCE_CHANGE_PASSWORD state until they sign in and set their password. Your invitation message template must have the {####} password placeholder if your users have passwords. If your template doesn't have this placeholder, Amazon Cognito doesn't deliver the invitation message. In this case, you must update your message template and resend the password with a new AdminCreateUser request with a MessageAction value of RESEND.

This action might generate an SMS text message. Starting June 1, 2021, US telecom carriers require you to register an origination phone number before you can send SMS messages to US phone numbers. If you use SMS text messages in Amazon Cognito, you must register a phone number with Amazon Pinpoint. Amazon Cognito uses the registered number automatically. Otherwise, Amazon Cognito users who must receive SMS messages might not be able to sign up, activate their accounts, or sign in.

If you have never used SMS text messages with Amazon Cognito or any other Amazon Web Services service, Amazon Simple Notification Service might place your account in the SMS sandbox. In sandbox mode , you can send messages only to verified phone numbers. After you test your app while in the sandbox environment, you can move out of the sandbox and into production. For more information, see SMS message settings for Amazon Cognito user pools in the Amazon Cognito Developer Guide.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ AdminCreateUserAsync()

template<typename AdminCreateUserRequestT = Model::AdminCreateUserRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminCreateUserAsync ( const AdminCreateUserRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AdminCreateUser that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 290 of file CognitoIdentityProviderClient.h.

◆ AdminCreateUserCallable()

template<typename AdminCreateUserRequestT = Model::AdminCreateUserRequest>
Model::AdminCreateUserOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminCreateUserCallable ( const AdminCreateUserRequestT &  request) const
inline

A Callable wrapper for AdminCreateUser that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 281 of file CognitoIdentityProviderClient.h.

◆ AdminDeleteUser()

virtual Model::AdminDeleteUserOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminDeleteUser ( const Model::AdminDeleteUserRequest request) const
virtual

Deletes a user profile in your user pool.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ AdminDeleteUserAsync()

template<typename AdminDeleteUserRequestT = Model::AdminDeleteUserRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminDeleteUserAsync ( const AdminDeleteUserRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AdminDeleteUser that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 324 of file CognitoIdentityProviderClient.h.

◆ AdminDeleteUserAttributes()

virtual Model::AdminDeleteUserAttributesOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminDeleteUserAttributes ( const Model::AdminDeleteUserAttributesRequest request) const
virtual

Deletes attribute values from a user. This operation doesn't affect tokens for existing user sessions. The next ID token that the user receives will no longer have the deleted attributes.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ AdminDeleteUserAttributesAsync()

template<typename AdminDeleteUserAttributesRequestT = Model::AdminDeleteUserAttributesRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminDeleteUserAttributesAsync ( const AdminDeleteUserAttributesRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AdminDeleteUserAttributes that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 360 of file CognitoIdentityProviderClient.h.

◆ AdminDeleteUserAttributesCallable()

template<typename AdminDeleteUserAttributesRequestT = Model::AdminDeleteUserAttributesRequest>
Model::AdminDeleteUserAttributesOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminDeleteUserAttributesCallable ( const AdminDeleteUserAttributesRequestT &  request) const
inline

A Callable wrapper for AdminDeleteUserAttributes that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 351 of file CognitoIdentityProviderClient.h.

◆ AdminDeleteUserCallable()

template<typename AdminDeleteUserRequestT = Model::AdminDeleteUserRequest>
Model::AdminDeleteUserOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminDeleteUserCallable ( const AdminDeleteUserRequestT &  request) const
inline

A Callable wrapper for AdminDeleteUser that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 315 of file CognitoIdentityProviderClient.h.

◆ AdminDisableProviderForUser()

virtual Model::AdminDisableProviderForUserOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminDisableProviderForUser ( const Model::AdminDisableProviderForUserRequest request) const
virtual

Prevents the user from signing in with the specified external (SAML or social) identity provider (IdP). If the user that you want to deactivate is a Amazon Cognito user pools native username + password user, they can't use their password to sign in. If the user to deactivate is a linked external IdP user, any link between that user and an existing user is removed. When the external user signs in again, and the user is no longer attached to the previously linked DestinationUser, the user must create a new user account.

The value of ProviderName must match the name of a user pool IdP.

To deactivate a local user, set ProviderName to Cognito and the ProviderAttributeName to Cognito_Subject. The ProviderAttributeValue must be user's local username.

The ProviderAttributeName must always be Cognito_Subject for social IdPs. The ProviderAttributeValue must always be the exact subject that was used when the user was originally linked as a source user.

For de-linking a SAML identity, there are two scenarios. If the linked identity has not yet been used to sign in, the ProviderAttributeName and ProviderAttributeValue must be the same values that were used for the SourceUser when the identities were originally linked using AdminLinkProviderForUser call. This is also true if the linking was done with ProviderAttributeName set to Cognito_Subject. If the user has already signed in, the ProviderAttributeName must be Cognito_Subject and ProviderAttributeValue must be the NameID from their SAML assertion.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ AdminDisableProviderForUserAsync()

template<typename AdminDisableProviderForUserRequestT = Model::AdminDisableProviderForUserRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminDisableProviderForUserAsync ( const AdminDisableProviderForUserRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AdminDisableProviderForUser that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 418 of file CognitoIdentityProviderClient.h.

◆ AdminDisableProviderForUserCallable()

template<typename AdminDisableProviderForUserRequestT = Model::AdminDisableProviderForUserRequest>
Model::AdminDisableProviderForUserOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminDisableProviderForUserCallable ( const AdminDisableProviderForUserRequestT &  request) const
inline

A Callable wrapper for AdminDisableProviderForUser that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 409 of file CognitoIdentityProviderClient.h.

◆ AdminDisableUser()

virtual Model::AdminDisableUserOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminDisableUser ( const Model::AdminDisableUserRequest request) const
virtual

Deactivates a user profile and revokes all access tokens for the user. A deactivated user can't sign in, but still appears in the responses to ListUsers API requests.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ AdminDisableUserAsync()

template<typename AdminDisableUserRequestT = Model::AdminDisableUserRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminDisableUserAsync ( const AdminDisableUserRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AdminDisableUser that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 454 of file CognitoIdentityProviderClient.h.

◆ AdminDisableUserCallable()

template<typename AdminDisableUserRequestT = Model::AdminDisableUserRequest>
Model::AdminDisableUserOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminDisableUserCallable ( const AdminDisableUserRequestT &  request) const
inline

A Callable wrapper for AdminDisableUser that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 445 of file CognitoIdentityProviderClient.h.

◆ AdminEnableUser()

virtual Model::AdminEnableUserOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminEnableUser ( const Model::AdminEnableUserRequest request) const
virtual

Activates sign-in for a user profile that previously had sign-in access disabled.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ AdminEnableUserAsync()

template<typename AdminEnableUserRequestT = Model::AdminEnableUserRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminEnableUserAsync ( const AdminEnableUserRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AdminEnableUser that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 489 of file CognitoIdentityProviderClient.h.

◆ AdminEnableUserCallable()

template<typename AdminEnableUserRequestT = Model::AdminEnableUserRequest>
Model::AdminEnableUserOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminEnableUserCallable ( const AdminEnableUserRequestT &  request) const
inline

A Callable wrapper for AdminEnableUser that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 480 of file CognitoIdentityProviderClient.h.

◆ AdminForgetDevice()

virtual Model::AdminForgetDeviceOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminForgetDevice ( const Model::AdminForgetDeviceRequest request) const
virtual

Forgets, or deletes, a remembered device from a user's profile. After you forget the device, the user can no longer complete device authentication with that device and when applicable, must submit MFA codes again. For more information, see Working with devices.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ AdminForgetDeviceAsync()

template<typename AdminForgetDeviceRequestT = Model::AdminForgetDeviceRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminForgetDeviceAsync ( const AdminForgetDeviceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AdminForgetDevice that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 528 of file CognitoIdentityProviderClient.h.

◆ AdminForgetDeviceCallable()

template<typename AdminForgetDeviceRequestT = Model::AdminForgetDeviceRequest>
Model::AdminForgetDeviceOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminForgetDeviceCallable ( const AdminForgetDeviceRequestT &  request) const
inline

A Callable wrapper for AdminForgetDevice that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 519 of file CognitoIdentityProviderClient.h.

◆ AdminGetDevice()

virtual Model::AdminGetDeviceOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminGetDevice ( const Model::AdminGetDeviceRequest request) const
virtual

Given the device key, returns details for a user's device. For more information, see Working with devices.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ AdminGetDeviceAsync()

template<typename AdminGetDeviceRequestT = Model::AdminGetDeviceRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminGetDeviceAsync ( const AdminGetDeviceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AdminGetDevice that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 565 of file CognitoIdentityProviderClient.h.

◆ AdminGetDeviceCallable()

template<typename AdminGetDeviceRequestT = Model::AdminGetDeviceRequest>
Model::AdminGetDeviceOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminGetDeviceCallable ( const AdminGetDeviceRequestT &  request) const
inline

A Callable wrapper for AdminGetDevice that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 556 of file CognitoIdentityProviderClient.h.

◆ AdminGetUser()

virtual Model::AdminGetUserOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminGetUser ( const Model::AdminGetUserRequest request) const
virtual

Given a username, returns details about a user profile in a user pool. You can specify alias attributes in the Username request parameter.

This operation contributes to your monthly active user (MAU) count for the purpose of billing.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ AdminGetUserAsync()

template<typename AdminGetUserRequestT = Model::AdminGetUserRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminGetUserAsync ( const AdminGetUserRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AdminGetUser that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 602 of file CognitoIdentityProviderClient.h.

◆ AdminGetUserCallable()

template<typename AdminGetUserRequestT = Model::AdminGetUserRequest>
Model::AdminGetUserOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminGetUserCallable ( const AdminGetUserRequestT &  request) const
inline

A Callable wrapper for AdminGetUser that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 593 of file CognitoIdentityProviderClient.h.

◆ AdminInitiateAuth()

virtual Model::AdminInitiateAuthOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminInitiateAuth ( const Model::AdminInitiateAuthRequest request) const
virtual

Starts sign-in for applications with a server-side component, for example a traditional web application. This operation specifies the authentication flow that you'd like to begin. The authentication flow that you specify must be supported in your app client configuration. For more information about authentication flows, see Authentication flows.

This action might generate an SMS text message. Starting June 1, 2021, US telecom carriers require you to register an origination phone number before you can send SMS messages to US phone numbers. If you use SMS text messages in Amazon Cognito, you must register a phone number with Amazon Pinpoint. Amazon Cognito uses the registered number automatically. Otherwise, Amazon Cognito users who must receive SMS messages might not be able to sign up, activate their accounts, or sign in.

If you have never used SMS text messages with Amazon Cognito or any other Amazon Web Services service, Amazon Simple Notification Service might place your account in the SMS sandbox. In sandbox mode , you can send messages only to verified phone numbers. After you test your app while in the sandbox environment, you can move out of the sandbox and into production. For more information, see SMS message settings for Amazon Cognito user pools in the Amazon Cognito Developer Guide.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ AdminInitiateAuthAsync()

template<typename AdminInitiateAuthRequestT = Model::AdminInitiateAuthRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminInitiateAuthAsync ( const AdminInitiateAuthRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AdminInitiateAuth that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 659 of file CognitoIdentityProviderClient.h.

◆ AdminInitiateAuthCallable()

template<typename AdminInitiateAuthRequestT = Model::AdminInitiateAuthRequest>
Model::AdminInitiateAuthOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminInitiateAuthCallable ( const AdminInitiateAuthRequestT &  request) const
inline

A Callable wrapper for AdminInitiateAuth that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 650 of file CognitoIdentityProviderClient.h.

◆ AdminLinkProviderForUser()

virtual Model::AdminLinkProviderForUserOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminLinkProviderForUser ( const Model::AdminLinkProviderForUserRequest request) const
virtual

Links an existing user account in a user pool, or DestinationUser, to an identity from an external IdP, or SourceUser, based on a specified attribute name and value from the external IdP.

This operation connects a local user profile with a user identity who hasn't yet signed in from their third-party IdP. When the user signs in with their IdP, they get access-control configuration from the local user profile. Linked local users can also sign in with SDK-based API operations like InitiateAuth after they sign in at least once through their IdP. For more information, see Linking federated users.

The maximum number of federated identities linked to a user is five.

Because this API allows a user with an external federated identity to sign in as a local user, it is critical that it only be used with external IdPs and linked attributes that you trust.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ AdminLinkProviderForUserAsync()

template<typename AdminLinkProviderForUserRequestT = Model::AdminLinkProviderForUserRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminLinkProviderForUserAsync ( const AdminLinkProviderForUserRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AdminLinkProviderForUser that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 707 of file CognitoIdentityProviderClient.h.

◆ AdminLinkProviderForUserCallable()

template<typename AdminLinkProviderForUserRequestT = Model::AdminLinkProviderForUserRequest>
Model::AdminLinkProviderForUserOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminLinkProviderForUserCallable ( const AdminLinkProviderForUserRequestT &  request) const
inline

A Callable wrapper for AdminLinkProviderForUser that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 698 of file CognitoIdentityProviderClient.h.

◆ AdminListDevices()

virtual Model::AdminListDevicesOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminListDevices ( const Model::AdminListDevicesRequest request) const
virtual

Lists a user's registered devices. Remembered devices are used in authentication services where you offer a "Remember me" option for users who you want to permit to sign in without MFA from a trusted device. Users can bypass MFA while your application performs device SRP authentication on the back end. For more information, see Working with devices.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ AdminListDevicesAsync()

template<typename AdminListDevicesRequestT = Model::AdminListDevicesRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminListDevicesAsync ( const AdminListDevicesRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AdminListDevices that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 747 of file CognitoIdentityProviderClient.h.

◆ AdminListDevicesCallable()

template<typename AdminListDevicesRequestT = Model::AdminListDevicesRequest>
Model::AdminListDevicesOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminListDevicesCallable ( const AdminListDevicesRequestT &  request) const
inline

A Callable wrapper for AdminListDevices that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 738 of file CognitoIdentityProviderClient.h.

◆ AdminListGroupsForUser()

virtual Model::AdminListGroupsForUserOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminListGroupsForUser ( const Model::AdminListGroupsForUserRequest request) const
virtual

Lists the groups that a user belongs to. User pool groups are identifiers that you can reference from the contents of ID and access tokens, and set preferred IAM roles for identity-pool authentication. For more information, see Adding groups to a user pool.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ AdminListGroupsForUserAsync()

template<typename AdminListGroupsForUserRequestT = Model::AdminListGroupsForUserRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminListGroupsForUserAsync ( const AdminListGroupsForUserRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AdminListGroupsForUser that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 786 of file CognitoIdentityProviderClient.h.

◆ AdminListGroupsForUserCallable()

template<typename AdminListGroupsForUserRequestT = Model::AdminListGroupsForUserRequest>
Model::AdminListGroupsForUserOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminListGroupsForUserCallable ( const AdminListGroupsForUserRequestT &  request) const
inline

A Callable wrapper for AdminListGroupsForUser that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 777 of file CognitoIdentityProviderClient.h.

◆ AdminListUserAuthEvents()

virtual Model::AdminListUserAuthEventsOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminListUserAuthEvents ( const Model::AdminListUserAuthEventsRequest request) const
virtual

Requests a history of user activity and any risks detected as part of Amazon Cognito threat protection. For more information, see Viewing user event history.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ AdminListUserAuthEventsAsync()

template<typename AdminListUserAuthEventsRequestT = Model::AdminListUserAuthEventsRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminListUserAuthEventsAsync ( const AdminListUserAuthEventsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AdminListUserAuthEvents that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 823 of file CognitoIdentityProviderClient.h.

◆ AdminListUserAuthEventsCallable()

template<typename AdminListUserAuthEventsRequestT = Model::AdminListUserAuthEventsRequest>
Model::AdminListUserAuthEventsOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminListUserAuthEventsCallable ( const AdminListUserAuthEventsRequestT &  request) const
inline

A Callable wrapper for AdminListUserAuthEvents that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 814 of file CognitoIdentityProviderClient.h.

◆ AdminRemoveUserFromGroup()

virtual Model::AdminRemoveUserFromGroupOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminRemoveUserFromGroup ( const Model::AdminRemoveUserFromGroupRequest request) const
virtual

Given a username and a group name, removes them from the group. User pool groups are identifiers that you can reference from the contents of ID and access tokens, and set preferred IAM roles for identity-pool authentication. For more information, see Adding groups to a user pool.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ AdminRemoveUserFromGroupAsync()

template<typename AdminRemoveUserFromGroupRequestT = Model::AdminRemoveUserFromGroupRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminRemoveUserFromGroupAsync ( const AdminRemoveUserFromGroupRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AdminRemoveUserFromGroup that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 862 of file CognitoIdentityProviderClient.h.

◆ AdminRemoveUserFromGroupCallable()

template<typename AdminRemoveUserFromGroupRequestT = Model::AdminRemoveUserFromGroupRequest>
Model::AdminRemoveUserFromGroupOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminRemoveUserFromGroupCallable ( const AdminRemoveUserFromGroupRequestT &  request) const
inline

A Callable wrapper for AdminRemoveUserFromGroup that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 853 of file CognitoIdentityProviderClient.h.

◆ AdminResetUserPassword()

virtual Model::AdminResetUserPasswordOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminResetUserPassword ( const Model::AdminResetUserPasswordRequest request) const
virtual

Resets the specified user's password in a user pool. This operation doesn't change the user's password, but sends a password-reset code.

To use this API operation, your user pool must have self-service account recovery configured.

This action might generate an SMS text message. Starting June 1, 2021, US telecom carriers require you to register an origination phone number before you can send SMS messages to US phone numbers. If you use SMS text messages in Amazon Cognito, you must register a phone number with Amazon Pinpoint. Amazon Cognito uses the registered number automatically. Otherwise, Amazon Cognito users who must receive SMS messages might not be able to sign up, activate their accounts, or sign in.

If you have never used SMS text messages with Amazon Cognito or any other Amazon Web Services service, Amazon Simple Notification Service might place your account in the SMS sandbox. In sandbox mode , you can send messages only to verified phone numbers. After you test your app while in the sandbox environment, you can move out of the sandbox and into production. For more information, see SMS message settings for Amazon Cognito user pools in the Amazon Cognito Developer Guide.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ AdminResetUserPasswordAsync()

template<typename AdminResetUserPasswordRequestT = Model::AdminResetUserPasswordRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminResetUserPasswordAsync ( const AdminResetUserPasswordRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AdminResetUserPassword that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 916 of file CognitoIdentityProviderClient.h.

◆ AdminResetUserPasswordCallable()

template<typename AdminResetUserPasswordRequestT = Model::AdminResetUserPasswordRequest>
Model::AdminResetUserPasswordOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminResetUserPasswordCallable ( const AdminResetUserPasswordRequestT &  request) const
inline

A Callable wrapper for AdminResetUserPassword that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 907 of file CognitoIdentityProviderClient.h.

◆ AdminRespondToAuthChallenge()

virtual Model::AdminRespondToAuthChallengeOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminRespondToAuthChallenge ( const Model::AdminRespondToAuthChallengeRequest request) const
virtual

Some API operations in a user pool generate a challenge, like a prompt for an MFA code, for device authentication that bypasses MFA, or for a custom authentication challenge. An AdminRespondToAuthChallenge API request provides the answer to that challenge, like a code or a secure remote password (SRP). The parameters of a response to an authentication challenge vary with the type of challenge.

For more information about custom authentication challenges, see Custom authentication challenge Lambda triggers.

This action might generate an SMS text message. Starting June 1, 2021, US telecom carriers require you to register an origination phone number before you can send SMS messages to US phone numbers. If you use SMS text messages in Amazon Cognito, you must register a phone number with Amazon Pinpoint. Amazon Cognito uses the registered number automatically. Otherwise, Amazon Cognito users who must receive SMS messages might not be able to sign up, activate their accounts, or sign in.

If you have never used SMS text messages with Amazon Cognito or any other Amazon Web Services service, Amazon Simple Notification Service might place your account in the SMS sandbox. In sandbox mode , you can send messages only to verified phone numbers. After you test your app while in the sandbox environment, you can move out of the sandbox and into production. For more information, see SMS message settings for Amazon Cognito user pools in the Amazon Cognito Developer Guide.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ AdminRespondToAuthChallengeAsync()

template<typename AdminRespondToAuthChallengeRequestT = Model::AdminRespondToAuthChallengeRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminRespondToAuthChallengeAsync ( const AdminRespondToAuthChallengeRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AdminRespondToAuthChallenge that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 975 of file CognitoIdentityProviderClient.h.

◆ AdminRespondToAuthChallengeCallable()

template<typename AdminRespondToAuthChallengeRequestT = Model::AdminRespondToAuthChallengeRequest>
Model::AdminRespondToAuthChallengeOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminRespondToAuthChallengeCallable ( const AdminRespondToAuthChallengeRequestT &  request) const
inline

A Callable wrapper for AdminRespondToAuthChallenge that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 966 of file CognitoIdentityProviderClient.h.

◆ AdminSetUserMFAPreference()

virtual Model::AdminSetUserMFAPreferenceOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminSetUserMFAPreference ( const Model::AdminSetUserMFAPreferenceRequest request) const
virtual

Sets the user's multi-factor authentication (MFA) preference, including which MFA options are activated, and if any are preferred. Only one factor can be set as preferred. The preferred MFA factor will be used to authenticate a user if multiple factors are activated. If multiple options are activated and no preference is set, a challenge to choose an MFA option will be returned during sign-in.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ AdminSetUserMFAPreferenceAsync()

template<typename AdminSetUserMFAPreferenceRequestT = Model::AdminSetUserMFAPreferenceRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminSetUserMFAPreferenceAsync ( const AdminSetUserMFAPreferenceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AdminSetUserMFAPreference that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1014 of file CognitoIdentityProviderClient.h.

◆ AdminSetUserMFAPreferenceCallable()

template<typename AdminSetUserMFAPreferenceRequestT = Model::AdminSetUserMFAPreferenceRequest>
Model::AdminSetUserMFAPreferenceOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminSetUserMFAPreferenceCallable ( const AdminSetUserMFAPreferenceRequestT &  request) const
inline

A Callable wrapper for AdminSetUserMFAPreference that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1005 of file CognitoIdentityProviderClient.h.

◆ AdminSetUserPassword()

virtual Model::AdminSetUserPasswordOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminSetUserPassword ( const Model::AdminSetUserPasswordRequest request) const
virtual

Sets the specified user's password in a user pool. This operation administratively sets a temporary or permanent password for a user. With this operation, you can bypass self-service password changes and permit immediate sign-in with the password that you set. To do this, set Permanent to true.

You can also set a new temporary password in this request, send it to a user, and require them to choose a new password on their next sign-in. To do this, set Permanent to false.

If the password is temporary, the user's Status becomes FORCE_CHANGE_PASSWORD. When the user next tries to sign in, the InitiateAuth or AdminInitiateAuth response includes the NEW_PASSWORD_REQUIRED challenge. If the user doesn't sign in before the temporary password expires, they can no longer sign in and you must repeat this operation to set a temporary or permanent password for them.

After the user sets a new password, or if you set a permanent password, their status becomes Confirmed.

AdminSetUserPassword can set a password for the user profile that Amazon Cognito creates for third-party federated users. When you set a password, the federated user's status changes from EXTERNAL_PROVIDER to CONFIRMED. A user in this state can sign in as a federated user, and initiate authentication flows in the API like a linked native user. They can also modify their password and attributes in token-authenticated API requests like ChangePassword and UpdateUserAttributes. As a best security practice and to keep users in sync with your external IdP, don't set passwords on federated user profiles. To set up a federated user for native sign-in with a linked native user, refer to Linking federated users to an existing user profile.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ AdminSetUserPasswordAsync()

template<typename AdminSetUserPasswordRequestT = Model::AdminSetUserPasswordRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminSetUserPasswordAsync ( const AdminSetUserPasswordRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AdminSetUserPassword that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1074 of file CognitoIdentityProviderClient.h.

◆ AdminSetUserPasswordCallable()

template<typename AdminSetUserPasswordRequestT = Model::AdminSetUserPasswordRequest>
Model::AdminSetUserPasswordOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminSetUserPasswordCallable ( const AdminSetUserPasswordRequestT &  request) const
inline

A Callable wrapper for AdminSetUserPassword that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1065 of file CognitoIdentityProviderClient.h.

◆ AdminSetUserSettings()

virtual Model::AdminSetUserSettingsOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminSetUserSettings ( const Model::AdminSetUserSettingsRequest request) const
virtual

This action is no longer supported. You can use it to configure only SMS MFA. You can't use it to configure time-based one-time password (TOTP) software token MFA.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ AdminSetUserSettingsAsync()

template<typename AdminSetUserSettingsRequestT = Model::AdminSetUserSettingsRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminSetUserSettingsAsync ( const AdminSetUserSettingsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AdminSetUserSettings that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1110 of file CognitoIdentityProviderClient.h.

◆ AdminSetUserSettingsCallable()

template<typename AdminSetUserSettingsRequestT = Model::AdminSetUserSettingsRequest>
Model::AdminSetUserSettingsOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminSetUserSettingsCallable ( const AdminSetUserSettingsRequestT &  request) const
inline

A Callable wrapper for AdminSetUserSettings that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1101 of file CognitoIdentityProviderClient.h.

◆ AdminUpdateAuthEventFeedback()

virtual Model::AdminUpdateAuthEventFeedbackOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminUpdateAuthEventFeedback ( const Model::AdminUpdateAuthEventFeedbackRequest request) const
virtual

Provides the feedback for an authentication event generated by threat protection features. Your response indicates that you think that the event either was from a valid user or was an unwanted authentication attempt. This feedback improves the risk evaluation decision for the user pool as part of Amazon Cognito threat protection. To activate this setting, your user pool must be on the Plus tier.

To train the threat-protection model to recognize trusted and untrusted sign-in characteristics, configure threat protection in audit-only mode and provide a mechanism for users or administrators to submit feedback. Your feedback can tell Amazon Cognito that a risk rating was assigned at a level you don't agree with.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ AdminUpdateAuthEventFeedbackAsync()

template<typename AdminUpdateAuthEventFeedbackRequestT = Model::AdminUpdateAuthEventFeedbackRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminUpdateAuthEventFeedbackAsync ( const AdminUpdateAuthEventFeedbackRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AdminUpdateAuthEventFeedback that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1155 of file CognitoIdentityProviderClient.h.

◆ AdminUpdateAuthEventFeedbackCallable()

template<typename AdminUpdateAuthEventFeedbackRequestT = Model::AdminUpdateAuthEventFeedbackRequest>
Model::AdminUpdateAuthEventFeedbackOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminUpdateAuthEventFeedbackCallable ( const AdminUpdateAuthEventFeedbackRequestT &  request) const
inline

A Callable wrapper for AdminUpdateAuthEventFeedback that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1146 of file CognitoIdentityProviderClient.h.

◆ AdminUpdateDeviceStatus()

virtual Model::AdminUpdateDeviceStatusOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminUpdateDeviceStatus ( const Model::AdminUpdateDeviceStatusRequest request) const
virtual

Updates the status of a user's device so that it is marked as remembered or not remembered for the purpose of device authentication. Device authentication is a "remember me" mechanism that silently completes sign-in from trusted devices with a device key instead of a user-provided MFA code. This operation changes the status of a device without deleting it, so you can enable it again later. For more information about device authentication, see Working with devices.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ AdminUpdateDeviceStatusAsync()

template<typename AdminUpdateDeviceStatusRequestT = Model::AdminUpdateDeviceStatusRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminUpdateDeviceStatusAsync ( const AdminUpdateDeviceStatusRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AdminUpdateDeviceStatus that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1196 of file CognitoIdentityProviderClient.h.

◆ AdminUpdateDeviceStatusCallable()

template<typename AdminUpdateDeviceStatusRequestT = Model::AdminUpdateDeviceStatusRequest>
Model::AdminUpdateDeviceStatusOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminUpdateDeviceStatusCallable ( const AdminUpdateDeviceStatusRequestT &  request) const
inline

A Callable wrapper for AdminUpdateDeviceStatus that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1187 of file CognitoIdentityProviderClient.h.

◆ AdminUpdateUserAttributes()

virtual Model::AdminUpdateUserAttributesOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminUpdateUserAttributes ( const Model::AdminUpdateUserAttributesRequest request) const
virtual

Updates the specified user's attributes. To delete an attribute from your user, submit the attribute in your API request with a blank value.

For custom attributes, you must add a custom: prefix to the attribute name, for example custom:department.

This operation can set a user's email address or phone number as verified and permit immediate sign-in in user pools that require verification of these attributes. To do this, set the email_verified or phone_number_verified attribute to true.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

This action might generate an SMS text message. Starting June 1, 2021, US telecom carriers require you to register an origination phone number before you can send SMS messages to US phone numbers. If you use SMS text messages in Amazon Cognito, you must register a phone number with Amazon Pinpoint. Amazon Cognito uses the registered number automatically. Otherwise, Amazon Cognito users who must receive SMS messages might not be able to sign up, activate their accounts, or sign in.

If you have never used SMS text messages with Amazon Cognito or any other Amazon Web Services service, Amazon Simple Notification Service might place your account in the SMS sandbox. In sandbox mode , you can send messages only to verified phone numbers. After you test your app while in the sandbox environment, you can move out of the sandbox and into production. For more information, see SMS message settings for Amazon Cognito user pools in the Amazon Cognito Developer Guide.

See Also:

AWS API Reference

◆ AdminUpdateUserAttributesAsync()

template<typename AdminUpdateUserAttributesRequestT = Model::AdminUpdateUserAttributesRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminUpdateUserAttributesAsync ( const AdminUpdateUserAttributesRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AdminUpdateUserAttributes that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1253 of file CognitoIdentityProviderClient.h.

◆ AdminUpdateUserAttributesCallable()

template<typename AdminUpdateUserAttributesRequestT = Model::AdminUpdateUserAttributesRequest>
Model::AdminUpdateUserAttributesOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminUpdateUserAttributesCallable ( const AdminUpdateUserAttributesRequestT &  request) const
inline

A Callable wrapper for AdminUpdateUserAttributes that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1244 of file CognitoIdentityProviderClient.h.

◆ AdminUserGlobalSignOut()

virtual Model::AdminUserGlobalSignOutOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminUserGlobalSignOut ( const Model::AdminUserGlobalSignOutRequest request) const
virtual

Invalidates the identity, access, and refresh tokens that Amazon Cognito issued to a user. Call this operation with your administrative credentials when your user signs out of your app. This results in the following behavior.

  • Amazon Cognito no longer accepts token-authorized user operations that you authorize with a signed-out user's access tokens. For more information, see Using the Amazon Cognito user pools API and user pool endpoints.

    Amazon Cognito returns an Access Token has been revoked error when your app attempts to authorize a user pools API request with a revoked access token that contains the scope aws.cognito.signin.user.admin.

  • Amazon Cognito no longer accepts a signed-out user's ID token in a GetId request to an identity pool with ServerSideTokenCheck enabled for its user pool IdP configuration in CognitoIdentityProvider.

  • Amazon Cognito no longer accepts a signed-out user's refresh tokens in refresh requests.

Other requests might be valid until your user's token expires. This operation doesn't clear the managed login session cookie. To clear the session for a user who signed in with managed login or the classic hosted UI, direct their browser session to the logout endpoint.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ AdminUserGlobalSignOutAsync()

template<typename AdminUserGlobalSignOutRequestT = Model::AdminUserGlobalSignOutRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminUserGlobalSignOutAsync ( const AdminUserGlobalSignOutRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AdminUserGlobalSignOut that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1310 of file CognitoIdentityProviderClient.h.

◆ AdminUserGlobalSignOutCallable()

template<typename AdminUserGlobalSignOutRequestT = Model::AdminUserGlobalSignOutRequest>
Model::AdminUserGlobalSignOutOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AdminUserGlobalSignOutCallable ( const AdminUserGlobalSignOutRequestT &  request) const
inline

A Callable wrapper for AdminUserGlobalSignOut that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1301 of file CognitoIdentityProviderClient.h.

◆ AssociateSoftwareToken()

virtual Model::AssociateSoftwareTokenOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AssociateSoftwareToken ( const Model::AssociateSoftwareTokenRequest request = {}) const
virtual

Begins setup of time-based one-time password (TOTP) multi-factor authentication (MFA) for a user, with a unique private key that Amazon Cognito generates and returns in the API response. You can authorize an AssociateSoftwareToken request with either the user's access token, or a session string from a challenge response that you received from Amazon Cognito.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

Authorize this action with a signed-in user's access token. It must include the scope aws.cognito.signin.user.admin.

See Also:


AWS API Reference

◆ AssociateSoftwareTokenAsync()

template<typename AssociateSoftwareTokenRequestT = Model::AssociateSoftwareTokenRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AssociateSoftwareTokenAsync ( const AssociateSoftwareTokenResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const AssociateSoftwareTokenRequestT &  request = {} 
) const
inline

An Async wrapper for AssociateSoftwareToken that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1349 of file CognitoIdentityProviderClient.h.

◆ AssociateSoftwareTokenCallable()

template<typename AssociateSoftwareTokenRequestT = Model::AssociateSoftwareTokenRequest>
Model::AssociateSoftwareTokenOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::AssociateSoftwareTokenCallable ( const AssociateSoftwareTokenRequestT &  request = {}) const
inline

A Callable wrapper for AssociateSoftwareToken that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1340 of file CognitoIdentityProviderClient.h.

◆ ChangePassword()

virtual Model::ChangePasswordOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ChangePassword ( const Model::ChangePasswordRequest request) const
virtual

Changes the password for the currently signed-in user.

Authorize this action with a signed-in user's access token. It must include the scope aws.cognito.signin.user.admin.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

See Also:

AWS API Reference

◆ ChangePasswordAsync()

template<typename ChangePasswordRequestT = Model::ChangePasswordRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ChangePasswordAsync ( const ChangePasswordRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ChangePassword that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1383 of file CognitoIdentityProviderClient.h.

◆ ChangePasswordCallable()

template<typename ChangePasswordRequestT = Model::ChangePasswordRequest>
Model::ChangePasswordOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ChangePasswordCallable ( const ChangePasswordRequestT &  request) const
inline

A Callable wrapper for ChangePassword that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1374 of file CognitoIdentityProviderClient.h.

◆ CompleteWebAuthnRegistration()

virtual Model::CompleteWebAuthnRegistrationOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CompleteWebAuthnRegistration ( const Model::CompleteWebAuthnRegistrationRequest request) const
virtual

Completes registration of a passkey authenticator for the currently signed-in user.

Authorize this action with a signed-in user's access token. It must include the scope aws.cognito.signin.user.admin.

See Also:

AWS API Reference

◆ CompleteWebAuthnRegistrationAsync()

template<typename CompleteWebAuthnRegistrationRequestT = Model::CompleteWebAuthnRegistrationRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CompleteWebAuthnRegistrationAsync ( const CompleteWebAuthnRegistrationRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CompleteWebAuthnRegistration that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1411 of file CognitoIdentityProviderClient.h.

◆ CompleteWebAuthnRegistrationCallable()

template<typename CompleteWebAuthnRegistrationRequestT = Model::CompleteWebAuthnRegistrationRequest>
Model::CompleteWebAuthnRegistrationOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CompleteWebAuthnRegistrationCallable ( const CompleteWebAuthnRegistrationRequestT &  request) const
inline

A Callable wrapper for CompleteWebAuthnRegistration that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1402 of file CognitoIdentityProviderClient.h.

◆ ConfirmDevice()

virtual Model::ConfirmDeviceOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ConfirmDevice ( const Model::ConfirmDeviceRequest request) const
virtual

Confirms a device that a user wants to remember. A remembered device is a "Remember me on this device" option for user pools that perform authentication with the device key of a trusted device in the back end, instead of a user-provided MFA code. For more information about device authentication, see Working with user devices in your user pool.

Authorize this action with a signed-in user's access token. It must include the scope aws.cognito.signin.user.admin.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

See Also:

AWS API Reference

◆ ConfirmDeviceAsync()

template<typename ConfirmDeviceRequestT = Model::ConfirmDeviceRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ConfirmDeviceAsync ( const ConfirmDeviceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ConfirmDevice that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1450 of file CognitoIdentityProviderClient.h.

◆ ConfirmDeviceCallable()

template<typename ConfirmDeviceRequestT = Model::ConfirmDeviceRequest>
Model::ConfirmDeviceOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ConfirmDeviceCallable ( const ConfirmDeviceRequestT &  request) const
inline

A Callable wrapper for ConfirmDevice that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1441 of file CognitoIdentityProviderClient.h.

◆ ConfirmForgotPassword()

virtual Model::ConfirmForgotPasswordOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ConfirmForgotPassword ( const Model::ConfirmForgotPasswordRequest request) const
virtual

This public API operation accepts a confirmation code that Amazon Cognito sent to a user and accepts a new password for that user.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

See Also:

AWS API Reference

◆ ConfirmForgotPasswordAsync()

template<typename ConfirmForgotPasswordRequestT = Model::ConfirmForgotPasswordRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ConfirmForgotPasswordAsync ( const ConfirmForgotPasswordRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ConfirmForgotPassword that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1484 of file CognitoIdentityProviderClient.h.

◆ ConfirmForgotPasswordCallable()

template<typename ConfirmForgotPasswordRequestT = Model::ConfirmForgotPasswordRequest>
Model::ConfirmForgotPasswordOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ConfirmForgotPasswordCallable ( const ConfirmForgotPasswordRequestT &  request) const
inline

A Callable wrapper for ConfirmForgotPassword that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1475 of file CognitoIdentityProviderClient.h.

◆ ConfirmSignUp()

virtual Model::ConfirmSignUpOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ConfirmSignUp ( const Model::ConfirmSignUpRequest request) const
virtual

Confirms the account of a new user. This public API operation submits a code that Amazon Cognito sent to your user when they signed up in your user pool. After your user enters their code, they confirm ownership of the email address or phone number that they provided, and their user account becomes active. Depending on your user pool configuration, your users will receive their confirmation code in an email or SMS message.

Local users who signed up in your user pool are the only type of user who can confirm sign-up with a code. Users who federate through an external identity provider (IdP) have already been confirmed by their IdP.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

See Also:

AWS API Reference

◆ ConfirmSignUpAsync()

template<typename ConfirmSignUpRequestT = Model::ConfirmSignUpRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ConfirmSignUpAsync ( const ConfirmSignUpRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ConfirmSignUp that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1524 of file CognitoIdentityProviderClient.h.

◆ ConfirmSignUpCallable()

template<typename ConfirmSignUpRequestT = Model::ConfirmSignUpRequest>
Model::ConfirmSignUpOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ConfirmSignUpCallable ( const ConfirmSignUpRequestT &  request) const
inline

A Callable wrapper for ConfirmSignUp that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1515 of file CognitoIdentityProviderClient.h.

◆ CreateGroup()

virtual Model::CreateGroupOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CreateGroup ( const Model::CreateGroupRequest request) const
virtual

Creates a new group in the specified user pool. For more information about user pool groups, see Adding groups to a user pool.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ CreateGroupAsync()

template<typename CreateGroupRequestT = Model::CreateGroupRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CreateGroupAsync ( const CreateGroupRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateGroup that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1561 of file CognitoIdentityProviderClient.h.

◆ CreateGroupCallable()

template<typename CreateGroupRequestT = Model::CreateGroupRequest>
Model::CreateGroupOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CreateGroupCallable ( const CreateGroupRequestT &  request) const
inline

A Callable wrapper for CreateGroup that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1552 of file CognitoIdentityProviderClient.h.

◆ CreateIdentityProvider()

virtual Model::CreateIdentityProviderOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CreateIdentityProvider ( const Model::CreateIdentityProviderRequest request) const
virtual

Adds a configuration and trust relationship between a third-party identity provider (IdP) and a user pool. Amazon Cognito accepts sign-in with third-party identity providers through managed login and OIDC relying-party libraries. For more information, see Third-party IdP sign-in.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ CreateIdentityProviderAsync()

template<typename CreateIdentityProviderRequestT = Model::CreateIdentityProviderRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CreateIdentityProviderAsync ( const CreateIdentityProviderRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateIdentityProvider that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1600 of file CognitoIdentityProviderClient.h.

◆ CreateIdentityProviderCallable()

template<typename CreateIdentityProviderRequestT = Model::CreateIdentityProviderRequest>
Model::CreateIdentityProviderOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CreateIdentityProviderCallable ( const CreateIdentityProviderRequestT &  request) const
inline

A Callable wrapper for CreateIdentityProvider that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1591 of file CognitoIdentityProviderClient.h.

◆ CreateManagedLoginBranding()

virtual Model::CreateManagedLoginBrandingOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CreateManagedLoginBranding ( const Model::CreateManagedLoginBrandingRequest request) const
virtual

Creates a new set of branding settings for a user pool style and associates it with an app client. This operation is the programmatic option for the creation of a new style in the branding designer.

Provides values for UI customization in a Settings JSON object and image files in an Assets array. To send the JSON object Document type parameter in Settings, you might need to update to the most recent version of your Amazon Web Services SDK. To create a new style with default settings, set UseCognitoProvidedValues to true and don't provide values for any other options.

This operation has a 2-megabyte request-size limit and include the CSS settings and image assets for your app client. Your branding settings might exceed 2MB in size. Amazon Cognito doesn't require that you pass all parameters in one request and preserves existing style settings that you don't specify. If your request is larger than 2MB, separate it into multiple requests, each with a size smaller than the limit.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ CreateManagedLoginBrandingAsync()

template<typename CreateManagedLoginBrandingRequestT = Model::CreateManagedLoginBrandingRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CreateManagedLoginBrandingAsync ( const CreateManagedLoginBrandingRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateManagedLoginBranding that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1648 of file CognitoIdentityProviderClient.h.

◆ CreateManagedLoginBrandingCallable()

template<typename CreateManagedLoginBrandingRequestT = Model::CreateManagedLoginBrandingRequest>
Model::CreateManagedLoginBrandingOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CreateManagedLoginBrandingCallable ( const CreateManagedLoginBrandingRequestT &  request) const
inline

A Callable wrapper for CreateManagedLoginBranding that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1639 of file CognitoIdentityProviderClient.h.

◆ CreateResourceServer()

virtual Model::CreateResourceServerOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CreateResourceServer ( const Model::CreateResourceServerRequest request) const
virtual

Creates a new OAuth2.0 resource server and defines custom scopes within it. Resource servers are associated with custom scopes and machine-to-machine (M2M) authorization. For more information, see Access control with resource servers.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ CreateResourceServerAsync()

template<typename CreateResourceServerRequestT = Model::CreateResourceServerRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CreateResourceServerAsync ( const CreateResourceServerRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateResourceServer that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1686 of file CognitoIdentityProviderClient.h.

◆ CreateResourceServerCallable()

template<typename CreateResourceServerRequestT = Model::CreateResourceServerRequest>
Model::CreateResourceServerOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CreateResourceServerCallable ( const CreateResourceServerRequestT &  request) const
inline

A Callable wrapper for CreateResourceServer that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1677 of file CognitoIdentityProviderClient.h.

◆ CreateUserImportJob()

virtual Model::CreateUserImportJobOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CreateUserImportJob ( const Model::CreateUserImportJobRequest request) const
virtual

Creates a user import job. You can import users into user pools from a comma-separated values (CSV) file without adding Amazon Cognito MAU costs to your Amazon Web Services bill.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ CreateUserImportJobAsync()

template<typename CreateUserImportJobRequestT = Model::CreateUserImportJobRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CreateUserImportJobAsync ( const CreateUserImportJobRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateUserImportJob that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1722 of file CognitoIdentityProviderClient.h.

◆ CreateUserImportJobCallable()

template<typename CreateUserImportJobRequestT = Model::CreateUserImportJobRequest>
Model::CreateUserImportJobOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CreateUserImportJobCallable ( const CreateUserImportJobRequestT &  request) const
inline

A Callable wrapper for CreateUserImportJob that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1713 of file CognitoIdentityProviderClient.h.

◆ CreateUserPool()

virtual Model::CreateUserPoolOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CreateUserPool ( const Model::CreateUserPoolRequest request) const
virtual

Creates a new Amazon Cognito user pool. This operation sets basic and advanced configuration options.

If you don't provide a value for an attribute, Amazon Cognito sets it to its default value.

This action might generate an SMS text message. Starting June 1, 2021, US telecom carriers require you to register an origination phone number before you can send SMS messages to US phone numbers. If you use SMS text messages in Amazon Cognito, you must register a phone number with Amazon Pinpoint. Amazon Cognito uses the registered number automatically. Otherwise, Amazon Cognito users who must receive SMS messages might not be able to sign up, activate their accounts, or sign in.

If you have never used SMS text messages with Amazon Cognito or any other Amazon Web Services service, Amazon Simple Notification Service might place your account in the SMS sandbox. In sandbox mode , you can send messages only to verified phone numbers. After you test your app while in the sandbox environment, you can move out of the sandbox and into production. For more information, see SMS message settings for Amazon Cognito user pools in the Amazon Cognito Developer Guide.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ CreateUserPoolAsync()

template<typename CreateUserPoolRequestT = Model::CreateUserPoolRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CreateUserPoolAsync ( const CreateUserPoolRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateUserPool that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1775 of file CognitoIdentityProviderClient.h.

◆ CreateUserPoolCallable()

template<typename CreateUserPoolRequestT = Model::CreateUserPoolRequest>
Model::CreateUserPoolOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CreateUserPoolCallable ( const CreateUserPoolRequestT &  request) const
inline

A Callable wrapper for CreateUserPool that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1766 of file CognitoIdentityProviderClient.h.

◆ CreateUserPoolClient()

virtual Model::CreateUserPoolClientOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CreateUserPoolClient ( const Model::CreateUserPoolClientRequest request) const
virtual

Creates an app client in a user pool. This operation sets basic and advanced configuration options.

Unlike app clients created in the console, Amazon Cognito doesn't automatically assign a branding style to app clients that you configure with this API operation. Managed login and classic hosted UI pages aren't available for your client until after you apply a branding style.

If you don't provide a value for an attribute, Amazon Cognito sets it to its default value.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ CreateUserPoolClientAsync()

template<typename CreateUserPoolClientRequestT = Model::CreateUserPoolClientRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CreateUserPoolClientAsync ( const CreateUserPoolClientRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateUserPoolClient that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1815 of file CognitoIdentityProviderClient.h.

◆ CreateUserPoolClientCallable()

template<typename CreateUserPoolClientRequestT = Model::CreateUserPoolClientRequest>
Model::CreateUserPoolClientOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CreateUserPoolClientCallable ( const CreateUserPoolClientRequestT &  request) const
inline

A Callable wrapper for CreateUserPoolClient that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1806 of file CognitoIdentityProviderClient.h.

◆ CreateUserPoolDomain()

virtual Model::CreateUserPoolDomainOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CreateUserPoolDomain ( const Model::CreateUserPoolDomainRequest request) const
virtual

A user pool domain hosts managed login, an authorization server and web server for authentication in your application. This operation creates a new user pool prefix domain or custom domain and sets the managed login branding version. Set the branding version to 1 for hosted UI (classic) or 2 for managed login. When you choose a custom domain, you must provide an SSL certificate in the US East (N. Virginia) Amazon Web Services Region in your request.

Your prefix domain might take up to one minute to take effect. Your custom domain is online within five minutes, but it can take up to one hour to distribute your SSL certificate.

For more information about adding a custom domain to your user pool, see Configuring a user pool domain.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ CreateUserPoolDomainAsync()

template<typename CreateUserPoolDomainRequestT = Model::CreateUserPoolDomainRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CreateUserPoolDomainAsync ( const CreateUserPoolDomainRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateUserPoolDomain that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1860 of file CognitoIdentityProviderClient.h.

◆ CreateUserPoolDomainCallable()

template<typename CreateUserPoolDomainRequestT = Model::CreateUserPoolDomainRequest>
Model::CreateUserPoolDomainOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::CreateUserPoolDomainCallable ( const CreateUserPoolDomainRequestT &  request) const
inline

A Callable wrapper for CreateUserPoolDomain that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1851 of file CognitoIdentityProviderClient.h.

◆ DeleteGroup()

virtual Model::DeleteGroupOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteGroup ( const Model::DeleteGroupRequest request) const
virtual

Deletes a group from the specified user pool. When you delete a group, that group no longer contributes to users' cognito:preferred_group or cognito:groups claims, and no longer influence access-control decision that are based on group membership. For more information about user pool groups, see Adding groups to a user pool.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ DeleteGroupAsync()

template<typename DeleteGroupRequestT = Model::DeleteGroupRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteGroupAsync ( const DeleteGroupRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteGroup that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1900 of file CognitoIdentityProviderClient.h.

◆ DeleteGroupCallable()

template<typename DeleteGroupRequestT = Model::DeleteGroupRequest>
Model::DeleteGroupOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteGroupCallable ( const DeleteGroupRequestT &  request) const
inline

A Callable wrapper for DeleteGroup that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1891 of file CognitoIdentityProviderClient.h.

◆ DeleteIdentityProvider()

virtual Model::DeleteIdentityProviderOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteIdentityProvider ( const Model::DeleteIdentityProviderRequest request) const
virtual

Deletes a user pool identity provider (IdP). After you delete an IdP, users can no longer sign in to your user pool through that IdP. For more information about user pool IdPs, see Third-party IdP sign-in.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ DeleteIdentityProviderAsync()

template<typename DeleteIdentityProviderRequestT = Model::DeleteIdentityProviderRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteIdentityProviderAsync ( const DeleteIdentityProviderRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteIdentityProvider that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1938 of file CognitoIdentityProviderClient.h.

◆ DeleteIdentityProviderCallable()

template<typename DeleteIdentityProviderRequestT = Model::DeleteIdentityProviderRequest>
Model::DeleteIdentityProviderOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteIdentityProviderCallable ( const DeleteIdentityProviderRequestT &  request) const
inline

A Callable wrapper for DeleteIdentityProvider that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1929 of file CognitoIdentityProviderClient.h.

◆ DeleteManagedLoginBranding()

virtual Model::DeleteManagedLoginBrandingOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteManagedLoginBranding ( const Model::DeleteManagedLoginBrandingRequest request) const
virtual

Deletes a managed login branding style. When you delete a style, you delete the branding association for an app client. When an app client doesn't have a style assigned, your managed login pages for that app client are nonfunctional until you create a new style or switch the domain branding version.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ DeleteManagedLoginBrandingAsync()

template<typename DeleteManagedLoginBrandingRequestT = Model::DeleteManagedLoginBrandingRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteManagedLoginBrandingAsync ( const DeleteManagedLoginBrandingRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteManagedLoginBranding that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1976 of file CognitoIdentityProviderClient.h.

◆ DeleteManagedLoginBrandingCallable()

template<typename DeleteManagedLoginBrandingRequestT = Model::DeleteManagedLoginBrandingRequest>
Model::DeleteManagedLoginBrandingOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteManagedLoginBrandingCallable ( const DeleteManagedLoginBrandingRequestT &  request) const
inline

A Callable wrapper for DeleteManagedLoginBranding that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1967 of file CognitoIdentityProviderClient.h.

◆ DeleteResourceServer()

virtual Model::DeleteResourceServerOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteResourceServer ( const Model::DeleteResourceServerRequest request) const
virtual

Deletes a resource server. After you delete a resource server, users can no longer generate access tokens with scopes that are associate with that resource server.

Resource servers are associated with custom scopes and machine-to-machine (M2M) authorization. For more information, see Access control with resource servers.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ DeleteResourceServerAsync()

template<typename DeleteResourceServerRequestT = Model::DeleteResourceServerRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteResourceServerAsync ( const DeleteResourceServerRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteResourceServer that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2015 of file CognitoIdentityProviderClient.h.

◆ DeleteResourceServerCallable()

template<typename DeleteResourceServerRequestT = Model::DeleteResourceServerRequest>
Model::DeleteResourceServerOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteResourceServerCallable ( const DeleteResourceServerRequestT &  request) const
inline

A Callable wrapper for DeleteResourceServer that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2006 of file CognitoIdentityProviderClient.h.

◆ DeleteUser()

virtual Model::DeleteUserOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteUser ( const Model::DeleteUserRequest request) const
virtual

Deletes the profile of the currently signed-in user. A deleted user profile can no longer be used to sign in and can't be restored.

Authorize this action with a signed-in user's access token. It must include the scope aws.cognito.signin.user.admin.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

See Also:

AWS API Reference

◆ DeleteUserAsync()

template<typename DeleteUserRequestT = Model::DeleteUserRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteUserAsync ( const DeleteUserRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteUser that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2050 of file CognitoIdentityProviderClient.h.

◆ DeleteUserAttributes()

virtual Model::DeleteUserAttributesOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteUserAttributes ( const Model::DeleteUserAttributesRequest request) const
virtual

Deletes attributes from the currently signed-in user. For example, your application can submit a request to this operation when a user wants to remove their birthdate attribute value.

Authorize this action with a signed-in user's access token. It must include the scope aws.cognito.signin.user.admin.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

See Also:

AWS API Reference

◆ DeleteUserAttributesAsync()

template<typename DeleteUserAttributesRequestT = Model::DeleteUserAttributesRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteUserAttributesAsync ( const DeleteUserAttributesRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteUserAttributes that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2086 of file CognitoIdentityProviderClient.h.

◆ DeleteUserAttributesCallable()

template<typename DeleteUserAttributesRequestT = Model::DeleteUserAttributesRequest>
Model::DeleteUserAttributesOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteUserAttributesCallable ( const DeleteUserAttributesRequestT &  request) const
inline

A Callable wrapper for DeleteUserAttributes that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2077 of file CognitoIdentityProviderClient.h.

◆ DeleteUserCallable()

template<typename DeleteUserRequestT = Model::DeleteUserRequest>
Model::DeleteUserOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteUserCallable ( const DeleteUserRequestT &  request) const
inline

A Callable wrapper for DeleteUser that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2041 of file CognitoIdentityProviderClient.h.

◆ DeleteUserPool()

virtual Model::DeleteUserPoolOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteUserPool ( const Model::DeleteUserPoolRequest request) const
virtual

Deletes a user pool. After you delete a user pool, users can no longer sign in to any associated applications.

When you delete a user pool, it's no longer visible or operational in your Amazon Web Services account. Amazon Cognito retains deleted user pools in an inactive state for 14 days, then begins a cleanup process that fully removes them from Amazon Web Services systems. In case of accidental deletion, contact Amazon Web ServicesSupport within 14 days for restoration assistance.

Amazon Cognito begins full deletion of all resources from deleted user pools after 14 days. In the case of large user pools, the cleanup process might take significant additional time before all user data is permanently deleted.

See Also:

AWS API Reference

◆ DeleteUserPoolAsync()

template<typename DeleteUserPoolRequestT = Model::DeleteUserPoolRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteUserPoolAsync ( const DeleteUserPoolRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteUserPool that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2120 of file CognitoIdentityProviderClient.h.

◆ DeleteUserPoolCallable()

template<typename DeleteUserPoolRequestT = Model::DeleteUserPoolRequest>
Model::DeleteUserPoolOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteUserPoolCallable ( const DeleteUserPoolRequestT &  request) const
inline

A Callable wrapper for DeleteUserPool that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2111 of file CognitoIdentityProviderClient.h.

◆ DeleteUserPoolClient()

virtual Model::DeleteUserPoolClientOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteUserPoolClient ( const Model::DeleteUserPoolClientRequest request) const
virtual

Deletes a user pool app client. After you delete an app client, users can no longer sign in to the associated application.

See Also:

AWS API Reference

◆ DeleteUserPoolClientAsync()

template<typename DeleteUserPoolClientRequestT = Model::DeleteUserPoolClientRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteUserPoolClientAsync ( const DeleteUserPoolClientRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteUserPoolClient that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2146 of file CognitoIdentityProviderClient.h.

◆ DeleteUserPoolClientCallable()

template<typename DeleteUserPoolClientRequestT = Model::DeleteUserPoolClientRequest>
Model::DeleteUserPoolClientOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteUserPoolClientCallable ( const DeleteUserPoolClientRequestT &  request) const
inline

A Callable wrapper for DeleteUserPoolClient that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2137 of file CognitoIdentityProviderClient.h.

◆ DeleteUserPoolDomain()

virtual Model::DeleteUserPoolDomainOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteUserPoolDomain ( const Model::DeleteUserPoolDomainRequest request) const
virtual

Given a user pool ID and domain identifier, deletes a user pool domain. After you delete a user pool domain, your managed login pages and authorization server are no longer available.

See Also:

AWS API Reference

◆ DeleteUserPoolDomainAsync()

template<typename DeleteUserPoolDomainRequestT = Model::DeleteUserPoolDomainRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteUserPoolDomainAsync ( const DeleteUserPoolDomainRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteUserPoolDomain that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2173 of file CognitoIdentityProviderClient.h.

◆ DeleteUserPoolDomainCallable()

template<typename DeleteUserPoolDomainRequestT = Model::DeleteUserPoolDomainRequest>
Model::DeleteUserPoolDomainOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteUserPoolDomainCallable ( const DeleteUserPoolDomainRequestT &  request) const
inline

A Callable wrapper for DeleteUserPoolDomain that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2164 of file CognitoIdentityProviderClient.h.

◆ DeleteWebAuthnCredential()

virtual Model::DeleteWebAuthnCredentialOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteWebAuthnCredential ( const Model::DeleteWebAuthnCredentialRequest request) const
virtual

Deletes a registered passkey, or WebAuthn, authenticator for the currently signed-in user.

Authorize this action with a signed-in user's access token. It must include the scope aws.cognito.signin.user.admin.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

See Also:

AWS API Reference

◆ DeleteWebAuthnCredentialAsync()

template<typename DeleteWebAuthnCredentialRequestT = Model::DeleteWebAuthnCredentialRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteWebAuthnCredentialAsync ( const DeleteWebAuthnCredentialRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteWebAuthnCredential that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2208 of file CognitoIdentityProviderClient.h.

◆ DeleteWebAuthnCredentialCallable()

template<typename DeleteWebAuthnCredentialRequestT = Model::DeleteWebAuthnCredentialRequest>
Model::DeleteWebAuthnCredentialOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DeleteWebAuthnCredentialCallable ( const DeleteWebAuthnCredentialRequestT &  request) const
inline

A Callable wrapper for DeleteWebAuthnCredential that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2199 of file CognitoIdentityProviderClient.h.

◆ DescribeIdentityProvider()

virtual Model::DescribeIdentityProviderOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeIdentityProvider ( const Model::DescribeIdentityProviderRequest request) const
virtual

Given a user pool ID and identity provider (IdP) name, returns details about the IdP.

See Also:

AWS API Reference

◆ DescribeIdentityProviderAsync()

template<typename DescribeIdentityProviderRequestT = Model::DescribeIdentityProviderRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeIdentityProviderAsync ( const DescribeIdentityProviderRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DescribeIdentityProvider that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2234 of file CognitoIdentityProviderClient.h.

◆ DescribeIdentityProviderCallable()

template<typename DescribeIdentityProviderRequestT = Model::DescribeIdentityProviderRequest>
Model::DescribeIdentityProviderOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeIdentityProviderCallable ( const DescribeIdentityProviderRequestT &  request) const
inline

A Callable wrapper for DescribeIdentityProvider that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2225 of file CognitoIdentityProviderClient.h.

◆ DescribeManagedLoginBranding()

virtual Model::DescribeManagedLoginBrandingOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeManagedLoginBranding ( const Model::DescribeManagedLoginBrandingRequest request) const
virtual

Given the ID of a managed login branding style, returns detailed information about the style.

See Also:

AWS API Reference

◆ DescribeManagedLoginBrandingAsync()

template<typename DescribeManagedLoginBrandingRequestT = Model::DescribeManagedLoginBrandingRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeManagedLoginBrandingAsync ( const DescribeManagedLoginBrandingRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DescribeManagedLoginBranding that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2260 of file CognitoIdentityProviderClient.h.

◆ DescribeManagedLoginBrandingByClient()

virtual Model::DescribeManagedLoginBrandingByClientOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeManagedLoginBrandingByClient ( const Model::DescribeManagedLoginBrandingByClientRequest request) const
virtual

Given the ID of a user pool app client, returns detailed information about the style assigned to the app client.

See Also:

AWS API Reference

◆ DescribeManagedLoginBrandingByClientAsync()

template<typename DescribeManagedLoginBrandingByClientRequestT = Model::DescribeManagedLoginBrandingByClientRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeManagedLoginBrandingByClientAsync ( const DescribeManagedLoginBrandingByClientRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DescribeManagedLoginBrandingByClient that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2286 of file CognitoIdentityProviderClient.h.

◆ DescribeManagedLoginBrandingByClientCallable()

template<typename DescribeManagedLoginBrandingByClientRequestT = Model::DescribeManagedLoginBrandingByClientRequest>
Model::DescribeManagedLoginBrandingByClientOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeManagedLoginBrandingByClientCallable ( const DescribeManagedLoginBrandingByClientRequestT &  request) const
inline

A Callable wrapper for DescribeManagedLoginBrandingByClient that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2277 of file CognitoIdentityProviderClient.h.

◆ DescribeManagedLoginBrandingCallable()

template<typename DescribeManagedLoginBrandingRequestT = Model::DescribeManagedLoginBrandingRequest>
Model::DescribeManagedLoginBrandingOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeManagedLoginBrandingCallable ( const DescribeManagedLoginBrandingRequestT &  request) const
inline

A Callable wrapper for DescribeManagedLoginBranding that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2251 of file CognitoIdentityProviderClient.h.

◆ DescribeResourceServer()

virtual Model::DescribeResourceServerOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeResourceServer ( const Model::DescribeResourceServerRequest request) const
virtual

Describes a resource server. For more information about resource servers, see Access control with resource servers.

See Also:

AWS API Reference

◆ DescribeResourceServerAsync()

template<typename DescribeResourceServerRequestT = Model::DescribeResourceServerRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeResourceServerAsync ( const DescribeResourceServerRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DescribeResourceServer that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2314 of file CognitoIdentityProviderClient.h.

◆ DescribeResourceServerCallable()

template<typename DescribeResourceServerRequestT = Model::DescribeResourceServerRequest>
Model::DescribeResourceServerOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeResourceServerCallable ( const DescribeResourceServerRequestT &  request) const
inline

A Callable wrapper for DescribeResourceServer that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2305 of file CognitoIdentityProviderClient.h.

◆ DescribeRiskConfiguration()

virtual Model::DescribeRiskConfigurationOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeRiskConfiguration ( const Model::DescribeRiskConfigurationRequest request) const
virtual

Given an app client or user pool ID where threat protection is configured, describes the risk configuration. This operation returns details about adaptive authentication, compromised credentials, and IP-address allow- and denylists. For more information about threat protection, see Threat protection.

See Also:

AWS API Reference

◆ DescribeRiskConfigurationAsync()

template<typename DescribeRiskConfigurationRequestT = Model::DescribeRiskConfigurationRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeRiskConfigurationAsync ( const DescribeRiskConfigurationRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DescribeRiskConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2344 of file CognitoIdentityProviderClient.h.

◆ DescribeRiskConfigurationCallable()

template<typename DescribeRiskConfigurationRequestT = Model::DescribeRiskConfigurationRequest>
Model::DescribeRiskConfigurationOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeRiskConfigurationCallable ( const DescribeRiskConfigurationRequestT &  request) const
inline

A Callable wrapper for DescribeRiskConfiguration that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2335 of file CognitoIdentityProviderClient.h.

◆ DescribeUserImportJob()

virtual Model::DescribeUserImportJobOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeUserImportJob ( const Model::DescribeUserImportJobRequest request) const
virtual

Describes a user import job. For more information about user CSV import, see Importing users from a CSV file.

See Also:

AWS API Reference

◆ DescribeUserImportJobAsync()

template<typename DescribeUserImportJobRequestT = Model::DescribeUserImportJobRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeUserImportJobAsync ( const DescribeUserImportJobRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DescribeUserImportJob that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2372 of file CognitoIdentityProviderClient.h.

◆ DescribeUserImportJobCallable()

template<typename DescribeUserImportJobRequestT = Model::DescribeUserImportJobRequest>
Model::DescribeUserImportJobOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeUserImportJobCallable ( const DescribeUserImportJobRequestT &  request) const
inline

A Callable wrapper for DescribeUserImportJob that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2363 of file CognitoIdentityProviderClient.h.

◆ DescribeUserPool()

virtual Model::DescribeUserPoolOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeUserPool ( const Model::DescribeUserPoolRequest request) const
virtual

Given a user pool ID, returns configuration information. This operation is useful when you want to inspect an existing user pool and programmatically replicate the configuration to another user pool.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ DescribeUserPoolAsync()

template<typename DescribeUserPoolRequestT = Model::DescribeUserPoolRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeUserPoolAsync ( const DescribeUserPoolRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DescribeUserPool that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2408 of file CognitoIdentityProviderClient.h.

◆ DescribeUserPoolCallable()

template<typename DescribeUserPoolRequestT = Model::DescribeUserPoolRequest>
Model::DescribeUserPoolOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeUserPoolCallable ( const DescribeUserPoolRequestT &  request) const
inline

A Callable wrapper for DescribeUserPool that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2399 of file CognitoIdentityProviderClient.h.

◆ DescribeUserPoolClient()

virtual Model::DescribeUserPoolClientOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeUserPoolClient ( const Model::DescribeUserPoolClientRequest request) const
virtual

Given an app client ID, returns configuration information. This operation is useful when you want to inspect an existing app client and programmatically replicate the configuration to another app client. For more information about app clients, see App clients.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ DescribeUserPoolClientAsync()

template<typename DescribeUserPoolClientRequestT = Model::DescribeUserPoolClientRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeUserPoolClientAsync ( const DescribeUserPoolClientRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DescribeUserPoolClient that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2447 of file CognitoIdentityProviderClient.h.

◆ DescribeUserPoolClientCallable()

template<typename DescribeUserPoolClientRequestT = Model::DescribeUserPoolClientRequest>
Model::DescribeUserPoolClientOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeUserPoolClientCallable ( const DescribeUserPoolClientRequestT &  request) const
inline

A Callable wrapper for DescribeUserPoolClient that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2438 of file CognitoIdentityProviderClient.h.

◆ DescribeUserPoolDomain()

virtual Model::DescribeUserPoolDomainOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeUserPoolDomain ( const Model::DescribeUserPoolDomainRequest request) const
virtual

Given a user pool domain name, returns information about the domain configuration.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ DescribeUserPoolDomainAsync()

template<typename DescribeUserPoolDomainRequestT = Model::DescribeUserPoolDomainRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeUserPoolDomainAsync ( const DescribeUserPoolDomainRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DescribeUserPoolDomain that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2482 of file CognitoIdentityProviderClient.h.

◆ DescribeUserPoolDomainCallable()

template<typename DescribeUserPoolDomainRequestT = Model::DescribeUserPoolDomainRequest>
Model::DescribeUserPoolDomainOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::DescribeUserPoolDomainCallable ( const DescribeUserPoolDomainRequestT &  request) const
inline

A Callable wrapper for DescribeUserPoolDomain that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2473 of file CognitoIdentityProviderClient.h.

◆ ForgetDevice()

virtual Model::ForgetDeviceOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ForgetDevice ( const Model::ForgetDeviceRequest request) const
virtual

Given a device key, deletes a remembered device as the currently signed-in user. For more information about device authentication, see Working with user devices in your user pool.

Authorize this action with a signed-in user's access token. It must include the scope aws.cognito.signin.user.admin.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

See Also:

AWS API Reference

◆ ForgetDeviceAsync()

template<typename ForgetDeviceRequestT = Model::ForgetDeviceRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ForgetDeviceAsync ( const ForgetDeviceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ForgetDevice that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2519 of file CognitoIdentityProviderClient.h.

◆ ForgetDeviceCallable()

template<typename ForgetDeviceRequestT = Model::ForgetDeviceRequest>
Model::ForgetDeviceOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ForgetDeviceCallable ( const ForgetDeviceRequestT &  request) const
inline

A Callable wrapper for ForgetDevice that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2510 of file CognitoIdentityProviderClient.h.

◆ ForgotPassword()

virtual Model::ForgotPasswordOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ForgotPassword ( const Model::ForgotPasswordRequest request) const
virtual

Sends a password-reset confirmation code for the currently signed-in user.

For the Username parameter, you can use the username or user alias.

If neither a verified phone number nor a verified email exists, Amazon Cognito responds with an InvalidParameterException error . If your app client has a client secret and you don't provide a SECRET_HASH parameter, this API returns NotAuthorizedException.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

This action might generate an SMS text message. Starting June 1, 2021, US telecom carriers require you to register an origination phone number before you can send SMS messages to US phone numbers. If you use SMS text messages in Amazon Cognito, you must register a phone number with Amazon Pinpoint. Amazon Cognito uses the registered number automatically. Otherwise, Amazon Cognito users who must receive SMS messages might not be able to sign up, activate their accounts, or sign in.

If you have never used SMS text messages with Amazon Cognito or any other Amazon Web Services service, Amazon Simple Notification Service might place your account in the SMS sandbox. In sandbox mode , you can send messages only to verified phone numbers. After you test your app while in the sandbox environment, you can move out of the sandbox and into production. For more information, see SMS message settings for Amazon Cognito user pools in the Amazon Cognito Developer Guide.

See Also:

AWS API Reference

◆ ForgotPasswordAsync()

template<typename ForgotPasswordRequestT = Model::ForgotPasswordRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ForgotPasswordAsync ( const ForgotPasswordRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ForgotPassword that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2573 of file CognitoIdentityProviderClient.h.

◆ ForgotPasswordCallable()

template<typename ForgotPasswordRequestT = Model::ForgotPasswordRequest>
Model::ForgotPasswordOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ForgotPasswordCallable ( const ForgotPasswordRequestT &  request) const
inline

A Callable wrapper for ForgotPassword that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2564 of file CognitoIdentityProviderClient.h.

◆ GetAllocationTag()

static const char * Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetAllocationTag ( )
static

◆ GetCSVHeader()

virtual Model::GetCSVHeaderOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetCSVHeader ( const Model::GetCSVHeaderRequest request) const
virtual

Given a user pool ID, generates a comma-separated value (CSV) list populated with available user attributes in the user pool. This list is the header for the CSV file that determines the users in a user import job. Save the content of CSVHeader in the response as a .csv file and populate it with the usernames and attributes of users that you want to import. For more information about CSV user import, see Importing users from a CSV file.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ GetCSVHeaderAsync()

template<typename GetCSVHeaderRequestT = Model::GetCSVHeaderRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetCSVHeaderAsync ( const GetCSVHeaderRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetCSVHeader that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2614 of file CognitoIdentityProviderClient.h.

◆ GetCSVHeaderCallable()

template<typename GetCSVHeaderRequestT = Model::GetCSVHeaderRequest>
Model::GetCSVHeaderOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetCSVHeaderCallable ( const GetCSVHeaderRequestT &  request) const
inline

A Callable wrapper for GetCSVHeader that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2605 of file CognitoIdentityProviderClient.h.

◆ GetDevice()

virtual Model::GetDeviceOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetDevice ( const Model::GetDeviceRequest request) const
virtual

Given a device key, returns information about a remembered device for the current user. For more information about device authentication, see Working with user devices in your user pool.

Authorize this action with a signed-in user's access token. It must include the scope aws.cognito.signin.user.admin.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

See Also:

AWS API Reference

◆ GetDeviceAsync()

template<typename GetDeviceRequestT = Model::GetDeviceRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetDeviceAsync ( const GetDeviceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetDevice that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2651 of file CognitoIdentityProviderClient.h.

◆ GetDeviceCallable()

template<typename GetDeviceRequestT = Model::GetDeviceRequest>
Model::GetDeviceOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetDeviceCallable ( const GetDeviceRequestT &  request) const
inline

A Callable wrapper for GetDevice that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2642 of file CognitoIdentityProviderClient.h.

◆ GetGroup()

virtual Model::GetGroupOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetGroup ( const Model::GetGroupRequest request) const
virtual

Given a user pool ID and a group name, returns information about the user group.

For more information about user pool groups, see Adding groups to a user pool.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ GetGroupAsync()

template<typename GetGroupRequestT = Model::GetGroupRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetGroupAsync ( const GetGroupRequestT &  request,
const GetGroupResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetGroup that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2688 of file CognitoIdentityProviderClient.h.

◆ GetGroupCallable()

template<typename GetGroupRequestT = Model::GetGroupRequest>
Model::GetGroupOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetGroupCallable ( const GetGroupRequestT &  request) const
inline

A Callable wrapper for GetGroup that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2679 of file CognitoIdentityProviderClient.h.

◆ GetIdentityProviderByIdentifier()

virtual Model::GetIdentityProviderByIdentifierOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetIdentityProviderByIdentifier ( const Model::GetIdentityProviderByIdentifierRequest request) const
virtual

Given the identifier of an identity provider (IdP), for example examplecorp, returns information about the user pool configuration for that IdP. For more information about IdPs, see Third-party IdP sign-in.

See Also:

AWS API Reference

◆ GetIdentityProviderByIdentifierAsync()

template<typename GetIdentityProviderByIdentifierRequestT = Model::GetIdentityProviderByIdentifierRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetIdentityProviderByIdentifierAsync ( const GetIdentityProviderByIdentifierRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetIdentityProviderByIdentifier that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2717 of file CognitoIdentityProviderClient.h.

◆ GetIdentityProviderByIdentifierCallable()

template<typename GetIdentityProviderByIdentifierRequestT = Model::GetIdentityProviderByIdentifierRequest>
Model::GetIdentityProviderByIdentifierOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetIdentityProviderByIdentifierCallable ( const GetIdentityProviderByIdentifierRequestT &  request) const
inline

A Callable wrapper for GetIdentityProviderByIdentifier that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2708 of file CognitoIdentityProviderClient.h.

◆ GetLogDeliveryConfiguration()

virtual Model::GetLogDeliveryConfigurationOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetLogDeliveryConfiguration ( const Model::GetLogDeliveryConfigurationRequest request) const
virtual

Given a user pool ID, returns the logging configuration. User pools can export message-delivery error and threat-protection activity logs to external Amazon Web Services services. For more information, see Exporting user pool logs.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ GetLogDeliveryConfigurationAsync()

template<typename GetLogDeliveryConfigurationRequestT = Model::GetLogDeliveryConfigurationRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetLogDeliveryConfigurationAsync ( const GetLogDeliveryConfigurationRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetLogDeliveryConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2755 of file CognitoIdentityProviderClient.h.

◆ GetLogDeliveryConfigurationCallable()

template<typename GetLogDeliveryConfigurationRequestT = Model::GetLogDeliveryConfigurationRequest>
Model::GetLogDeliveryConfigurationOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetLogDeliveryConfigurationCallable ( const GetLogDeliveryConfigurationRequestT &  request) const
inline

A Callable wrapper for GetLogDeliveryConfiguration that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2746 of file CognitoIdentityProviderClient.h.

◆ GetServiceName()

static const char * Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetServiceName ( )
static

◆ GetSigningCertificate()

virtual Model::GetSigningCertificateOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetSigningCertificate ( const Model::GetSigningCertificateRequest request) const
virtual

Given a user pool ID, returns the signing certificate for SAML 2.0 federation.

Issued certificates are valid for 10 years from the date of issue. Amazon Cognito issues and assigns a new signing certificate annually. This renewal process returns a new value in the response to GetSigningCertificate, but doesn't invalidate the original certificate.

For more information, see Signing SAML requests.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ GetSigningCertificateAsync()

template<typename GetSigningCertificateRequestT = Model::GetSigningCertificateRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetSigningCertificateAsync ( const GetSigningCertificateRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetSigningCertificate that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2796 of file CognitoIdentityProviderClient.h.

◆ GetSigningCertificateCallable()

template<typename GetSigningCertificateRequestT = Model::GetSigningCertificateRequest>
Model::GetSigningCertificateOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetSigningCertificateCallable ( const GetSigningCertificateRequestT &  request) const
inline

A Callable wrapper for GetSigningCertificate that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2787 of file CognitoIdentityProviderClient.h.

◆ GetTokensFromRefreshToken()

virtual Model::GetTokensFromRefreshTokenOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetTokensFromRefreshToken ( const Model::GetTokensFromRefreshTokenRequest request) const
virtual

Given a refresh token, issues new ID, access, and optionally refresh tokens for the user who owns the submitted token. This operation issues a new refresh token and invalidates the original refresh token after an optional grace period when refresh token rotation is enabled. If refresh token rotation is disabled, issues new ID and access tokens only.

See Also:

AWS API Reference

◆ GetTokensFromRefreshTokenAsync()

template<typename GetTokensFromRefreshTokenRequestT = Model::GetTokensFromRefreshTokenRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetTokensFromRefreshTokenAsync ( const GetTokensFromRefreshTokenRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetTokensFromRefreshToken that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2825 of file CognitoIdentityProviderClient.h.

◆ GetTokensFromRefreshTokenCallable()

template<typename GetTokensFromRefreshTokenRequestT = Model::GetTokensFromRefreshTokenRequest>
Model::GetTokensFromRefreshTokenOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetTokensFromRefreshTokenCallable ( const GetTokensFromRefreshTokenRequestT &  request) const
inline

A Callable wrapper for GetTokensFromRefreshToken that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2816 of file CognitoIdentityProviderClient.h.

◆ GetUICustomization()

virtual Model::GetUICustomizationOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetUICustomization ( const Model::GetUICustomizationRequest request) const
virtual

Given a user pool ID or app client, returns information about classic hosted UI branding that you applied, if any. Returns user-pool level branding information if no app client branding is applied, or if you don't specify an app client ID. Returns an empty object if you haven't applied hosted UI branding to either the client or the user pool. For more information, see Hosted UI (classic) branding.

See Also:

AWS API Reference

◆ GetUICustomizationAsync()

template<typename GetUICustomizationRequestT = Model::GetUICustomizationRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetUICustomizationAsync ( const GetUICustomizationRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetUICustomization that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2856 of file CognitoIdentityProviderClient.h.

◆ GetUICustomizationCallable()

template<typename GetUICustomizationRequestT = Model::GetUICustomizationRequest>
Model::GetUICustomizationOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetUICustomizationCallable ( const GetUICustomizationRequestT &  request) const
inline

A Callable wrapper for GetUICustomization that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2847 of file CognitoIdentityProviderClient.h.

◆ GetUser()

virtual Model::GetUserOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetUser ( const Model::GetUserRequest request) const
virtual

Gets user attributes and and MFA settings for the currently signed-in user.

Authorize this action with a signed-in user's access token. It must include the scope aws.cognito.signin.user.admin.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

See Also:

AWS API Reference

◆ GetUserAsync()

template<typename GetUserRequestT = Model::GetUserRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetUserAsync ( const GetUserRequestT &  request,
const GetUserResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetUser that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2891 of file CognitoIdentityProviderClient.h.

◆ GetUserAttributeVerificationCode()

virtual Model::GetUserAttributeVerificationCodeOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetUserAttributeVerificationCode ( const Model::GetUserAttributeVerificationCodeRequest request) const
virtual

Given an attribute name, sends a user attribute verification code for the specified attribute name to the currently signed-in user.

Authorize this action with a signed-in user's access token. It must include the scope aws.cognito.signin.user.admin.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

This action might generate an SMS text message. Starting June 1, 2021, US telecom carriers require you to register an origination phone number before you can send SMS messages to US phone numbers. If you use SMS text messages in Amazon Cognito, you must register a phone number with Amazon Pinpoint. Amazon Cognito uses the registered number automatically. Otherwise, Amazon Cognito users who must receive SMS messages might not be able to sign up, activate their accounts, or sign in.

If you have never used SMS text messages with Amazon Cognito or any other Amazon Web Services service, Amazon Simple Notification Service might place your account in the SMS sandbox. In sandbox mode , you can send messages only to verified phone numbers. After you test your app while in the sandbox environment, you can move out of the sandbox and into production. For more information, see SMS message settings for Amazon Cognito user pools in the Amazon Cognito Developer Guide.

See Also:

AWS API Reference

◆ GetUserAttributeVerificationCodeAsync()

template<typename GetUserAttributeVerificationCodeRequestT = Model::GetUserAttributeVerificationCodeRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetUserAttributeVerificationCodeAsync ( const GetUserAttributeVerificationCodeRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetUserAttributeVerificationCode that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2942 of file CognitoIdentityProviderClient.h.

◆ GetUserAttributeVerificationCodeCallable()

template<typename GetUserAttributeVerificationCodeRequestT = Model::GetUserAttributeVerificationCodeRequest>
Model::GetUserAttributeVerificationCodeOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetUserAttributeVerificationCodeCallable ( const GetUserAttributeVerificationCodeRequestT &  request) const
inline

A Callable wrapper for GetUserAttributeVerificationCode that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2933 of file CognitoIdentityProviderClient.h.

◆ GetUserAuthFactors()

virtual Model::GetUserAuthFactorsOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetUserAuthFactors ( const Model::GetUserAuthFactorsRequest request) const
virtual

Lists the authentication options for the currently signed-in user. Returns the following:

  1. The user's multi-factor authentication (MFA) preferences.

  2. The user's options for choice-based authentication with the USER_AUTH flow.

Authorize this action with a signed-in user's access token. It must include the scope aws.cognito.signin.user.admin.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

See Also:

AWS API Reference

◆ GetUserAuthFactorsAsync()

template<typename GetUserAuthFactorsRequestT = Model::GetUserAuthFactorsRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetUserAuthFactorsAsync ( const GetUserAuthFactorsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetUserAuthFactors that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2980 of file CognitoIdentityProviderClient.h.

◆ GetUserAuthFactorsCallable()

template<typename GetUserAuthFactorsRequestT = Model::GetUserAuthFactorsRequest>
Model::GetUserAuthFactorsOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetUserAuthFactorsCallable ( const GetUserAuthFactorsRequestT &  request) const
inline

A Callable wrapper for GetUserAuthFactors that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2971 of file CognitoIdentityProviderClient.h.

◆ GetUserCallable()

template<typename GetUserRequestT = Model::GetUserRequest>
Model::GetUserOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetUserCallable ( const GetUserRequestT &  request) const
inline

A Callable wrapper for GetUser that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2882 of file CognitoIdentityProviderClient.h.

◆ GetUserPoolMfaConfig()

virtual Model::GetUserPoolMfaConfigOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetUserPoolMfaConfig ( const Model::GetUserPoolMfaConfigRequest request) const
virtual

Given a user pool ID, returns configuration for sign-in with WebAuthn authenticators and for multi-factor authentication (MFA). This operation describes the following:

  • The WebAuthn relying party (RP) ID and user-verification settings.

  • The required, optional, or disabled state of MFA for all user pool users.

  • The message templates for email and SMS MFA.

  • The enabled or disabled state of time-based one-time password (TOTP) MFA.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ GetUserPoolMfaConfigAsync()

template<typename GetUserPoolMfaConfigRequestT = Model::GetUserPoolMfaConfigRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetUserPoolMfaConfigAsync ( const GetUserPoolMfaConfigRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetUserPoolMfaConfig that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3020 of file CognitoIdentityProviderClient.h.

◆ GetUserPoolMfaConfigCallable()

template<typename GetUserPoolMfaConfigRequestT = Model::GetUserPoolMfaConfigRequest>
Model::GetUserPoolMfaConfigOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GetUserPoolMfaConfigCallable ( const GetUserPoolMfaConfigRequestT &  request) const
inline

A Callable wrapper for GetUserPoolMfaConfig that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3011 of file CognitoIdentityProviderClient.h.

◆ GlobalSignOut()

virtual Model::GlobalSignOutOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GlobalSignOut ( const Model::GlobalSignOutRequest request) const
virtual

Invalidates the identity, access, and refresh tokens that Amazon Cognito issued to a user. Call this operation when your user signs out of your app. This results in the following behavior.

  • Amazon Cognito no longer accepts token-authorized user operations that you authorize with a signed-out user's access tokens. For more information, see Using the Amazon Cognito user pools API and user pool endpoints.

    Amazon Cognito returns an Access Token has been revoked error when your app attempts to authorize a user pools API request with a revoked access token that contains the scope aws.cognito.signin.user.admin.

  • Amazon Cognito no longer accepts a signed-out user's ID token in a GetId request to an identity pool with ServerSideTokenCheck enabled for its user pool IdP configuration in CognitoIdentityProvider.

  • Amazon Cognito no longer accepts a signed-out user's refresh tokens in refresh requests.

Other requests might be valid until your user's token expires. This operation doesn't clear the managed login session cookie. To clear the session for a user who signed in with managed login or the classic hosted UI, direct their browser session to the logout endpoint.

Authorize this action with a signed-in user's access token. It must include the scope aws.cognito.signin.user.admin.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

See Also:

AWS API Reference

◆ GlobalSignOutAsync()

template<typename GlobalSignOutRequestT = Model::GlobalSignOutRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GlobalSignOutAsync ( const GlobalSignOutRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GlobalSignOut that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3076 of file CognitoIdentityProviderClient.h.

◆ GlobalSignOutCallable()

template<typename GlobalSignOutRequestT = Model::GlobalSignOutRequest>
Model::GlobalSignOutOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::GlobalSignOutCallable ( const GlobalSignOutRequestT &  request) const
inline

A Callable wrapper for GlobalSignOut that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3067 of file CognitoIdentityProviderClient.h.

◆ InitiateAuth()

virtual Model::InitiateAuthOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::InitiateAuth ( const Model::InitiateAuthRequest request) const
virtual

Declares an authentication flow and initiates sign-in for a user in the Amazon Cognito user directory. Amazon Cognito might respond with an additional challenge or an AuthenticationResult that contains the outcome of a successful authentication. You can't sign in a user with a federated IdP with InitiateAuth. For more information, see Authentication.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

This action might generate an SMS text message. Starting June 1, 2021, US telecom carriers require you to register an origination phone number before you can send SMS messages to US phone numbers. If you use SMS text messages in Amazon Cognito, you must register a phone number with Amazon Pinpoint. Amazon Cognito uses the registered number automatically. Otherwise, Amazon Cognito users who must receive SMS messages might not be able to sign up, activate their accounts, or sign in.

If you have never used SMS text messages with Amazon Cognito or any other Amazon Web Services service, Amazon Simple Notification Service might place your account in the SMS sandbox. In sandbox mode , you can send messages only to verified phone numbers. After you test your app while in the sandbox environment, you can move out of the sandbox and into production. For more information, see SMS message settings for Amazon Cognito user pools in the Amazon Cognito Developer Guide.

See Also:

AWS API Reference

◆ InitiateAuthAsync()

template<typename InitiateAuthRequestT = Model::InitiateAuthRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::InitiateAuthAsync ( const InitiateAuthRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for InitiateAuth that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3130 of file CognitoIdentityProviderClient.h.

◆ InitiateAuthCallable()

template<typename InitiateAuthRequestT = Model::InitiateAuthRequest>
Model::InitiateAuthOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::InitiateAuthCallable ( const InitiateAuthRequestT &  request) const
inline

A Callable wrapper for InitiateAuth that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3121 of file CognitoIdentityProviderClient.h.

◆ ListDevices()

virtual Model::ListDevicesOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListDevices ( const Model::ListDevicesRequest request) const
virtual

Lists the devices that Amazon Cognito has registered to the currently signed-in user. For more information about device authentication, see Working with user devices in your user pool.

Authorize this action with a signed-in user's access token. It must include the scope aws.cognito.signin.user.admin.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

See Also:

AWS API Reference

◆ ListDevicesAsync()

template<typename ListDevicesRequestT = Model::ListDevicesRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListDevicesAsync ( const ListDevicesRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ListDevices that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3167 of file CognitoIdentityProviderClient.h.

◆ ListDevicesCallable()

template<typename ListDevicesRequestT = Model::ListDevicesRequest>
Model::ListDevicesOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListDevicesCallable ( const ListDevicesRequestT &  request) const
inline

A Callable wrapper for ListDevices that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3158 of file CognitoIdentityProviderClient.h.

◆ ListGroups()

virtual Model::ListGroupsOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListGroups ( const Model::ListGroupsRequest request) const
virtual

Given a user pool ID, returns user pool groups and their details.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ ListGroupsAsync()

template<typename ListGroupsRequestT = Model::ListGroupsRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListGroupsAsync ( const ListGroupsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ListGroups that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3202 of file CognitoIdentityProviderClient.h.

◆ ListGroupsCallable()

template<typename ListGroupsRequestT = Model::ListGroupsRequest>
Model::ListGroupsOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListGroupsCallable ( const ListGroupsRequestT &  request) const
inline

A Callable wrapper for ListGroups that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3193 of file CognitoIdentityProviderClient.h.

◆ ListIdentityProviders()

virtual Model::ListIdentityProvidersOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListIdentityProviders ( const Model::ListIdentityProvidersRequest request) const
virtual

Given a user pool ID, returns information about configured identity providers (IdPs). For more information about IdPs, see Third-party IdP sign-in.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ ListIdentityProvidersAsync()

template<typename ListIdentityProvidersRequestT = Model::ListIdentityProvidersRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListIdentityProvidersAsync ( const ListIdentityProvidersRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ListIdentityProviders that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3239 of file CognitoIdentityProviderClient.h.

◆ ListIdentityProvidersCallable()

template<typename ListIdentityProvidersRequestT = Model::ListIdentityProvidersRequest>
Model::ListIdentityProvidersOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListIdentityProvidersCallable ( const ListIdentityProvidersRequestT &  request) const
inline

A Callable wrapper for ListIdentityProviders that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3230 of file CognitoIdentityProviderClient.h.

◆ ListResourceServers()

virtual Model::ListResourceServersOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListResourceServers ( const Model::ListResourceServersRequest request) const
virtual

Given a user pool ID, returns all resource servers and their details. For more information about resource servers, see Access control with resource servers.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ ListResourceServersAsync()

template<typename ListResourceServersRequestT = Model::ListResourceServersRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListResourceServersAsync ( const ListResourceServersRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ListResourceServers that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3276 of file CognitoIdentityProviderClient.h.

◆ ListResourceServersCallable()

template<typename ListResourceServersRequestT = Model::ListResourceServersRequest>
Model::ListResourceServersOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListResourceServersCallable ( const ListResourceServersRequestT &  request) const
inline

A Callable wrapper for ListResourceServers that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3267 of file CognitoIdentityProviderClient.h.

◆ ListTagsForResource()

virtual Model::ListTagsForResourceOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListTagsForResource ( const Model::ListTagsForResourceRequest request) const
virtual

Lists the tags that are assigned to an Amazon Cognito user pool. For more information, see Tagging resources.

See Also:

AWS API Reference

◆ ListTagsForResourceAsync()

template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListTagsForResourceAsync ( const ListTagsForResourceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3304 of file CognitoIdentityProviderClient.h.

◆ ListTagsForResourceCallable()

template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
Model::ListTagsForResourceOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListTagsForResourceCallable ( const ListTagsForResourceRequestT &  request) const
inline

A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3295 of file CognitoIdentityProviderClient.h.

◆ ListUserImportJobs()

virtual Model::ListUserImportJobsOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListUserImportJobs ( const Model::ListUserImportJobsRequest request) const
virtual

Given a user pool ID, returns user import jobs and their details. Import jobs are retained in user pool configuration so that you can stage, stop, start, review, and delete them. For more information about user import, see Importing users from a CSV file.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ ListUserImportJobsAsync()

template<typename ListUserImportJobsRequestT = Model::ListUserImportJobsRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListUserImportJobsAsync ( const ListUserImportJobsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ListUserImportJobs that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3342 of file CognitoIdentityProviderClient.h.

◆ ListUserImportJobsCallable()

template<typename ListUserImportJobsRequestT = Model::ListUserImportJobsRequest>
Model::ListUserImportJobsOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListUserImportJobsCallable ( const ListUserImportJobsRequestT &  request) const
inline

A Callable wrapper for ListUserImportJobs that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3333 of file CognitoIdentityProviderClient.h.

◆ ListUserPoolClients()

virtual Model::ListUserPoolClientsOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListUserPoolClients ( const Model::ListUserPoolClientsRequest request) const
virtual

Given a user pool ID, lists app clients. App clients are sets of rules for the access that you want a user pool to grant to one application. For more information, see App clients.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ ListUserPoolClientsAsync()

template<typename ListUserPoolClientsRequestT = Model::ListUserPoolClientsRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListUserPoolClientsAsync ( const ListUserPoolClientsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ListUserPoolClients that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3380 of file CognitoIdentityProviderClient.h.

◆ ListUserPoolClientsCallable()

template<typename ListUserPoolClientsRequestT = Model::ListUserPoolClientsRequest>
Model::ListUserPoolClientsOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListUserPoolClientsCallable ( const ListUserPoolClientsRequestT &  request) const
inline

A Callable wrapper for ListUserPoolClients that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3371 of file CognitoIdentityProviderClient.h.

◆ ListUserPools()

virtual Model::ListUserPoolsOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListUserPools ( const Model::ListUserPoolsRequest request) const
virtual

Lists user pools and their details in the current Amazon Web Services account.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ ListUserPoolsAsync()

template<typename ListUserPoolsRequestT = Model::ListUserPoolsRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListUserPoolsAsync ( const ListUserPoolsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ListUserPools that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3415 of file CognitoIdentityProviderClient.h.

◆ ListUserPoolsCallable()

template<typename ListUserPoolsRequestT = Model::ListUserPoolsRequest>
Model::ListUserPoolsOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListUserPoolsCallable ( const ListUserPoolsRequestT &  request) const
inline

A Callable wrapper for ListUserPools that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3406 of file CognitoIdentityProviderClient.h.

◆ ListUsers()

virtual Model::ListUsersOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListUsers ( const Model::ListUsersRequest request) const
virtual

Given a user pool ID, returns a list of users and their basic details in a user pool.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ ListUsersAsync()

template<typename ListUsersRequestT = Model::ListUsersRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListUsersAsync ( const ListUsersRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ListUsers that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3450 of file CognitoIdentityProviderClient.h.

◆ ListUsersCallable()

template<typename ListUsersRequestT = Model::ListUsersRequest>
Model::ListUsersOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListUsersCallable ( const ListUsersRequestT &  request) const
inline

A Callable wrapper for ListUsers that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3441 of file CognitoIdentityProviderClient.h.

◆ ListUsersInGroup()

virtual Model::ListUsersInGroupOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListUsersInGroup ( const Model::ListUsersInGroupRequest request) const
virtual

Given a user pool ID and a group name, returns a list of users in the group. For more information about user pool groups, see Adding groups to a user pool.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ ListUsersInGroupAsync()

template<typename ListUsersInGroupRequestT = Model::ListUsersInGroupRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListUsersInGroupAsync ( const ListUsersInGroupRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ListUsersInGroup that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3487 of file CognitoIdentityProviderClient.h.

◆ ListUsersInGroupCallable()

template<typename ListUsersInGroupRequestT = Model::ListUsersInGroupRequest>
Model::ListUsersInGroupOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListUsersInGroupCallable ( const ListUsersInGroupRequestT &  request) const
inline

A Callable wrapper for ListUsersInGroup that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3478 of file CognitoIdentityProviderClient.h.

◆ ListWebAuthnCredentials()

virtual Model::ListWebAuthnCredentialsOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListWebAuthnCredentials ( const Model::ListWebAuthnCredentialsRequest request) const
virtual

Generates a list of the currently signed-in user's registered passkey, or WebAuthn, credentials.

Authorize this action with a signed-in user's access token. It must include the scope aws.cognito.signin.user.admin.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

See Also:

AWS API Reference

◆ ListWebAuthnCredentialsAsync()

template<typename ListWebAuthnCredentialsRequestT = Model::ListWebAuthnCredentialsRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListWebAuthnCredentialsAsync ( const ListWebAuthnCredentialsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ListWebAuthnCredentials that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3522 of file CognitoIdentityProviderClient.h.

◆ ListWebAuthnCredentialsCallable()

template<typename ListWebAuthnCredentialsRequestT = Model::ListWebAuthnCredentialsRequest>
Model::ListWebAuthnCredentialsOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ListWebAuthnCredentialsCallable ( const ListWebAuthnCredentialsRequestT &  request) const
inline

A Callable wrapper for ListWebAuthnCredentials that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3513 of file CognitoIdentityProviderClient.h.

◆ OverrideEndpoint()

void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::OverrideEndpoint ( const Aws::String endpoint)

◆ ResendConfirmationCode()

virtual Model::ResendConfirmationCodeOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ResendConfirmationCode ( const Model::ResendConfirmationCodeRequest request) const
virtual

Resends the code that confirms a new account for a user who has signed up in your user pool. Amazon Cognito sends confirmation codes to the user attribute in the AutoVerifiedAttributes property of your user pool. When you prompt new users for the confirmation code, include a "Resend code" option that generates a call to this API operation.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

This action might generate an SMS text message. Starting June 1, 2021, US telecom carriers require you to register an origination phone number before you can send SMS messages to US phone numbers. If you use SMS text messages in Amazon Cognito, you must register a phone number with Amazon Pinpoint. Amazon Cognito uses the registered number automatically. Otherwise, Amazon Cognito users who must receive SMS messages might not be able to sign up, activate their accounts, or sign in.

If you have never used SMS text messages with Amazon Cognito or any other Amazon Web Services service, Amazon Simple Notification Service might place your account in the SMS sandbox. In sandbox mode , you can send messages only to verified phone numbers. After you test your app while in the sandbox environment, you can move out of the sandbox and into production. For more information, see SMS message settings for Amazon Cognito user pools in the Amazon Cognito Developer Guide.

See Also:

AWS API Reference

◆ ResendConfirmationCodeAsync()

template<typename ResendConfirmationCodeRequestT = Model::ResendConfirmationCodeRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ResendConfirmationCodeAsync ( const ResendConfirmationCodeRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ResendConfirmationCode that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3574 of file CognitoIdentityProviderClient.h.

◆ ResendConfirmationCodeCallable()

template<typename ResendConfirmationCodeRequestT = Model::ResendConfirmationCodeRequest>
Model::ResendConfirmationCodeOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::ResendConfirmationCodeCallable ( const ResendConfirmationCodeRequestT &  request) const
inline

A Callable wrapper for ResendConfirmationCode that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3565 of file CognitoIdentityProviderClient.h.

◆ RespondToAuthChallenge()

virtual Model::RespondToAuthChallengeOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::RespondToAuthChallenge ( const Model::RespondToAuthChallengeRequest request) const
virtual

Some API operations in a user pool generate a challenge, like a prompt for an MFA code, for device authentication that bypasses MFA, or for a custom authentication challenge. A RespondToAuthChallenge API request provides the answer to that challenge, like a code or a secure remote password (SRP). The parameters of a response to an authentication challenge vary with the type of challenge.

For more information about custom authentication challenges, see Custom authentication challenge Lambda triggers.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

This action might generate an SMS text message. Starting June 1, 2021, US telecom carriers require you to register an origination phone number before you can send SMS messages to US phone numbers. If you use SMS text messages in Amazon Cognito, you must register a phone number with Amazon Pinpoint. Amazon Cognito uses the registered number automatically. Otherwise, Amazon Cognito users who must receive SMS messages might not be able to sign up, activate their accounts, or sign in.

If you have never used SMS text messages with Amazon Cognito or any other Amazon Web Services service, Amazon Simple Notification Service might place your account in the SMS sandbox. In sandbox mode , you can send messages only to verified phone numbers. After you test your app while in the sandbox environment, you can move out of the sandbox and into production. For more information, see SMS message settings for Amazon Cognito user pools in the Amazon Cognito Developer Guide.

See Also:

AWS API Reference

◆ RespondToAuthChallengeAsync()

template<typename RespondToAuthChallengeRequestT = Model::RespondToAuthChallengeRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::RespondToAuthChallengeAsync ( const RespondToAuthChallengeRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for RespondToAuthChallenge that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3630 of file CognitoIdentityProviderClient.h.

◆ RespondToAuthChallengeCallable()

template<typename RespondToAuthChallengeRequestT = Model::RespondToAuthChallengeRequest>
Model::RespondToAuthChallengeOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::RespondToAuthChallengeCallable ( const RespondToAuthChallengeRequestT &  request) const
inline

A Callable wrapper for RespondToAuthChallenge that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3621 of file CognitoIdentityProviderClient.h.

◆ RevokeToken()

virtual Model::RevokeTokenOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::RevokeToken ( const Model::RevokeTokenRequest request) const
virtual

Revokes all of the access tokens generated by, and at the same time as, the specified refresh token. After a token is revoked, you can't use the revoked token to access Amazon Cognito user APIs, or to authorize access to your resource server.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

See Also:

AWS API Reference

◆ RevokeTokenAsync()

template<typename RevokeTokenRequestT = Model::RevokeTokenRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::RevokeTokenAsync ( const RevokeTokenRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for RevokeToken that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3665 of file CognitoIdentityProviderClient.h.

◆ RevokeTokenCallable()

template<typename RevokeTokenRequestT = Model::RevokeTokenRequest>
Model::RevokeTokenOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::RevokeTokenCallable ( const RevokeTokenRequestT &  request) const
inline

A Callable wrapper for RevokeToken that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3656 of file CognitoIdentityProviderClient.h.

◆ SetLogDeliveryConfiguration()

virtual Model::SetLogDeliveryConfigurationOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::SetLogDeliveryConfiguration ( const Model::SetLogDeliveryConfigurationRequest request) const
virtual

Sets up or modifies the logging configuration of a user pool. User pools can export user notification logs and, when threat protection is active, user-activity logs. For more information, see Exporting user pool logs.

See Also:

AWS API Reference

◆ SetLogDeliveryConfigurationAsync()

template<typename SetLogDeliveryConfigurationRequestT = Model::SetLogDeliveryConfigurationRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::SetLogDeliveryConfigurationAsync ( const SetLogDeliveryConfigurationRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for SetLogDeliveryConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3694 of file CognitoIdentityProviderClient.h.

◆ SetLogDeliveryConfigurationCallable()

template<typename SetLogDeliveryConfigurationRequestT = Model::SetLogDeliveryConfigurationRequest>
Model::SetLogDeliveryConfigurationOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::SetLogDeliveryConfigurationCallable ( const SetLogDeliveryConfigurationRequestT &  request) const
inline

A Callable wrapper for SetLogDeliveryConfiguration that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3685 of file CognitoIdentityProviderClient.h.

◆ SetRiskConfiguration()

virtual Model::SetRiskConfigurationOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::SetRiskConfiguration ( const Model::SetRiskConfigurationRequest request) const
virtual

Configures threat protection for a user pool or app client. Sets configuration for the following.

  • Responses to risks with adaptive authentication

  • Responses to vulnerable passwords with compromised-credentials detection

  • Notifications to users who have had risky activity detected

  • IP-address denylist and allowlist

To set the risk configuration for the user pool to defaults, send this request with only the UserPoolId parameter. To reset the threat protection settings of an app client to be inherited from the user pool, send UserPoolId and ClientId parameters only. To change threat protection to audit-only or off, update the value of UserPoolAddOns in an UpdateUserPool request. To activate this setting, your user pool must be on the Plus tier.

See Also:

AWS API Reference

◆ SetRiskConfigurationAsync()

template<typename SetRiskConfigurationRequestT = Model::SetRiskConfigurationRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::SetRiskConfigurationAsync ( const SetRiskConfigurationRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for SetRiskConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3732 of file CognitoIdentityProviderClient.h.

◆ SetRiskConfigurationCallable()

template<typename SetRiskConfigurationRequestT = Model::SetRiskConfigurationRequest>
Model::SetRiskConfigurationOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::SetRiskConfigurationCallable ( const SetRiskConfigurationRequestT &  request) const
inline

A Callable wrapper for SetRiskConfiguration that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3723 of file CognitoIdentityProviderClient.h.

◆ SetUICustomization()

virtual Model::SetUICustomizationOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::SetUICustomization ( const Model::SetUICustomizationRequest request) const
virtual

Configures UI branding settings for domains with the hosted UI (classic) branding version. Your user pool must have a domain. Configure a domain with .

Set the default configuration for all clients with a ClientId of ALL. When the ClientId value is an app client ID, the settings you pass in this request apply to that app client and override the default ALL configuration.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ SetUICustomizationAsync()

template<typename SetUICustomizationRequestT = Model::SetUICustomizationRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::SetUICustomizationAsync ( const SetUICustomizationRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for SetUICustomization that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3772 of file CognitoIdentityProviderClient.h.

◆ SetUICustomizationCallable()

template<typename SetUICustomizationRequestT = Model::SetUICustomizationRequest>
Model::SetUICustomizationOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::SetUICustomizationCallable ( const SetUICustomizationRequestT &  request) const
inline

A Callable wrapper for SetUICustomization that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3763 of file CognitoIdentityProviderClient.h.

◆ SetUserMFAPreference()

virtual Model::SetUserMFAPreferenceOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::SetUserMFAPreference ( const Model::SetUserMFAPreferenceRequest request) const
virtual

Set the user's multi-factor authentication (MFA) method preference, including which MFA factors are activated and if any are preferred. Only one factor can be set as preferred. The preferred MFA factor will be used to authenticate a user if multiple factors are activated. If multiple options are activated and no preference is set, a challenge to choose an MFA option will be returned during sign-in. If an MFA type is activated for a user, the user will be prompted for MFA during all sign-in attempts unless device tracking is turned on and the device has been trusted. If you want MFA to be applied selectively based on the assessed risk level of sign-in attempts, deactivate MFA for users and turn on Adaptive Authentication for the user pool.

Authorize this action with a signed-in user's access token. It must include the scope aws.cognito.signin.user.admin.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

See Also:

AWS API Reference

◆ SetUserMFAPreferenceAsync()

template<typename SetUserMFAPreferenceRequestT = Model::SetUserMFAPreferenceRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::SetUserMFAPreferenceAsync ( const SetUserMFAPreferenceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for SetUserMFAPreference that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3815 of file CognitoIdentityProviderClient.h.

◆ SetUserMFAPreferenceCallable()

template<typename SetUserMFAPreferenceRequestT = Model::SetUserMFAPreferenceRequest>
Model::SetUserMFAPreferenceOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::SetUserMFAPreferenceCallable ( const SetUserMFAPreferenceRequestT &  request) const
inline

A Callable wrapper for SetUserMFAPreference that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3806 of file CognitoIdentityProviderClient.h.

◆ SetUserPoolMfaConfig()

virtual Model::SetUserPoolMfaConfigOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::SetUserPoolMfaConfig ( const Model::SetUserPoolMfaConfigRequest request) const
virtual

Sets user pool multi-factor authentication (MFA) and passkey configuration. For more information about user pool MFA, see Adding MFA. For more information about WebAuthn passkeys see Authentication flows.

This action might generate an SMS text message. Starting June 1, 2021, US telecom carriers require you to register an origination phone number before you can send SMS messages to US phone numbers. If you use SMS text messages in Amazon Cognito, you must register a phone number with Amazon Pinpoint. Amazon Cognito uses the registered number automatically. Otherwise, Amazon Cognito users who must receive SMS messages might not be able to sign up, activate their accounts, or sign in.

If you have never used SMS text messages with Amazon Cognito or any other Amazon Web Services service, Amazon Simple Notification Service might place your account in the SMS sandbox. In sandbox mode , you can send messages only to verified phone numbers. After you test your app while in the sandbox environment, you can move out of the sandbox and into production. For more information, see SMS message settings for Amazon Cognito user pools in the Amazon Cognito Developer Guide.

See Also:

AWS API Reference

◆ SetUserPoolMfaConfigAsync()

template<typename SetUserPoolMfaConfigRequestT = Model::SetUserPoolMfaConfigRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::SetUserPoolMfaConfigAsync ( const SetUserPoolMfaConfigRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for SetUserPoolMfaConfig that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3862 of file CognitoIdentityProviderClient.h.

◆ SetUserPoolMfaConfigCallable()

template<typename SetUserPoolMfaConfigRequestT = Model::SetUserPoolMfaConfigRequest>
Model::SetUserPoolMfaConfigOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::SetUserPoolMfaConfigCallable ( const SetUserPoolMfaConfigRequestT &  request) const
inline

A Callable wrapper for SetUserPoolMfaConfig that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3853 of file CognitoIdentityProviderClient.h.

◆ SetUserSettings()

virtual Model::SetUserSettingsOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::SetUserSettings ( const Model::SetUserSettingsRequest request) const
virtual

This action is no longer supported. You can use it to configure only SMS MFA. You can't use it to configure time-based one-time password (TOTP) software token or email MFA.

Authorize this action with a signed-in user's access token. It must include the scope aws.cognito.signin.user.admin.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

See Also:

AWS API Reference

◆ SetUserSettingsAsync()

template<typename SetUserSettingsRequestT = Model::SetUserSettingsRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::SetUserSettingsAsync ( const SetUserSettingsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for SetUserSettings that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3898 of file CognitoIdentityProviderClient.h.

◆ SetUserSettingsCallable()

template<typename SetUserSettingsRequestT = Model::SetUserSettingsRequest>
Model::SetUserSettingsOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::SetUserSettingsCallable ( const SetUserSettingsRequestT &  request) const
inline

A Callable wrapper for SetUserSettings that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3889 of file CognitoIdentityProviderClient.h.

◆ SignUp()

virtual Model::SignUpOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::SignUp ( const Model::SignUpRequest request) const
virtual

Registers a user with an app client and requests a user name, password, and user attributes in the user pool.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

This action might generate an SMS text message. Starting June 1, 2021, US telecom carriers require you to register an origination phone number before you can send SMS messages to US phone numbers. If you use SMS text messages in Amazon Cognito, you must register a phone number with Amazon Pinpoint. Amazon Cognito uses the registered number automatically. Otherwise, Amazon Cognito users who must receive SMS messages might not be able to sign up, activate their accounts, or sign in.

If you have never used SMS text messages with Amazon Cognito or any other Amazon Web Services service, Amazon Simple Notification Service might place your account in the SMS sandbox. In sandbox mode , you can send messages only to verified phone numbers. After you test your app while in the sandbox environment, you can move out of the sandbox and into production. For more information, see SMS message settings for Amazon Cognito user pools in the Amazon Cognito Developer Guide.

You might receive a LimitExceeded exception in response to this request if you have exceeded a rate quota for email or SMS messages, and if your user pool automatically verifies email addresses or phone numbers. When you get this exception in the response, the user is successfully created and is in an UNCONFIRMED state.

See Also:

AWS API Reference

◆ SignUpAsync()

template<typename SignUpRequestT = Model::SignUpRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::SignUpAsync ( const SignUpRequestT &  request,
const SignUpResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for SignUp that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3952 of file CognitoIdentityProviderClient.h.

◆ SignUpCallable()

template<typename SignUpRequestT = Model::SignUpRequest>
Model::SignUpOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::SignUpCallable ( const SignUpRequestT &  request) const
inline

A Callable wrapper for SignUp that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3943 of file CognitoIdentityProviderClient.h.

◆ StartUserImportJob()

virtual Model::StartUserImportJobOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::StartUserImportJob ( const Model::StartUserImportJobRequest request) const
virtual

Instructs your user pool to start importing users from a CSV file that contains their usernames and attributes. For more information about importing users from a CSV file, see Importing users from a CSV file.

See Also:

AWS API Reference

◆ StartUserImportJobAsync()

template<typename StartUserImportJobRequestT = Model::StartUserImportJobRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::StartUserImportJobAsync ( const StartUserImportJobRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for StartUserImportJob that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 3981 of file CognitoIdentityProviderClient.h.

◆ StartUserImportJobCallable()

template<typename StartUserImportJobRequestT = Model::StartUserImportJobRequest>
Model::StartUserImportJobOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::StartUserImportJobCallable ( const StartUserImportJobRequestT &  request) const
inline

A Callable wrapper for StartUserImportJob that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 3972 of file CognitoIdentityProviderClient.h.

◆ StartWebAuthnRegistration()

virtual Model::StartWebAuthnRegistrationOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::StartWebAuthnRegistration ( const Model::StartWebAuthnRegistrationRequest request) const
virtual

Requests credential creation options from your user pool for the currently signed-in user. Returns information about the user pool, the user profile, and authentication requirements. Users must provide this information in their request to enroll your application with their passkey provider.

Authorize this action with a signed-in user's access token. It must include the scope aws.cognito.signin.user.admin.

See Also:

AWS API Reference

◆ StartWebAuthnRegistrationAsync()

template<typename StartWebAuthnRegistrationRequestT = Model::StartWebAuthnRegistrationRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::StartWebAuthnRegistrationAsync ( const StartWebAuthnRegistrationRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for StartWebAuthnRegistration that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4011 of file CognitoIdentityProviderClient.h.

◆ StartWebAuthnRegistrationCallable()

template<typename StartWebAuthnRegistrationRequestT = Model::StartWebAuthnRegistrationRequest>
Model::StartWebAuthnRegistrationOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::StartWebAuthnRegistrationCallable ( const StartWebAuthnRegistrationRequestT &  request) const
inline

A Callable wrapper for StartWebAuthnRegistration that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4002 of file CognitoIdentityProviderClient.h.

◆ StopUserImportJob()

virtual Model::StopUserImportJobOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::StopUserImportJob ( const Model::StopUserImportJobRequest request) const
virtual

Instructs your user pool to stop a running job that's importing users from a CSV file that contains their usernames and attributes. For more information about importing users from a CSV file, see Importing users from a CSV file.

See Also:

AWS API Reference

◆ StopUserImportJobAsync()

template<typename StopUserImportJobRequestT = Model::StopUserImportJobRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::StopUserImportJobAsync ( const StopUserImportJobRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for StopUserImportJob that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4040 of file CognitoIdentityProviderClient.h.

◆ StopUserImportJobCallable()

template<typename StopUserImportJobRequestT = Model::StopUserImportJobRequest>
Model::StopUserImportJobOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::StopUserImportJobCallable ( const StopUserImportJobRequestT &  request) const
inline

A Callable wrapper for StopUserImportJob that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4031 of file CognitoIdentityProviderClient.h.

◆ TagResource()

virtual Model::TagResourceOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::TagResource ( const Model::TagResourceRequest request) const
virtual

Assigns a set of tags to an Amazon Cognito user pool. A tag is a label that you can use to categorize and manage user pools in different ways, such as by purpose, owner, environment, or other criteria.

Each tag consists of a key and value, both of which you define. A key is a general category for more specific values. For example, if you have two versions of a user pool, one for testing and another for production, you might assign an Environment tag key to both user pools. The value of this key might be Test for one user pool, and Production for the other.

Tags are useful for cost tracking and access control. You can activate your tags so that they appear on the Billing and Cost Management console, where you can track the costs associated with your user pools. In an Identity and Access Management policy, you can constrain permissions for user pools based on specific tags or tag values.

You can use this action up to 5 times per second, per account. A user pool can have as many as 50 tags.

See Also:

AWS API Reference

◆ TagResourceAsync()

template<typename TagResourceRequestT = Model::TagResourceRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::TagResourceAsync ( const TagResourceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4078 of file CognitoIdentityProviderClient.h.

◆ TagResourceCallable()

template<typename TagResourceRequestT = Model::TagResourceRequest>
Model::TagResourceOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::TagResourceCallable ( const TagResourceRequestT &  request) const
inline

A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4069 of file CognitoIdentityProviderClient.h.

◆ UntagResource()

virtual Model::UntagResourceOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UntagResource ( const Model::UntagResourceRequest request) const
virtual

Given tag IDs that you previously assigned to a user pool, removes them.

See Also:

AWS API Reference

◆ UntagResourceAsync()

template<typename UntagResourceRequestT = Model::UntagResourceRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UntagResourceAsync ( const UntagResourceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4104 of file CognitoIdentityProviderClient.h.

◆ UntagResourceCallable()

template<typename UntagResourceRequestT = Model::UntagResourceRequest>
Model::UntagResourceOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UntagResourceCallable ( const UntagResourceRequestT &  request) const
inline

A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4095 of file CognitoIdentityProviderClient.h.

◆ UpdateAuthEventFeedback()

virtual Model::UpdateAuthEventFeedbackOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateAuthEventFeedback ( const Model::UpdateAuthEventFeedbackRequest request) const
virtual

Provides the feedback for an authentication event generated by threat protection features. The user's response indicates that you think that the event either was from a valid user or was an unwanted authentication attempt. This feedback improves the risk evaluation decision for the user pool as part of Amazon Cognito threat protection. To activate this setting, your user pool must be on the Plus tier.

This operation requires a FeedbackToken that Amazon Cognito generates and adds to notification emails when users have potentially suspicious authentication events. Users invoke this operation when they select the link that corresponds to {one-click-link-valid} or {one-click-link-invalid} in your notification template. Because FeedbackToken is a required parameter, you can' make requests to UpdateAuthEventFeedback without the contents of the notification email message.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

See Also:

AWS API Reference

◆ UpdateAuthEventFeedbackAsync()

template<typename UpdateAuthEventFeedbackRequestT = Model::UpdateAuthEventFeedbackRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateAuthEventFeedbackAsync ( const UpdateAuthEventFeedbackRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateAuthEventFeedback that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4150 of file CognitoIdentityProviderClient.h.

◆ UpdateAuthEventFeedbackCallable()

template<typename UpdateAuthEventFeedbackRequestT = Model::UpdateAuthEventFeedbackRequest>
Model::UpdateAuthEventFeedbackOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateAuthEventFeedbackCallable ( const UpdateAuthEventFeedbackRequestT &  request) const
inline

A Callable wrapper for UpdateAuthEventFeedback that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4141 of file CognitoIdentityProviderClient.h.

◆ UpdateDeviceStatus()

virtual Model::UpdateDeviceStatusOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateDeviceStatus ( const Model::UpdateDeviceStatusRequest request) const
virtual

Updates the status of a the currently signed-in user's device so that it is marked as remembered or not remembered for the purpose of device authentication. Device authentication is a "remember me" mechanism that silently completes sign-in from trusted devices with a device key instead of a user-provided MFA code. This operation changes the status of a device without deleting it, so you can enable it again later. For more information about device authentication, see Working with devices.

Authorize this action with a signed-in user's access token. It must include the scope aws.cognito.signin.user.admin.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

See Also:

AWS API Reference

◆ UpdateDeviceStatusAsync()

template<typename UpdateDeviceStatusRequestT = Model::UpdateDeviceStatusRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateDeviceStatusAsync ( const UpdateDeviceStatusRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateDeviceStatus that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4192 of file CognitoIdentityProviderClient.h.

◆ UpdateDeviceStatusCallable()

template<typename UpdateDeviceStatusRequestT = Model::UpdateDeviceStatusRequest>
Model::UpdateDeviceStatusOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateDeviceStatusCallable ( const UpdateDeviceStatusRequestT &  request) const
inline

A Callable wrapper for UpdateDeviceStatus that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4183 of file CognitoIdentityProviderClient.h.

◆ UpdateGroup()

virtual Model::UpdateGroupOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateGroup ( const Model::UpdateGroupRequest request) const
virtual

Given the name of a user pool group, updates any of the properties for precedence, IAM role, or description. For more information about user pool groups, see Adding groups to a user pool.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ UpdateGroupAsync()

template<typename UpdateGroupRequestT = Model::UpdateGroupRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateGroupAsync ( const UpdateGroupRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateGroup that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4230 of file CognitoIdentityProviderClient.h.

◆ UpdateGroupCallable()

template<typename UpdateGroupRequestT = Model::UpdateGroupRequest>
Model::UpdateGroupOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateGroupCallable ( const UpdateGroupRequestT &  request) const
inline

A Callable wrapper for UpdateGroup that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4221 of file CognitoIdentityProviderClient.h.

◆ UpdateIdentityProvider()

virtual Model::UpdateIdentityProviderOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateIdentityProvider ( const Model::UpdateIdentityProviderRequest request) const
virtual

Modifies the configuration and trust relationship between a third-party identity provider (IdP) and a user pool. Amazon Cognito accepts sign-in with third-party identity providers through managed login and OIDC relying-party libraries. For more information, see Third-party IdP sign-in.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ UpdateIdentityProviderAsync()

template<typename UpdateIdentityProviderRequestT = Model::UpdateIdentityProviderRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateIdentityProviderAsync ( const UpdateIdentityProviderRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateIdentityProvider that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4269 of file CognitoIdentityProviderClient.h.

◆ UpdateIdentityProviderCallable()

template<typename UpdateIdentityProviderRequestT = Model::UpdateIdentityProviderRequest>
Model::UpdateIdentityProviderOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateIdentityProviderCallable ( const UpdateIdentityProviderRequestT &  request) const
inline

A Callable wrapper for UpdateIdentityProvider that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4260 of file CognitoIdentityProviderClient.h.

◆ UpdateManagedLoginBranding()

virtual Model::UpdateManagedLoginBrandingOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateManagedLoginBranding ( const Model::UpdateManagedLoginBrandingRequest request = {}) const
virtual

Configures the branding settings for a user pool style. This operation is the programmatic option for the configuration of a style in the branding designer.

Provides values for UI customization in a Settings JSON object and image files in an Assets array.

This operation has a 2-megabyte request-size limit and include the CSS settings and image assets for your app client. Your branding settings might exceed 2MB in size. Amazon Cognito doesn't require that you pass all parameters in one request and preserves existing style settings that you don't specify. If your request is larger than 2MB, separate it into multiple requests, each with a size smaller than the limit.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ UpdateManagedLoginBrandingAsync()

template<typename UpdateManagedLoginBrandingRequestT = Model::UpdateManagedLoginBrandingRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateManagedLoginBrandingAsync ( const UpdateManagedLoginBrandingResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const UpdateManagedLoginBrandingRequestT &  request = {} 
) const
inline

An Async wrapper for UpdateManagedLoginBranding that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4312 of file CognitoIdentityProviderClient.h.

◆ UpdateManagedLoginBrandingCallable()

template<typename UpdateManagedLoginBrandingRequestT = Model::UpdateManagedLoginBrandingRequest>
Model::UpdateManagedLoginBrandingOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateManagedLoginBrandingCallable ( const UpdateManagedLoginBrandingRequestT &  request = {}) const
inline

A Callable wrapper for UpdateManagedLoginBranding that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4303 of file CognitoIdentityProviderClient.h.

◆ UpdateResourceServer()

virtual Model::UpdateResourceServerOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateResourceServer ( const Model::UpdateResourceServerRequest request) const
virtual

Updates the name and scopes of a resource server. All other fields are read-only. For more information about resource servers, see Access control with resource servers.

If you don't provide a value for an attribute, it is set to the default value.


Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ UpdateResourceServerAsync()

template<typename UpdateResourceServerRequestT = Model::UpdateResourceServerRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateResourceServerAsync ( const UpdateResourceServerRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateResourceServer that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4351 of file CognitoIdentityProviderClient.h.

◆ UpdateResourceServerCallable()

template<typename UpdateResourceServerRequestT = Model::UpdateResourceServerRequest>
Model::UpdateResourceServerOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateResourceServerCallable ( const UpdateResourceServerRequestT &  request) const
inline

A Callable wrapper for UpdateResourceServer that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4342 of file CognitoIdentityProviderClient.h.

◆ UpdateUserAttributes()

virtual Model::UpdateUserAttributesOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateUserAttributes ( const Model::UpdateUserAttributesRequest request) const
virtual

Updates the currently signed-in user's attributes. To delete an attribute from the user, submit the attribute in your API request with a blank value.

For custom attributes, you must add a custom: prefix to the attribute name, for example custom:department.

Authorize this action with a signed-in user's access token. It must include the scope aws.cognito.signin.user.admin.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

This action might generate an SMS text message. Starting June 1, 2021, US telecom carriers require you to register an origination phone number before you can send SMS messages to US phone numbers. If you use SMS text messages in Amazon Cognito, you must register a phone number with Amazon Pinpoint. Amazon Cognito uses the registered number automatically. Otherwise, Amazon Cognito users who must receive SMS messages might not be able to sign up, activate their accounts, or sign in.

If you have never used SMS text messages with Amazon Cognito or any other Amazon Web Services service, Amazon Simple Notification Service might place your account in the SMS sandbox. In sandbox mode , you can send messages only to verified phone numbers. After you test your app while in the sandbox environment, you can move out of the sandbox and into production. For more information, see SMS message settings for Amazon Cognito user pools in the Amazon Cognito Developer Guide.

See Also:

AWS API Reference

◆ UpdateUserAttributesAsync()

template<typename UpdateUserAttributesRequestT = Model::UpdateUserAttributesRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateUserAttributesAsync ( const UpdateUserAttributesRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateUserAttributes that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4404 of file CognitoIdentityProviderClient.h.

◆ UpdateUserAttributesCallable()

template<typename UpdateUserAttributesRequestT = Model::UpdateUserAttributesRequest>
Model::UpdateUserAttributesOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateUserAttributesCallable ( const UpdateUserAttributesRequestT &  request) const
inline

A Callable wrapper for UpdateUserAttributes that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4395 of file CognitoIdentityProviderClient.h.

◆ UpdateUserPool()

virtual Model::UpdateUserPoolOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateUserPool ( const Model::UpdateUserPoolRequest request) const
virtual

Updates the configuration of a user pool. To avoid setting parameters to Amazon Cognito defaults, construct this API request to pass the existing configuration of your user pool, modified to include the changes that you want to make.

If you don't provide a value for an attribute, Amazon Cognito sets it to its default value.

This action might generate an SMS text message. Starting June 1, 2021, US telecom carriers require you to register an origination phone number before you can send SMS messages to US phone numbers. If you use SMS text messages in Amazon Cognito, you must register a phone number with Amazon Pinpoint. Amazon Cognito uses the registered number automatically. Otherwise, Amazon Cognito users who must receive SMS messages might not be able to sign up, activate their accounts, or sign in.

If you have never used SMS text messages with Amazon Cognito or any other Amazon Web Services service, Amazon Simple Notification Service might place your account in the SMS sandbox. In sandbox mode , you can send messages only to verified phone numbers. After you test your app while in the sandbox environment, you can move out of the sandbox and into production. For more information, see SMS message settings for Amazon Cognito user pools in the Amazon Cognito Developer Guide.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ UpdateUserPoolAsync()

template<typename UpdateUserPoolRequestT = Model::UpdateUserPoolRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateUserPoolAsync ( const UpdateUserPoolRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateUserPool that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4459 of file CognitoIdentityProviderClient.h.

◆ UpdateUserPoolCallable()

template<typename UpdateUserPoolRequestT = Model::UpdateUserPoolRequest>
Model::UpdateUserPoolOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateUserPoolCallable ( const UpdateUserPoolRequestT &  request) const
inline

A Callable wrapper for UpdateUserPool that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4450 of file CognitoIdentityProviderClient.h.

◆ UpdateUserPoolClient()

virtual Model::UpdateUserPoolClientOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateUserPoolClient ( const Model::UpdateUserPoolClientRequest request) const
virtual

Given a user pool app client ID, updates the configuration. To avoid setting parameters to Amazon Cognito defaults, construct this API request to pass the existing configuration of your app client, modified to include the changes that you want to make.

If you don't provide a value for an attribute, Amazon Cognito sets it to its default value.

Unlike app clients created in the console, Amazon Cognito doesn't automatically assign a branding style to app clients that you configure with this API operation. Managed login and classic hosted UI pages aren't available for your client until after you apply a branding style.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ UpdateUserPoolClientAsync()

template<typename UpdateUserPoolClientRequestT = Model::UpdateUserPoolClientRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateUserPoolClientAsync ( const UpdateUserPoolClientRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateUserPoolClient that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4501 of file CognitoIdentityProviderClient.h.

◆ UpdateUserPoolClientCallable()

template<typename UpdateUserPoolClientRequestT = Model::UpdateUserPoolClientRequest>
Model::UpdateUserPoolClientOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateUserPoolClientCallable ( const UpdateUserPoolClientRequestT &  request) const
inline

A Callable wrapper for UpdateUserPoolClient that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4492 of file CognitoIdentityProviderClient.h.

◆ UpdateUserPoolDomain()

virtual Model::UpdateUserPoolDomainOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateUserPoolDomain ( const Model::UpdateUserPoolDomainRequest request) const
virtual

A user pool domain hosts managed login, an authorization server and web server for authentication in your application. This operation updates the branding version for user pool domains between 1 for hosted UI (classic) and 2 for managed login. It also updates the SSL certificate for user pool custom domains.

Changes to the domain branding version take up to one minute to take effect for a prefix domain and up to five minutes for a custom domain.

This operation doesn't change the name of your user pool domain. To change your domain, delete it with DeleteUserPoolDomain and create a new domain with CreateUserPoolDomain.

You can pass the ARN of a new Certificate Manager certificate in this request. Typically, ACM certificates automatically renew and you user pool can continue to use the same ARN. But if you generate a new certificate for your custom domain name, replace the original configuration with the new ARN in this request.

ACM certificates for custom domains must be in the US East (N. Virginia) Amazon Web Services Region. After you submit your request, Amazon Cognito requires up to 1 hour to distribute your new certificate to your custom domain.

For more information about adding a custom domain to your user pool, see Configuring a user pool domain.

Amazon Cognito evaluates Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you must use IAM credentials to authorize requests, and you must grant yourself the corresponding IAM permission in a policy.

Learn more

See Also:

AWS API Reference

◆ UpdateUserPoolDomainAsync()

template<typename UpdateUserPoolDomainRequestT = Model::UpdateUserPoolDomainRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateUserPoolDomainAsync ( const UpdateUserPoolDomainRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateUserPoolDomain that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4554 of file CognitoIdentityProviderClient.h.

◆ UpdateUserPoolDomainCallable()

template<typename UpdateUserPoolDomainRequestT = Model::UpdateUserPoolDomainRequest>
Model::UpdateUserPoolDomainOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::UpdateUserPoolDomainCallable ( const UpdateUserPoolDomainRequestT &  request) const
inline

A Callable wrapper for UpdateUserPoolDomain that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4545 of file CognitoIdentityProviderClient.h.

◆ VerifySoftwareToken()

virtual Model::VerifySoftwareTokenOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::VerifySoftwareToken ( const Model::VerifySoftwareTokenRequest request) const
virtual

Registers the current user's time-based one-time password (TOTP) authenticator with a code generated in their authenticator app from a private key that's supplied by your user pool. Marks the user's software token MFA status as "verified" if successful. The request takes an access token or a session string, but not both.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

See Also:

AWS API Reference

◆ VerifySoftwareTokenAsync()

template<typename VerifySoftwareTokenRequestT = Model::VerifySoftwareTokenRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::VerifySoftwareTokenAsync ( const VerifySoftwareTokenRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for VerifySoftwareToken that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4590 of file CognitoIdentityProviderClient.h.

◆ VerifySoftwareTokenCallable()

template<typename VerifySoftwareTokenRequestT = Model::VerifySoftwareTokenRequest>
Model::VerifySoftwareTokenOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::VerifySoftwareTokenCallable ( const VerifySoftwareTokenRequestT &  request) const
inline

A Callable wrapper for VerifySoftwareToken that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4581 of file CognitoIdentityProviderClient.h.

◆ VerifyUserAttribute()

virtual Model::VerifyUserAttributeOutcome Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::VerifyUserAttribute ( const Model::VerifyUserAttributeRequest request) const
virtual

Submits a verification code for a signed-in user who has added or changed a value of an auto-verified attribute. When successful, the user's attribute becomes verified and the attribute email_verified or phone_number_verified becomes true.

If your user pool requires verification before Amazon Cognito updates the attribute value, this operation updates the affected attribute to its pending value.

Authorize this action with a signed-in user's access token. It must include the scope aws.cognito.signin.user.admin.

Amazon Cognito doesn't evaluate Identity and Access Management (IAM) policies in requests for this API operation. For this operation, you can't use IAM credentials to authorize requests, and you can't grant IAM permissions in policies. For more information about authorization models in Amazon Cognito, see Using the Amazon Cognito user pools API and user pool endpoints.

See Also:

AWS API Reference

◆ VerifyUserAttributeAsync()

template<typename VerifyUserAttributeRequestT = Model::VerifyUserAttributeRequest>
void Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::VerifyUserAttributeAsync ( const VerifyUserAttributeRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for VerifyUserAttribute that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 4630 of file CognitoIdentityProviderClient.h.

◆ VerifyUserAttributeCallable()

template<typename VerifyUserAttributeRequestT = Model::VerifyUserAttributeRequest>
Model::VerifyUserAttributeOutcomeCallable Aws::CognitoIdentityProvider::CognitoIdentityProviderClient::VerifyUserAttributeCallable ( const VerifyUserAttributeRequestT &  request) const
inline

A Callable wrapper for VerifyUserAttribute that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 4621 of file CognitoIdentityProviderClient.h.

Friends And Related Symbol Documentation

◆ Aws::Client::ClientWithAsyncTemplateMethods< CognitoIdentityProviderClient >

Definition at line 4637 of file CognitoIdentityProviderClient.h.


The documentation for this class was generated from the following file: