Lesson 35 - Get Compute Auth Token Working
This commit is contained in:
Norman Lansing
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,61 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/client/GenericClientConfiguration.h>
|
||||
#include <aws/core/endpoint/DefaultEndpointProvider.h>
|
||||
#include <aws/core/endpoint/EndpointParameter.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderEndpointRules.h>
|
||||
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Endpoint
|
||||
{
|
||||
using EndpointParameters = Aws::Endpoint::EndpointParameters;
|
||||
using Aws::Endpoint::EndpointProviderBase;
|
||||
using Aws::Endpoint::DefaultEndpointProvider;
|
||||
|
||||
using CognitoIdentityProviderClientContextParameters = Aws::Endpoint::ClientContextParameters;
|
||||
|
||||
using CognitoIdentityProviderClientConfiguration = Aws::Client::GenericClientConfiguration;
|
||||
using CognitoIdentityProviderBuiltInParameters = Aws::Endpoint::BuiltInParameters;
|
||||
|
||||
/**
|
||||
* The type for the CognitoIdentityProvider Client Endpoint Provider.
|
||||
* Inherit from this Base class / "Interface" should you want to provide a custom endpoint provider.
|
||||
* The SDK must use service-specific type for each service per specification.
|
||||
*/
|
||||
using CognitoIdentityProviderEndpointProviderBase =
|
||||
EndpointProviderBase<CognitoIdentityProviderClientConfiguration, CognitoIdentityProviderBuiltInParameters, CognitoIdentityProviderClientContextParameters>;
|
||||
|
||||
using CognitoIdentityProviderDefaultEpProviderBase =
|
||||
DefaultEndpointProvider<CognitoIdentityProviderClientConfiguration, CognitoIdentityProviderBuiltInParameters, CognitoIdentityProviderClientContextParameters>;
|
||||
|
||||
/**
|
||||
* Default endpoint provider used for this service
|
||||
*/
|
||||
class AWS_COGNITOIDENTITYPROVIDER_API CognitoIdentityProviderEndpointProvider : public CognitoIdentityProviderDefaultEpProviderBase
|
||||
{
|
||||
public:
|
||||
using CognitoIdentityProviderResolveEndpointOutcome = Aws::Endpoint::ResolveEndpointOutcome;
|
||||
|
||||
CognitoIdentityProviderEndpointProvider()
|
||||
: CognitoIdentityProviderDefaultEpProviderBase(Aws::CognitoIdentityProvider::CognitoIdentityProviderEndpointRules::GetRulesBlob(), Aws::CognitoIdentityProvider::CognitoIdentityProviderEndpointRules::RulesBlobSize)
|
||||
{}
|
||||
|
||||
~CognitoIdentityProviderEndpointProvider()
|
||||
{
|
||||
}
|
||||
};
|
||||
} // namespace Endpoint
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,23 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <cstddef>
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
class CognitoIdentityProviderEndpointRules
|
||||
{
|
||||
public:
|
||||
static const size_t RulesBlobStrLen;
|
||||
static const size_t RulesBlobSize;
|
||||
|
||||
static const char* GetRulesBlob();
|
||||
};
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,23 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/client/AWSErrorMarshaller.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Client
|
||||
{
|
||||
|
||||
class AWS_COGNITOIDENTITYPROVIDER_API CognitoIdentityProviderErrorMarshaller : public Aws::Client::JsonErrorMarshaller
|
||||
{
|
||||
public:
|
||||
Aws::Client::AWSError<Aws::Client::CoreErrors> FindErrorByName(const char* exceptionName) const override;
|
||||
};
|
||||
|
||||
} // namespace Client
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,112 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <aws/core/client/AWSError.h>
|
||||
#include <aws/core/client/CoreErrors.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
enum class CognitoIdentityProviderErrors
|
||||
{
|
||||
//From Core//
|
||||
//////////////////////////////////////////////////////////////////////////////////////////
|
||||
INCOMPLETE_SIGNATURE = 0,
|
||||
INTERNAL_FAILURE = 1,
|
||||
INVALID_ACTION = 2,
|
||||
INVALID_CLIENT_TOKEN_ID = 3,
|
||||
INVALID_PARAMETER_COMBINATION = 4,
|
||||
INVALID_QUERY_PARAMETER = 5,
|
||||
INVALID_PARAMETER_VALUE = 6,
|
||||
MISSING_ACTION = 7, // SDK should never allow
|
||||
MISSING_AUTHENTICATION_TOKEN = 8, // SDK should never allow
|
||||
MISSING_PARAMETER = 9, // SDK should never allow
|
||||
OPT_IN_REQUIRED = 10,
|
||||
REQUEST_EXPIRED = 11,
|
||||
SERVICE_UNAVAILABLE = 12,
|
||||
THROTTLING = 13,
|
||||
VALIDATION = 14,
|
||||
ACCESS_DENIED = 15,
|
||||
RESOURCE_NOT_FOUND = 16,
|
||||
UNRECOGNIZED_CLIENT = 17,
|
||||
MALFORMED_QUERY_STRING = 18,
|
||||
SLOW_DOWN = 19,
|
||||
REQUEST_TIME_TOO_SKEWED = 20,
|
||||
INVALID_SIGNATURE = 21,
|
||||
SIGNATURE_DOES_NOT_MATCH = 22,
|
||||
INVALID_ACCESS_KEY_ID = 23,
|
||||
REQUEST_TIMEOUT = 24,
|
||||
NETWORK_CONNECTION = 99,
|
||||
|
||||
UNKNOWN = 100,
|
||||
///////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
ALIAS_EXISTS= static_cast<int>(Aws::Client::CoreErrors::SERVICE_EXTENSION_START_RANGE) + 1,
|
||||
CODE_DELIVERY_FAILURE,
|
||||
CODE_MISMATCH,
|
||||
CONCURRENT_MODIFICATION,
|
||||
DUPLICATE_PROVIDER,
|
||||
ENABLE_SOFTWARE_TOKEN_M_F_A,
|
||||
EXPIRED_CODE,
|
||||
FORBIDDEN,
|
||||
GROUP_EXISTS,
|
||||
INTERNAL_ERROR,
|
||||
INVALID_EMAIL_ROLE_ACCESS_POLICY,
|
||||
INVALID_LAMBDA_RESPONSE,
|
||||
INVALID_O_AUTH_FLOW,
|
||||
INVALID_PARAMETER,
|
||||
INVALID_PASSWORD,
|
||||
INVALID_SMS_ROLE_ACCESS_POLICY,
|
||||
INVALID_SMS_ROLE_TRUST_RELATIONSHIP,
|
||||
INVALID_USER_POOL_CONFIGURATION,
|
||||
LIMIT_EXCEEDED,
|
||||
M_F_A_METHOD_NOT_FOUND,
|
||||
NOT_AUTHORIZED,
|
||||
PASSWORD_HISTORY_POLICY_VIOLATION,
|
||||
PASSWORD_RESET_REQUIRED,
|
||||
PRECONDITION_NOT_MET,
|
||||
SCOPE_DOES_NOT_EXIST,
|
||||
SOFTWARE_TOKEN_M_F_A_NOT_FOUND,
|
||||
TOO_MANY_FAILED_ATTEMPTS,
|
||||
TOO_MANY_REQUESTS,
|
||||
UNAUTHORIZED,
|
||||
UNEXPECTED_LAMBDA,
|
||||
UNSUPPORTED_IDENTITY_PROVIDER,
|
||||
UNSUPPORTED_OPERATION,
|
||||
UNSUPPORTED_TOKEN_TYPE,
|
||||
UNSUPPORTED_USER_STATE,
|
||||
USERNAME_EXISTS,
|
||||
USER_IMPORT_IN_PROGRESS,
|
||||
USER_LAMBDA_VALIDATION,
|
||||
USER_NOT_CONFIRMED,
|
||||
USER_NOT_FOUND,
|
||||
USER_POOL_ADD_ON_NOT_ENABLED,
|
||||
USER_POOL_TAGGING
|
||||
};
|
||||
|
||||
class AWS_COGNITOIDENTITYPROVIDER_API CognitoIdentityProviderError : public Aws::Client::AWSError<CognitoIdentityProviderErrors>
|
||||
{
|
||||
public:
|
||||
CognitoIdentityProviderError() {}
|
||||
CognitoIdentityProviderError(const Aws::Client::AWSError<Aws::Client::CoreErrors>& rhs) : Aws::Client::AWSError<CognitoIdentityProviderErrors>(rhs) {}
|
||||
CognitoIdentityProviderError(Aws::Client::AWSError<Aws::Client::CoreErrors>&& rhs) : Aws::Client::AWSError<CognitoIdentityProviderErrors>(rhs) {}
|
||||
CognitoIdentityProviderError(const Aws::Client::AWSError<CognitoIdentityProviderErrors>& rhs) : Aws::Client::AWSError<CognitoIdentityProviderErrors>(rhs) {}
|
||||
CognitoIdentityProviderError(Aws::Client::AWSError<CognitoIdentityProviderErrors>&& rhs) : Aws::Client::AWSError<CognitoIdentityProviderErrors>(rhs) {}
|
||||
|
||||
template <typename T>
|
||||
T GetModeledError();
|
||||
};
|
||||
|
||||
namespace CognitoIdentityProviderErrorMapper
|
||||
{
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Client::AWSError<Aws::Client::CoreErrors> GetErrorForName(const char* errorName);
|
||||
}
|
||||
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,46 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/endpoint/AWSEndpoint.h>
|
||||
#include <aws/core/AmazonSerializableWebServiceRequest.h>
|
||||
#include <aws/core/utils/UnreferencedParam.h>
|
||||
#include <aws/core/http/HttpRequest.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
class AWS_COGNITOIDENTITYPROVIDER_API CognitoIdentityProviderRequest : public Aws::AmazonSerializableWebServiceRequest
|
||||
{
|
||||
public:
|
||||
using EndpointParameter = Aws::Endpoint::EndpointParameter;
|
||||
using EndpointParameters = Aws::Endpoint::EndpointParameters;
|
||||
|
||||
virtual ~CognitoIdentityProviderRequest () {}
|
||||
|
||||
void AddParametersToRequest(Aws::Http::HttpRequest& httpRequest) const { AWS_UNREFERENCED_PARAM(httpRequest); }
|
||||
|
||||
inline Aws::Http::HeaderValueCollection GetHeaders() const override
|
||||
{
|
||||
auto headers = GetRequestSpecificHeaders();
|
||||
|
||||
if(headers.size() == 0 || (headers.size() > 0 && headers.count(Aws::Http::CONTENT_TYPE_HEADER) == 0))
|
||||
{
|
||||
headers.emplace(Aws::Http::HeaderValuePair(Aws::Http::CONTENT_TYPE_HEADER, Aws::AMZN_JSON_CONTENT_TYPE_1_1 ));
|
||||
}
|
||||
headers.emplace(Aws::Http::HeaderValuePair(Aws::Http::API_VERSION_HEADER, "2016-04-18"));
|
||||
return headers;
|
||||
}
|
||||
|
||||
protected:
|
||||
virtual Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const { return Aws::Http::HeaderValueCollection(); }
|
||||
|
||||
};
|
||||
|
||||
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,581 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
/* Generic header includes */
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderErrors.h>
|
||||
#include <aws/core/client/GenericClientConfiguration.h>
|
||||
#include <aws/core/client/AWSError.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/client/AsyncCallerContext.h>
|
||||
#include <aws/core/http/HttpTypes.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderEndpointProvider.h>
|
||||
#include <future>
|
||||
#include <functional>
|
||||
/* End of generic header includes */
|
||||
|
||||
/* Service model headers required in CognitoIdentityProviderClient header */
|
||||
#include <aws/cognito-idp/model/AddCustomAttributesResult.h>
|
||||
#include <aws/cognito-idp/model/AdminConfirmSignUpResult.h>
|
||||
#include <aws/cognito-idp/model/AdminCreateUserResult.h>
|
||||
#include <aws/cognito-idp/model/AdminDeleteUserAttributesResult.h>
|
||||
#include <aws/cognito-idp/model/AdminDisableProviderForUserResult.h>
|
||||
#include <aws/cognito-idp/model/AdminDisableUserResult.h>
|
||||
#include <aws/cognito-idp/model/AdminEnableUserResult.h>
|
||||
#include <aws/cognito-idp/model/AdminGetDeviceResult.h>
|
||||
#include <aws/cognito-idp/model/AdminGetUserResult.h>
|
||||
#include <aws/cognito-idp/model/AdminInitiateAuthResult.h>
|
||||
#include <aws/cognito-idp/model/AdminLinkProviderForUserResult.h>
|
||||
#include <aws/cognito-idp/model/AdminListDevicesResult.h>
|
||||
#include <aws/cognito-idp/model/AdminListGroupsForUserResult.h>
|
||||
#include <aws/cognito-idp/model/AdminListUserAuthEventsResult.h>
|
||||
#include <aws/cognito-idp/model/AdminResetUserPasswordResult.h>
|
||||
#include <aws/cognito-idp/model/AdminRespondToAuthChallengeResult.h>
|
||||
#include <aws/cognito-idp/model/AdminSetUserMFAPreferenceResult.h>
|
||||
#include <aws/cognito-idp/model/AdminSetUserPasswordResult.h>
|
||||
#include <aws/cognito-idp/model/AdminSetUserSettingsResult.h>
|
||||
#include <aws/cognito-idp/model/AdminUpdateAuthEventFeedbackResult.h>
|
||||
#include <aws/cognito-idp/model/AdminUpdateDeviceStatusResult.h>
|
||||
#include <aws/cognito-idp/model/AdminUpdateUserAttributesResult.h>
|
||||
#include <aws/cognito-idp/model/AdminUserGlobalSignOutResult.h>
|
||||
#include <aws/cognito-idp/model/AssociateSoftwareTokenResult.h>
|
||||
#include <aws/cognito-idp/model/ChangePasswordResult.h>
|
||||
#include <aws/cognito-idp/model/ConfirmDeviceResult.h>
|
||||
#include <aws/cognito-idp/model/ConfirmForgotPasswordResult.h>
|
||||
#include <aws/cognito-idp/model/ConfirmSignUpResult.h>
|
||||
#include <aws/cognito-idp/model/CreateGroupResult.h>
|
||||
#include <aws/cognito-idp/model/CreateIdentityProviderResult.h>
|
||||
#include <aws/cognito-idp/model/CreateResourceServerResult.h>
|
||||
#include <aws/cognito-idp/model/CreateUserImportJobResult.h>
|
||||
#include <aws/cognito-idp/model/CreateUserPoolResult.h>
|
||||
#include <aws/cognito-idp/model/CreateUserPoolClientResult.h>
|
||||
#include <aws/cognito-idp/model/CreateUserPoolDomainResult.h>
|
||||
#include <aws/cognito-idp/model/DeleteUserAttributesResult.h>
|
||||
#include <aws/cognito-idp/model/DeleteUserPoolDomainResult.h>
|
||||
#include <aws/cognito-idp/model/DescribeIdentityProviderResult.h>
|
||||
#include <aws/cognito-idp/model/DescribeResourceServerResult.h>
|
||||
#include <aws/cognito-idp/model/DescribeRiskConfigurationResult.h>
|
||||
#include <aws/cognito-idp/model/DescribeUserImportJobResult.h>
|
||||
#include <aws/cognito-idp/model/DescribeUserPoolResult.h>
|
||||
#include <aws/cognito-idp/model/DescribeUserPoolClientResult.h>
|
||||
#include <aws/cognito-idp/model/DescribeUserPoolDomainResult.h>
|
||||
#include <aws/cognito-idp/model/ForgotPasswordResult.h>
|
||||
#include <aws/cognito-idp/model/GetCSVHeaderResult.h>
|
||||
#include <aws/cognito-idp/model/GetDeviceResult.h>
|
||||
#include <aws/cognito-idp/model/GetGroupResult.h>
|
||||
#include <aws/cognito-idp/model/GetIdentityProviderByIdentifierResult.h>
|
||||
#include <aws/cognito-idp/model/GetLogDeliveryConfigurationResult.h>
|
||||
#include <aws/cognito-idp/model/GetSigningCertificateResult.h>
|
||||
#include <aws/cognito-idp/model/GetUICustomizationResult.h>
|
||||
#include <aws/cognito-idp/model/GetUserResult.h>
|
||||
#include <aws/cognito-idp/model/GetUserAttributeVerificationCodeResult.h>
|
||||
#include <aws/cognito-idp/model/GetUserPoolMfaConfigResult.h>
|
||||
#include <aws/cognito-idp/model/GlobalSignOutResult.h>
|
||||
#include <aws/cognito-idp/model/InitiateAuthResult.h>
|
||||
#include <aws/cognito-idp/model/ListDevicesResult.h>
|
||||
#include <aws/cognito-idp/model/ListGroupsResult.h>
|
||||
#include <aws/cognito-idp/model/ListIdentityProvidersResult.h>
|
||||
#include <aws/cognito-idp/model/ListResourceServersResult.h>
|
||||
#include <aws/cognito-idp/model/ListTagsForResourceResult.h>
|
||||
#include <aws/cognito-idp/model/ListUserImportJobsResult.h>
|
||||
#include <aws/cognito-idp/model/ListUserPoolClientsResult.h>
|
||||
#include <aws/cognito-idp/model/ListUserPoolsResult.h>
|
||||
#include <aws/cognito-idp/model/ListUsersResult.h>
|
||||
#include <aws/cognito-idp/model/ListUsersInGroupResult.h>
|
||||
#include <aws/cognito-idp/model/ResendConfirmationCodeResult.h>
|
||||
#include <aws/cognito-idp/model/RespondToAuthChallengeResult.h>
|
||||
#include <aws/cognito-idp/model/RevokeTokenResult.h>
|
||||
#include <aws/cognito-idp/model/SetLogDeliveryConfigurationResult.h>
|
||||
#include <aws/cognito-idp/model/SetRiskConfigurationResult.h>
|
||||
#include <aws/cognito-idp/model/SetUICustomizationResult.h>
|
||||
#include <aws/cognito-idp/model/SetUserMFAPreferenceResult.h>
|
||||
#include <aws/cognito-idp/model/SetUserPoolMfaConfigResult.h>
|
||||
#include <aws/cognito-idp/model/SetUserSettingsResult.h>
|
||||
#include <aws/cognito-idp/model/SignUpResult.h>
|
||||
#include <aws/cognito-idp/model/StartUserImportJobResult.h>
|
||||
#include <aws/cognito-idp/model/StopUserImportJobResult.h>
|
||||
#include <aws/cognito-idp/model/TagResourceResult.h>
|
||||
#include <aws/cognito-idp/model/UntagResourceResult.h>
|
||||
#include <aws/cognito-idp/model/UpdateAuthEventFeedbackResult.h>
|
||||
#include <aws/cognito-idp/model/UpdateDeviceStatusResult.h>
|
||||
#include <aws/cognito-idp/model/UpdateGroupResult.h>
|
||||
#include <aws/cognito-idp/model/UpdateIdentityProviderResult.h>
|
||||
#include <aws/cognito-idp/model/UpdateResourceServerResult.h>
|
||||
#include <aws/cognito-idp/model/UpdateUserAttributesResult.h>
|
||||
#include <aws/cognito-idp/model/UpdateUserPoolResult.h>
|
||||
#include <aws/cognito-idp/model/UpdateUserPoolClientResult.h>
|
||||
#include <aws/cognito-idp/model/UpdateUserPoolDomainResult.h>
|
||||
#include <aws/cognito-idp/model/VerifySoftwareTokenResult.h>
|
||||
#include <aws/cognito-idp/model/VerifyUserAttributeResult.h>
|
||||
#include <aws/cognito-idp/model/AssociateSoftwareTokenRequest.h>
|
||||
#include <aws/core/NoResult.h>
|
||||
/* End of service model headers required in CognitoIdentityProviderClient header */
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Http
|
||||
{
|
||||
class HttpClient;
|
||||
class HttpClientFactory;
|
||||
} // namespace Http
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
template< typename R, typename E> class Outcome;
|
||||
|
||||
namespace Threading
|
||||
{
|
||||
class Executor;
|
||||
} // namespace Threading
|
||||
} // namespace Utils
|
||||
|
||||
namespace Auth
|
||||
{
|
||||
class AWSCredentials;
|
||||
class AWSCredentialsProvider;
|
||||
} // namespace Auth
|
||||
|
||||
namespace Client
|
||||
{
|
||||
class RetryStrategy;
|
||||
} // namespace Client
|
||||
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
using CognitoIdentityProviderClientConfiguration = Aws::Client::GenericClientConfiguration;
|
||||
using CognitoIdentityProviderEndpointProviderBase = Aws::CognitoIdentityProvider::Endpoint::CognitoIdentityProviderEndpointProviderBase;
|
||||
using CognitoIdentityProviderEndpointProvider = Aws::CognitoIdentityProvider::Endpoint::CognitoIdentityProviderEndpointProvider;
|
||||
|
||||
namespace Model
|
||||
{
|
||||
/* Service model forward declarations required in CognitoIdentityProviderClient header */
|
||||
class AddCustomAttributesRequest;
|
||||
class AdminAddUserToGroupRequest;
|
||||
class AdminConfirmSignUpRequest;
|
||||
class AdminCreateUserRequest;
|
||||
class AdminDeleteUserRequest;
|
||||
class AdminDeleteUserAttributesRequest;
|
||||
class AdminDisableProviderForUserRequest;
|
||||
class AdminDisableUserRequest;
|
||||
class AdminEnableUserRequest;
|
||||
class AdminForgetDeviceRequest;
|
||||
class AdminGetDeviceRequest;
|
||||
class AdminGetUserRequest;
|
||||
class AdminInitiateAuthRequest;
|
||||
class AdminLinkProviderForUserRequest;
|
||||
class AdminListDevicesRequest;
|
||||
class AdminListGroupsForUserRequest;
|
||||
class AdminListUserAuthEventsRequest;
|
||||
class AdminRemoveUserFromGroupRequest;
|
||||
class AdminResetUserPasswordRequest;
|
||||
class AdminRespondToAuthChallengeRequest;
|
||||
class AdminSetUserMFAPreferenceRequest;
|
||||
class AdminSetUserPasswordRequest;
|
||||
class AdminSetUserSettingsRequest;
|
||||
class AdminUpdateAuthEventFeedbackRequest;
|
||||
class AdminUpdateDeviceStatusRequest;
|
||||
class AdminUpdateUserAttributesRequest;
|
||||
class AdminUserGlobalSignOutRequest;
|
||||
class AssociateSoftwareTokenRequest;
|
||||
class ChangePasswordRequest;
|
||||
class ConfirmDeviceRequest;
|
||||
class ConfirmForgotPasswordRequest;
|
||||
class ConfirmSignUpRequest;
|
||||
class CreateGroupRequest;
|
||||
class CreateIdentityProviderRequest;
|
||||
class CreateResourceServerRequest;
|
||||
class CreateUserImportJobRequest;
|
||||
class CreateUserPoolRequest;
|
||||
class CreateUserPoolClientRequest;
|
||||
class CreateUserPoolDomainRequest;
|
||||
class DeleteGroupRequest;
|
||||
class DeleteIdentityProviderRequest;
|
||||
class DeleteResourceServerRequest;
|
||||
class DeleteUserRequest;
|
||||
class DeleteUserAttributesRequest;
|
||||
class DeleteUserPoolRequest;
|
||||
class DeleteUserPoolClientRequest;
|
||||
class DeleteUserPoolDomainRequest;
|
||||
class DescribeIdentityProviderRequest;
|
||||
class DescribeResourceServerRequest;
|
||||
class DescribeRiskConfigurationRequest;
|
||||
class DescribeUserImportJobRequest;
|
||||
class DescribeUserPoolRequest;
|
||||
class DescribeUserPoolClientRequest;
|
||||
class DescribeUserPoolDomainRequest;
|
||||
class ForgetDeviceRequest;
|
||||
class ForgotPasswordRequest;
|
||||
class GetCSVHeaderRequest;
|
||||
class GetDeviceRequest;
|
||||
class GetGroupRequest;
|
||||
class GetIdentityProviderByIdentifierRequest;
|
||||
class GetLogDeliveryConfigurationRequest;
|
||||
class GetSigningCertificateRequest;
|
||||
class GetUICustomizationRequest;
|
||||
class GetUserRequest;
|
||||
class GetUserAttributeVerificationCodeRequest;
|
||||
class GetUserPoolMfaConfigRequest;
|
||||
class GlobalSignOutRequest;
|
||||
class InitiateAuthRequest;
|
||||
class ListDevicesRequest;
|
||||
class ListGroupsRequest;
|
||||
class ListIdentityProvidersRequest;
|
||||
class ListResourceServersRequest;
|
||||
class ListTagsForResourceRequest;
|
||||
class ListUserImportJobsRequest;
|
||||
class ListUserPoolClientsRequest;
|
||||
class ListUserPoolsRequest;
|
||||
class ListUsersRequest;
|
||||
class ListUsersInGroupRequest;
|
||||
class ResendConfirmationCodeRequest;
|
||||
class RespondToAuthChallengeRequest;
|
||||
class RevokeTokenRequest;
|
||||
class SetLogDeliveryConfigurationRequest;
|
||||
class SetRiskConfigurationRequest;
|
||||
class SetUICustomizationRequest;
|
||||
class SetUserMFAPreferenceRequest;
|
||||
class SetUserPoolMfaConfigRequest;
|
||||
class SetUserSettingsRequest;
|
||||
class SignUpRequest;
|
||||
class StartUserImportJobRequest;
|
||||
class StopUserImportJobRequest;
|
||||
class TagResourceRequest;
|
||||
class UntagResourceRequest;
|
||||
class UpdateAuthEventFeedbackRequest;
|
||||
class UpdateDeviceStatusRequest;
|
||||
class UpdateGroupRequest;
|
||||
class UpdateIdentityProviderRequest;
|
||||
class UpdateResourceServerRequest;
|
||||
class UpdateUserAttributesRequest;
|
||||
class UpdateUserPoolRequest;
|
||||
class UpdateUserPoolClientRequest;
|
||||
class UpdateUserPoolDomainRequest;
|
||||
class VerifySoftwareTokenRequest;
|
||||
class VerifyUserAttributeRequest;
|
||||
/* End of service model forward declarations required in CognitoIdentityProviderClient header */
|
||||
|
||||
/* Service model Outcome class definitions */
|
||||
typedef Aws::Utils::Outcome<AddCustomAttributesResult, CognitoIdentityProviderError> AddCustomAttributesOutcome;
|
||||
typedef Aws::Utils::Outcome<Aws::NoResult, CognitoIdentityProviderError> AdminAddUserToGroupOutcome;
|
||||
typedef Aws::Utils::Outcome<AdminConfirmSignUpResult, CognitoIdentityProviderError> AdminConfirmSignUpOutcome;
|
||||
typedef Aws::Utils::Outcome<AdminCreateUserResult, CognitoIdentityProviderError> AdminCreateUserOutcome;
|
||||
typedef Aws::Utils::Outcome<Aws::NoResult, CognitoIdentityProviderError> AdminDeleteUserOutcome;
|
||||
typedef Aws::Utils::Outcome<AdminDeleteUserAttributesResult, CognitoIdentityProviderError> AdminDeleteUserAttributesOutcome;
|
||||
typedef Aws::Utils::Outcome<AdminDisableProviderForUserResult, CognitoIdentityProviderError> AdminDisableProviderForUserOutcome;
|
||||
typedef Aws::Utils::Outcome<AdminDisableUserResult, CognitoIdentityProviderError> AdminDisableUserOutcome;
|
||||
typedef Aws::Utils::Outcome<AdminEnableUserResult, CognitoIdentityProviderError> AdminEnableUserOutcome;
|
||||
typedef Aws::Utils::Outcome<Aws::NoResult, CognitoIdentityProviderError> AdminForgetDeviceOutcome;
|
||||
typedef Aws::Utils::Outcome<AdminGetDeviceResult, CognitoIdentityProviderError> AdminGetDeviceOutcome;
|
||||
typedef Aws::Utils::Outcome<AdminGetUserResult, CognitoIdentityProviderError> AdminGetUserOutcome;
|
||||
typedef Aws::Utils::Outcome<AdminInitiateAuthResult, CognitoIdentityProviderError> AdminInitiateAuthOutcome;
|
||||
typedef Aws::Utils::Outcome<AdminLinkProviderForUserResult, CognitoIdentityProviderError> AdminLinkProviderForUserOutcome;
|
||||
typedef Aws::Utils::Outcome<AdminListDevicesResult, CognitoIdentityProviderError> AdminListDevicesOutcome;
|
||||
typedef Aws::Utils::Outcome<AdminListGroupsForUserResult, CognitoIdentityProviderError> AdminListGroupsForUserOutcome;
|
||||
typedef Aws::Utils::Outcome<AdminListUserAuthEventsResult, CognitoIdentityProviderError> AdminListUserAuthEventsOutcome;
|
||||
typedef Aws::Utils::Outcome<Aws::NoResult, CognitoIdentityProviderError> AdminRemoveUserFromGroupOutcome;
|
||||
typedef Aws::Utils::Outcome<AdminResetUserPasswordResult, CognitoIdentityProviderError> AdminResetUserPasswordOutcome;
|
||||
typedef Aws::Utils::Outcome<AdminRespondToAuthChallengeResult, CognitoIdentityProviderError> AdminRespondToAuthChallengeOutcome;
|
||||
typedef Aws::Utils::Outcome<AdminSetUserMFAPreferenceResult, CognitoIdentityProviderError> AdminSetUserMFAPreferenceOutcome;
|
||||
typedef Aws::Utils::Outcome<AdminSetUserPasswordResult, CognitoIdentityProviderError> AdminSetUserPasswordOutcome;
|
||||
typedef Aws::Utils::Outcome<AdminSetUserSettingsResult, CognitoIdentityProviderError> AdminSetUserSettingsOutcome;
|
||||
typedef Aws::Utils::Outcome<AdminUpdateAuthEventFeedbackResult, CognitoIdentityProviderError> AdminUpdateAuthEventFeedbackOutcome;
|
||||
typedef Aws::Utils::Outcome<AdminUpdateDeviceStatusResult, CognitoIdentityProviderError> AdminUpdateDeviceStatusOutcome;
|
||||
typedef Aws::Utils::Outcome<AdminUpdateUserAttributesResult, CognitoIdentityProviderError> AdminUpdateUserAttributesOutcome;
|
||||
typedef Aws::Utils::Outcome<AdminUserGlobalSignOutResult, CognitoIdentityProviderError> AdminUserGlobalSignOutOutcome;
|
||||
typedef Aws::Utils::Outcome<AssociateSoftwareTokenResult, CognitoIdentityProviderError> AssociateSoftwareTokenOutcome;
|
||||
typedef Aws::Utils::Outcome<ChangePasswordResult, CognitoIdentityProviderError> ChangePasswordOutcome;
|
||||
typedef Aws::Utils::Outcome<ConfirmDeviceResult, CognitoIdentityProviderError> ConfirmDeviceOutcome;
|
||||
typedef Aws::Utils::Outcome<ConfirmForgotPasswordResult, CognitoIdentityProviderError> ConfirmForgotPasswordOutcome;
|
||||
typedef Aws::Utils::Outcome<ConfirmSignUpResult, CognitoIdentityProviderError> ConfirmSignUpOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateGroupResult, CognitoIdentityProviderError> CreateGroupOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateIdentityProviderResult, CognitoIdentityProviderError> CreateIdentityProviderOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateResourceServerResult, CognitoIdentityProviderError> CreateResourceServerOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateUserImportJobResult, CognitoIdentityProviderError> CreateUserImportJobOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateUserPoolResult, CognitoIdentityProviderError> CreateUserPoolOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateUserPoolClientResult, CognitoIdentityProviderError> CreateUserPoolClientOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateUserPoolDomainResult, CognitoIdentityProviderError> CreateUserPoolDomainOutcome;
|
||||
typedef Aws::Utils::Outcome<Aws::NoResult, CognitoIdentityProviderError> DeleteGroupOutcome;
|
||||
typedef Aws::Utils::Outcome<Aws::NoResult, CognitoIdentityProviderError> DeleteIdentityProviderOutcome;
|
||||
typedef Aws::Utils::Outcome<Aws::NoResult, CognitoIdentityProviderError> DeleteResourceServerOutcome;
|
||||
typedef Aws::Utils::Outcome<Aws::NoResult, CognitoIdentityProviderError> DeleteUserOutcome;
|
||||
typedef Aws::Utils::Outcome<DeleteUserAttributesResult, CognitoIdentityProviderError> DeleteUserAttributesOutcome;
|
||||
typedef Aws::Utils::Outcome<Aws::NoResult, CognitoIdentityProviderError> DeleteUserPoolOutcome;
|
||||
typedef Aws::Utils::Outcome<Aws::NoResult, CognitoIdentityProviderError> DeleteUserPoolClientOutcome;
|
||||
typedef Aws::Utils::Outcome<DeleteUserPoolDomainResult, CognitoIdentityProviderError> DeleteUserPoolDomainOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeIdentityProviderResult, CognitoIdentityProviderError> DescribeIdentityProviderOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeResourceServerResult, CognitoIdentityProviderError> DescribeResourceServerOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeRiskConfigurationResult, CognitoIdentityProviderError> DescribeRiskConfigurationOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeUserImportJobResult, CognitoIdentityProviderError> DescribeUserImportJobOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeUserPoolResult, CognitoIdentityProviderError> DescribeUserPoolOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeUserPoolClientResult, CognitoIdentityProviderError> DescribeUserPoolClientOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeUserPoolDomainResult, CognitoIdentityProviderError> DescribeUserPoolDomainOutcome;
|
||||
typedef Aws::Utils::Outcome<Aws::NoResult, CognitoIdentityProviderError> ForgetDeviceOutcome;
|
||||
typedef Aws::Utils::Outcome<ForgotPasswordResult, CognitoIdentityProviderError> ForgotPasswordOutcome;
|
||||
typedef Aws::Utils::Outcome<GetCSVHeaderResult, CognitoIdentityProviderError> GetCSVHeaderOutcome;
|
||||
typedef Aws::Utils::Outcome<GetDeviceResult, CognitoIdentityProviderError> GetDeviceOutcome;
|
||||
typedef Aws::Utils::Outcome<GetGroupResult, CognitoIdentityProviderError> GetGroupOutcome;
|
||||
typedef Aws::Utils::Outcome<GetIdentityProviderByIdentifierResult, CognitoIdentityProviderError> GetIdentityProviderByIdentifierOutcome;
|
||||
typedef Aws::Utils::Outcome<GetLogDeliveryConfigurationResult, CognitoIdentityProviderError> GetLogDeliveryConfigurationOutcome;
|
||||
typedef Aws::Utils::Outcome<GetSigningCertificateResult, CognitoIdentityProviderError> GetSigningCertificateOutcome;
|
||||
typedef Aws::Utils::Outcome<GetUICustomizationResult, CognitoIdentityProviderError> GetUICustomizationOutcome;
|
||||
typedef Aws::Utils::Outcome<GetUserResult, CognitoIdentityProviderError> GetUserOutcome;
|
||||
typedef Aws::Utils::Outcome<GetUserAttributeVerificationCodeResult, CognitoIdentityProviderError> GetUserAttributeVerificationCodeOutcome;
|
||||
typedef Aws::Utils::Outcome<GetUserPoolMfaConfigResult, CognitoIdentityProviderError> GetUserPoolMfaConfigOutcome;
|
||||
typedef Aws::Utils::Outcome<GlobalSignOutResult, CognitoIdentityProviderError> GlobalSignOutOutcome;
|
||||
typedef Aws::Utils::Outcome<InitiateAuthResult, CognitoIdentityProviderError> InitiateAuthOutcome;
|
||||
typedef Aws::Utils::Outcome<ListDevicesResult, CognitoIdentityProviderError> ListDevicesOutcome;
|
||||
typedef Aws::Utils::Outcome<ListGroupsResult, CognitoIdentityProviderError> ListGroupsOutcome;
|
||||
typedef Aws::Utils::Outcome<ListIdentityProvidersResult, CognitoIdentityProviderError> ListIdentityProvidersOutcome;
|
||||
typedef Aws::Utils::Outcome<ListResourceServersResult, CognitoIdentityProviderError> ListResourceServersOutcome;
|
||||
typedef Aws::Utils::Outcome<ListTagsForResourceResult, CognitoIdentityProviderError> ListTagsForResourceOutcome;
|
||||
typedef Aws::Utils::Outcome<ListUserImportJobsResult, CognitoIdentityProviderError> ListUserImportJobsOutcome;
|
||||
typedef Aws::Utils::Outcome<ListUserPoolClientsResult, CognitoIdentityProviderError> ListUserPoolClientsOutcome;
|
||||
typedef Aws::Utils::Outcome<ListUserPoolsResult, CognitoIdentityProviderError> ListUserPoolsOutcome;
|
||||
typedef Aws::Utils::Outcome<ListUsersResult, CognitoIdentityProviderError> ListUsersOutcome;
|
||||
typedef Aws::Utils::Outcome<ListUsersInGroupResult, CognitoIdentityProviderError> ListUsersInGroupOutcome;
|
||||
typedef Aws::Utils::Outcome<ResendConfirmationCodeResult, CognitoIdentityProviderError> ResendConfirmationCodeOutcome;
|
||||
typedef Aws::Utils::Outcome<RespondToAuthChallengeResult, CognitoIdentityProviderError> RespondToAuthChallengeOutcome;
|
||||
typedef Aws::Utils::Outcome<RevokeTokenResult, CognitoIdentityProviderError> RevokeTokenOutcome;
|
||||
typedef Aws::Utils::Outcome<SetLogDeliveryConfigurationResult, CognitoIdentityProviderError> SetLogDeliveryConfigurationOutcome;
|
||||
typedef Aws::Utils::Outcome<SetRiskConfigurationResult, CognitoIdentityProviderError> SetRiskConfigurationOutcome;
|
||||
typedef Aws::Utils::Outcome<SetUICustomizationResult, CognitoIdentityProviderError> SetUICustomizationOutcome;
|
||||
typedef Aws::Utils::Outcome<SetUserMFAPreferenceResult, CognitoIdentityProviderError> SetUserMFAPreferenceOutcome;
|
||||
typedef Aws::Utils::Outcome<SetUserPoolMfaConfigResult, CognitoIdentityProviderError> SetUserPoolMfaConfigOutcome;
|
||||
typedef Aws::Utils::Outcome<SetUserSettingsResult, CognitoIdentityProviderError> SetUserSettingsOutcome;
|
||||
typedef Aws::Utils::Outcome<SignUpResult, CognitoIdentityProviderError> SignUpOutcome;
|
||||
typedef Aws::Utils::Outcome<StartUserImportJobResult, CognitoIdentityProviderError> StartUserImportJobOutcome;
|
||||
typedef Aws::Utils::Outcome<StopUserImportJobResult, CognitoIdentityProviderError> StopUserImportJobOutcome;
|
||||
typedef Aws::Utils::Outcome<TagResourceResult, CognitoIdentityProviderError> TagResourceOutcome;
|
||||
typedef Aws::Utils::Outcome<UntagResourceResult, CognitoIdentityProviderError> UntagResourceOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateAuthEventFeedbackResult, CognitoIdentityProviderError> UpdateAuthEventFeedbackOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateDeviceStatusResult, CognitoIdentityProviderError> UpdateDeviceStatusOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateGroupResult, CognitoIdentityProviderError> UpdateGroupOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateIdentityProviderResult, CognitoIdentityProviderError> UpdateIdentityProviderOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateResourceServerResult, CognitoIdentityProviderError> UpdateResourceServerOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateUserAttributesResult, CognitoIdentityProviderError> UpdateUserAttributesOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateUserPoolResult, CognitoIdentityProviderError> UpdateUserPoolOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateUserPoolClientResult, CognitoIdentityProviderError> UpdateUserPoolClientOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateUserPoolDomainResult, CognitoIdentityProviderError> UpdateUserPoolDomainOutcome;
|
||||
typedef Aws::Utils::Outcome<VerifySoftwareTokenResult, CognitoIdentityProviderError> VerifySoftwareTokenOutcome;
|
||||
typedef Aws::Utils::Outcome<VerifyUserAttributeResult, CognitoIdentityProviderError> VerifyUserAttributeOutcome;
|
||||
/* End of service model Outcome class definitions */
|
||||
|
||||
/* Service model Outcome callable definitions */
|
||||
typedef std::future<AddCustomAttributesOutcome> AddCustomAttributesOutcomeCallable;
|
||||
typedef std::future<AdminAddUserToGroupOutcome> AdminAddUserToGroupOutcomeCallable;
|
||||
typedef std::future<AdminConfirmSignUpOutcome> AdminConfirmSignUpOutcomeCallable;
|
||||
typedef std::future<AdminCreateUserOutcome> AdminCreateUserOutcomeCallable;
|
||||
typedef std::future<AdminDeleteUserOutcome> AdminDeleteUserOutcomeCallable;
|
||||
typedef std::future<AdminDeleteUserAttributesOutcome> AdminDeleteUserAttributesOutcomeCallable;
|
||||
typedef std::future<AdminDisableProviderForUserOutcome> AdminDisableProviderForUserOutcomeCallable;
|
||||
typedef std::future<AdminDisableUserOutcome> AdminDisableUserOutcomeCallable;
|
||||
typedef std::future<AdminEnableUserOutcome> AdminEnableUserOutcomeCallable;
|
||||
typedef std::future<AdminForgetDeviceOutcome> AdminForgetDeviceOutcomeCallable;
|
||||
typedef std::future<AdminGetDeviceOutcome> AdminGetDeviceOutcomeCallable;
|
||||
typedef std::future<AdminGetUserOutcome> AdminGetUserOutcomeCallable;
|
||||
typedef std::future<AdminInitiateAuthOutcome> AdminInitiateAuthOutcomeCallable;
|
||||
typedef std::future<AdminLinkProviderForUserOutcome> AdminLinkProviderForUserOutcomeCallable;
|
||||
typedef std::future<AdminListDevicesOutcome> AdminListDevicesOutcomeCallable;
|
||||
typedef std::future<AdminListGroupsForUserOutcome> AdminListGroupsForUserOutcomeCallable;
|
||||
typedef std::future<AdminListUserAuthEventsOutcome> AdminListUserAuthEventsOutcomeCallable;
|
||||
typedef std::future<AdminRemoveUserFromGroupOutcome> AdminRemoveUserFromGroupOutcomeCallable;
|
||||
typedef std::future<AdminResetUserPasswordOutcome> AdminResetUserPasswordOutcomeCallable;
|
||||
typedef std::future<AdminRespondToAuthChallengeOutcome> AdminRespondToAuthChallengeOutcomeCallable;
|
||||
typedef std::future<AdminSetUserMFAPreferenceOutcome> AdminSetUserMFAPreferenceOutcomeCallable;
|
||||
typedef std::future<AdminSetUserPasswordOutcome> AdminSetUserPasswordOutcomeCallable;
|
||||
typedef std::future<AdminSetUserSettingsOutcome> AdminSetUserSettingsOutcomeCallable;
|
||||
typedef std::future<AdminUpdateAuthEventFeedbackOutcome> AdminUpdateAuthEventFeedbackOutcomeCallable;
|
||||
typedef std::future<AdminUpdateDeviceStatusOutcome> AdminUpdateDeviceStatusOutcomeCallable;
|
||||
typedef std::future<AdminUpdateUserAttributesOutcome> AdminUpdateUserAttributesOutcomeCallable;
|
||||
typedef std::future<AdminUserGlobalSignOutOutcome> AdminUserGlobalSignOutOutcomeCallable;
|
||||
typedef std::future<AssociateSoftwareTokenOutcome> AssociateSoftwareTokenOutcomeCallable;
|
||||
typedef std::future<ChangePasswordOutcome> ChangePasswordOutcomeCallable;
|
||||
typedef std::future<ConfirmDeviceOutcome> ConfirmDeviceOutcomeCallable;
|
||||
typedef std::future<ConfirmForgotPasswordOutcome> ConfirmForgotPasswordOutcomeCallable;
|
||||
typedef std::future<ConfirmSignUpOutcome> ConfirmSignUpOutcomeCallable;
|
||||
typedef std::future<CreateGroupOutcome> CreateGroupOutcomeCallable;
|
||||
typedef std::future<CreateIdentityProviderOutcome> CreateIdentityProviderOutcomeCallable;
|
||||
typedef std::future<CreateResourceServerOutcome> CreateResourceServerOutcomeCallable;
|
||||
typedef std::future<CreateUserImportJobOutcome> CreateUserImportJobOutcomeCallable;
|
||||
typedef std::future<CreateUserPoolOutcome> CreateUserPoolOutcomeCallable;
|
||||
typedef std::future<CreateUserPoolClientOutcome> CreateUserPoolClientOutcomeCallable;
|
||||
typedef std::future<CreateUserPoolDomainOutcome> CreateUserPoolDomainOutcomeCallable;
|
||||
typedef std::future<DeleteGroupOutcome> DeleteGroupOutcomeCallable;
|
||||
typedef std::future<DeleteIdentityProviderOutcome> DeleteIdentityProviderOutcomeCallable;
|
||||
typedef std::future<DeleteResourceServerOutcome> DeleteResourceServerOutcomeCallable;
|
||||
typedef std::future<DeleteUserOutcome> DeleteUserOutcomeCallable;
|
||||
typedef std::future<DeleteUserAttributesOutcome> DeleteUserAttributesOutcomeCallable;
|
||||
typedef std::future<DeleteUserPoolOutcome> DeleteUserPoolOutcomeCallable;
|
||||
typedef std::future<DeleteUserPoolClientOutcome> DeleteUserPoolClientOutcomeCallable;
|
||||
typedef std::future<DeleteUserPoolDomainOutcome> DeleteUserPoolDomainOutcomeCallable;
|
||||
typedef std::future<DescribeIdentityProviderOutcome> DescribeIdentityProviderOutcomeCallable;
|
||||
typedef std::future<DescribeResourceServerOutcome> DescribeResourceServerOutcomeCallable;
|
||||
typedef std::future<DescribeRiskConfigurationOutcome> DescribeRiskConfigurationOutcomeCallable;
|
||||
typedef std::future<DescribeUserImportJobOutcome> DescribeUserImportJobOutcomeCallable;
|
||||
typedef std::future<DescribeUserPoolOutcome> DescribeUserPoolOutcomeCallable;
|
||||
typedef std::future<DescribeUserPoolClientOutcome> DescribeUserPoolClientOutcomeCallable;
|
||||
typedef std::future<DescribeUserPoolDomainOutcome> DescribeUserPoolDomainOutcomeCallable;
|
||||
typedef std::future<ForgetDeviceOutcome> ForgetDeviceOutcomeCallable;
|
||||
typedef std::future<ForgotPasswordOutcome> ForgotPasswordOutcomeCallable;
|
||||
typedef std::future<GetCSVHeaderOutcome> GetCSVHeaderOutcomeCallable;
|
||||
typedef std::future<GetDeviceOutcome> GetDeviceOutcomeCallable;
|
||||
typedef std::future<GetGroupOutcome> GetGroupOutcomeCallable;
|
||||
typedef std::future<GetIdentityProviderByIdentifierOutcome> GetIdentityProviderByIdentifierOutcomeCallable;
|
||||
typedef std::future<GetLogDeliveryConfigurationOutcome> GetLogDeliveryConfigurationOutcomeCallable;
|
||||
typedef std::future<GetSigningCertificateOutcome> GetSigningCertificateOutcomeCallable;
|
||||
typedef std::future<GetUICustomizationOutcome> GetUICustomizationOutcomeCallable;
|
||||
typedef std::future<GetUserOutcome> GetUserOutcomeCallable;
|
||||
typedef std::future<GetUserAttributeVerificationCodeOutcome> GetUserAttributeVerificationCodeOutcomeCallable;
|
||||
typedef std::future<GetUserPoolMfaConfigOutcome> GetUserPoolMfaConfigOutcomeCallable;
|
||||
typedef std::future<GlobalSignOutOutcome> GlobalSignOutOutcomeCallable;
|
||||
typedef std::future<InitiateAuthOutcome> InitiateAuthOutcomeCallable;
|
||||
typedef std::future<ListDevicesOutcome> ListDevicesOutcomeCallable;
|
||||
typedef std::future<ListGroupsOutcome> ListGroupsOutcomeCallable;
|
||||
typedef std::future<ListIdentityProvidersOutcome> ListIdentityProvidersOutcomeCallable;
|
||||
typedef std::future<ListResourceServersOutcome> ListResourceServersOutcomeCallable;
|
||||
typedef std::future<ListTagsForResourceOutcome> ListTagsForResourceOutcomeCallable;
|
||||
typedef std::future<ListUserImportJobsOutcome> ListUserImportJobsOutcomeCallable;
|
||||
typedef std::future<ListUserPoolClientsOutcome> ListUserPoolClientsOutcomeCallable;
|
||||
typedef std::future<ListUserPoolsOutcome> ListUserPoolsOutcomeCallable;
|
||||
typedef std::future<ListUsersOutcome> ListUsersOutcomeCallable;
|
||||
typedef std::future<ListUsersInGroupOutcome> ListUsersInGroupOutcomeCallable;
|
||||
typedef std::future<ResendConfirmationCodeOutcome> ResendConfirmationCodeOutcomeCallable;
|
||||
typedef std::future<RespondToAuthChallengeOutcome> RespondToAuthChallengeOutcomeCallable;
|
||||
typedef std::future<RevokeTokenOutcome> RevokeTokenOutcomeCallable;
|
||||
typedef std::future<SetLogDeliveryConfigurationOutcome> SetLogDeliveryConfigurationOutcomeCallable;
|
||||
typedef std::future<SetRiskConfigurationOutcome> SetRiskConfigurationOutcomeCallable;
|
||||
typedef std::future<SetUICustomizationOutcome> SetUICustomizationOutcomeCallable;
|
||||
typedef std::future<SetUserMFAPreferenceOutcome> SetUserMFAPreferenceOutcomeCallable;
|
||||
typedef std::future<SetUserPoolMfaConfigOutcome> SetUserPoolMfaConfigOutcomeCallable;
|
||||
typedef std::future<SetUserSettingsOutcome> SetUserSettingsOutcomeCallable;
|
||||
typedef std::future<SignUpOutcome> SignUpOutcomeCallable;
|
||||
typedef std::future<StartUserImportJobOutcome> StartUserImportJobOutcomeCallable;
|
||||
typedef std::future<StopUserImportJobOutcome> StopUserImportJobOutcomeCallable;
|
||||
typedef std::future<TagResourceOutcome> TagResourceOutcomeCallable;
|
||||
typedef std::future<UntagResourceOutcome> UntagResourceOutcomeCallable;
|
||||
typedef std::future<UpdateAuthEventFeedbackOutcome> UpdateAuthEventFeedbackOutcomeCallable;
|
||||
typedef std::future<UpdateDeviceStatusOutcome> UpdateDeviceStatusOutcomeCallable;
|
||||
typedef std::future<UpdateGroupOutcome> UpdateGroupOutcomeCallable;
|
||||
typedef std::future<UpdateIdentityProviderOutcome> UpdateIdentityProviderOutcomeCallable;
|
||||
typedef std::future<UpdateResourceServerOutcome> UpdateResourceServerOutcomeCallable;
|
||||
typedef std::future<UpdateUserAttributesOutcome> UpdateUserAttributesOutcomeCallable;
|
||||
typedef std::future<UpdateUserPoolOutcome> UpdateUserPoolOutcomeCallable;
|
||||
typedef std::future<UpdateUserPoolClientOutcome> UpdateUserPoolClientOutcomeCallable;
|
||||
typedef std::future<UpdateUserPoolDomainOutcome> UpdateUserPoolDomainOutcomeCallable;
|
||||
typedef std::future<VerifySoftwareTokenOutcome> VerifySoftwareTokenOutcomeCallable;
|
||||
typedef std::future<VerifyUserAttributeOutcome> VerifyUserAttributeOutcomeCallable;
|
||||
/* End of service model Outcome callable definitions */
|
||||
} // namespace Model
|
||||
|
||||
class CognitoIdentityProviderClient;
|
||||
|
||||
/* Service model async handlers definitions */
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AddCustomAttributesRequest&, const Model::AddCustomAttributesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AddCustomAttributesResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AdminAddUserToGroupRequest&, const Model::AdminAddUserToGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AdminAddUserToGroupResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AdminConfirmSignUpRequest&, const Model::AdminConfirmSignUpOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AdminConfirmSignUpResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AdminCreateUserRequest&, const Model::AdminCreateUserOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AdminCreateUserResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AdminDeleteUserRequest&, const Model::AdminDeleteUserOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AdminDeleteUserResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AdminDeleteUserAttributesRequest&, const Model::AdminDeleteUserAttributesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AdminDeleteUserAttributesResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AdminDisableProviderForUserRequest&, const Model::AdminDisableProviderForUserOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AdminDisableProviderForUserResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AdminDisableUserRequest&, const Model::AdminDisableUserOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AdminDisableUserResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AdminEnableUserRequest&, const Model::AdminEnableUserOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AdminEnableUserResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AdminForgetDeviceRequest&, const Model::AdminForgetDeviceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AdminForgetDeviceResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AdminGetDeviceRequest&, const Model::AdminGetDeviceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AdminGetDeviceResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AdminGetUserRequest&, const Model::AdminGetUserOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AdminGetUserResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AdminInitiateAuthRequest&, const Model::AdminInitiateAuthOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AdminInitiateAuthResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AdminLinkProviderForUserRequest&, const Model::AdminLinkProviderForUserOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AdminLinkProviderForUserResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AdminListDevicesRequest&, const Model::AdminListDevicesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AdminListDevicesResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AdminListGroupsForUserRequest&, const Model::AdminListGroupsForUserOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AdminListGroupsForUserResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AdminListUserAuthEventsRequest&, const Model::AdminListUserAuthEventsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AdminListUserAuthEventsResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AdminRemoveUserFromGroupRequest&, const Model::AdminRemoveUserFromGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AdminRemoveUserFromGroupResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AdminResetUserPasswordRequest&, const Model::AdminResetUserPasswordOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AdminResetUserPasswordResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AdminRespondToAuthChallengeRequest&, const Model::AdminRespondToAuthChallengeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AdminRespondToAuthChallengeResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AdminSetUserMFAPreferenceRequest&, const Model::AdminSetUserMFAPreferenceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AdminSetUserMFAPreferenceResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AdminSetUserPasswordRequest&, const Model::AdminSetUserPasswordOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AdminSetUserPasswordResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AdminSetUserSettingsRequest&, const Model::AdminSetUserSettingsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AdminSetUserSettingsResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AdminUpdateAuthEventFeedbackRequest&, const Model::AdminUpdateAuthEventFeedbackOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AdminUpdateAuthEventFeedbackResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AdminUpdateDeviceStatusRequest&, const Model::AdminUpdateDeviceStatusOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AdminUpdateDeviceStatusResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AdminUpdateUserAttributesRequest&, const Model::AdminUpdateUserAttributesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AdminUpdateUserAttributesResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AdminUserGlobalSignOutRequest&, const Model::AdminUserGlobalSignOutOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AdminUserGlobalSignOutResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::AssociateSoftwareTokenRequest&, const Model::AssociateSoftwareTokenOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AssociateSoftwareTokenResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::ChangePasswordRequest&, const Model::ChangePasswordOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ChangePasswordResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::ConfirmDeviceRequest&, const Model::ConfirmDeviceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ConfirmDeviceResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::ConfirmForgotPasswordRequest&, const Model::ConfirmForgotPasswordOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ConfirmForgotPasswordResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::ConfirmSignUpRequest&, const Model::ConfirmSignUpOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ConfirmSignUpResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::CreateGroupRequest&, const Model::CreateGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateGroupResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::CreateIdentityProviderRequest&, const Model::CreateIdentityProviderOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateIdentityProviderResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::CreateResourceServerRequest&, const Model::CreateResourceServerOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateResourceServerResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::CreateUserImportJobRequest&, const Model::CreateUserImportJobOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateUserImportJobResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::CreateUserPoolRequest&, const Model::CreateUserPoolOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateUserPoolResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::CreateUserPoolClientRequest&, const Model::CreateUserPoolClientOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateUserPoolClientResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::CreateUserPoolDomainRequest&, const Model::CreateUserPoolDomainOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateUserPoolDomainResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::DeleteGroupRequest&, const Model::DeleteGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteGroupResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::DeleteIdentityProviderRequest&, const Model::DeleteIdentityProviderOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteIdentityProviderResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::DeleteResourceServerRequest&, const Model::DeleteResourceServerOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteResourceServerResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::DeleteUserRequest&, const Model::DeleteUserOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteUserResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::DeleteUserAttributesRequest&, const Model::DeleteUserAttributesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteUserAttributesResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::DeleteUserPoolRequest&, const Model::DeleteUserPoolOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteUserPoolResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::DeleteUserPoolClientRequest&, const Model::DeleteUserPoolClientOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteUserPoolClientResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::DeleteUserPoolDomainRequest&, const Model::DeleteUserPoolDomainOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteUserPoolDomainResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::DescribeIdentityProviderRequest&, const Model::DescribeIdentityProviderOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeIdentityProviderResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::DescribeResourceServerRequest&, const Model::DescribeResourceServerOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeResourceServerResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::DescribeRiskConfigurationRequest&, const Model::DescribeRiskConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeRiskConfigurationResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::DescribeUserImportJobRequest&, const Model::DescribeUserImportJobOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeUserImportJobResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::DescribeUserPoolRequest&, const Model::DescribeUserPoolOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeUserPoolResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::DescribeUserPoolClientRequest&, const Model::DescribeUserPoolClientOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeUserPoolClientResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::DescribeUserPoolDomainRequest&, const Model::DescribeUserPoolDomainOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeUserPoolDomainResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::ForgetDeviceRequest&, const Model::ForgetDeviceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ForgetDeviceResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::ForgotPasswordRequest&, const Model::ForgotPasswordOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ForgotPasswordResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::GetCSVHeaderRequest&, const Model::GetCSVHeaderOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetCSVHeaderResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::GetDeviceRequest&, const Model::GetDeviceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetDeviceResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::GetGroupRequest&, const Model::GetGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetGroupResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::GetIdentityProviderByIdentifierRequest&, const Model::GetIdentityProviderByIdentifierOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetIdentityProviderByIdentifierResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::GetLogDeliveryConfigurationRequest&, const Model::GetLogDeliveryConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetLogDeliveryConfigurationResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::GetSigningCertificateRequest&, const Model::GetSigningCertificateOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetSigningCertificateResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::GetUICustomizationRequest&, const Model::GetUICustomizationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetUICustomizationResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::GetUserRequest&, const Model::GetUserOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetUserResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::GetUserAttributeVerificationCodeRequest&, const Model::GetUserAttributeVerificationCodeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetUserAttributeVerificationCodeResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::GetUserPoolMfaConfigRequest&, const Model::GetUserPoolMfaConfigOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetUserPoolMfaConfigResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::GlobalSignOutRequest&, const Model::GlobalSignOutOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GlobalSignOutResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::InitiateAuthRequest&, const Model::InitiateAuthOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > InitiateAuthResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::ListDevicesRequest&, const Model::ListDevicesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListDevicesResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::ListGroupsRequest&, const Model::ListGroupsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListGroupsResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::ListIdentityProvidersRequest&, const Model::ListIdentityProvidersOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListIdentityProvidersResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::ListResourceServersRequest&, const Model::ListResourceServersOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListResourceServersResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::ListTagsForResourceRequest&, const Model::ListTagsForResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListTagsForResourceResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::ListUserImportJobsRequest&, const Model::ListUserImportJobsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListUserImportJobsResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::ListUserPoolClientsRequest&, const Model::ListUserPoolClientsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListUserPoolClientsResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::ListUserPoolsRequest&, const Model::ListUserPoolsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListUserPoolsResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::ListUsersRequest&, const Model::ListUsersOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListUsersResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::ListUsersInGroupRequest&, const Model::ListUsersInGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListUsersInGroupResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::ResendConfirmationCodeRequest&, const Model::ResendConfirmationCodeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ResendConfirmationCodeResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::RespondToAuthChallengeRequest&, const Model::RespondToAuthChallengeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RespondToAuthChallengeResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::RevokeTokenRequest&, const Model::RevokeTokenOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RevokeTokenResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::SetLogDeliveryConfigurationRequest&, const Model::SetLogDeliveryConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SetLogDeliveryConfigurationResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::SetRiskConfigurationRequest&, const Model::SetRiskConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SetRiskConfigurationResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::SetUICustomizationRequest&, const Model::SetUICustomizationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SetUICustomizationResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::SetUserMFAPreferenceRequest&, const Model::SetUserMFAPreferenceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SetUserMFAPreferenceResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::SetUserPoolMfaConfigRequest&, const Model::SetUserPoolMfaConfigOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SetUserPoolMfaConfigResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::SetUserSettingsRequest&, const Model::SetUserSettingsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SetUserSettingsResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::SignUpRequest&, const Model::SignUpOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SignUpResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::StartUserImportJobRequest&, const Model::StartUserImportJobOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > StartUserImportJobResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::StopUserImportJobRequest&, const Model::StopUserImportJobOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > StopUserImportJobResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::TagResourceRequest&, const Model::TagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > TagResourceResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::UntagResourceRequest&, const Model::UntagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UntagResourceResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::UpdateAuthEventFeedbackRequest&, const Model::UpdateAuthEventFeedbackOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateAuthEventFeedbackResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::UpdateDeviceStatusRequest&, const Model::UpdateDeviceStatusOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateDeviceStatusResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::UpdateGroupRequest&, const Model::UpdateGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateGroupResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::UpdateIdentityProviderRequest&, const Model::UpdateIdentityProviderOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateIdentityProviderResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::UpdateResourceServerRequest&, const Model::UpdateResourceServerOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateResourceServerResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::UpdateUserAttributesRequest&, const Model::UpdateUserAttributesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateUserAttributesResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::UpdateUserPoolRequest&, const Model::UpdateUserPoolOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateUserPoolResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::UpdateUserPoolClientRequest&, const Model::UpdateUserPoolClientOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateUserPoolClientResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::UpdateUserPoolDomainRequest&, const Model::UpdateUserPoolDomainOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateUserPoolDomainResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::VerifySoftwareTokenRequest&, const Model::VerifySoftwareTokenOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > VerifySoftwareTokenResponseReceivedHandler;
|
||||
typedef std::function<void(const CognitoIdentityProviderClient*, const Model::VerifyUserAttributeRequest&, const Model::VerifyUserAttributeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > VerifyUserAttributeResponseReceivedHandler;
|
||||
/* End of service model async handlers definitions */
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,32 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#ifdef _MSC_VER
|
||||
//disable windows complaining about max template size.
|
||||
#pragma warning (disable : 4503)
|
||||
#endif // _MSC_VER
|
||||
|
||||
#if defined (USE_WINDOWS_DLL_SEMANTICS) || defined (_WIN32)
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning(disable : 4251)
|
||||
#endif // _MSC_VER
|
||||
|
||||
#ifdef USE_IMPORT_EXPORT
|
||||
#ifdef AWS_COGNITOIDENTITYPROVIDER_EXPORTS
|
||||
#define AWS_COGNITOIDENTITYPROVIDER_API __declspec(dllexport)
|
||||
#else
|
||||
#define AWS_COGNITOIDENTITYPROVIDER_API __declspec(dllimport)
|
||||
#endif /* AWS_COGNITOIDENTITYPROVIDER_EXPORTS */
|
||||
#define AWS_COGNITOIDENTITYPROVIDER_EXTERN
|
||||
#else
|
||||
#define AWS_COGNITOIDENTITYPROVIDER_API
|
||||
#define AWS_COGNITOIDENTITYPROVIDER_EXTERN extern
|
||||
#endif // USE_IMPORT_EXPORT
|
||||
#else // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)
|
||||
#define AWS_COGNITOIDENTITYPROVIDER_API
|
||||
#define AWS_COGNITOIDENTITYPROVIDER_EXTERN extern
|
||||
#endif // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)
|
||||
@@ -0,0 +1,63 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/cognito-idp/model/RecoveryOptionType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The data type for <code>AccountRecoverySetting</code>.</p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AccountRecoverySettingType">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AccountRecoverySettingType
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AccountRecoverySettingType();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AccountRecoverySettingType(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AccountRecoverySettingType& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The list of <code>RecoveryOptionTypes</code>.</p>
|
||||
*/
|
||||
inline const Aws::Vector<RecoveryOptionType>& GetRecoveryMechanisms() const{ return m_recoveryMechanisms; }
|
||||
inline bool RecoveryMechanismsHasBeenSet() const { return m_recoveryMechanismsHasBeenSet; }
|
||||
inline void SetRecoveryMechanisms(const Aws::Vector<RecoveryOptionType>& value) { m_recoveryMechanismsHasBeenSet = true; m_recoveryMechanisms = value; }
|
||||
inline void SetRecoveryMechanisms(Aws::Vector<RecoveryOptionType>&& value) { m_recoveryMechanismsHasBeenSet = true; m_recoveryMechanisms = std::move(value); }
|
||||
inline AccountRecoverySettingType& WithRecoveryMechanisms(const Aws::Vector<RecoveryOptionType>& value) { SetRecoveryMechanisms(value); return *this;}
|
||||
inline AccountRecoverySettingType& WithRecoveryMechanisms(Aws::Vector<RecoveryOptionType>&& value) { SetRecoveryMechanisms(std::move(value)); return *this;}
|
||||
inline AccountRecoverySettingType& AddRecoveryMechanisms(const RecoveryOptionType& value) { m_recoveryMechanismsHasBeenSet = true; m_recoveryMechanisms.push_back(value); return *this; }
|
||||
inline AccountRecoverySettingType& AddRecoveryMechanisms(RecoveryOptionType&& value) { m_recoveryMechanismsHasBeenSet = true; m_recoveryMechanisms.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::Vector<RecoveryOptionType> m_recoveryMechanisms;
|
||||
bool m_recoveryMechanismsHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,78 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/model/AccountTakeoverEventActionType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Account takeover action type.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AccountTakeoverActionType">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AccountTakeoverActionType
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AccountTakeoverActionType();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AccountTakeoverActionType(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AccountTakeoverActionType& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Flag specifying whether to send a notification.</p>
|
||||
*/
|
||||
inline bool GetNotify() const{ return m_notify; }
|
||||
inline bool NotifyHasBeenSet() const { return m_notifyHasBeenSet; }
|
||||
inline void SetNotify(bool value) { m_notifyHasBeenSet = true; m_notify = value; }
|
||||
inline AccountTakeoverActionType& WithNotify(bool value) { SetNotify(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The action to take in response to the account takeover action. Valid values
|
||||
* are as follows:</p> <ul> <li> <p> <code>BLOCK</code> Choosing this action will
|
||||
* block the request.</p> </li> <li> <p> <code>MFA_IF_CONFIGURED</code> Present an
|
||||
* MFA challenge if user has configured it, else allow the request.</p> </li> <li>
|
||||
* <p> <code>MFA_REQUIRED</code> Present an MFA challenge if user has configured
|
||||
* it, else block the request.</p> </li> <li> <p> <code>NO_ACTION</code> Allow the
|
||||
* user to sign in.</p> </li> </ul>
|
||||
*/
|
||||
inline const AccountTakeoverEventActionType& GetEventAction() const{ return m_eventAction; }
|
||||
inline bool EventActionHasBeenSet() const { return m_eventActionHasBeenSet; }
|
||||
inline void SetEventAction(const AccountTakeoverEventActionType& value) { m_eventActionHasBeenSet = true; m_eventAction = value; }
|
||||
inline void SetEventAction(AccountTakeoverEventActionType&& value) { m_eventActionHasBeenSet = true; m_eventAction = std::move(value); }
|
||||
inline AccountTakeoverActionType& WithEventAction(const AccountTakeoverEventActionType& value) { SetEventAction(value); return *this;}
|
||||
inline AccountTakeoverActionType& WithEventAction(AccountTakeoverEventActionType&& value) { SetEventAction(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
bool m_notify;
|
||||
bool m_notifyHasBeenSet = false;
|
||||
|
||||
AccountTakeoverEventActionType m_eventAction;
|
||||
bool m_eventActionHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,89 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/model/AccountTakeoverActionType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Account takeover actions type.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AccountTakeoverActionsType">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AccountTakeoverActionsType
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AccountTakeoverActionsType();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AccountTakeoverActionsType(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AccountTakeoverActionsType& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Action to take for a low risk.</p>
|
||||
*/
|
||||
inline const AccountTakeoverActionType& GetLowAction() const{ return m_lowAction; }
|
||||
inline bool LowActionHasBeenSet() const { return m_lowActionHasBeenSet; }
|
||||
inline void SetLowAction(const AccountTakeoverActionType& value) { m_lowActionHasBeenSet = true; m_lowAction = value; }
|
||||
inline void SetLowAction(AccountTakeoverActionType&& value) { m_lowActionHasBeenSet = true; m_lowAction = std::move(value); }
|
||||
inline AccountTakeoverActionsType& WithLowAction(const AccountTakeoverActionType& value) { SetLowAction(value); return *this;}
|
||||
inline AccountTakeoverActionsType& WithLowAction(AccountTakeoverActionType&& value) { SetLowAction(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Action to take for a medium risk.</p>
|
||||
*/
|
||||
inline const AccountTakeoverActionType& GetMediumAction() const{ return m_mediumAction; }
|
||||
inline bool MediumActionHasBeenSet() const { return m_mediumActionHasBeenSet; }
|
||||
inline void SetMediumAction(const AccountTakeoverActionType& value) { m_mediumActionHasBeenSet = true; m_mediumAction = value; }
|
||||
inline void SetMediumAction(AccountTakeoverActionType&& value) { m_mediumActionHasBeenSet = true; m_mediumAction = std::move(value); }
|
||||
inline AccountTakeoverActionsType& WithMediumAction(const AccountTakeoverActionType& value) { SetMediumAction(value); return *this;}
|
||||
inline AccountTakeoverActionsType& WithMediumAction(AccountTakeoverActionType&& value) { SetMediumAction(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Action to take for a high risk.</p>
|
||||
*/
|
||||
inline const AccountTakeoverActionType& GetHighAction() const{ return m_highAction; }
|
||||
inline bool HighActionHasBeenSet() const { return m_highActionHasBeenSet; }
|
||||
inline void SetHighAction(const AccountTakeoverActionType& value) { m_highActionHasBeenSet = true; m_highAction = value; }
|
||||
inline void SetHighAction(AccountTakeoverActionType&& value) { m_highActionHasBeenSet = true; m_highAction = std::move(value); }
|
||||
inline AccountTakeoverActionsType& WithHighAction(const AccountTakeoverActionType& value) { SetHighAction(value); return *this;}
|
||||
inline AccountTakeoverActionsType& WithHighAction(AccountTakeoverActionType&& value) { SetHighAction(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
AccountTakeoverActionType m_lowAction;
|
||||
bool m_lowActionHasBeenSet = false;
|
||||
|
||||
AccountTakeoverActionType m_mediumAction;
|
||||
bool m_mediumActionHasBeenSet = false;
|
||||
|
||||
AccountTakeoverActionType m_highAction;
|
||||
bool m_highActionHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,33 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class AccountTakeoverEventActionType
|
||||
{
|
||||
NOT_SET,
|
||||
BLOCK,
|
||||
MFA_IF_CONFIGURED,
|
||||
MFA_REQUIRED,
|
||||
NO_ACTION
|
||||
};
|
||||
|
||||
namespace AccountTakeoverEventActionTypeMapper
|
||||
{
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AccountTakeoverEventActionType GetAccountTakeoverEventActionTypeForName(const Aws::String& name);
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String GetNameForAccountTakeoverEventActionType(AccountTakeoverEventActionType value);
|
||||
} // namespace AccountTakeoverEventActionTypeMapper
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,76 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/model/NotifyConfigurationType.h>
|
||||
#include <aws/cognito-idp/model/AccountTakeoverActionsType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Configuration for mitigation actions and notification for different levels of
|
||||
* risk detected for a potential account takeover.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AccountTakeoverRiskConfigurationType">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AccountTakeoverRiskConfigurationType
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AccountTakeoverRiskConfigurationType();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AccountTakeoverRiskConfigurationType(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AccountTakeoverRiskConfigurationType& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The notify configuration used to construct email notifications.</p>
|
||||
*/
|
||||
inline const NotifyConfigurationType& GetNotifyConfiguration() const{ return m_notifyConfiguration; }
|
||||
inline bool NotifyConfigurationHasBeenSet() const { return m_notifyConfigurationHasBeenSet; }
|
||||
inline void SetNotifyConfiguration(const NotifyConfigurationType& value) { m_notifyConfigurationHasBeenSet = true; m_notifyConfiguration = value; }
|
||||
inline void SetNotifyConfiguration(NotifyConfigurationType&& value) { m_notifyConfigurationHasBeenSet = true; m_notifyConfiguration = std::move(value); }
|
||||
inline AccountTakeoverRiskConfigurationType& WithNotifyConfiguration(const NotifyConfigurationType& value) { SetNotifyConfiguration(value); return *this;}
|
||||
inline AccountTakeoverRiskConfigurationType& WithNotifyConfiguration(NotifyConfigurationType&& value) { SetNotifyConfiguration(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Account takeover risk configuration actions.</p>
|
||||
*/
|
||||
inline const AccountTakeoverActionsType& GetActions() const{ return m_actions; }
|
||||
inline bool ActionsHasBeenSet() const { return m_actionsHasBeenSet; }
|
||||
inline void SetActions(const AccountTakeoverActionsType& value) { m_actionsHasBeenSet = true; m_actions = value; }
|
||||
inline void SetActions(AccountTakeoverActionsType&& value) { m_actionsHasBeenSet = true; m_actions = std::move(value); }
|
||||
inline AccountTakeoverRiskConfigurationType& WithActions(const AccountTakeoverActionsType& value) { SetActions(value); return *this;}
|
||||
inline AccountTakeoverRiskConfigurationType& WithActions(AccountTakeoverActionsType&& value) { SetActions(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
NotifyConfigurationType m_notifyConfiguration;
|
||||
bool m_notifyConfigurationHasBeenSet = false;
|
||||
|
||||
AccountTakeoverActionsType m_actions;
|
||||
bool m_actionsHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,82 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/cognito-idp/model/SchemaAttributeType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Represents the request to add custom attributes.</p><p><h3>See Also:</h3>
|
||||
* <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AddCustomAttributesRequest">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AddCustomAttributesRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AddCustomAttributesRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AddCustomAttributes"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user pool ID for the user pool where you want to add custom
|
||||
* attributes.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AddCustomAttributesRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AddCustomAttributesRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AddCustomAttributesRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>An array of custom attributes, such as Mutable and Name.</p>
|
||||
*/
|
||||
inline const Aws::Vector<SchemaAttributeType>& GetCustomAttributes() const{ return m_customAttributes; }
|
||||
inline bool CustomAttributesHasBeenSet() const { return m_customAttributesHasBeenSet; }
|
||||
inline void SetCustomAttributes(const Aws::Vector<SchemaAttributeType>& value) { m_customAttributesHasBeenSet = true; m_customAttributes = value; }
|
||||
inline void SetCustomAttributes(Aws::Vector<SchemaAttributeType>&& value) { m_customAttributesHasBeenSet = true; m_customAttributes = std::move(value); }
|
||||
inline AddCustomAttributesRequest& WithCustomAttributes(const Aws::Vector<SchemaAttributeType>& value) { SetCustomAttributes(value); return *this;}
|
||||
inline AddCustomAttributesRequest& WithCustomAttributes(Aws::Vector<SchemaAttributeType>&& value) { SetCustomAttributes(std::move(value)); return *this;}
|
||||
inline AddCustomAttributesRequest& AddCustomAttributes(const SchemaAttributeType& value) { m_customAttributesHasBeenSet = true; m_customAttributes.push_back(value); return *this; }
|
||||
inline AddCustomAttributesRequest& AddCustomAttributes(SchemaAttributeType&& value) { m_customAttributesHasBeenSet = true; m_customAttributes.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
Aws::Vector<SchemaAttributeType> m_customAttributes;
|
||||
bool m_customAttributesHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,58 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>Represents the response from the server for the request to add custom
|
||||
* attributes.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AddCustomAttributesResponse">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AddCustomAttributesResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AddCustomAttributesResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AddCustomAttributesResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AddCustomAttributesResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline AddCustomAttributesResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline AddCustomAttributesResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline AddCustomAttributesResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,96 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class AdminAddUserToGroupRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminAddUserToGroupRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AdminAddUserToGroup"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user pool ID for the user pool.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AdminAddUserToGroupRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AdminAddUserToGroupRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AdminAddUserToGroupRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The username of the user that you want to query or modify. The value of this
|
||||
* parameter is typically your user's username, but it can be any of their alias
|
||||
* attributes. If <code>username</code> isn't an alias attribute in your user pool,
|
||||
* this value must be the <code>sub</code> of a local user or the username of a
|
||||
* user from a third-party IdP.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUsername() const{ return m_username; }
|
||||
inline bool UsernameHasBeenSet() const { return m_usernameHasBeenSet; }
|
||||
inline void SetUsername(const Aws::String& value) { m_usernameHasBeenSet = true; m_username = value; }
|
||||
inline void SetUsername(Aws::String&& value) { m_usernameHasBeenSet = true; m_username = std::move(value); }
|
||||
inline void SetUsername(const char* value) { m_usernameHasBeenSet = true; m_username.assign(value); }
|
||||
inline AdminAddUserToGroupRequest& WithUsername(const Aws::String& value) { SetUsername(value); return *this;}
|
||||
inline AdminAddUserToGroupRequest& WithUsername(Aws::String&& value) { SetUsername(std::move(value)); return *this;}
|
||||
inline AdminAddUserToGroupRequest& WithUsername(const char* value) { SetUsername(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of the group that you want to add your user to.</p>
|
||||
*/
|
||||
inline const Aws::String& GetGroupName() const{ return m_groupName; }
|
||||
inline bool GroupNameHasBeenSet() const { return m_groupNameHasBeenSet; }
|
||||
inline void SetGroupName(const Aws::String& value) { m_groupNameHasBeenSet = true; m_groupName = value; }
|
||||
inline void SetGroupName(Aws::String&& value) { m_groupNameHasBeenSet = true; m_groupName = std::move(value); }
|
||||
inline void SetGroupName(const char* value) { m_groupNameHasBeenSet = true; m_groupName.assign(value); }
|
||||
inline AdminAddUserToGroupRequest& WithGroupName(const Aws::String& value) { SetGroupName(value); return *this;}
|
||||
inline AdminAddUserToGroupRequest& WithGroupName(Aws::String&& value) { SetGroupName(std::move(value)); return *this;}
|
||||
inline AdminAddUserToGroupRequest& WithGroupName(const char* value) { SetGroupName(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_username;
|
||||
bool m_usernameHasBeenSet = false;
|
||||
|
||||
Aws::String m_groupName;
|
||||
bool m_groupNameHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,125 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSMap.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Confirm a user's registration as a user pool administrator.</p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminConfirmSignUpRequest">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminConfirmSignUpRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminConfirmSignUpRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AdminConfirmSignUp"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user pool ID for which you want to confirm user registration.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AdminConfirmSignUpRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AdminConfirmSignUpRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AdminConfirmSignUpRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The username of the user that you want to query or modify. The value of this
|
||||
* parameter is typically your user's username, but it can be any of their alias
|
||||
* attributes. If <code>username</code> isn't an alias attribute in your user pool,
|
||||
* this value must be the <code>sub</code> of a local user or the username of a
|
||||
* user from a third-party IdP.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUsername() const{ return m_username; }
|
||||
inline bool UsernameHasBeenSet() const { return m_usernameHasBeenSet; }
|
||||
inline void SetUsername(const Aws::String& value) { m_usernameHasBeenSet = true; m_username = value; }
|
||||
inline void SetUsername(Aws::String&& value) { m_usernameHasBeenSet = true; m_username = std::move(value); }
|
||||
inline void SetUsername(const char* value) { m_usernameHasBeenSet = true; m_username.assign(value); }
|
||||
inline AdminConfirmSignUpRequest& WithUsername(const Aws::String& value) { SetUsername(value); return *this;}
|
||||
inline AdminConfirmSignUpRequest& WithUsername(Aws::String&& value) { SetUsername(std::move(value)); return *this;}
|
||||
inline AdminConfirmSignUpRequest& WithUsername(const char* value) { SetUsername(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A map of custom key-value pairs that you can provide as input for any custom
|
||||
* workflows that this action triggers.</p> <p>If your user pool configuration
|
||||
* includes triggers, the AdminConfirmSignUp API action invokes the Lambda function
|
||||
* that is specified for the <i>post confirmation</i> trigger. When Amazon Cognito
|
||||
* invokes this function, it passes a JSON payload, which the function receives as
|
||||
* input. In this payload, the <code>clientMetadata</code> attribute provides the
|
||||
* data that you assigned to the ClientMetadata parameter in your
|
||||
* AdminConfirmSignUp request. In your function code in Lambda, you can process the
|
||||
* ClientMetadata value to enhance your workflow for your specific needs.</p>
|
||||
* <p>For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html">
|
||||
* Customizing user pool Workflows with Lambda Triggers</a> in the <i>Amazon
|
||||
* Cognito Developer Guide</i>.</p> <p>When you use the ClientMetadata
|
||||
* parameter, remember that Amazon Cognito won't do the following:</p> <ul> <li>
|
||||
* <p>Store the ClientMetadata value. This data is available only to Lambda
|
||||
* triggers that are assigned to a user pool to support custom workflows. If your
|
||||
* user pool configuration doesn't include triggers, the ClientMetadata parameter
|
||||
* serves no purpose.</p> </li> <li> <p>Validate the ClientMetadata value.</p>
|
||||
* </li> <li> <p>Encrypt the ClientMetadata value. Don't use Amazon Cognito to
|
||||
* provide sensitive information.</p> </li> </ul>
|
||||
*/
|
||||
inline const Aws::Map<Aws::String, Aws::String>& GetClientMetadata() const{ return m_clientMetadata; }
|
||||
inline bool ClientMetadataHasBeenSet() const { return m_clientMetadataHasBeenSet; }
|
||||
inline void SetClientMetadata(const Aws::Map<Aws::String, Aws::String>& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata = value; }
|
||||
inline void SetClientMetadata(Aws::Map<Aws::String, Aws::String>&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata = std::move(value); }
|
||||
inline AdminConfirmSignUpRequest& WithClientMetadata(const Aws::Map<Aws::String, Aws::String>& value) { SetClientMetadata(value); return *this;}
|
||||
inline AdminConfirmSignUpRequest& WithClientMetadata(Aws::Map<Aws::String, Aws::String>&& value) { SetClientMetadata(std::move(value)); return *this;}
|
||||
inline AdminConfirmSignUpRequest& AddClientMetadata(const Aws::String& key, const Aws::String& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, value); return *this; }
|
||||
inline AdminConfirmSignUpRequest& AddClientMetadata(Aws::String&& key, const Aws::String& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(std::move(key), value); return *this; }
|
||||
inline AdminConfirmSignUpRequest& AddClientMetadata(const Aws::String& key, Aws::String&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, std::move(value)); return *this; }
|
||||
inline AdminConfirmSignUpRequest& AddClientMetadata(Aws::String&& key, Aws::String&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(std::move(key), std::move(value)); return *this; }
|
||||
inline AdminConfirmSignUpRequest& AddClientMetadata(const char* key, Aws::String&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, std::move(value)); return *this; }
|
||||
inline AdminConfirmSignUpRequest& AddClientMetadata(Aws::String&& key, const char* value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(std::move(key), value); return *this; }
|
||||
inline AdminConfirmSignUpRequest& AddClientMetadata(const char* key, const char* value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, value); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_username;
|
||||
bool m_usernameHasBeenSet = false;
|
||||
|
||||
Aws::Map<Aws::String, Aws::String> m_clientMetadata;
|
||||
bool m_clientMetadataHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,58 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>Represents the response from the server for the request to confirm
|
||||
* registration.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminConfirmSignUpResponse">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminConfirmSignUpResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminConfirmSignUpResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminConfirmSignUpResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminConfirmSignUpResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline AdminConfirmSignUpResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline AdminConfirmSignUpResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline AdminConfirmSignUpResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,98 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/model/MessageTemplateType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The configuration for creating a new user profile.</p><p><h3>See Also:</h3>
|
||||
* <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminCreateUserConfigType">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminCreateUserConfigType
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminCreateUserConfigType();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminCreateUserConfigType(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminCreateUserConfigType& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Set to <code>True</code> if only the administrator is allowed to create user
|
||||
* profiles. Set to <code>False</code> if users can sign themselves up via an
|
||||
* app.</p>
|
||||
*/
|
||||
inline bool GetAllowAdminCreateUserOnly() const{ return m_allowAdminCreateUserOnly; }
|
||||
inline bool AllowAdminCreateUserOnlyHasBeenSet() const { return m_allowAdminCreateUserOnlyHasBeenSet; }
|
||||
inline void SetAllowAdminCreateUserOnly(bool value) { m_allowAdminCreateUserOnlyHasBeenSet = true; m_allowAdminCreateUserOnly = value; }
|
||||
inline AdminCreateUserConfigType& WithAllowAdminCreateUserOnly(bool value) { SetAllowAdminCreateUserOnly(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user account expiration limit, in days, after which a new account that
|
||||
* hasn't signed in is no longer usable. To reset the account after that time
|
||||
* limit, you must call <code>AdminCreateUser</code> again, specifying
|
||||
* <code>"RESEND"</code> for the <code>MessageAction</code> parameter. The default
|
||||
* value for this parameter is 7.</p> <p>If you set a value for
|
||||
* <code>TemporaryPasswordValidityDays</code> in <code>PasswordPolicy</code>, that
|
||||
* value will be used, and <code>UnusedAccountValidityDays</code> will be no longer
|
||||
* be an available parameter for that user pool.</p>
|
||||
*/
|
||||
inline int GetUnusedAccountValidityDays() const{ return m_unusedAccountValidityDays; }
|
||||
inline bool UnusedAccountValidityDaysHasBeenSet() const { return m_unusedAccountValidityDaysHasBeenSet; }
|
||||
inline void SetUnusedAccountValidityDays(int value) { m_unusedAccountValidityDaysHasBeenSet = true; m_unusedAccountValidityDays = value; }
|
||||
inline AdminCreateUserConfigType& WithUnusedAccountValidityDays(int value) { SetUnusedAccountValidityDays(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The message template to be used for the welcome message to new users.</p>
|
||||
* <p>See also <a
|
||||
* href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pool-settings-message-customizations.html#cognito-user-pool-settings-user-invitation-message-customization">Customizing
|
||||
* User Invitation Messages</a>.</p>
|
||||
*/
|
||||
inline const MessageTemplateType& GetInviteMessageTemplate() const{ return m_inviteMessageTemplate; }
|
||||
inline bool InviteMessageTemplateHasBeenSet() const { return m_inviteMessageTemplateHasBeenSet; }
|
||||
inline void SetInviteMessageTemplate(const MessageTemplateType& value) { m_inviteMessageTemplateHasBeenSet = true; m_inviteMessageTemplate = value; }
|
||||
inline void SetInviteMessageTemplate(MessageTemplateType&& value) { m_inviteMessageTemplateHasBeenSet = true; m_inviteMessageTemplate = std::move(value); }
|
||||
inline AdminCreateUserConfigType& WithInviteMessageTemplate(const MessageTemplateType& value) { SetInviteMessageTemplate(value); return *this;}
|
||||
inline AdminCreateUserConfigType& WithInviteMessageTemplate(MessageTemplateType&& value) { SetInviteMessageTemplate(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
bool m_allowAdminCreateUserOnly;
|
||||
bool m_allowAdminCreateUserOnlyHasBeenSet = false;
|
||||
|
||||
int m_unusedAccountValidityDays;
|
||||
bool m_unusedAccountValidityDaysHasBeenSet = false;
|
||||
|
||||
MessageTemplateType m_inviteMessageTemplate;
|
||||
bool m_inviteMessageTemplateHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,287 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/cognito-idp/model/MessageActionType.h>
|
||||
#include <aws/core/utils/memory/stl/AWSMap.h>
|
||||
#include <aws/cognito-idp/model/AttributeType.h>
|
||||
#include <aws/cognito-idp/model/DeliveryMediumType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Represents the request to create a user in the specified user
|
||||
* pool.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminCreateUserRequest">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminCreateUserRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminCreateUserRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AdminCreateUser"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user pool ID for the user pool where the user will be created.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AdminCreateUserRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AdminCreateUserRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AdminCreateUserRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The value that you want to set as the username sign-in attribute. The
|
||||
* following conditions apply to the username parameter.</p> <ul> <li> <p>The
|
||||
* username can't be a duplicate of another username in the same user pool.</p>
|
||||
* </li> <li> <p>You can't change the value of a username after you create it.</p>
|
||||
* </li> <li> <p>You can only provide a value if usernames are a valid sign-in
|
||||
* attribute for your user pool. If your user pool only supports phone numbers or
|
||||
* email addresses as sign-in attributes, Amazon Cognito automatically generates a
|
||||
* username value. For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/cognito/latest/developerguide/user-pool-settings-attributes.html#user-pool-settings-aliases">Customizing
|
||||
* sign-in attributes</a>.</p> </li> </ul>
|
||||
*/
|
||||
inline const Aws::String& GetUsername() const{ return m_username; }
|
||||
inline bool UsernameHasBeenSet() const { return m_usernameHasBeenSet; }
|
||||
inline void SetUsername(const Aws::String& value) { m_usernameHasBeenSet = true; m_username = value; }
|
||||
inline void SetUsername(Aws::String&& value) { m_usernameHasBeenSet = true; m_username = std::move(value); }
|
||||
inline void SetUsername(const char* value) { m_usernameHasBeenSet = true; m_username.assign(value); }
|
||||
inline AdminCreateUserRequest& WithUsername(const Aws::String& value) { SetUsername(value); return *this;}
|
||||
inline AdminCreateUserRequest& WithUsername(Aws::String&& value) { SetUsername(std::move(value)); return *this;}
|
||||
inline AdminCreateUserRequest& WithUsername(const char* value) { SetUsername(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>An array of name-value pairs that contain user attributes and attribute
|
||||
* values to be set for the user to be created. You can create a user without
|
||||
* specifying any attributes other than <code>Username</code>. However, any
|
||||
* attributes that you specify as required (when creating a user pool or in the
|
||||
* <b>Attributes</b> tab of the console) either you should supply (in your call to
|
||||
* <code>AdminCreateUser</code>) or the user should supply (when they sign up in
|
||||
* response to your welcome message).</p> <p>For custom attributes, you must
|
||||
* prepend the <code>custom:</code> prefix to the attribute name.</p> <p>To send a
|
||||
* message inviting the user to sign up, you must specify the user's email address
|
||||
* or phone number. You can do this in your call to AdminCreateUser or in the
|
||||
* <b>Users</b> tab of the Amazon Cognito console for managing your user pools.</p>
|
||||
* <p>In your call to <code>AdminCreateUser</code>, you can set the
|
||||
* <code>email_verified</code> attribute to <code>True</code>, and you can set the
|
||||
* <code>phone_number_verified</code> attribute to <code>True</code>. You can also
|
||||
* do this by calling <a
|
||||
* href="https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminUpdateUserAttributes.html">AdminUpdateUserAttributes</a>.</p>
|
||||
* <ul> <li> <p> <b>email</b>: The email address of the user to whom the message
|
||||
* that contains the code and username will be sent. Required if the
|
||||
* <code>email_verified</code> attribute is set to <code>True</code>, or if
|
||||
* <code>"EMAIL"</code> is specified in the <code>DesiredDeliveryMediums</code>
|
||||
* parameter.</p> </li> <li> <p> <b>phone_number</b>: The phone number of the user
|
||||
* to whom the message that contains the code and username will be sent. Required
|
||||
* if the <code>phone_number_verified</code> attribute is set to <code>True</code>,
|
||||
* or if <code>"SMS"</code> is specified in the <code>DesiredDeliveryMediums</code>
|
||||
* parameter.</p> </li> </ul>
|
||||
*/
|
||||
inline const Aws::Vector<AttributeType>& GetUserAttributes() const{ return m_userAttributes; }
|
||||
inline bool UserAttributesHasBeenSet() const { return m_userAttributesHasBeenSet; }
|
||||
inline void SetUserAttributes(const Aws::Vector<AttributeType>& value) { m_userAttributesHasBeenSet = true; m_userAttributes = value; }
|
||||
inline void SetUserAttributes(Aws::Vector<AttributeType>&& value) { m_userAttributesHasBeenSet = true; m_userAttributes = std::move(value); }
|
||||
inline AdminCreateUserRequest& WithUserAttributes(const Aws::Vector<AttributeType>& value) { SetUserAttributes(value); return *this;}
|
||||
inline AdminCreateUserRequest& WithUserAttributes(Aws::Vector<AttributeType>&& value) { SetUserAttributes(std::move(value)); return *this;}
|
||||
inline AdminCreateUserRequest& AddUserAttributes(const AttributeType& value) { m_userAttributesHasBeenSet = true; m_userAttributes.push_back(value); return *this; }
|
||||
inline AdminCreateUserRequest& AddUserAttributes(AttributeType&& value) { m_userAttributesHasBeenSet = true; m_userAttributes.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Temporary user attributes that contribute to the outcomes of your pre sign-up
|
||||
* Lambda trigger. This set of key-value pairs are for custom validation of
|
||||
* information that you collect from your users but don't need to retain.</p>
|
||||
* <p>Your Lambda function can analyze this additional data and act on it. Your
|
||||
* function might perform external API operations like logging user attributes and
|
||||
* validation data to Amazon CloudWatch Logs. Validation data might also affect the
|
||||
* response that your function returns to Amazon Cognito, like automatically
|
||||
* confirming the user if they sign up from within your network.</p> <p>For more
|
||||
* information about the pre sign-up Lambda trigger, see <a
|
||||
* href="https://docs.aws.amazon.com/cognito/latest/developerguide/user-pool-lambda-pre-sign-up.html">Pre
|
||||
* sign-up Lambda trigger</a>.</p>
|
||||
*/
|
||||
inline const Aws::Vector<AttributeType>& GetValidationData() const{ return m_validationData; }
|
||||
inline bool ValidationDataHasBeenSet() const { return m_validationDataHasBeenSet; }
|
||||
inline void SetValidationData(const Aws::Vector<AttributeType>& value) { m_validationDataHasBeenSet = true; m_validationData = value; }
|
||||
inline void SetValidationData(Aws::Vector<AttributeType>&& value) { m_validationDataHasBeenSet = true; m_validationData = std::move(value); }
|
||||
inline AdminCreateUserRequest& WithValidationData(const Aws::Vector<AttributeType>& value) { SetValidationData(value); return *this;}
|
||||
inline AdminCreateUserRequest& WithValidationData(Aws::Vector<AttributeType>&& value) { SetValidationData(std::move(value)); return *this;}
|
||||
inline AdminCreateUserRequest& AddValidationData(const AttributeType& value) { m_validationDataHasBeenSet = true; m_validationData.push_back(value); return *this; }
|
||||
inline AdminCreateUserRequest& AddValidationData(AttributeType&& value) { m_validationDataHasBeenSet = true; m_validationData.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user's temporary password. This password must conform to the password
|
||||
* policy that you specified when you created the user pool.</p> <p>The temporary
|
||||
* password is valid only once. To complete the Admin Create User flow, the user
|
||||
* must enter the temporary password in the sign-in page, along with a new password
|
||||
* to be used in all future sign-ins.</p> <p>This parameter isn't required. If you
|
||||
* don't specify a value, Amazon Cognito generates one for you.</p> <p>The
|
||||
* temporary password can only be used until the user account expiration limit that
|
||||
* you set for your user pool. To reset the account after that time limit, you must
|
||||
* call <code>AdminCreateUser</code> again and specify <code>RESEND</code> for the
|
||||
* <code>MessageAction</code> parameter.</p>
|
||||
*/
|
||||
inline const Aws::String& GetTemporaryPassword() const{ return m_temporaryPassword; }
|
||||
inline bool TemporaryPasswordHasBeenSet() const { return m_temporaryPasswordHasBeenSet; }
|
||||
inline void SetTemporaryPassword(const Aws::String& value) { m_temporaryPasswordHasBeenSet = true; m_temporaryPassword = value; }
|
||||
inline void SetTemporaryPassword(Aws::String&& value) { m_temporaryPasswordHasBeenSet = true; m_temporaryPassword = std::move(value); }
|
||||
inline void SetTemporaryPassword(const char* value) { m_temporaryPasswordHasBeenSet = true; m_temporaryPassword.assign(value); }
|
||||
inline AdminCreateUserRequest& WithTemporaryPassword(const Aws::String& value) { SetTemporaryPassword(value); return *this;}
|
||||
inline AdminCreateUserRequest& WithTemporaryPassword(Aws::String&& value) { SetTemporaryPassword(std::move(value)); return *this;}
|
||||
inline AdminCreateUserRequest& WithTemporaryPassword(const char* value) { SetTemporaryPassword(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>This parameter is used only if the <code>phone_number_verified</code> or
|
||||
* <code>email_verified</code> attribute is set to <code>True</code>. Otherwise, it
|
||||
* is ignored.</p> <p>If this parameter is set to <code>True</code> and the phone
|
||||
* number or email address specified in the UserAttributes parameter already exists
|
||||
* as an alias with a different user, the API call will migrate the alias from the
|
||||
* previous user to the newly created user. The previous user will no longer be
|
||||
* able to log in using that alias.</p> <p>If this parameter is set to
|
||||
* <code>False</code>, the API throws an <code>AliasExistsException</code> error if
|
||||
* the alias already exists. The default value is <code>False</code>.</p>
|
||||
*/
|
||||
inline bool GetForceAliasCreation() const{ return m_forceAliasCreation; }
|
||||
inline bool ForceAliasCreationHasBeenSet() const { return m_forceAliasCreationHasBeenSet; }
|
||||
inline void SetForceAliasCreation(bool value) { m_forceAliasCreationHasBeenSet = true; m_forceAliasCreation = value; }
|
||||
inline AdminCreateUserRequest& WithForceAliasCreation(bool value) { SetForceAliasCreation(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Set to <code>RESEND</code> to resend the invitation message to a user that
|
||||
* already exists and reset the expiration limit on the user's account. Set to
|
||||
* <code>SUPPRESS</code> to suppress sending the message. You can specify only one
|
||||
* value.</p>
|
||||
*/
|
||||
inline const MessageActionType& GetMessageAction() const{ return m_messageAction; }
|
||||
inline bool MessageActionHasBeenSet() const { return m_messageActionHasBeenSet; }
|
||||
inline void SetMessageAction(const MessageActionType& value) { m_messageActionHasBeenSet = true; m_messageAction = value; }
|
||||
inline void SetMessageAction(MessageActionType&& value) { m_messageActionHasBeenSet = true; m_messageAction = std::move(value); }
|
||||
inline AdminCreateUserRequest& WithMessageAction(const MessageActionType& value) { SetMessageAction(value); return *this;}
|
||||
inline AdminCreateUserRequest& WithMessageAction(MessageActionType&& value) { SetMessageAction(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Specify <code>"EMAIL"</code> if email will be used to send the welcome
|
||||
* message. Specify <code>"SMS"</code> if the phone number will be used. The
|
||||
* default value is <code>"SMS"</code>. You can specify more than one value.</p>
|
||||
*/
|
||||
inline const Aws::Vector<DeliveryMediumType>& GetDesiredDeliveryMediums() const{ return m_desiredDeliveryMediums; }
|
||||
inline bool DesiredDeliveryMediumsHasBeenSet() const { return m_desiredDeliveryMediumsHasBeenSet; }
|
||||
inline void SetDesiredDeliveryMediums(const Aws::Vector<DeliveryMediumType>& value) { m_desiredDeliveryMediumsHasBeenSet = true; m_desiredDeliveryMediums = value; }
|
||||
inline void SetDesiredDeliveryMediums(Aws::Vector<DeliveryMediumType>&& value) { m_desiredDeliveryMediumsHasBeenSet = true; m_desiredDeliveryMediums = std::move(value); }
|
||||
inline AdminCreateUserRequest& WithDesiredDeliveryMediums(const Aws::Vector<DeliveryMediumType>& value) { SetDesiredDeliveryMediums(value); return *this;}
|
||||
inline AdminCreateUserRequest& WithDesiredDeliveryMediums(Aws::Vector<DeliveryMediumType>&& value) { SetDesiredDeliveryMediums(std::move(value)); return *this;}
|
||||
inline AdminCreateUserRequest& AddDesiredDeliveryMediums(const DeliveryMediumType& value) { m_desiredDeliveryMediumsHasBeenSet = true; m_desiredDeliveryMediums.push_back(value); return *this; }
|
||||
inline AdminCreateUserRequest& AddDesiredDeliveryMediums(DeliveryMediumType&& value) { m_desiredDeliveryMediumsHasBeenSet = true; m_desiredDeliveryMediums.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A map of custom key-value pairs that you can provide as input for any custom
|
||||
* workflows that this action triggers.</p> <p>You create custom workflows by
|
||||
* assigning Lambda functions to user pool triggers. When you use the
|
||||
* AdminCreateUser API action, Amazon Cognito invokes the function that is assigned
|
||||
* to the <i>pre sign-up</i> trigger. When Amazon Cognito invokes this function, it
|
||||
* passes a JSON payload, which the function receives as input. This payload
|
||||
* contains a <code>clientMetadata</code> attribute, which provides the data that
|
||||
* you assigned to the ClientMetadata parameter in your AdminCreateUser request. In
|
||||
* your function code in Lambda, you can process the <code>clientMetadata</code>
|
||||
* value to enhance your workflow for your specific needs.</p> <p>For more
|
||||
* information, see <a
|
||||
* href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html">
|
||||
* Customizing user pool Workflows with Lambda Triggers</a> in the <i>Amazon
|
||||
* Cognito Developer Guide</i>.</p> <p>When you use the ClientMetadata
|
||||
* parameter, remember that Amazon Cognito won't do the following:</p> <ul> <li>
|
||||
* <p>Store the ClientMetadata value. This data is available only to Lambda
|
||||
* triggers that are assigned to a user pool to support custom workflows. If your
|
||||
* user pool configuration doesn't include triggers, the ClientMetadata parameter
|
||||
* serves no purpose.</p> </li> <li> <p>Validate the ClientMetadata value.</p>
|
||||
* </li> <li> <p>Encrypt the ClientMetadata value. Don't use Amazon Cognito to
|
||||
* provide sensitive information.</p> </li> </ul>
|
||||
*/
|
||||
inline const Aws::Map<Aws::String, Aws::String>& GetClientMetadata() const{ return m_clientMetadata; }
|
||||
inline bool ClientMetadataHasBeenSet() const { return m_clientMetadataHasBeenSet; }
|
||||
inline void SetClientMetadata(const Aws::Map<Aws::String, Aws::String>& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata = value; }
|
||||
inline void SetClientMetadata(Aws::Map<Aws::String, Aws::String>&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata = std::move(value); }
|
||||
inline AdminCreateUserRequest& WithClientMetadata(const Aws::Map<Aws::String, Aws::String>& value) { SetClientMetadata(value); return *this;}
|
||||
inline AdminCreateUserRequest& WithClientMetadata(Aws::Map<Aws::String, Aws::String>&& value) { SetClientMetadata(std::move(value)); return *this;}
|
||||
inline AdminCreateUserRequest& AddClientMetadata(const Aws::String& key, const Aws::String& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, value); return *this; }
|
||||
inline AdminCreateUserRequest& AddClientMetadata(Aws::String&& key, const Aws::String& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(std::move(key), value); return *this; }
|
||||
inline AdminCreateUserRequest& AddClientMetadata(const Aws::String& key, Aws::String&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, std::move(value)); return *this; }
|
||||
inline AdminCreateUserRequest& AddClientMetadata(Aws::String&& key, Aws::String&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(std::move(key), std::move(value)); return *this; }
|
||||
inline AdminCreateUserRequest& AddClientMetadata(const char* key, Aws::String&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, std::move(value)); return *this; }
|
||||
inline AdminCreateUserRequest& AddClientMetadata(Aws::String&& key, const char* value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(std::move(key), value); return *this; }
|
||||
inline AdminCreateUserRequest& AddClientMetadata(const char* key, const char* value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, value); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_username;
|
||||
bool m_usernameHasBeenSet = false;
|
||||
|
||||
Aws::Vector<AttributeType> m_userAttributes;
|
||||
bool m_userAttributesHasBeenSet = false;
|
||||
|
||||
Aws::Vector<AttributeType> m_validationData;
|
||||
bool m_validationDataHasBeenSet = false;
|
||||
|
||||
Aws::String m_temporaryPassword;
|
||||
bool m_temporaryPasswordHasBeenSet = false;
|
||||
|
||||
bool m_forceAliasCreation;
|
||||
bool m_forceAliasCreationHasBeenSet = false;
|
||||
|
||||
MessageActionType m_messageAction;
|
||||
bool m_messageActionHasBeenSet = false;
|
||||
|
||||
Aws::Vector<DeliveryMediumType> m_desiredDeliveryMediums;
|
||||
bool m_desiredDeliveryMediumsHasBeenSet = false;
|
||||
|
||||
Aws::Map<Aws::String, Aws::String> m_clientMetadata;
|
||||
bool m_clientMetadataHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,72 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/model/UserType.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>Represents the response from the server to the request to create the
|
||||
* user.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminCreateUserResponse">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminCreateUserResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminCreateUserResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminCreateUserResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminCreateUserResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The newly created user.</p>
|
||||
*/
|
||||
inline const UserType& GetUser() const{ return m_user; }
|
||||
inline void SetUser(const UserType& value) { m_user = value; }
|
||||
inline void SetUser(UserType&& value) { m_user = std::move(value); }
|
||||
inline AdminCreateUserResult& WithUser(const UserType& value) { SetUser(value); return *this;}
|
||||
inline AdminCreateUserResult& WithUser(UserType&& value) { SetUser(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline AdminCreateUserResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline AdminCreateUserResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline AdminCreateUserResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
UserType m_user;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,105 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Represents the request to delete user attributes as an
|
||||
* administrator.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminDeleteUserAttributesRequest">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminDeleteUserAttributesRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminDeleteUserAttributesRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AdminDeleteUserAttributes"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user pool ID for the user pool where you want to delete user
|
||||
* attributes.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AdminDeleteUserAttributesRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AdminDeleteUserAttributesRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AdminDeleteUserAttributesRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The username of the user that you want to query or modify. The value of this
|
||||
* parameter is typically your user's username, but it can be any of their alias
|
||||
* attributes. If <code>username</code> isn't an alias attribute in your user pool,
|
||||
* this value must be the <code>sub</code> of a local user or the username of a
|
||||
* user from a third-party IdP.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUsername() const{ return m_username; }
|
||||
inline bool UsernameHasBeenSet() const { return m_usernameHasBeenSet; }
|
||||
inline void SetUsername(const Aws::String& value) { m_usernameHasBeenSet = true; m_username = value; }
|
||||
inline void SetUsername(Aws::String&& value) { m_usernameHasBeenSet = true; m_username = std::move(value); }
|
||||
inline void SetUsername(const char* value) { m_usernameHasBeenSet = true; m_username.assign(value); }
|
||||
inline AdminDeleteUserAttributesRequest& WithUsername(const Aws::String& value) { SetUsername(value); return *this;}
|
||||
inline AdminDeleteUserAttributesRequest& WithUsername(Aws::String&& value) { SetUsername(std::move(value)); return *this;}
|
||||
inline AdminDeleteUserAttributesRequest& WithUsername(const char* value) { SetUsername(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>An array of strings representing the user attribute names you want to
|
||||
* delete.</p> <p>For custom attributes, you must prepend the <code>custom:</code>
|
||||
* prefix to the attribute name.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetUserAttributeNames() const{ return m_userAttributeNames; }
|
||||
inline bool UserAttributeNamesHasBeenSet() const { return m_userAttributeNamesHasBeenSet; }
|
||||
inline void SetUserAttributeNames(const Aws::Vector<Aws::String>& value) { m_userAttributeNamesHasBeenSet = true; m_userAttributeNames = value; }
|
||||
inline void SetUserAttributeNames(Aws::Vector<Aws::String>&& value) { m_userAttributeNamesHasBeenSet = true; m_userAttributeNames = std::move(value); }
|
||||
inline AdminDeleteUserAttributesRequest& WithUserAttributeNames(const Aws::Vector<Aws::String>& value) { SetUserAttributeNames(value); return *this;}
|
||||
inline AdminDeleteUserAttributesRequest& WithUserAttributeNames(Aws::Vector<Aws::String>&& value) { SetUserAttributeNames(std::move(value)); return *this;}
|
||||
inline AdminDeleteUserAttributesRequest& AddUserAttributeNames(const Aws::String& value) { m_userAttributeNamesHasBeenSet = true; m_userAttributeNames.push_back(value); return *this; }
|
||||
inline AdminDeleteUserAttributesRequest& AddUserAttributeNames(Aws::String&& value) { m_userAttributeNamesHasBeenSet = true; m_userAttributeNames.push_back(std::move(value)); return *this; }
|
||||
inline AdminDeleteUserAttributesRequest& AddUserAttributeNames(const char* value) { m_userAttributeNamesHasBeenSet = true; m_userAttributeNames.push_back(value); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_username;
|
||||
bool m_usernameHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Aws::String> m_userAttributeNames;
|
||||
bool m_userAttributeNamesHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,58 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>Represents the response received from the server for a request to delete user
|
||||
* attributes.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminDeleteUserAttributesResponse">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminDeleteUserAttributesResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminDeleteUserAttributesResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminDeleteUserAttributesResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminDeleteUserAttributesResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline AdminDeleteUserAttributesResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline AdminDeleteUserAttributesResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline AdminDeleteUserAttributesResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,83 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Represents the request to delete a user as an administrator.</p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminDeleteUserRequest">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminDeleteUserRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminDeleteUserRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AdminDeleteUser"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user pool ID for the user pool where you want to delete the user.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AdminDeleteUserRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AdminDeleteUserRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AdminDeleteUserRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The username of the user that you want to query or modify. The value of this
|
||||
* parameter is typically your user's username, but it can be any of their alias
|
||||
* attributes. If <code>username</code> isn't an alias attribute in your user pool,
|
||||
* this value must be the <code>sub</code> of a local user or the username of a
|
||||
* user from a third-party IdP.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUsername() const{ return m_username; }
|
||||
inline bool UsernameHasBeenSet() const { return m_usernameHasBeenSet; }
|
||||
inline void SetUsername(const Aws::String& value) { m_usernameHasBeenSet = true; m_username = value; }
|
||||
inline void SetUsername(Aws::String&& value) { m_usernameHasBeenSet = true; m_username = std::move(value); }
|
||||
inline void SetUsername(const char* value) { m_usernameHasBeenSet = true; m_username.assign(value); }
|
||||
inline AdminDeleteUserRequest& WithUsername(const Aws::String& value) { SetUsername(value); return *this;}
|
||||
inline AdminDeleteUserRequest& WithUsername(Aws::String&& value) { SetUsername(std::move(value)); return *this;}
|
||||
inline AdminDeleteUserRequest& WithUsername(const char* value) { SetUsername(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_username;
|
||||
bool m_usernameHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,74 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cognito-idp/model/ProviderUserIdentifierType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class AdminDisableProviderForUserRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminDisableProviderForUserRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AdminDisableProviderForUser"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user pool ID for the user pool.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AdminDisableProviderForUserRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AdminDisableProviderForUserRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AdminDisableProviderForUserRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user to be disabled.</p>
|
||||
*/
|
||||
inline const ProviderUserIdentifierType& GetUser() const{ return m_user; }
|
||||
inline bool UserHasBeenSet() const { return m_userHasBeenSet; }
|
||||
inline void SetUser(const ProviderUserIdentifierType& value) { m_userHasBeenSet = true; m_user = value; }
|
||||
inline void SetUser(ProviderUserIdentifierType&& value) { m_userHasBeenSet = true; m_user = std::move(value); }
|
||||
inline AdminDisableProviderForUserRequest& WithUser(const ProviderUserIdentifierType& value) { SetUser(value); return *this;}
|
||||
inline AdminDisableProviderForUserRequest& WithUser(ProviderUserIdentifierType&& value) { SetUser(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
ProviderUserIdentifierType m_user;
|
||||
bool m_userHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,52 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class AdminDisableProviderForUserResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminDisableProviderForUserResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminDisableProviderForUserResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminDisableProviderForUserResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline AdminDisableProviderForUserResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline AdminDisableProviderForUserResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline AdminDisableProviderForUserResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,83 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Represents the request to disable the user as an administrator.</p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminDisableUserRequest">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminDisableUserRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminDisableUserRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AdminDisableUser"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user pool ID for the user pool where you want to disable the user.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AdminDisableUserRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AdminDisableUserRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AdminDisableUserRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The username of the user that you want to query or modify. The value of this
|
||||
* parameter is typically your user's username, but it can be any of their alias
|
||||
* attributes. If <code>username</code> isn't an alias attribute in your user pool,
|
||||
* this value must be the <code>sub</code> of a local user or the username of a
|
||||
* user from a third-party IdP.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUsername() const{ return m_username; }
|
||||
inline bool UsernameHasBeenSet() const { return m_usernameHasBeenSet; }
|
||||
inline void SetUsername(const Aws::String& value) { m_usernameHasBeenSet = true; m_username = value; }
|
||||
inline void SetUsername(Aws::String&& value) { m_usernameHasBeenSet = true; m_username = std::move(value); }
|
||||
inline void SetUsername(const char* value) { m_usernameHasBeenSet = true; m_username.assign(value); }
|
||||
inline AdminDisableUserRequest& WithUsername(const Aws::String& value) { SetUsername(value); return *this;}
|
||||
inline AdminDisableUserRequest& WithUsername(Aws::String&& value) { SetUsername(std::move(value)); return *this;}
|
||||
inline AdminDisableUserRequest& WithUsername(const char* value) { SetUsername(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_username;
|
||||
bool m_usernameHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,58 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>Represents the response received from the server to disable the user as an
|
||||
* administrator.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminDisableUserResponse">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminDisableUserResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminDisableUserResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminDisableUserResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminDisableUserResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline AdminDisableUserResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline AdminDisableUserResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline AdminDisableUserResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,83 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Represents the request that enables the user as an
|
||||
* administrator.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminEnableUserRequest">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminEnableUserRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminEnableUserRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AdminEnableUser"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user pool ID for the user pool where you want to enable the user.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AdminEnableUserRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AdminEnableUserRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AdminEnableUserRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The username of the user that you want to query or modify. The value of this
|
||||
* parameter is typically your user's username, but it can be any of their alias
|
||||
* attributes. If <code>username</code> isn't an alias attribute in your user pool,
|
||||
* this value must be the <code>sub</code> of a local user or the username of a
|
||||
* user from a third-party IdP.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUsername() const{ return m_username; }
|
||||
inline bool UsernameHasBeenSet() const { return m_usernameHasBeenSet; }
|
||||
inline void SetUsername(const Aws::String& value) { m_usernameHasBeenSet = true; m_username = value; }
|
||||
inline void SetUsername(Aws::String&& value) { m_usernameHasBeenSet = true; m_username = std::move(value); }
|
||||
inline void SetUsername(const char* value) { m_usernameHasBeenSet = true; m_username.assign(value); }
|
||||
inline AdminEnableUserRequest& WithUsername(const Aws::String& value) { SetUsername(value); return *this;}
|
||||
inline AdminEnableUserRequest& WithUsername(Aws::String&& value) { SetUsername(std::move(value)); return *this;}
|
||||
inline AdminEnableUserRequest& WithUsername(const char* value) { SetUsername(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_username;
|
||||
bool m_usernameHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,58 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>Represents the response from the server for the request to enable a user as
|
||||
* an administrator.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminEnableUserResponse">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminEnableUserResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminEnableUserResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminEnableUserResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminEnableUserResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline AdminEnableUserResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline AdminEnableUserResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline AdminEnableUserResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,100 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Sends the forgot device request, as an administrator.</p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminForgetDeviceRequest">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminForgetDeviceRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminForgetDeviceRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AdminForgetDevice"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user pool ID.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AdminForgetDeviceRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AdminForgetDeviceRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AdminForgetDeviceRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The username of the user that you want to query or modify. The value of this
|
||||
* parameter is typically your user's username, but it can be any of their alias
|
||||
* attributes. If <code>username</code> isn't an alias attribute in your user pool,
|
||||
* this value must be the <code>sub</code> of a local user or the username of a
|
||||
* user from a third-party IdP.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUsername() const{ return m_username; }
|
||||
inline bool UsernameHasBeenSet() const { return m_usernameHasBeenSet; }
|
||||
inline void SetUsername(const Aws::String& value) { m_usernameHasBeenSet = true; m_username = value; }
|
||||
inline void SetUsername(Aws::String&& value) { m_usernameHasBeenSet = true; m_username = std::move(value); }
|
||||
inline void SetUsername(const char* value) { m_usernameHasBeenSet = true; m_username.assign(value); }
|
||||
inline AdminForgetDeviceRequest& WithUsername(const Aws::String& value) { SetUsername(value); return *this;}
|
||||
inline AdminForgetDeviceRequest& WithUsername(Aws::String&& value) { SetUsername(std::move(value)); return *this;}
|
||||
inline AdminForgetDeviceRequest& WithUsername(const char* value) { SetUsername(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The device key.</p>
|
||||
*/
|
||||
inline const Aws::String& GetDeviceKey() const{ return m_deviceKey; }
|
||||
inline bool DeviceKeyHasBeenSet() const { return m_deviceKeyHasBeenSet; }
|
||||
inline void SetDeviceKey(const Aws::String& value) { m_deviceKeyHasBeenSet = true; m_deviceKey = value; }
|
||||
inline void SetDeviceKey(Aws::String&& value) { m_deviceKeyHasBeenSet = true; m_deviceKey = std::move(value); }
|
||||
inline void SetDeviceKey(const char* value) { m_deviceKeyHasBeenSet = true; m_deviceKey.assign(value); }
|
||||
inline AdminForgetDeviceRequest& WithDeviceKey(const Aws::String& value) { SetDeviceKey(value); return *this;}
|
||||
inline AdminForgetDeviceRequest& WithDeviceKey(Aws::String&& value) { SetDeviceKey(std::move(value)); return *this;}
|
||||
inline AdminForgetDeviceRequest& WithDeviceKey(const char* value) { SetDeviceKey(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_username;
|
||||
bool m_usernameHasBeenSet = false;
|
||||
|
||||
Aws::String m_deviceKey;
|
||||
bool m_deviceKeyHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,100 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Represents the request to get the device, as an administrator.</p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminGetDeviceRequest">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminGetDeviceRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminGetDeviceRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AdminGetDevice"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The device key.</p>
|
||||
*/
|
||||
inline const Aws::String& GetDeviceKey() const{ return m_deviceKey; }
|
||||
inline bool DeviceKeyHasBeenSet() const { return m_deviceKeyHasBeenSet; }
|
||||
inline void SetDeviceKey(const Aws::String& value) { m_deviceKeyHasBeenSet = true; m_deviceKey = value; }
|
||||
inline void SetDeviceKey(Aws::String&& value) { m_deviceKeyHasBeenSet = true; m_deviceKey = std::move(value); }
|
||||
inline void SetDeviceKey(const char* value) { m_deviceKeyHasBeenSet = true; m_deviceKey.assign(value); }
|
||||
inline AdminGetDeviceRequest& WithDeviceKey(const Aws::String& value) { SetDeviceKey(value); return *this;}
|
||||
inline AdminGetDeviceRequest& WithDeviceKey(Aws::String&& value) { SetDeviceKey(std::move(value)); return *this;}
|
||||
inline AdminGetDeviceRequest& WithDeviceKey(const char* value) { SetDeviceKey(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user pool ID.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AdminGetDeviceRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AdminGetDeviceRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AdminGetDeviceRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The username of the user that you want to query or modify. The value of this
|
||||
* parameter is typically your user's username, but it can be any of their alias
|
||||
* attributes. If <code>username</code> isn't an alias attribute in your user pool,
|
||||
* this value must be the <code>sub</code> of a local user or the username of a
|
||||
* user from a third-party IdP.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUsername() const{ return m_username; }
|
||||
inline bool UsernameHasBeenSet() const { return m_usernameHasBeenSet; }
|
||||
inline void SetUsername(const Aws::String& value) { m_usernameHasBeenSet = true; m_username = value; }
|
||||
inline void SetUsername(Aws::String&& value) { m_usernameHasBeenSet = true; m_username = std::move(value); }
|
||||
inline void SetUsername(const char* value) { m_usernameHasBeenSet = true; m_username.assign(value); }
|
||||
inline AdminGetDeviceRequest& WithUsername(const Aws::String& value) { SetUsername(value); return *this;}
|
||||
inline AdminGetDeviceRequest& WithUsername(Aws::String&& value) { SetUsername(std::move(value)); return *this;}
|
||||
inline AdminGetDeviceRequest& WithUsername(const char* value) { SetUsername(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_deviceKey;
|
||||
bool m_deviceKeyHasBeenSet = false;
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_username;
|
||||
bool m_usernameHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,71 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/model/DeviceType.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>Gets the device response, as an administrator.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminGetDeviceResponse">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminGetDeviceResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminGetDeviceResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminGetDeviceResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminGetDeviceResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The device.</p>
|
||||
*/
|
||||
inline const DeviceType& GetDevice() const{ return m_device; }
|
||||
inline void SetDevice(const DeviceType& value) { m_device = value; }
|
||||
inline void SetDevice(DeviceType&& value) { m_device = std::move(value); }
|
||||
inline AdminGetDeviceResult& WithDevice(const DeviceType& value) { SetDevice(value); return *this;}
|
||||
inline AdminGetDeviceResult& WithDevice(DeviceType&& value) { SetDevice(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline AdminGetDeviceResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline AdminGetDeviceResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline AdminGetDeviceResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
DeviceType m_device;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,84 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Represents the request to get the specified user as an
|
||||
* administrator.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminGetUserRequest">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminGetUserRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminGetUserRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AdminGetUser"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user pool ID for the user pool where you want to get information about
|
||||
* the user.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AdminGetUserRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AdminGetUserRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AdminGetUserRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The username of the user that you want to query or modify. The value of this
|
||||
* parameter is typically your user's username, but it can be any of their alias
|
||||
* attributes. If <code>username</code> isn't an alias attribute in your user pool,
|
||||
* this value must be the <code>sub</code> of a local user or the username of a
|
||||
* user from a third-party IdP.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUsername() const{ return m_username; }
|
||||
inline bool UsernameHasBeenSet() const { return m_usernameHasBeenSet; }
|
||||
inline void SetUsername(const Aws::String& value) { m_usernameHasBeenSet = true; m_username = value; }
|
||||
inline void SetUsername(Aws::String&& value) { m_usernameHasBeenSet = true; m_username = std::move(value); }
|
||||
inline void SetUsername(const char* value) { m_usernameHasBeenSet = true; m_username.assign(value); }
|
||||
inline AdminGetUserRequest& WithUsername(const Aws::String& value) { SetUsername(value); return *this;}
|
||||
inline AdminGetUserRequest& WithUsername(Aws::String&& value) { SetUsername(std::move(value)); return *this;}
|
||||
inline AdminGetUserRequest& WithUsername(const char* value) { SetUsername(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_username;
|
||||
bool m_usernameHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,204 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/core/utils/DateTime.h>
|
||||
#include <aws/cognito-idp/model/UserStatusType.h>
|
||||
#include <aws/cognito-idp/model/AttributeType.h>
|
||||
#include <aws/cognito-idp/model/MFAOptionType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>Represents the response from the server from the request to get the specified
|
||||
* user as an administrator.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminGetUserResponse">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminGetUserResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminGetUserResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminGetUserResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminGetUserResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The username of the user that you requested.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUsername() const{ return m_username; }
|
||||
inline void SetUsername(const Aws::String& value) { m_username = value; }
|
||||
inline void SetUsername(Aws::String&& value) { m_username = std::move(value); }
|
||||
inline void SetUsername(const char* value) { m_username.assign(value); }
|
||||
inline AdminGetUserResult& WithUsername(const Aws::String& value) { SetUsername(value); return *this;}
|
||||
inline AdminGetUserResult& WithUsername(Aws::String&& value) { SetUsername(std::move(value)); return *this;}
|
||||
inline AdminGetUserResult& WithUsername(const char* value) { SetUsername(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>An array of name-value pairs representing user attributes.</p>
|
||||
*/
|
||||
inline const Aws::Vector<AttributeType>& GetUserAttributes() const{ return m_userAttributes; }
|
||||
inline void SetUserAttributes(const Aws::Vector<AttributeType>& value) { m_userAttributes = value; }
|
||||
inline void SetUserAttributes(Aws::Vector<AttributeType>&& value) { m_userAttributes = std::move(value); }
|
||||
inline AdminGetUserResult& WithUserAttributes(const Aws::Vector<AttributeType>& value) { SetUserAttributes(value); return *this;}
|
||||
inline AdminGetUserResult& WithUserAttributes(Aws::Vector<AttributeType>&& value) { SetUserAttributes(std::move(value)); return *this;}
|
||||
inline AdminGetUserResult& AddUserAttributes(const AttributeType& value) { m_userAttributes.push_back(value); return *this; }
|
||||
inline AdminGetUserResult& AddUserAttributes(AttributeType&& value) { m_userAttributes.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The date the user was created.</p>
|
||||
*/
|
||||
inline const Aws::Utils::DateTime& GetUserCreateDate() const{ return m_userCreateDate; }
|
||||
inline void SetUserCreateDate(const Aws::Utils::DateTime& value) { m_userCreateDate = value; }
|
||||
inline void SetUserCreateDate(Aws::Utils::DateTime&& value) { m_userCreateDate = std::move(value); }
|
||||
inline AdminGetUserResult& WithUserCreateDate(const Aws::Utils::DateTime& value) { SetUserCreateDate(value); return *this;}
|
||||
inline AdminGetUserResult& WithUserCreateDate(Aws::Utils::DateTime&& value) { SetUserCreateDate(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The date and time when the item was modified. Amazon Cognito returns this
|
||||
* timestamp in UNIX epoch time format. Your SDK might render the output in a
|
||||
* human-readable format like ISO 8601 or a Java <code>Date</code> object.</p>
|
||||
*/
|
||||
inline const Aws::Utils::DateTime& GetUserLastModifiedDate() const{ return m_userLastModifiedDate; }
|
||||
inline void SetUserLastModifiedDate(const Aws::Utils::DateTime& value) { m_userLastModifiedDate = value; }
|
||||
inline void SetUserLastModifiedDate(Aws::Utils::DateTime&& value) { m_userLastModifiedDate = std::move(value); }
|
||||
inline AdminGetUserResult& WithUserLastModifiedDate(const Aws::Utils::DateTime& value) { SetUserLastModifiedDate(value); return *this;}
|
||||
inline AdminGetUserResult& WithUserLastModifiedDate(Aws::Utils::DateTime&& value) { SetUserLastModifiedDate(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Indicates that the status is <code>enabled</code>.</p>
|
||||
*/
|
||||
inline bool GetEnabled() const{ return m_enabled; }
|
||||
inline void SetEnabled(bool value) { m_enabled = value; }
|
||||
inline AdminGetUserResult& WithEnabled(bool value) { SetEnabled(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user status. Can be one of the following:</p> <ul> <li> <p>UNCONFIRMED -
|
||||
* User has been created but not confirmed.</p> </li> <li> <p>CONFIRMED - User has
|
||||
* been confirmed.</p> </li> <li> <p>UNKNOWN - User status isn't known.</p> </li>
|
||||
* <li> <p>RESET_REQUIRED - User is confirmed, but the user must request a code and
|
||||
* reset their password before they can sign in.</p> </li> <li>
|
||||
* <p>FORCE_CHANGE_PASSWORD - The user is confirmed and the user can sign in using
|
||||
* a temporary password, but on first sign-in, the user must change their password
|
||||
* to a new value before doing anything else. </p> </li> </ul>
|
||||
*/
|
||||
inline const UserStatusType& GetUserStatus() const{ return m_userStatus; }
|
||||
inline void SetUserStatus(const UserStatusType& value) { m_userStatus = value; }
|
||||
inline void SetUserStatus(UserStatusType&& value) { m_userStatus = std::move(value); }
|
||||
inline AdminGetUserResult& WithUserStatus(const UserStatusType& value) { SetUserStatus(value); return *this;}
|
||||
inline AdminGetUserResult& WithUserStatus(UserStatusType&& value) { SetUserStatus(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p> <i>This response parameter is no longer supported.</i> It provides
|
||||
* information only about SMS MFA configurations. It doesn't provide information
|
||||
* about time-based one-time password (TOTP) software token MFA configurations. To
|
||||
* look up information about either type of MFA configuration, use
|
||||
* UserMFASettingList instead.</p>
|
||||
*/
|
||||
inline const Aws::Vector<MFAOptionType>& GetMFAOptions() const{ return m_mFAOptions; }
|
||||
inline void SetMFAOptions(const Aws::Vector<MFAOptionType>& value) { m_mFAOptions = value; }
|
||||
inline void SetMFAOptions(Aws::Vector<MFAOptionType>&& value) { m_mFAOptions = std::move(value); }
|
||||
inline AdminGetUserResult& WithMFAOptions(const Aws::Vector<MFAOptionType>& value) { SetMFAOptions(value); return *this;}
|
||||
inline AdminGetUserResult& WithMFAOptions(Aws::Vector<MFAOptionType>&& value) { SetMFAOptions(std::move(value)); return *this;}
|
||||
inline AdminGetUserResult& AddMFAOptions(const MFAOptionType& value) { m_mFAOptions.push_back(value); return *this; }
|
||||
inline AdminGetUserResult& AddMFAOptions(MFAOptionType&& value) { m_mFAOptions.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user's preferred MFA setting.</p>
|
||||
*/
|
||||
inline const Aws::String& GetPreferredMfaSetting() const{ return m_preferredMfaSetting; }
|
||||
inline void SetPreferredMfaSetting(const Aws::String& value) { m_preferredMfaSetting = value; }
|
||||
inline void SetPreferredMfaSetting(Aws::String&& value) { m_preferredMfaSetting = std::move(value); }
|
||||
inline void SetPreferredMfaSetting(const char* value) { m_preferredMfaSetting.assign(value); }
|
||||
inline AdminGetUserResult& WithPreferredMfaSetting(const Aws::String& value) { SetPreferredMfaSetting(value); return *this;}
|
||||
inline AdminGetUserResult& WithPreferredMfaSetting(Aws::String&& value) { SetPreferredMfaSetting(std::move(value)); return *this;}
|
||||
inline AdminGetUserResult& WithPreferredMfaSetting(const char* value) { SetPreferredMfaSetting(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The MFA options that are activated for the user. The possible values in this
|
||||
* list are <code>SMS_MFA</code>, <code>EMAIL_OTP</code>, and
|
||||
* <code>SOFTWARE_TOKEN_MFA</code>.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetUserMFASettingList() const{ return m_userMFASettingList; }
|
||||
inline void SetUserMFASettingList(const Aws::Vector<Aws::String>& value) { m_userMFASettingList = value; }
|
||||
inline void SetUserMFASettingList(Aws::Vector<Aws::String>&& value) { m_userMFASettingList = std::move(value); }
|
||||
inline AdminGetUserResult& WithUserMFASettingList(const Aws::Vector<Aws::String>& value) { SetUserMFASettingList(value); return *this;}
|
||||
inline AdminGetUserResult& WithUserMFASettingList(Aws::Vector<Aws::String>&& value) { SetUserMFASettingList(std::move(value)); return *this;}
|
||||
inline AdminGetUserResult& AddUserMFASettingList(const Aws::String& value) { m_userMFASettingList.push_back(value); return *this; }
|
||||
inline AdminGetUserResult& AddUserMFASettingList(Aws::String&& value) { m_userMFASettingList.push_back(std::move(value)); return *this; }
|
||||
inline AdminGetUserResult& AddUserMFASettingList(const char* value) { m_userMFASettingList.push_back(value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline AdminGetUserResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline AdminGetUserResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline AdminGetUserResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_username;
|
||||
|
||||
Aws::Vector<AttributeType> m_userAttributes;
|
||||
|
||||
Aws::Utils::DateTime m_userCreateDate;
|
||||
|
||||
Aws::Utils::DateTime m_userLastModifiedDate;
|
||||
|
||||
bool m_enabled;
|
||||
|
||||
UserStatusType m_userStatus;
|
||||
|
||||
Aws::Vector<MFAOptionType> m_mFAOptions;
|
||||
|
||||
Aws::String m_preferredMfaSetting;
|
||||
|
||||
Aws::Vector<Aws::String> m_userMFASettingList;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,244 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cognito-idp/model/AuthFlowType.h>
|
||||
#include <aws/core/utils/memory/stl/AWSMap.h>
|
||||
#include <aws/cognito-idp/model/AnalyticsMetadataType.h>
|
||||
#include <aws/cognito-idp/model/ContextDataType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Initiates the authorization request, as an administrator.</p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminInitiateAuthRequest">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminInitiateAuthRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminInitiateAuthRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AdminInitiateAuth"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The ID of the Amazon Cognito user pool.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AdminInitiateAuthRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AdminInitiateAuthRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AdminInitiateAuthRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The app client ID.</p>
|
||||
*/
|
||||
inline const Aws::String& GetClientId() const{ return m_clientId; }
|
||||
inline bool ClientIdHasBeenSet() const { return m_clientIdHasBeenSet; }
|
||||
inline void SetClientId(const Aws::String& value) { m_clientIdHasBeenSet = true; m_clientId = value; }
|
||||
inline void SetClientId(Aws::String&& value) { m_clientIdHasBeenSet = true; m_clientId = std::move(value); }
|
||||
inline void SetClientId(const char* value) { m_clientIdHasBeenSet = true; m_clientId.assign(value); }
|
||||
inline AdminInitiateAuthRequest& WithClientId(const Aws::String& value) { SetClientId(value); return *this;}
|
||||
inline AdminInitiateAuthRequest& WithClientId(Aws::String&& value) { SetClientId(std::move(value)); return *this;}
|
||||
inline AdminInitiateAuthRequest& WithClientId(const char* value) { SetClientId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The authentication flow for this call to run. The API action will depend on
|
||||
* this value. For example:</p> <ul> <li> <p> <code>REFRESH_TOKEN_AUTH</code> will
|
||||
* take in a valid refresh token and return new tokens.</p> </li> <li> <p>
|
||||
* <code>USER_SRP_AUTH</code> will take in <code>USERNAME</code> and
|
||||
* <code>SRP_A</code> and return the Secure Remote Password (SRP) protocol
|
||||
* variables to be used for next challenge execution.</p> </li> <li> <p>
|
||||
* <code>ADMIN_USER_PASSWORD_AUTH</code> will take in <code>USERNAME</code> and
|
||||
* <code>PASSWORD</code> and return the next challenge or tokens.</p> </li> </ul>
|
||||
* <p>Valid values include:</p> <ul> <li> <p> <code>USER_SRP_AUTH</code>:
|
||||
* Authentication flow for the Secure Remote Password (SRP) protocol.</p> </li>
|
||||
* <li> <p> <code>REFRESH_TOKEN_AUTH</code>/<code>REFRESH_TOKEN</code>:
|
||||
* Authentication flow for refreshing the access token and ID token by supplying a
|
||||
* valid refresh token.</p> </li> <li> <p> <code>CUSTOM_AUTH</code>: Custom
|
||||
* authentication flow.</p> </li> <li> <p> <code>ADMIN_NO_SRP_AUTH</code>: Non-SRP
|
||||
* authentication flow; you can pass in the USERNAME and PASSWORD directly if the
|
||||
* flow is enabled for calling the app client.</p> </li> <li> <p>
|
||||
* <code>ADMIN_USER_PASSWORD_AUTH</code>: Admin-based user password authentication.
|
||||
* This replaces the <code>ADMIN_NO_SRP_AUTH</code> authentication flow. In this
|
||||
* flow, Amazon Cognito receives the password in the request instead of using the
|
||||
* SRP process to verify passwords.</p> </li> </ul>
|
||||
*/
|
||||
inline const AuthFlowType& GetAuthFlow() const{ return m_authFlow; }
|
||||
inline bool AuthFlowHasBeenSet() const { return m_authFlowHasBeenSet; }
|
||||
inline void SetAuthFlow(const AuthFlowType& value) { m_authFlowHasBeenSet = true; m_authFlow = value; }
|
||||
inline void SetAuthFlow(AuthFlowType&& value) { m_authFlowHasBeenSet = true; m_authFlow = std::move(value); }
|
||||
inline AdminInitiateAuthRequest& WithAuthFlow(const AuthFlowType& value) { SetAuthFlow(value); return *this;}
|
||||
inline AdminInitiateAuthRequest& WithAuthFlow(AuthFlowType&& value) { SetAuthFlow(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The authentication parameters. These are inputs corresponding to the
|
||||
* <code>AuthFlow</code> that you're invoking. The required values depend on the
|
||||
* value of <code>AuthFlow</code>:</p> <ul> <li> <p>For <code>USER_SRP_AUTH</code>:
|
||||
* <code>USERNAME</code> (required), <code>SRP_A</code> (required),
|
||||
* <code>SECRET_HASH</code> (required if the app client is configured with a client
|
||||
* secret), <code>DEVICE_KEY</code>.</p> </li> <li> <p>For
|
||||
* <code>ADMIN_USER_PASSWORD_AUTH</code>: <code>USERNAME</code> (required),
|
||||
* <code>PASSWORD</code> (required), <code>SECRET_HASH</code> (required if the app
|
||||
* client is configured with a client secret), <code>DEVICE_KEY</code>.</p> </li>
|
||||
* <li> <p>For <code>REFRESH_TOKEN_AUTH/REFRESH_TOKEN</code>:
|
||||
* <code>REFRESH_TOKEN</code> (required), <code>SECRET_HASH</code> (required if the
|
||||
* app client is configured with a client secret), <code>DEVICE_KEY</code>.</p>
|
||||
* </li> <li> <p>For <code>CUSTOM_AUTH</code>: <code>USERNAME</code> (required),
|
||||
* <code>SECRET_HASH</code> (if app client is configured with client secret),
|
||||
* <code>DEVICE_KEY</code>. To start the authentication flow with password
|
||||
* verification, include <code>ChallengeName: SRP_A</code> and <code>SRP_A: (The
|
||||
* SRP_A Value)</code>.</p> </li> </ul> <p>For more information about
|
||||
* <code>SECRET_HASH</code>, see <a
|
||||
* href="https://docs.aws.amazon.com/cognito/latest/developerguide/signing-up-users-in-your-app.html#cognito-user-pools-computing-secret-hash">Computing
|
||||
* secret hash values</a>. For information about <code>DEVICE_KEY</code>, see <a
|
||||
* href="https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-device-tracking.html">Working
|
||||
* with user devices in your user pool</a>.</p>
|
||||
*/
|
||||
inline const Aws::Map<Aws::String, Aws::String>& GetAuthParameters() const{ return m_authParameters; }
|
||||
inline bool AuthParametersHasBeenSet() const { return m_authParametersHasBeenSet; }
|
||||
inline void SetAuthParameters(const Aws::Map<Aws::String, Aws::String>& value) { m_authParametersHasBeenSet = true; m_authParameters = value; }
|
||||
inline void SetAuthParameters(Aws::Map<Aws::String, Aws::String>&& value) { m_authParametersHasBeenSet = true; m_authParameters = std::move(value); }
|
||||
inline AdminInitiateAuthRequest& WithAuthParameters(const Aws::Map<Aws::String, Aws::String>& value) { SetAuthParameters(value); return *this;}
|
||||
inline AdminInitiateAuthRequest& WithAuthParameters(Aws::Map<Aws::String, Aws::String>&& value) { SetAuthParameters(std::move(value)); return *this;}
|
||||
inline AdminInitiateAuthRequest& AddAuthParameters(const Aws::String& key, const Aws::String& value) { m_authParametersHasBeenSet = true; m_authParameters.emplace(key, value); return *this; }
|
||||
inline AdminInitiateAuthRequest& AddAuthParameters(Aws::String&& key, const Aws::String& value) { m_authParametersHasBeenSet = true; m_authParameters.emplace(std::move(key), value); return *this; }
|
||||
inline AdminInitiateAuthRequest& AddAuthParameters(const Aws::String& key, Aws::String&& value) { m_authParametersHasBeenSet = true; m_authParameters.emplace(key, std::move(value)); return *this; }
|
||||
inline AdminInitiateAuthRequest& AddAuthParameters(Aws::String&& key, Aws::String&& value) { m_authParametersHasBeenSet = true; m_authParameters.emplace(std::move(key), std::move(value)); return *this; }
|
||||
inline AdminInitiateAuthRequest& AddAuthParameters(const char* key, Aws::String&& value) { m_authParametersHasBeenSet = true; m_authParameters.emplace(key, std::move(value)); return *this; }
|
||||
inline AdminInitiateAuthRequest& AddAuthParameters(Aws::String&& key, const char* value) { m_authParametersHasBeenSet = true; m_authParameters.emplace(std::move(key), value); return *this; }
|
||||
inline AdminInitiateAuthRequest& AddAuthParameters(const char* key, const char* value) { m_authParametersHasBeenSet = true; m_authParameters.emplace(key, value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A map of custom key-value pairs that you can provide as input for certain
|
||||
* custom workflows that this action triggers.</p> <p>You create custom workflows
|
||||
* by assigning Lambda functions to user pool triggers. When you use the
|
||||
* AdminInitiateAuth API action, Amazon Cognito invokes the Lambda functions that
|
||||
* are specified for various triggers. The ClientMetadata value is passed as input
|
||||
* to the functions for only the following triggers:</p> <ul> <li> <p>Pre
|
||||
* signup</p> </li> <li> <p>Pre authentication</p> </li> <li> <p>User migration</p>
|
||||
* </li> </ul> <p>When Amazon Cognito invokes the functions for these triggers, it
|
||||
* passes a JSON payload, which the function receives as input. This payload
|
||||
* contains a <code>validationData</code> attribute, which provides the data that
|
||||
* you assigned to the ClientMetadata parameter in your AdminInitiateAuth request.
|
||||
* In your function code in Lambda, you can process the <code>validationData</code>
|
||||
* value to enhance your workflow for your specific needs.</p> <p>When you use the
|
||||
* AdminInitiateAuth API action, Amazon Cognito also invokes the functions for the
|
||||
* following triggers, but it doesn't provide the ClientMetadata value as
|
||||
* input:</p> <ul> <li> <p>Post authentication</p> </li> <li> <p>Custom message</p>
|
||||
* </li> <li> <p>Pre token generation</p> </li> <li> <p>Create auth challenge</p>
|
||||
* </li> <li> <p>Define auth challenge</p> </li> </ul> <p>For more information, see
|
||||
* <a
|
||||
* href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html">
|
||||
* Customizing user pool Workflows with Lambda Triggers</a> in the <i>Amazon
|
||||
* Cognito Developer Guide</i>.</p> <p>When you use the ClientMetadata
|
||||
* parameter, remember that Amazon Cognito won't do the following:</p> <ul> <li>
|
||||
* <p>Store the ClientMetadata value. This data is available only to Lambda
|
||||
* triggers that are assigned to a user pool to support custom workflows. If your
|
||||
* user pool configuration doesn't include triggers, the ClientMetadata parameter
|
||||
* serves no purpose.</p> </li> <li> <p>Validate the ClientMetadata value.</p>
|
||||
* </li> <li> <p>Encrypt the ClientMetadata value. Don't use Amazon Cognito to
|
||||
* provide sensitive information.</p> </li> </ul>
|
||||
*/
|
||||
inline const Aws::Map<Aws::String, Aws::String>& GetClientMetadata() const{ return m_clientMetadata; }
|
||||
inline bool ClientMetadataHasBeenSet() const { return m_clientMetadataHasBeenSet; }
|
||||
inline void SetClientMetadata(const Aws::Map<Aws::String, Aws::String>& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata = value; }
|
||||
inline void SetClientMetadata(Aws::Map<Aws::String, Aws::String>&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata = std::move(value); }
|
||||
inline AdminInitiateAuthRequest& WithClientMetadata(const Aws::Map<Aws::String, Aws::String>& value) { SetClientMetadata(value); return *this;}
|
||||
inline AdminInitiateAuthRequest& WithClientMetadata(Aws::Map<Aws::String, Aws::String>&& value) { SetClientMetadata(std::move(value)); return *this;}
|
||||
inline AdminInitiateAuthRequest& AddClientMetadata(const Aws::String& key, const Aws::String& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, value); return *this; }
|
||||
inline AdminInitiateAuthRequest& AddClientMetadata(Aws::String&& key, const Aws::String& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(std::move(key), value); return *this; }
|
||||
inline AdminInitiateAuthRequest& AddClientMetadata(const Aws::String& key, Aws::String&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, std::move(value)); return *this; }
|
||||
inline AdminInitiateAuthRequest& AddClientMetadata(Aws::String&& key, Aws::String&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(std::move(key), std::move(value)); return *this; }
|
||||
inline AdminInitiateAuthRequest& AddClientMetadata(const char* key, Aws::String&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, std::move(value)); return *this; }
|
||||
inline AdminInitiateAuthRequest& AddClientMetadata(Aws::String&& key, const char* value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(std::move(key), value); return *this; }
|
||||
inline AdminInitiateAuthRequest& AddClientMetadata(const char* key, const char* value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The analytics metadata for collecting Amazon Pinpoint metrics for
|
||||
* <code>AdminInitiateAuth</code> calls.</p>
|
||||
*/
|
||||
inline const AnalyticsMetadataType& GetAnalyticsMetadata() const{ return m_analyticsMetadata; }
|
||||
inline bool AnalyticsMetadataHasBeenSet() const { return m_analyticsMetadataHasBeenSet; }
|
||||
inline void SetAnalyticsMetadata(const AnalyticsMetadataType& value) { m_analyticsMetadataHasBeenSet = true; m_analyticsMetadata = value; }
|
||||
inline void SetAnalyticsMetadata(AnalyticsMetadataType&& value) { m_analyticsMetadataHasBeenSet = true; m_analyticsMetadata = std::move(value); }
|
||||
inline AdminInitiateAuthRequest& WithAnalyticsMetadata(const AnalyticsMetadataType& value) { SetAnalyticsMetadata(value); return *this;}
|
||||
inline AdminInitiateAuthRequest& WithAnalyticsMetadata(AnalyticsMetadataType&& value) { SetAnalyticsMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Contextual data about your user session, such as the device fingerprint, IP
|
||||
* address, or location. Amazon Cognito advanced security evaluates the risk of an
|
||||
* authentication event based on the context that your app generates and passes to
|
||||
* Amazon Cognito when it makes API requests.</p>
|
||||
*/
|
||||
inline const ContextDataType& GetContextData() const{ return m_contextData; }
|
||||
inline bool ContextDataHasBeenSet() const { return m_contextDataHasBeenSet; }
|
||||
inline void SetContextData(const ContextDataType& value) { m_contextDataHasBeenSet = true; m_contextData = value; }
|
||||
inline void SetContextData(ContextDataType&& value) { m_contextDataHasBeenSet = true; m_contextData = std::move(value); }
|
||||
inline AdminInitiateAuthRequest& WithContextData(const ContextDataType& value) { SetContextData(value); return *this;}
|
||||
inline AdminInitiateAuthRequest& WithContextData(ContextDataType&& value) { SetContextData(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_clientId;
|
||||
bool m_clientIdHasBeenSet = false;
|
||||
|
||||
AuthFlowType m_authFlow;
|
||||
bool m_authFlowHasBeenSet = false;
|
||||
|
||||
Aws::Map<Aws::String, Aws::String> m_authParameters;
|
||||
bool m_authParametersHasBeenSet = false;
|
||||
|
||||
Aws::Map<Aws::String, Aws::String> m_clientMetadata;
|
||||
bool m_clientMetadataHasBeenSet = false;
|
||||
|
||||
AnalyticsMetadataType m_analyticsMetadata;
|
||||
bool m_analyticsMetadataHasBeenSet = false;
|
||||
|
||||
ContextDataType m_contextData;
|
||||
bool m_contextDataHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,188 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/model/ChallengeNameType.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSMap.h>
|
||||
#include <aws/cognito-idp/model/AuthenticationResultType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>Initiates the authentication response, as an administrator.</p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminInitiateAuthResponse">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminInitiateAuthResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminInitiateAuthResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminInitiateAuthResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminInitiateAuthResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of the challenge that you're responding to with this call. This is
|
||||
* returned in the <code>AdminInitiateAuth</code> response if you must pass another
|
||||
* challenge.</p> <ul> <li> <p> <code>MFA_SETUP</code>: If MFA is required, users
|
||||
* who don't have at least one of the MFA methods set up are presented with an
|
||||
* <code>MFA_SETUP</code> challenge. The user must set up at least one MFA type to
|
||||
* continue to authenticate.</p> </li> <li> <p> <code>SELECT_MFA_TYPE</code>:
|
||||
* Selects the MFA type. Valid MFA options are <code>SMS_MFA</code> for SMS message
|
||||
* MFA, <code>EMAIL_OTP</code> for email message MFA, and
|
||||
* <code>SOFTWARE_TOKEN_MFA</code> for time-based one-time password (TOTP) software
|
||||
* token MFA.</p> </li> <li> <p> <code>SMS_MFA</code>: Next challenge is to supply
|
||||
* an <code>SMS_MFA_CODE</code>that your user pool delivered in an SMS message.</p>
|
||||
* </li> <li> <p> <code>EMAIL_OTP</code>: Next challenge is to supply an
|
||||
* <code>EMAIL_OTP_CODE</code> that your user pool delivered in an email
|
||||
* message.</p> </li> <li> <p> <code>PASSWORD_VERIFIER</code>: Next challenge is to
|
||||
* supply <code>PASSWORD_CLAIM_SIGNATURE</code>,
|
||||
* <code>PASSWORD_CLAIM_SECRET_BLOCK</code>, and <code>TIMESTAMP</code> after the
|
||||
* client-side SRP calculations.</p> </li> <li> <p> <code>CUSTOM_CHALLENGE</code>:
|
||||
* This is returned if your custom authentication flow determines that the user
|
||||
* should pass another challenge before tokens are issued.</p> </li> <li> <p>
|
||||
* <code>DEVICE_SRP_AUTH</code>: If device tracking was activated in your user pool
|
||||
* and the previous challenges were passed, this challenge is returned so that
|
||||
* Amazon Cognito can start tracking this device.</p> </li> <li> <p>
|
||||
* <code>DEVICE_PASSWORD_VERIFIER</code>: Similar to
|
||||
* <code>PASSWORD_VERIFIER</code>, but for devices only.</p> </li> <li> <p>
|
||||
* <code>ADMIN_NO_SRP_AUTH</code>: This is returned if you must authenticate with
|
||||
* <code>USERNAME</code> and <code>PASSWORD</code> directly. An app client must be
|
||||
* enabled to use this flow.</p> </li> <li> <p> <code>NEW_PASSWORD_REQUIRED</code>:
|
||||
* For users who are required to change their passwords after successful first
|
||||
* login. Respond to this challenge with <code>NEW_PASSWORD</code> and any required
|
||||
* attributes that Amazon Cognito returned in the <code>requiredAttributes</code>
|
||||
* parameter. You can also set values for attributes that aren't required by your
|
||||
* user pool and that your app client can write. For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminRespondToAuthChallenge.html">AdminRespondToAuthChallenge</a>.</p>
|
||||
* <p>In a <code>NEW_PASSWORD_REQUIRED</code> challenge response, you can't
|
||||
* modify a required attribute that already has a value. In
|
||||
* <code>AdminRespondToAuthChallenge</code>, set a value for any keys that Amazon
|
||||
* Cognito returned in the <code>requiredAttributes</code> parameter, then use the
|
||||
* <code>AdminUpdateUserAttributes</code> API operation to modify the value of any
|
||||
* additional attributes.</p> </li> <li> <p> <code>MFA_SETUP</code>: For
|
||||
* users who are required to set up an MFA factor before they can sign in. The MFA
|
||||
* types activated for the user pool will be listed in the challenge parameters
|
||||
* <code>MFAS_CAN_SETUP</code> value. </p> <p> To set up software token MFA, use
|
||||
* the session returned here from <code>InitiateAuth</code> as an input to
|
||||
* <code>AssociateSoftwareToken</code>, and use the session returned by
|
||||
* <code>VerifySoftwareToken</code> as an input to
|
||||
* <code>RespondToAuthChallenge</code> with challenge name <code>MFA_SETUP</code>
|
||||
* to complete sign-in. To set up SMS MFA, users will need help from an
|
||||
* administrator to add a phone number to their account and then call
|
||||
* <code>InitiateAuth</code> again to restart sign-in.</p> </li> </ul>
|
||||
*/
|
||||
inline const ChallengeNameType& GetChallengeName() const{ return m_challengeName; }
|
||||
inline void SetChallengeName(const ChallengeNameType& value) { m_challengeName = value; }
|
||||
inline void SetChallengeName(ChallengeNameType&& value) { m_challengeName = std::move(value); }
|
||||
inline AdminInitiateAuthResult& WithChallengeName(const ChallengeNameType& value) { SetChallengeName(value); return *this;}
|
||||
inline AdminInitiateAuthResult& WithChallengeName(ChallengeNameType&& value) { SetChallengeName(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The session that should be passed both ways in challenge-response calls to
|
||||
* the service. If <code>AdminInitiateAuth</code> or
|
||||
* <code>AdminRespondToAuthChallenge</code> API call determines that the caller
|
||||
* must pass another challenge, they return a session with other challenge
|
||||
* parameters. This session should be passed as it is to the next
|
||||
* <code>AdminRespondToAuthChallenge</code> API call.</p>
|
||||
*/
|
||||
inline const Aws::String& GetSession() const{ return m_session; }
|
||||
inline void SetSession(const Aws::String& value) { m_session = value; }
|
||||
inline void SetSession(Aws::String&& value) { m_session = std::move(value); }
|
||||
inline void SetSession(const char* value) { m_session.assign(value); }
|
||||
inline AdminInitiateAuthResult& WithSession(const Aws::String& value) { SetSession(value); return *this;}
|
||||
inline AdminInitiateAuthResult& WithSession(Aws::String&& value) { SetSession(std::move(value)); return *this;}
|
||||
inline AdminInitiateAuthResult& WithSession(const char* value) { SetSession(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The challenge parameters. These are returned to you in the
|
||||
* <code>AdminInitiateAuth</code> response if you must pass another challenge. The
|
||||
* responses in this parameter should be used to compute inputs to the next call
|
||||
* (<code>AdminRespondToAuthChallenge</code>).</p> <p>All challenges require
|
||||
* <code>USERNAME</code> and <code>SECRET_HASH</code> (if applicable).</p> <p>The
|
||||
* value of the <code>USER_ID_FOR_SRP</code> attribute is the user's actual
|
||||
* username, not an alias (such as email address or phone number), even if you
|
||||
* specified an alias in your call to <code>AdminInitiateAuth</code>. This happens
|
||||
* because, in the <code>AdminRespondToAuthChallenge</code> API
|
||||
* <code>ChallengeResponses</code>, the <code>USERNAME</code> attribute can't be an
|
||||
* alias.</p>
|
||||
*/
|
||||
inline const Aws::Map<Aws::String, Aws::String>& GetChallengeParameters() const{ return m_challengeParameters; }
|
||||
inline void SetChallengeParameters(const Aws::Map<Aws::String, Aws::String>& value) { m_challengeParameters = value; }
|
||||
inline void SetChallengeParameters(Aws::Map<Aws::String, Aws::String>&& value) { m_challengeParameters = std::move(value); }
|
||||
inline AdminInitiateAuthResult& WithChallengeParameters(const Aws::Map<Aws::String, Aws::String>& value) { SetChallengeParameters(value); return *this;}
|
||||
inline AdminInitiateAuthResult& WithChallengeParameters(Aws::Map<Aws::String, Aws::String>&& value) { SetChallengeParameters(std::move(value)); return *this;}
|
||||
inline AdminInitiateAuthResult& AddChallengeParameters(const Aws::String& key, const Aws::String& value) { m_challengeParameters.emplace(key, value); return *this; }
|
||||
inline AdminInitiateAuthResult& AddChallengeParameters(Aws::String&& key, const Aws::String& value) { m_challengeParameters.emplace(std::move(key), value); return *this; }
|
||||
inline AdminInitiateAuthResult& AddChallengeParameters(const Aws::String& key, Aws::String&& value) { m_challengeParameters.emplace(key, std::move(value)); return *this; }
|
||||
inline AdminInitiateAuthResult& AddChallengeParameters(Aws::String&& key, Aws::String&& value) { m_challengeParameters.emplace(std::move(key), std::move(value)); return *this; }
|
||||
inline AdminInitiateAuthResult& AddChallengeParameters(const char* key, Aws::String&& value) { m_challengeParameters.emplace(key, std::move(value)); return *this; }
|
||||
inline AdminInitiateAuthResult& AddChallengeParameters(Aws::String&& key, const char* value) { m_challengeParameters.emplace(std::move(key), value); return *this; }
|
||||
inline AdminInitiateAuthResult& AddChallengeParameters(const char* key, const char* value) { m_challengeParameters.emplace(key, value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The result of the authentication response. This is only returned if the
|
||||
* caller doesn't need to pass another challenge. If the caller does need to pass
|
||||
* another challenge before it gets tokens, <code>ChallengeName</code>,
|
||||
* <code>ChallengeParameters</code>, and <code>Session</code> are returned.</p>
|
||||
*/
|
||||
inline const AuthenticationResultType& GetAuthenticationResult() const{ return m_authenticationResult; }
|
||||
inline void SetAuthenticationResult(const AuthenticationResultType& value) { m_authenticationResult = value; }
|
||||
inline void SetAuthenticationResult(AuthenticationResultType&& value) { m_authenticationResult = std::move(value); }
|
||||
inline AdminInitiateAuthResult& WithAuthenticationResult(const AuthenticationResultType& value) { SetAuthenticationResult(value); return *this;}
|
||||
inline AdminInitiateAuthResult& WithAuthenticationResult(AuthenticationResultType&& value) { SetAuthenticationResult(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline AdminInitiateAuthResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline AdminInitiateAuthResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline AdminInitiateAuthResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
ChallengeNameType m_challengeName;
|
||||
|
||||
Aws::String m_session;
|
||||
|
||||
Aws::Map<Aws::String, Aws::String> m_challengeParameters;
|
||||
|
||||
AuthenticationResultType m_authenticationResult;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,127 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cognito-idp/model/ProviderUserIdentifierType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class AdminLinkProviderForUserRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminLinkProviderForUserRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AdminLinkProviderForUser"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user pool ID for the user pool.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AdminLinkProviderForUserRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AdminLinkProviderForUserRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AdminLinkProviderForUserRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The existing user in the user pool that you want to assign to the external
|
||||
* IdP user account. This user can be a local (Username + Password) Amazon Cognito
|
||||
* user pools user or a federated user (for example, a SAML or Facebook user). If
|
||||
* the user doesn't exist, Amazon Cognito generates an exception. Amazon Cognito
|
||||
* returns this user when the new user (with the linked IdP attribute) signs
|
||||
* in.</p> <p>For a native username + password user, the
|
||||
* <code>ProviderAttributeValue</code> for the <code>DestinationUser</code> should
|
||||
* be the username in the user pool. For a federated user, it should be the
|
||||
* provider-specific <code>user_id</code>.</p> <p>The
|
||||
* <code>ProviderAttributeName</code> of the <code>DestinationUser</code> is
|
||||
* ignored.</p> <p>The <code>ProviderName</code> should be set to
|
||||
* <code>Cognito</code> for users in Cognito user pools.</p> <p>All
|
||||
* attributes in the DestinationUser profile must be mutable. If you have assigned
|
||||
* the user any immutable custom attributes, the operation won't succeed.</p>
|
||||
*
|
||||
*/
|
||||
inline const ProviderUserIdentifierType& GetDestinationUser() const{ return m_destinationUser; }
|
||||
inline bool DestinationUserHasBeenSet() const { return m_destinationUserHasBeenSet; }
|
||||
inline void SetDestinationUser(const ProviderUserIdentifierType& value) { m_destinationUserHasBeenSet = true; m_destinationUser = value; }
|
||||
inline void SetDestinationUser(ProviderUserIdentifierType&& value) { m_destinationUserHasBeenSet = true; m_destinationUser = std::move(value); }
|
||||
inline AdminLinkProviderForUserRequest& WithDestinationUser(const ProviderUserIdentifierType& value) { SetDestinationUser(value); return *this;}
|
||||
inline AdminLinkProviderForUserRequest& WithDestinationUser(ProviderUserIdentifierType&& value) { SetDestinationUser(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>An external IdP account for a user who doesn't exist yet in the user pool.
|
||||
* This user must be a federated user (for example, a SAML or Facebook user), not
|
||||
* another native user.</p> <p>If the <code>SourceUser</code> is using a federated
|
||||
* social IdP, such as Facebook, Google, or Login with Amazon, you must set the
|
||||
* <code>ProviderAttributeName</code> to <code>Cognito_Subject</code>. For social
|
||||
* IdPs, the <code>ProviderName</code> will be <code>Facebook</code>,
|
||||
* <code>Google</code>, or <code>LoginWithAmazon</code>, and Amazon Cognito will
|
||||
* automatically parse the Facebook, Google, and Login with Amazon tokens for
|
||||
* <code>id</code>, <code>sub</code>, and <code>user_id</code>, respectively. The
|
||||
* <code>ProviderAttributeValue</code> for the user must be the same value as the
|
||||
* <code>id</code>, <code>sub</code>, or <code>user_id</code> value found in the
|
||||
* social IdP token.</p> <p/> <p>For OIDC, the <code>ProviderAttributeName</code>
|
||||
* can be any value that matches a claim in the ID token, or that your app
|
||||
* retrieves from the <code>userInfo</code> endpoint. You must map the claim to a
|
||||
* user pool attribute in your IdP configuration, and set the user pool attribute
|
||||
* name as the value of <code>ProviderAttributeName</code> in your
|
||||
* <code>AdminLinkProviderForUser</code> request.</p> <p>For SAML, the
|
||||
* <code>ProviderAttributeName</code> can be any value that matches a claim in the
|
||||
* SAML assertion. To link SAML users based on the subject of the SAML assertion,
|
||||
* map the subject to a claim through the SAML IdP and set that claim name as the
|
||||
* value of <code>ProviderAttributeName</code> in your
|
||||
* <code>AdminLinkProviderForUser</code> request.</p> <p>For both OIDC and SAML
|
||||
* users, when you set <code>ProviderAttributeName</code> to
|
||||
* <code>Cognito_Subject</code>, Amazon Cognito will automatically parse the
|
||||
* default unique identifier found in the subject from the IdP token.</p>
|
||||
*/
|
||||
inline const ProviderUserIdentifierType& GetSourceUser() const{ return m_sourceUser; }
|
||||
inline bool SourceUserHasBeenSet() const { return m_sourceUserHasBeenSet; }
|
||||
inline void SetSourceUser(const ProviderUserIdentifierType& value) { m_sourceUserHasBeenSet = true; m_sourceUser = value; }
|
||||
inline void SetSourceUser(ProviderUserIdentifierType&& value) { m_sourceUserHasBeenSet = true; m_sourceUser = std::move(value); }
|
||||
inline AdminLinkProviderForUserRequest& WithSourceUser(const ProviderUserIdentifierType& value) { SetSourceUser(value); return *this;}
|
||||
inline AdminLinkProviderForUserRequest& WithSourceUser(ProviderUserIdentifierType&& value) { SetSourceUser(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
ProviderUserIdentifierType m_destinationUser;
|
||||
bool m_destinationUserHasBeenSet = false;
|
||||
|
||||
ProviderUserIdentifierType m_sourceUser;
|
||||
bool m_sourceUserHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,52 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class AdminLinkProviderForUserResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminLinkProviderForUserResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminLinkProviderForUserResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminLinkProviderForUserResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline AdminLinkProviderForUserResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline AdminLinkProviderForUserResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline AdminLinkProviderForUserResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,118 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Represents the request to list devices, as an administrator.</p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminListDevicesRequest">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminListDevicesRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminListDevicesRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AdminListDevices"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user pool ID.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AdminListDevicesRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AdminListDevicesRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AdminListDevicesRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The username of the user that you want to query or modify. The value of this
|
||||
* parameter is typically your user's username, but it can be any of their alias
|
||||
* attributes. If <code>username</code> isn't an alias attribute in your user pool,
|
||||
* this value must be the <code>sub</code> of a local user or the username of a
|
||||
* user from a third-party IdP.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUsername() const{ return m_username; }
|
||||
inline bool UsernameHasBeenSet() const { return m_usernameHasBeenSet; }
|
||||
inline void SetUsername(const Aws::String& value) { m_usernameHasBeenSet = true; m_username = value; }
|
||||
inline void SetUsername(Aws::String&& value) { m_usernameHasBeenSet = true; m_username = std::move(value); }
|
||||
inline void SetUsername(const char* value) { m_usernameHasBeenSet = true; m_username.assign(value); }
|
||||
inline AdminListDevicesRequest& WithUsername(const Aws::String& value) { SetUsername(value); return *this;}
|
||||
inline AdminListDevicesRequest& WithUsername(Aws::String&& value) { SetUsername(std::move(value)); return *this;}
|
||||
inline AdminListDevicesRequest& WithUsername(const char* value) { SetUsername(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The limit of the devices request.</p>
|
||||
*/
|
||||
inline int GetLimit() const{ return m_limit; }
|
||||
inline bool LimitHasBeenSet() const { return m_limitHasBeenSet; }
|
||||
inline void SetLimit(int value) { m_limitHasBeenSet = true; m_limit = value; }
|
||||
inline AdminListDevicesRequest& WithLimit(int value) { SetLimit(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>This API operation returns a limited number of results. The pagination token
|
||||
* is an identifier that you can present in an additional API request with the same
|
||||
* parameters. When you include the pagination token, Amazon Cognito returns the
|
||||
* next set of items after the current list. Subsequent requests return a new
|
||||
* pagination token. By use of this token, you can paginate through the full list
|
||||
* of items.</p>
|
||||
*/
|
||||
inline const Aws::String& GetPaginationToken() const{ return m_paginationToken; }
|
||||
inline bool PaginationTokenHasBeenSet() const { return m_paginationTokenHasBeenSet; }
|
||||
inline void SetPaginationToken(const Aws::String& value) { m_paginationTokenHasBeenSet = true; m_paginationToken = value; }
|
||||
inline void SetPaginationToken(Aws::String&& value) { m_paginationTokenHasBeenSet = true; m_paginationToken = std::move(value); }
|
||||
inline void SetPaginationToken(const char* value) { m_paginationTokenHasBeenSet = true; m_paginationToken.assign(value); }
|
||||
inline AdminListDevicesRequest& WithPaginationToken(const Aws::String& value) { SetPaginationToken(value); return *this;}
|
||||
inline AdminListDevicesRequest& WithPaginationToken(Aws::String&& value) { SetPaginationToken(std::move(value)); return *this;}
|
||||
inline AdminListDevicesRequest& WithPaginationToken(const char* value) { SetPaginationToken(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_username;
|
||||
bool m_usernameHasBeenSet = false;
|
||||
|
||||
int m_limit;
|
||||
bool m_limitHasBeenSet = false;
|
||||
|
||||
Aws::String m_paginationToken;
|
||||
bool m_paginationTokenHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,93 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cognito-idp/model/DeviceType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>Lists the device's response, as an administrator.</p><p><h3>See Also:</h3>
|
||||
* <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminListDevicesResponse">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminListDevicesResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminListDevicesResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminListDevicesResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminListDevicesResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The devices in the list of devices response.</p>
|
||||
*/
|
||||
inline const Aws::Vector<DeviceType>& GetDevices() const{ return m_devices; }
|
||||
inline void SetDevices(const Aws::Vector<DeviceType>& value) { m_devices = value; }
|
||||
inline void SetDevices(Aws::Vector<DeviceType>&& value) { m_devices = std::move(value); }
|
||||
inline AdminListDevicesResult& WithDevices(const Aws::Vector<DeviceType>& value) { SetDevices(value); return *this;}
|
||||
inline AdminListDevicesResult& WithDevices(Aws::Vector<DeviceType>&& value) { SetDevices(std::move(value)); return *this;}
|
||||
inline AdminListDevicesResult& AddDevices(const DeviceType& value) { m_devices.push_back(value); return *this; }
|
||||
inline AdminListDevicesResult& AddDevices(DeviceType&& value) { m_devices.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The identifier that Amazon Cognito returned with the previous request to this
|
||||
* operation. When you include a pagination token in your request, Amazon Cognito
|
||||
* returns the next set of items in the list. By use of this token, you can
|
||||
* paginate through the full list of items.</p>
|
||||
*/
|
||||
inline const Aws::String& GetPaginationToken() const{ return m_paginationToken; }
|
||||
inline void SetPaginationToken(const Aws::String& value) { m_paginationToken = value; }
|
||||
inline void SetPaginationToken(Aws::String&& value) { m_paginationToken = std::move(value); }
|
||||
inline void SetPaginationToken(const char* value) { m_paginationToken.assign(value); }
|
||||
inline AdminListDevicesResult& WithPaginationToken(const Aws::String& value) { SetPaginationToken(value); return *this;}
|
||||
inline AdminListDevicesResult& WithPaginationToken(Aws::String&& value) { SetPaginationToken(std::move(value)); return *this;}
|
||||
inline AdminListDevicesResult& WithPaginationToken(const char* value) { SetPaginationToken(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline AdminListDevicesResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline AdminListDevicesResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline AdminListDevicesResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::Vector<DeviceType> m_devices;
|
||||
|
||||
Aws::String m_paginationToken;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,110 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class AdminListGroupsForUserRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminListGroupsForUserRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AdminListGroupsForUser"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The username of the user that you want to query or modify. The value of this
|
||||
* parameter is typically your user's username, but it can be any of their alias
|
||||
* attributes. If <code>username</code> isn't an alias attribute in your user pool,
|
||||
* this value must be the <code>sub</code> of a local user or the username of a
|
||||
* user from a third-party IdP.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUsername() const{ return m_username; }
|
||||
inline bool UsernameHasBeenSet() const { return m_usernameHasBeenSet; }
|
||||
inline void SetUsername(const Aws::String& value) { m_usernameHasBeenSet = true; m_username = value; }
|
||||
inline void SetUsername(Aws::String&& value) { m_usernameHasBeenSet = true; m_username = std::move(value); }
|
||||
inline void SetUsername(const char* value) { m_usernameHasBeenSet = true; m_username.assign(value); }
|
||||
inline AdminListGroupsForUserRequest& WithUsername(const Aws::String& value) { SetUsername(value); return *this;}
|
||||
inline AdminListGroupsForUserRequest& WithUsername(Aws::String&& value) { SetUsername(std::move(value)); return *this;}
|
||||
inline AdminListGroupsForUserRequest& WithUsername(const char* value) { SetUsername(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user pool ID for the user pool.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AdminListGroupsForUserRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AdminListGroupsForUserRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AdminListGroupsForUserRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The limit of the request to list groups.</p>
|
||||
*/
|
||||
inline int GetLimit() const{ return m_limit; }
|
||||
inline bool LimitHasBeenSet() const { return m_limitHasBeenSet; }
|
||||
inline void SetLimit(int value) { m_limitHasBeenSet = true; m_limit = value; }
|
||||
inline AdminListGroupsForUserRequest& WithLimit(int value) { SetLimit(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>An identifier that was returned from the previous call to this operation,
|
||||
* which can be used to return the next set of items in the list.</p>
|
||||
*/
|
||||
inline const Aws::String& GetNextToken() const{ return m_nextToken; }
|
||||
inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
|
||||
inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
|
||||
inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
|
||||
inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
|
||||
inline AdminListGroupsForUserRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
|
||||
inline AdminListGroupsForUserRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
|
||||
inline AdminListGroupsForUserRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_username;
|
||||
bool m_usernameHasBeenSet = false;
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
int m_limit;
|
||||
bool m_limitHasBeenSet = false;
|
||||
|
||||
Aws::String m_nextToken;
|
||||
bool m_nextTokenHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,85 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cognito-idp/model/GroupType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class AdminListGroupsForUserResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminListGroupsForUserResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminListGroupsForUserResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminListGroupsForUserResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The groups that the user belongs to.</p>
|
||||
*/
|
||||
inline const Aws::Vector<GroupType>& GetGroups() const{ return m_groups; }
|
||||
inline void SetGroups(const Aws::Vector<GroupType>& value) { m_groups = value; }
|
||||
inline void SetGroups(Aws::Vector<GroupType>&& value) { m_groups = std::move(value); }
|
||||
inline AdminListGroupsForUserResult& WithGroups(const Aws::Vector<GroupType>& value) { SetGroups(value); return *this;}
|
||||
inline AdminListGroupsForUserResult& WithGroups(Aws::Vector<GroupType>&& value) { SetGroups(std::move(value)); return *this;}
|
||||
inline AdminListGroupsForUserResult& AddGroups(const GroupType& value) { m_groups.push_back(value); return *this; }
|
||||
inline AdminListGroupsForUserResult& AddGroups(GroupType&& value) { m_groups.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>An identifier that was returned from the previous call to this operation,
|
||||
* which can be used to return the next set of items in the list.</p>
|
||||
*/
|
||||
inline const Aws::String& GetNextToken() const{ return m_nextToken; }
|
||||
inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
|
||||
inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
|
||||
inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
|
||||
inline AdminListGroupsForUserResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
|
||||
inline AdminListGroupsForUserResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
|
||||
inline AdminListGroupsForUserResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline AdminListGroupsForUserResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline AdminListGroupsForUserResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline AdminListGroupsForUserResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::Vector<GroupType> m_groups;
|
||||
|
||||
Aws::String m_nextToken;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,111 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class AdminListUserAuthEventsRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminListUserAuthEventsRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AdminListUserAuthEvents"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user pool ID.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AdminListUserAuthEventsRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AdminListUserAuthEventsRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AdminListUserAuthEventsRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The username of the user that you want to query or modify. The value of this
|
||||
* parameter is typically your user's username, but it can be any of their alias
|
||||
* attributes. If <code>username</code> isn't an alias attribute in your user pool,
|
||||
* this value must be the <code>sub</code> of a local user or the username of a
|
||||
* user from a third-party IdP.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUsername() const{ return m_username; }
|
||||
inline bool UsernameHasBeenSet() const { return m_usernameHasBeenSet; }
|
||||
inline void SetUsername(const Aws::String& value) { m_usernameHasBeenSet = true; m_username = value; }
|
||||
inline void SetUsername(Aws::String&& value) { m_usernameHasBeenSet = true; m_username = std::move(value); }
|
||||
inline void SetUsername(const char* value) { m_usernameHasBeenSet = true; m_username.assign(value); }
|
||||
inline AdminListUserAuthEventsRequest& WithUsername(const Aws::String& value) { SetUsername(value); return *this;}
|
||||
inline AdminListUserAuthEventsRequest& WithUsername(Aws::String&& value) { SetUsername(std::move(value)); return *this;}
|
||||
inline AdminListUserAuthEventsRequest& WithUsername(const char* value) { SetUsername(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The maximum number of authentication events to return. Returns 60 events if
|
||||
* you set <code>MaxResults</code> to 0, or if you don't include a
|
||||
* <code>MaxResults</code> parameter.</p>
|
||||
*/
|
||||
inline int GetMaxResults() const{ return m_maxResults; }
|
||||
inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
|
||||
inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }
|
||||
inline AdminListUserAuthEventsRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A pagination token.</p>
|
||||
*/
|
||||
inline const Aws::String& GetNextToken() const{ return m_nextToken; }
|
||||
inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
|
||||
inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
|
||||
inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
|
||||
inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
|
||||
inline AdminListUserAuthEventsRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
|
||||
inline AdminListUserAuthEventsRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
|
||||
inline AdminListUserAuthEventsRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_username;
|
||||
bool m_usernameHasBeenSet = false;
|
||||
|
||||
int m_maxResults;
|
||||
bool m_maxResultsHasBeenSet = false;
|
||||
|
||||
Aws::String m_nextToken;
|
||||
bool m_nextTokenHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,86 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cognito-idp/model/AuthEventType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class AdminListUserAuthEventsResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminListUserAuthEventsResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminListUserAuthEventsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminListUserAuthEventsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The response object. It includes the <code>EventID</code>,
|
||||
* <code>EventType</code>, <code>CreationDate</code>, <code>EventRisk</code>, and
|
||||
* <code>EventResponse</code>.</p>
|
||||
*/
|
||||
inline const Aws::Vector<AuthEventType>& GetAuthEvents() const{ return m_authEvents; }
|
||||
inline void SetAuthEvents(const Aws::Vector<AuthEventType>& value) { m_authEvents = value; }
|
||||
inline void SetAuthEvents(Aws::Vector<AuthEventType>&& value) { m_authEvents = std::move(value); }
|
||||
inline AdminListUserAuthEventsResult& WithAuthEvents(const Aws::Vector<AuthEventType>& value) { SetAuthEvents(value); return *this;}
|
||||
inline AdminListUserAuthEventsResult& WithAuthEvents(Aws::Vector<AuthEventType>&& value) { SetAuthEvents(std::move(value)); return *this;}
|
||||
inline AdminListUserAuthEventsResult& AddAuthEvents(const AuthEventType& value) { m_authEvents.push_back(value); return *this; }
|
||||
inline AdminListUserAuthEventsResult& AddAuthEvents(AuthEventType&& value) { m_authEvents.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A pagination token.</p>
|
||||
*/
|
||||
inline const Aws::String& GetNextToken() const{ return m_nextToken; }
|
||||
inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }
|
||||
inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }
|
||||
inline void SetNextToken(const char* value) { m_nextToken.assign(value); }
|
||||
inline AdminListUserAuthEventsResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
|
||||
inline AdminListUserAuthEventsResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
|
||||
inline AdminListUserAuthEventsResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline AdminListUserAuthEventsResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline AdminListUserAuthEventsResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline AdminListUserAuthEventsResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::Vector<AuthEventType> m_authEvents;
|
||||
|
||||
Aws::String m_nextToken;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,96 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class AdminRemoveUserFromGroupRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminRemoveUserFromGroupRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AdminRemoveUserFromGroup"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user pool ID for the user pool.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AdminRemoveUserFromGroupRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AdminRemoveUserFromGroupRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AdminRemoveUserFromGroupRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The username of the user that you want to query or modify. The value of this
|
||||
* parameter is typically your user's username, but it can be any of their alias
|
||||
* attributes. If <code>username</code> isn't an alias attribute in your user pool,
|
||||
* this value must be the <code>sub</code> of a local user or the username of a
|
||||
* user from a third-party IdP.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUsername() const{ return m_username; }
|
||||
inline bool UsernameHasBeenSet() const { return m_usernameHasBeenSet; }
|
||||
inline void SetUsername(const Aws::String& value) { m_usernameHasBeenSet = true; m_username = value; }
|
||||
inline void SetUsername(Aws::String&& value) { m_usernameHasBeenSet = true; m_username = std::move(value); }
|
||||
inline void SetUsername(const char* value) { m_usernameHasBeenSet = true; m_username.assign(value); }
|
||||
inline AdminRemoveUserFromGroupRequest& WithUsername(const Aws::String& value) { SetUsername(value); return *this;}
|
||||
inline AdminRemoveUserFromGroupRequest& WithUsername(Aws::String&& value) { SetUsername(std::move(value)); return *this;}
|
||||
inline AdminRemoveUserFromGroupRequest& WithUsername(const char* value) { SetUsername(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The group name.</p>
|
||||
*/
|
||||
inline const Aws::String& GetGroupName() const{ return m_groupName; }
|
||||
inline bool GroupNameHasBeenSet() const { return m_groupNameHasBeenSet; }
|
||||
inline void SetGroupName(const Aws::String& value) { m_groupNameHasBeenSet = true; m_groupName = value; }
|
||||
inline void SetGroupName(Aws::String&& value) { m_groupNameHasBeenSet = true; m_groupName = std::move(value); }
|
||||
inline void SetGroupName(const char* value) { m_groupNameHasBeenSet = true; m_groupName.assign(value); }
|
||||
inline AdminRemoveUserFromGroupRequest& WithGroupName(const Aws::String& value) { SetGroupName(value); return *this;}
|
||||
inline AdminRemoveUserFromGroupRequest& WithGroupName(Aws::String&& value) { SetGroupName(std::move(value)); return *this;}
|
||||
inline AdminRemoveUserFromGroupRequest& WithGroupName(const char* value) { SetGroupName(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_username;
|
||||
bool m_usernameHasBeenSet = false;
|
||||
|
||||
Aws::String m_groupName;
|
||||
bool m_groupNameHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,127 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSMap.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Represents the request to reset a user's password as an
|
||||
* administrator.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminResetUserPasswordRequest">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminResetUserPasswordRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminResetUserPasswordRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AdminResetUserPassword"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user pool ID for the user pool where you want to reset the user's
|
||||
* password.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AdminResetUserPasswordRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AdminResetUserPasswordRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AdminResetUserPasswordRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The username of the user that you want to query or modify. The value of this
|
||||
* parameter is typically your user's username, but it can be any of their alias
|
||||
* attributes. If <code>username</code> isn't an alias attribute in your user pool,
|
||||
* this value must be the <code>sub</code> of a local user or the username of a
|
||||
* user from a third-party IdP.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUsername() const{ return m_username; }
|
||||
inline bool UsernameHasBeenSet() const { return m_usernameHasBeenSet; }
|
||||
inline void SetUsername(const Aws::String& value) { m_usernameHasBeenSet = true; m_username = value; }
|
||||
inline void SetUsername(Aws::String&& value) { m_usernameHasBeenSet = true; m_username = std::move(value); }
|
||||
inline void SetUsername(const char* value) { m_usernameHasBeenSet = true; m_username.assign(value); }
|
||||
inline AdminResetUserPasswordRequest& WithUsername(const Aws::String& value) { SetUsername(value); return *this;}
|
||||
inline AdminResetUserPasswordRequest& WithUsername(Aws::String&& value) { SetUsername(std::move(value)); return *this;}
|
||||
inline AdminResetUserPasswordRequest& WithUsername(const char* value) { SetUsername(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A map of custom key-value pairs that you can provide as input for any custom
|
||||
* workflows that this action triggers.</p> <p>You create custom workflows by
|
||||
* assigning Lambda functions to user pool triggers. When you use the
|
||||
* AdminResetUserPassword API action, Amazon Cognito invokes the function that is
|
||||
* assigned to the <i>custom message</i> trigger. When Amazon Cognito invokes this
|
||||
* function, it passes a JSON payload, which the function receives as input. This
|
||||
* payload contains a <code>clientMetadata</code> attribute, which provides the
|
||||
* data that you assigned to the ClientMetadata parameter in your
|
||||
* AdminResetUserPassword request. In your function code in Lambda, you can process
|
||||
* the <code>clientMetadata</code> value to enhance your workflow for your specific
|
||||
* needs. </p> <p>For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html">
|
||||
* Customizing user pool Workflows with Lambda Triggers</a> in the <i>Amazon
|
||||
* Cognito Developer Guide</i>.</p> <p>When you use the ClientMetadata
|
||||
* parameter, remember that Amazon Cognito won't do the following:</p> <ul> <li>
|
||||
* <p>Store the ClientMetadata value. This data is available only to Lambda
|
||||
* triggers that are assigned to a user pool to support custom workflows. If your
|
||||
* user pool configuration doesn't include triggers, the ClientMetadata parameter
|
||||
* serves no purpose.</p> </li> <li> <p>Validate the ClientMetadata value.</p>
|
||||
* </li> <li> <p>Encrypt the ClientMetadata value. Don't use Amazon Cognito to
|
||||
* provide sensitive information.</p> </li> </ul>
|
||||
*/
|
||||
inline const Aws::Map<Aws::String, Aws::String>& GetClientMetadata() const{ return m_clientMetadata; }
|
||||
inline bool ClientMetadataHasBeenSet() const { return m_clientMetadataHasBeenSet; }
|
||||
inline void SetClientMetadata(const Aws::Map<Aws::String, Aws::String>& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata = value; }
|
||||
inline void SetClientMetadata(Aws::Map<Aws::String, Aws::String>&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata = std::move(value); }
|
||||
inline AdminResetUserPasswordRequest& WithClientMetadata(const Aws::Map<Aws::String, Aws::String>& value) { SetClientMetadata(value); return *this;}
|
||||
inline AdminResetUserPasswordRequest& WithClientMetadata(Aws::Map<Aws::String, Aws::String>&& value) { SetClientMetadata(std::move(value)); return *this;}
|
||||
inline AdminResetUserPasswordRequest& AddClientMetadata(const Aws::String& key, const Aws::String& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, value); return *this; }
|
||||
inline AdminResetUserPasswordRequest& AddClientMetadata(Aws::String&& key, const Aws::String& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(std::move(key), value); return *this; }
|
||||
inline AdminResetUserPasswordRequest& AddClientMetadata(const Aws::String& key, Aws::String&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, std::move(value)); return *this; }
|
||||
inline AdminResetUserPasswordRequest& AddClientMetadata(Aws::String&& key, Aws::String&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(std::move(key), std::move(value)); return *this; }
|
||||
inline AdminResetUserPasswordRequest& AddClientMetadata(const char* key, Aws::String&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, std::move(value)); return *this; }
|
||||
inline AdminResetUserPasswordRequest& AddClientMetadata(Aws::String&& key, const char* value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(std::move(key), value); return *this; }
|
||||
inline AdminResetUserPasswordRequest& AddClientMetadata(const char* key, const char* value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, value); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_username;
|
||||
bool m_usernameHasBeenSet = false;
|
||||
|
||||
Aws::Map<Aws::String, Aws::String> m_clientMetadata;
|
||||
bool m_clientMetadataHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,58 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>Represents the response from the server to reset a user password as an
|
||||
* administrator.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminResetUserPasswordResponse">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminResetUserPasswordResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminResetUserPasswordResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminResetUserPasswordResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminResetUserPasswordResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline AdminResetUserPasswordResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline AdminResetUserPasswordResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline AdminResetUserPasswordResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,276 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cognito-idp/model/ChallengeNameType.h>
|
||||
#include <aws/core/utils/memory/stl/AWSMap.h>
|
||||
#include <aws/cognito-idp/model/AnalyticsMetadataType.h>
|
||||
#include <aws/cognito-idp/model/ContextDataType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The request to respond to the authentication challenge, as an
|
||||
* administrator.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminRespondToAuthChallengeRequest">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminRespondToAuthChallengeRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminRespondToAuthChallengeRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AdminRespondToAuthChallenge"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The ID of the Amazon Cognito user pool.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AdminRespondToAuthChallengeRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AdminRespondToAuthChallengeRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AdminRespondToAuthChallengeRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The app client ID.</p>
|
||||
*/
|
||||
inline const Aws::String& GetClientId() const{ return m_clientId; }
|
||||
inline bool ClientIdHasBeenSet() const { return m_clientIdHasBeenSet; }
|
||||
inline void SetClientId(const Aws::String& value) { m_clientIdHasBeenSet = true; m_clientId = value; }
|
||||
inline void SetClientId(Aws::String&& value) { m_clientIdHasBeenSet = true; m_clientId = std::move(value); }
|
||||
inline void SetClientId(const char* value) { m_clientIdHasBeenSet = true; m_clientId.assign(value); }
|
||||
inline AdminRespondToAuthChallengeRequest& WithClientId(const Aws::String& value) { SetClientId(value); return *this;}
|
||||
inline AdminRespondToAuthChallengeRequest& WithClientId(Aws::String&& value) { SetClientId(std::move(value)); return *this;}
|
||||
inline AdminRespondToAuthChallengeRequest& WithClientId(const char* value) { SetClientId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The challenge name. For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminInitiateAuth.html">AdminInitiateAuth</a>.</p>
|
||||
*/
|
||||
inline const ChallengeNameType& GetChallengeName() const{ return m_challengeName; }
|
||||
inline bool ChallengeNameHasBeenSet() const { return m_challengeNameHasBeenSet; }
|
||||
inline void SetChallengeName(const ChallengeNameType& value) { m_challengeNameHasBeenSet = true; m_challengeName = value; }
|
||||
inline void SetChallengeName(ChallengeNameType&& value) { m_challengeNameHasBeenSet = true; m_challengeName = std::move(value); }
|
||||
inline AdminRespondToAuthChallengeRequest& WithChallengeName(const ChallengeNameType& value) { SetChallengeName(value); return *this;}
|
||||
inline AdminRespondToAuthChallengeRequest& WithChallengeName(ChallengeNameType&& value) { SetChallengeName(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The responses to the challenge that you received in the previous request.
|
||||
* Each challenge has its own required response parameters. The following examples
|
||||
* are partial JSON request bodies that highlight challenge-response
|
||||
* parameters.</p> <p>You must provide a SECRET_HASH parameter in all
|
||||
* challenge responses to an app client that has a client secret.</p>
|
||||
* <dl> <dt>SMS_MFA</dt> <dd> <p> <code>"ChallengeName": "SMS_MFA",
|
||||
* "ChallengeResponses": {"SMS_MFA_CODE": "[code]", "USERNAME":
|
||||
* "[username]"}</code> </p> </dd> <dt>EMAIL_OTP</dt> <dd> <p>
|
||||
* <code>"ChallengeName": "EMAIL_OTP", "ChallengeResponses": {"EMAIL_OTP_CODE":
|
||||
* "[code]", "USERNAME": "[username]"}</code> </p> </dd> <dt>PASSWORD_VERIFIER</dt>
|
||||
* <dd> <p>This challenge response is part of the SRP flow. Amazon Cognito requires
|
||||
* that your application respond to this challenge within a few seconds. When the
|
||||
* response time exceeds this period, your user pool returns a
|
||||
* <code>NotAuthorizedException</code> error.</p> <p> <code>"ChallengeName":
|
||||
* "PASSWORD_VERIFIER", "ChallengeResponses": {"PASSWORD_CLAIM_SIGNATURE":
|
||||
* "[claim_signature]", "PASSWORD_CLAIM_SECRET_BLOCK": "[secret_block]",
|
||||
* "TIMESTAMP": [timestamp], "USERNAME": "[username]"}</code> </p> <p>Add
|
||||
* <code>"DEVICE_KEY"</code> when you sign in with a remembered device.</p> </dd>
|
||||
* <dt>CUSTOM_CHALLENGE</dt> <dd> <p> <code>"ChallengeName": "CUSTOM_CHALLENGE",
|
||||
* "ChallengeResponses": {"USERNAME": "[username]", "ANSWER":
|
||||
* "[challenge_answer]"}</code> </p> <p>Add <code>"DEVICE_KEY"</code> when you sign
|
||||
* in with a remembered device.</p> </dd> <dt>NEW_PASSWORD_REQUIRED</dt> <dd> <p>
|
||||
* <code>"ChallengeName": "NEW_PASSWORD_REQUIRED", "ChallengeResponses":
|
||||
* {"NEW_PASSWORD": "[new_password]", "USERNAME": "[username]"}</code> </p> <p>To
|
||||
* set any required attributes that <code>InitiateAuth</code> returned in an
|
||||
* <code>requiredAttributes</code> parameter, add
|
||||
* <code>"userAttributes.[attribute_name]": "[attribute_value]"</code>. This
|
||||
* parameter can also set values for writable attributes that aren't required by
|
||||
* your user pool.</p> <p>In a <code>NEW_PASSWORD_REQUIRED</code> challenge
|
||||
* response, you can't modify a required attribute that already has a value. In
|
||||
* <code>RespondToAuthChallenge</code>, set a value for any keys that Amazon
|
||||
* Cognito returned in the <code>requiredAttributes</code> parameter, then use the
|
||||
* <code>UpdateUserAttributes</code> API operation to modify the value of any
|
||||
* additional attributes.</p> </dd> <dt>SOFTWARE_TOKEN_MFA</dt> <dd> <p>
|
||||
* <code>"ChallengeName": "SOFTWARE_TOKEN_MFA", "ChallengeResponses": {"USERNAME":
|
||||
* "[username]", "SOFTWARE_TOKEN_MFA_CODE": [authenticator_code]}</code> </p> </dd>
|
||||
* <dt>DEVICE_SRP_AUTH</dt> <dd> <p> <code>"ChallengeName": "DEVICE_SRP_AUTH",
|
||||
* "ChallengeResponses": {"USERNAME": "[username]", "DEVICE_KEY": "[device_key]",
|
||||
* "SRP_A": "[srp_a]"}</code> </p> </dd> <dt>DEVICE_PASSWORD_VERIFIER</dt> <dd> <p>
|
||||
* <code>"ChallengeName": "DEVICE_PASSWORD_VERIFIER", "ChallengeResponses":
|
||||
* {"DEVICE_KEY": "[device_key]", "PASSWORD_CLAIM_SIGNATURE": "[claim_signature]",
|
||||
* "PASSWORD_CLAIM_SECRET_BLOCK": "[secret_block]", "TIMESTAMP": [timestamp],
|
||||
* "USERNAME": "[username]"}</code> </p> </dd> <dt>MFA_SETUP</dt> <dd> <p>
|
||||
* <code>"ChallengeName": "MFA_SETUP", "ChallengeResponses": {"USERNAME":
|
||||
* "[username]"}, "SESSION": "[Session ID from VerifySoftwareToken]"</code> </p>
|
||||
* </dd> <dt>SELECT_MFA_TYPE</dt> <dd> <p> <code>"ChallengeName":
|
||||
* "SELECT_MFA_TYPE", "ChallengeResponses": {"USERNAME": "[username]", "ANSWER":
|
||||
* "[SMS_MFA or SOFTWARE_TOKEN_MFA]"}</code> </p> </dd> </dl> <p>For more
|
||||
* information about <code>SECRET_HASH</code>, see <a
|
||||
* href="https://docs.aws.amazon.com/cognito/latest/developerguide/signing-up-users-in-your-app.html#cognito-user-pools-computing-secret-hash">Computing
|
||||
* secret hash values</a>. For information about <code>DEVICE_KEY</code>, see <a
|
||||
* href="https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-device-tracking.html">Working
|
||||
* with user devices in your user pool</a>.</p>
|
||||
*/
|
||||
inline const Aws::Map<Aws::String, Aws::String>& GetChallengeResponses() const{ return m_challengeResponses; }
|
||||
inline bool ChallengeResponsesHasBeenSet() const { return m_challengeResponsesHasBeenSet; }
|
||||
inline void SetChallengeResponses(const Aws::Map<Aws::String, Aws::String>& value) { m_challengeResponsesHasBeenSet = true; m_challengeResponses = value; }
|
||||
inline void SetChallengeResponses(Aws::Map<Aws::String, Aws::String>&& value) { m_challengeResponsesHasBeenSet = true; m_challengeResponses = std::move(value); }
|
||||
inline AdminRespondToAuthChallengeRequest& WithChallengeResponses(const Aws::Map<Aws::String, Aws::String>& value) { SetChallengeResponses(value); return *this;}
|
||||
inline AdminRespondToAuthChallengeRequest& WithChallengeResponses(Aws::Map<Aws::String, Aws::String>&& value) { SetChallengeResponses(std::move(value)); return *this;}
|
||||
inline AdminRespondToAuthChallengeRequest& AddChallengeResponses(const Aws::String& key, const Aws::String& value) { m_challengeResponsesHasBeenSet = true; m_challengeResponses.emplace(key, value); return *this; }
|
||||
inline AdminRespondToAuthChallengeRequest& AddChallengeResponses(Aws::String&& key, const Aws::String& value) { m_challengeResponsesHasBeenSet = true; m_challengeResponses.emplace(std::move(key), value); return *this; }
|
||||
inline AdminRespondToAuthChallengeRequest& AddChallengeResponses(const Aws::String& key, Aws::String&& value) { m_challengeResponsesHasBeenSet = true; m_challengeResponses.emplace(key, std::move(value)); return *this; }
|
||||
inline AdminRespondToAuthChallengeRequest& AddChallengeResponses(Aws::String&& key, Aws::String&& value) { m_challengeResponsesHasBeenSet = true; m_challengeResponses.emplace(std::move(key), std::move(value)); return *this; }
|
||||
inline AdminRespondToAuthChallengeRequest& AddChallengeResponses(const char* key, Aws::String&& value) { m_challengeResponsesHasBeenSet = true; m_challengeResponses.emplace(key, std::move(value)); return *this; }
|
||||
inline AdminRespondToAuthChallengeRequest& AddChallengeResponses(Aws::String&& key, const char* value) { m_challengeResponsesHasBeenSet = true; m_challengeResponses.emplace(std::move(key), value); return *this; }
|
||||
inline AdminRespondToAuthChallengeRequest& AddChallengeResponses(const char* key, const char* value) { m_challengeResponsesHasBeenSet = true; m_challengeResponses.emplace(key, value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The session that should be passed both ways in challenge-response calls to
|
||||
* the service. If an <code>InitiateAuth</code> or
|
||||
* <code>RespondToAuthChallenge</code> API call determines that the caller must
|
||||
* pass another challenge, it returns a session with other challenge parameters.
|
||||
* This session should be passed as it is to the next
|
||||
* <code>RespondToAuthChallenge</code> API call.</p>
|
||||
*/
|
||||
inline const Aws::String& GetSession() const{ return m_session; }
|
||||
inline bool SessionHasBeenSet() const { return m_sessionHasBeenSet; }
|
||||
inline void SetSession(const Aws::String& value) { m_sessionHasBeenSet = true; m_session = value; }
|
||||
inline void SetSession(Aws::String&& value) { m_sessionHasBeenSet = true; m_session = std::move(value); }
|
||||
inline void SetSession(const char* value) { m_sessionHasBeenSet = true; m_session.assign(value); }
|
||||
inline AdminRespondToAuthChallengeRequest& WithSession(const Aws::String& value) { SetSession(value); return *this;}
|
||||
inline AdminRespondToAuthChallengeRequest& WithSession(Aws::String&& value) { SetSession(std::move(value)); return *this;}
|
||||
inline AdminRespondToAuthChallengeRequest& WithSession(const char* value) { SetSession(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The analytics metadata for collecting Amazon Pinpoint metrics for
|
||||
* <code>AdminRespondToAuthChallenge</code> calls.</p>
|
||||
*/
|
||||
inline const AnalyticsMetadataType& GetAnalyticsMetadata() const{ return m_analyticsMetadata; }
|
||||
inline bool AnalyticsMetadataHasBeenSet() const { return m_analyticsMetadataHasBeenSet; }
|
||||
inline void SetAnalyticsMetadata(const AnalyticsMetadataType& value) { m_analyticsMetadataHasBeenSet = true; m_analyticsMetadata = value; }
|
||||
inline void SetAnalyticsMetadata(AnalyticsMetadataType&& value) { m_analyticsMetadataHasBeenSet = true; m_analyticsMetadata = std::move(value); }
|
||||
inline AdminRespondToAuthChallengeRequest& WithAnalyticsMetadata(const AnalyticsMetadataType& value) { SetAnalyticsMetadata(value); return *this;}
|
||||
inline AdminRespondToAuthChallengeRequest& WithAnalyticsMetadata(AnalyticsMetadataType&& value) { SetAnalyticsMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Contextual data about your user session, such as the device fingerprint, IP
|
||||
* address, or location. Amazon Cognito advanced security evaluates the risk of an
|
||||
* authentication event based on the context that your app generates and passes to
|
||||
* Amazon Cognito when it makes API requests.</p>
|
||||
*/
|
||||
inline const ContextDataType& GetContextData() const{ return m_contextData; }
|
||||
inline bool ContextDataHasBeenSet() const { return m_contextDataHasBeenSet; }
|
||||
inline void SetContextData(const ContextDataType& value) { m_contextDataHasBeenSet = true; m_contextData = value; }
|
||||
inline void SetContextData(ContextDataType&& value) { m_contextDataHasBeenSet = true; m_contextData = std::move(value); }
|
||||
inline AdminRespondToAuthChallengeRequest& WithContextData(const ContextDataType& value) { SetContextData(value); return *this;}
|
||||
inline AdminRespondToAuthChallengeRequest& WithContextData(ContextDataType&& value) { SetContextData(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A map of custom key-value pairs that you can provide as input for any custom
|
||||
* workflows that this action triggers.</p> <p>You create custom workflows by
|
||||
* assigning Lambda functions to user pool triggers. When you use the
|
||||
* AdminRespondToAuthChallenge API action, Amazon Cognito invokes any functions
|
||||
* that you have assigned to the following triggers: </p> <ul> <li> <p>pre
|
||||
* sign-up</p> </li> <li> <p>custom message</p> </li> <li> <p>post
|
||||
* authentication</p> </li> <li> <p>user migration</p> </li> <li> <p>pre token
|
||||
* generation</p> </li> <li> <p>define auth challenge</p> </li> <li> <p>create auth
|
||||
* challenge</p> </li> <li> <p>verify auth challenge response</p> </li> </ul>
|
||||
* <p>When Amazon Cognito invokes any of these functions, it passes a JSON payload,
|
||||
* which the function receives as input. This payload contains a
|
||||
* <code>clientMetadata</code> attribute that provides the data that you assigned
|
||||
* to the ClientMetadata parameter in your AdminRespondToAuthChallenge request. In
|
||||
* your function code in Lambda, you can process the <code>clientMetadata</code>
|
||||
* value to enhance your workflow for your specific needs.</p> <p>For more
|
||||
* information, see <a
|
||||
* href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html">
|
||||
* Customizing user pool Workflows with Lambda Triggers</a> in the <i>Amazon
|
||||
* Cognito Developer Guide</i>.</p> <p>When you use the ClientMetadata
|
||||
* parameter, remember that Amazon Cognito won't do the following:</p> <ul> <li>
|
||||
* <p>Store the ClientMetadata value. This data is available only to Lambda
|
||||
* triggers that are assigned to a user pool to support custom workflows. If your
|
||||
* user pool configuration doesn't include triggers, the ClientMetadata parameter
|
||||
* serves no purpose.</p> </li> <li> <p>Validate the ClientMetadata value.</p>
|
||||
* </li> <li> <p>Encrypt the ClientMetadata value. Don't use Amazon Cognito to
|
||||
* provide sensitive information.</p> </li> </ul>
|
||||
*/
|
||||
inline const Aws::Map<Aws::String, Aws::String>& GetClientMetadata() const{ return m_clientMetadata; }
|
||||
inline bool ClientMetadataHasBeenSet() const { return m_clientMetadataHasBeenSet; }
|
||||
inline void SetClientMetadata(const Aws::Map<Aws::String, Aws::String>& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata = value; }
|
||||
inline void SetClientMetadata(Aws::Map<Aws::String, Aws::String>&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata = std::move(value); }
|
||||
inline AdminRespondToAuthChallengeRequest& WithClientMetadata(const Aws::Map<Aws::String, Aws::String>& value) { SetClientMetadata(value); return *this;}
|
||||
inline AdminRespondToAuthChallengeRequest& WithClientMetadata(Aws::Map<Aws::String, Aws::String>&& value) { SetClientMetadata(std::move(value)); return *this;}
|
||||
inline AdminRespondToAuthChallengeRequest& AddClientMetadata(const Aws::String& key, const Aws::String& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, value); return *this; }
|
||||
inline AdminRespondToAuthChallengeRequest& AddClientMetadata(Aws::String&& key, const Aws::String& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(std::move(key), value); return *this; }
|
||||
inline AdminRespondToAuthChallengeRequest& AddClientMetadata(const Aws::String& key, Aws::String&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, std::move(value)); return *this; }
|
||||
inline AdminRespondToAuthChallengeRequest& AddClientMetadata(Aws::String&& key, Aws::String&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(std::move(key), std::move(value)); return *this; }
|
||||
inline AdminRespondToAuthChallengeRequest& AddClientMetadata(const char* key, Aws::String&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, std::move(value)); return *this; }
|
||||
inline AdminRespondToAuthChallengeRequest& AddClientMetadata(Aws::String&& key, const char* value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(std::move(key), value); return *this; }
|
||||
inline AdminRespondToAuthChallengeRequest& AddClientMetadata(const char* key, const char* value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, value); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_clientId;
|
||||
bool m_clientIdHasBeenSet = false;
|
||||
|
||||
ChallengeNameType m_challengeName;
|
||||
bool m_challengeNameHasBeenSet = false;
|
||||
|
||||
Aws::Map<Aws::String, Aws::String> m_challengeResponses;
|
||||
bool m_challengeResponsesHasBeenSet = false;
|
||||
|
||||
Aws::String m_session;
|
||||
bool m_sessionHasBeenSet = false;
|
||||
|
||||
AnalyticsMetadataType m_analyticsMetadata;
|
||||
bool m_analyticsMetadataHasBeenSet = false;
|
||||
|
||||
ContextDataType m_contextData;
|
||||
bool m_contextDataHasBeenSet = false;
|
||||
|
||||
Aws::Map<Aws::String, Aws::String> m_clientMetadata;
|
||||
bool m_clientMetadataHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,128 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/model/ChallengeNameType.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSMap.h>
|
||||
#include <aws/cognito-idp/model/AuthenticationResultType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>Responds to the authentication challenge, as an administrator.</p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminRespondToAuthChallengeResponse">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminRespondToAuthChallengeResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminRespondToAuthChallengeResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminRespondToAuthChallengeResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminRespondToAuthChallengeResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of the challenge. For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminInitiateAuth.html">AdminInitiateAuth</a>.</p>
|
||||
*/
|
||||
inline const ChallengeNameType& GetChallengeName() const{ return m_challengeName; }
|
||||
inline void SetChallengeName(const ChallengeNameType& value) { m_challengeName = value; }
|
||||
inline void SetChallengeName(ChallengeNameType&& value) { m_challengeName = std::move(value); }
|
||||
inline AdminRespondToAuthChallengeResult& WithChallengeName(const ChallengeNameType& value) { SetChallengeName(value); return *this;}
|
||||
inline AdminRespondToAuthChallengeResult& WithChallengeName(ChallengeNameType&& value) { SetChallengeName(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The session that should be passed both ways in challenge-response calls to
|
||||
* the service. If the caller must pass another challenge, they return a session
|
||||
* with other challenge parameters. This session should be passed as it is to the
|
||||
* next <code>RespondToAuthChallenge</code> API call.</p>
|
||||
*/
|
||||
inline const Aws::String& GetSession() const{ return m_session; }
|
||||
inline void SetSession(const Aws::String& value) { m_session = value; }
|
||||
inline void SetSession(Aws::String&& value) { m_session = std::move(value); }
|
||||
inline void SetSession(const char* value) { m_session.assign(value); }
|
||||
inline AdminRespondToAuthChallengeResult& WithSession(const Aws::String& value) { SetSession(value); return *this;}
|
||||
inline AdminRespondToAuthChallengeResult& WithSession(Aws::String&& value) { SetSession(std::move(value)); return *this;}
|
||||
inline AdminRespondToAuthChallengeResult& WithSession(const char* value) { SetSession(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The challenge parameters. For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminInitiateAuth.html">AdminInitiateAuth</a>.</p>
|
||||
*/
|
||||
inline const Aws::Map<Aws::String, Aws::String>& GetChallengeParameters() const{ return m_challengeParameters; }
|
||||
inline void SetChallengeParameters(const Aws::Map<Aws::String, Aws::String>& value) { m_challengeParameters = value; }
|
||||
inline void SetChallengeParameters(Aws::Map<Aws::String, Aws::String>&& value) { m_challengeParameters = std::move(value); }
|
||||
inline AdminRespondToAuthChallengeResult& WithChallengeParameters(const Aws::Map<Aws::String, Aws::String>& value) { SetChallengeParameters(value); return *this;}
|
||||
inline AdminRespondToAuthChallengeResult& WithChallengeParameters(Aws::Map<Aws::String, Aws::String>&& value) { SetChallengeParameters(std::move(value)); return *this;}
|
||||
inline AdminRespondToAuthChallengeResult& AddChallengeParameters(const Aws::String& key, const Aws::String& value) { m_challengeParameters.emplace(key, value); return *this; }
|
||||
inline AdminRespondToAuthChallengeResult& AddChallengeParameters(Aws::String&& key, const Aws::String& value) { m_challengeParameters.emplace(std::move(key), value); return *this; }
|
||||
inline AdminRespondToAuthChallengeResult& AddChallengeParameters(const Aws::String& key, Aws::String&& value) { m_challengeParameters.emplace(key, std::move(value)); return *this; }
|
||||
inline AdminRespondToAuthChallengeResult& AddChallengeParameters(Aws::String&& key, Aws::String&& value) { m_challengeParameters.emplace(std::move(key), std::move(value)); return *this; }
|
||||
inline AdminRespondToAuthChallengeResult& AddChallengeParameters(const char* key, Aws::String&& value) { m_challengeParameters.emplace(key, std::move(value)); return *this; }
|
||||
inline AdminRespondToAuthChallengeResult& AddChallengeParameters(Aws::String&& key, const char* value) { m_challengeParameters.emplace(std::move(key), value); return *this; }
|
||||
inline AdminRespondToAuthChallengeResult& AddChallengeParameters(const char* key, const char* value) { m_challengeParameters.emplace(key, value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The result returned by the server in response to the authentication
|
||||
* request.</p>
|
||||
*/
|
||||
inline const AuthenticationResultType& GetAuthenticationResult() const{ return m_authenticationResult; }
|
||||
inline void SetAuthenticationResult(const AuthenticationResultType& value) { m_authenticationResult = value; }
|
||||
inline void SetAuthenticationResult(AuthenticationResultType&& value) { m_authenticationResult = std::move(value); }
|
||||
inline AdminRespondToAuthChallengeResult& WithAuthenticationResult(const AuthenticationResultType& value) { SetAuthenticationResult(value); return *this;}
|
||||
inline AdminRespondToAuthChallengeResult& WithAuthenticationResult(AuthenticationResultType&& value) { SetAuthenticationResult(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline AdminRespondToAuthChallengeResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline AdminRespondToAuthChallengeResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline AdminRespondToAuthChallengeResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
ChallengeNameType m_challengeName;
|
||||
|
||||
Aws::String m_session;
|
||||
|
||||
Aws::Map<Aws::String, Aws::String> m_challengeParameters;
|
||||
|
||||
AuthenticationResultType m_authenticationResult;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,134 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/cognito-idp/model/SMSMfaSettingsType.h>
|
||||
#include <aws/cognito-idp/model/SoftwareTokenMfaSettingsType.h>
|
||||
#include <aws/cognito-idp/model/EmailMfaSettingsType.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class AdminSetUserMFAPreferenceRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminSetUserMFAPreferenceRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AdminSetUserMFAPreference"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>User preferences for SMS message MFA. Activates or deactivates SMS MFA and
|
||||
* sets it as the preferred MFA method when multiple methods are available.</p>
|
||||
*/
|
||||
inline const SMSMfaSettingsType& GetSMSMfaSettings() const{ return m_sMSMfaSettings; }
|
||||
inline bool SMSMfaSettingsHasBeenSet() const { return m_sMSMfaSettingsHasBeenSet; }
|
||||
inline void SetSMSMfaSettings(const SMSMfaSettingsType& value) { m_sMSMfaSettingsHasBeenSet = true; m_sMSMfaSettings = value; }
|
||||
inline void SetSMSMfaSettings(SMSMfaSettingsType&& value) { m_sMSMfaSettingsHasBeenSet = true; m_sMSMfaSettings = std::move(value); }
|
||||
inline AdminSetUserMFAPreferenceRequest& WithSMSMfaSettings(const SMSMfaSettingsType& value) { SetSMSMfaSettings(value); return *this;}
|
||||
inline AdminSetUserMFAPreferenceRequest& WithSMSMfaSettings(SMSMfaSettingsType&& value) { SetSMSMfaSettings(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>User preferences for time-based one-time password (TOTP) MFA. Activates or
|
||||
* deactivates TOTP MFA and sets it as the preferred MFA method when multiple
|
||||
* methods are available.</p>
|
||||
*/
|
||||
inline const SoftwareTokenMfaSettingsType& GetSoftwareTokenMfaSettings() const{ return m_softwareTokenMfaSettings; }
|
||||
inline bool SoftwareTokenMfaSettingsHasBeenSet() const { return m_softwareTokenMfaSettingsHasBeenSet; }
|
||||
inline void SetSoftwareTokenMfaSettings(const SoftwareTokenMfaSettingsType& value) { m_softwareTokenMfaSettingsHasBeenSet = true; m_softwareTokenMfaSettings = value; }
|
||||
inline void SetSoftwareTokenMfaSettings(SoftwareTokenMfaSettingsType&& value) { m_softwareTokenMfaSettingsHasBeenSet = true; m_softwareTokenMfaSettings = std::move(value); }
|
||||
inline AdminSetUserMFAPreferenceRequest& WithSoftwareTokenMfaSettings(const SoftwareTokenMfaSettingsType& value) { SetSoftwareTokenMfaSettings(value); return *this;}
|
||||
inline AdminSetUserMFAPreferenceRequest& WithSoftwareTokenMfaSettings(SoftwareTokenMfaSettingsType&& value) { SetSoftwareTokenMfaSettings(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>User preferences for email message MFA. Activates or deactivates email MFA
|
||||
* and sets it as the preferred MFA method when multiple methods are available. To
|
||||
* activate this setting, <a
|
||||
* href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pool-settings-advanced-security.html">
|
||||
* advanced security features</a> must be active in your user pool.</p>
|
||||
*/
|
||||
inline const EmailMfaSettingsType& GetEmailMfaSettings() const{ return m_emailMfaSettings; }
|
||||
inline bool EmailMfaSettingsHasBeenSet() const { return m_emailMfaSettingsHasBeenSet; }
|
||||
inline void SetEmailMfaSettings(const EmailMfaSettingsType& value) { m_emailMfaSettingsHasBeenSet = true; m_emailMfaSettings = value; }
|
||||
inline void SetEmailMfaSettings(EmailMfaSettingsType&& value) { m_emailMfaSettingsHasBeenSet = true; m_emailMfaSettings = std::move(value); }
|
||||
inline AdminSetUserMFAPreferenceRequest& WithEmailMfaSettings(const EmailMfaSettingsType& value) { SetEmailMfaSettings(value); return *this;}
|
||||
inline AdminSetUserMFAPreferenceRequest& WithEmailMfaSettings(EmailMfaSettingsType&& value) { SetEmailMfaSettings(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The username of the user that you want to query or modify. The value of this
|
||||
* parameter is typically your user's username, but it can be any of their alias
|
||||
* attributes. If <code>username</code> isn't an alias attribute in your user pool,
|
||||
* this value must be the <code>sub</code> of a local user or the username of a
|
||||
* user from a third-party IdP.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUsername() const{ return m_username; }
|
||||
inline bool UsernameHasBeenSet() const { return m_usernameHasBeenSet; }
|
||||
inline void SetUsername(const Aws::String& value) { m_usernameHasBeenSet = true; m_username = value; }
|
||||
inline void SetUsername(Aws::String&& value) { m_usernameHasBeenSet = true; m_username = std::move(value); }
|
||||
inline void SetUsername(const char* value) { m_usernameHasBeenSet = true; m_username.assign(value); }
|
||||
inline AdminSetUserMFAPreferenceRequest& WithUsername(const Aws::String& value) { SetUsername(value); return *this;}
|
||||
inline AdminSetUserMFAPreferenceRequest& WithUsername(Aws::String&& value) { SetUsername(std::move(value)); return *this;}
|
||||
inline AdminSetUserMFAPreferenceRequest& WithUsername(const char* value) { SetUsername(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The ID of the user pool where you want to set a user's MFA preferences.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AdminSetUserMFAPreferenceRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AdminSetUserMFAPreferenceRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AdminSetUserMFAPreferenceRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
SMSMfaSettingsType m_sMSMfaSettings;
|
||||
bool m_sMSMfaSettingsHasBeenSet = false;
|
||||
|
||||
SoftwareTokenMfaSettingsType m_softwareTokenMfaSettings;
|
||||
bool m_softwareTokenMfaSettingsHasBeenSet = false;
|
||||
|
||||
EmailMfaSettingsType m_emailMfaSettings;
|
||||
bool m_emailMfaSettingsHasBeenSet = false;
|
||||
|
||||
Aws::String m_username;
|
||||
bool m_usernameHasBeenSet = false;
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,52 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class AdminSetUserMFAPreferenceResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminSetUserMFAPreferenceResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminSetUserMFAPreferenceResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminSetUserMFAPreferenceResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline AdminSetUserMFAPreferenceResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline AdminSetUserMFAPreferenceResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline AdminSetUserMFAPreferenceResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,111 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class AdminSetUserPasswordRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminSetUserPasswordRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AdminSetUserPassword"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user pool ID for the user pool where you want to set the user's
|
||||
* password.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AdminSetUserPasswordRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AdminSetUserPasswordRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AdminSetUserPasswordRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The username of the user that you want to query or modify. The value of this
|
||||
* parameter is typically your user's username, but it can be any of their alias
|
||||
* attributes. If <code>username</code> isn't an alias attribute in your user pool,
|
||||
* this value must be the <code>sub</code> of a local user or the username of a
|
||||
* user from a third-party IdP.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUsername() const{ return m_username; }
|
||||
inline bool UsernameHasBeenSet() const { return m_usernameHasBeenSet; }
|
||||
inline void SetUsername(const Aws::String& value) { m_usernameHasBeenSet = true; m_username = value; }
|
||||
inline void SetUsername(Aws::String&& value) { m_usernameHasBeenSet = true; m_username = std::move(value); }
|
||||
inline void SetUsername(const char* value) { m_usernameHasBeenSet = true; m_username.assign(value); }
|
||||
inline AdminSetUserPasswordRequest& WithUsername(const Aws::String& value) { SetUsername(value); return *this;}
|
||||
inline AdminSetUserPasswordRequest& WithUsername(Aws::String&& value) { SetUsername(std::move(value)); return *this;}
|
||||
inline AdminSetUserPasswordRequest& WithUsername(const char* value) { SetUsername(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The password for the user.</p>
|
||||
*/
|
||||
inline const Aws::String& GetPassword() const{ return m_password; }
|
||||
inline bool PasswordHasBeenSet() const { return m_passwordHasBeenSet; }
|
||||
inline void SetPassword(const Aws::String& value) { m_passwordHasBeenSet = true; m_password = value; }
|
||||
inline void SetPassword(Aws::String&& value) { m_passwordHasBeenSet = true; m_password = std::move(value); }
|
||||
inline void SetPassword(const char* value) { m_passwordHasBeenSet = true; m_password.assign(value); }
|
||||
inline AdminSetUserPasswordRequest& WithPassword(const Aws::String& value) { SetPassword(value); return *this;}
|
||||
inline AdminSetUserPasswordRequest& WithPassword(Aws::String&& value) { SetPassword(std::move(value)); return *this;}
|
||||
inline AdminSetUserPasswordRequest& WithPassword(const char* value) { SetPassword(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p> <code>True</code> if the password is permanent, <code>False</code> if it is
|
||||
* temporary.</p>
|
||||
*/
|
||||
inline bool GetPermanent() const{ return m_permanent; }
|
||||
inline bool PermanentHasBeenSet() const { return m_permanentHasBeenSet; }
|
||||
inline void SetPermanent(bool value) { m_permanentHasBeenSet = true; m_permanent = value; }
|
||||
inline AdminSetUserPasswordRequest& WithPermanent(bool value) { SetPermanent(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_username;
|
||||
bool m_usernameHasBeenSet = false;
|
||||
|
||||
Aws::String m_password;
|
||||
bool m_passwordHasBeenSet = false;
|
||||
|
||||
bool m_permanent;
|
||||
bool m_permanentHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,52 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class AdminSetUserPasswordResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminSetUserPasswordResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminSetUserPasswordResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminSetUserPasswordResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline AdminSetUserPasswordResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline AdminSetUserPasswordResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline AdminSetUserPasswordResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,104 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/cognito-idp/model/MFAOptionType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>You can use this parameter to set an MFA configuration that uses the SMS
|
||||
* delivery medium.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminSetUserSettingsRequest">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminSetUserSettingsRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminSetUserSettingsRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AdminSetUserSettings"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The ID of the user pool that contains the user whose options you're
|
||||
* setting.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AdminSetUserSettingsRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AdminSetUserSettingsRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AdminSetUserSettingsRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The username of the user that you want to query or modify. The value of this
|
||||
* parameter is typically your user's username, but it can be any of their alias
|
||||
* attributes. If <code>username</code> isn't an alias attribute in your user pool,
|
||||
* this value must be the <code>sub</code> of a local user or the username of a
|
||||
* user from a third-party IdP.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUsername() const{ return m_username; }
|
||||
inline bool UsernameHasBeenSet() const { return m_usernameHasBeenSet; }
|
||||
inline void SetUsername(const Aws::String& value) { m_usernameHasBeenSet = true; m_username = value; }
|
||||
inline void SetUsername(Aws::String&& value) { m_usernameHasBeenSet = true; m_username = std::move(value); }
|
||||
inline void SetUsername(const char* value) { m_usernameHasBeenSet = true; m_username.assign(value); }
|
||||
inline AdminSetUserSettingsRequest& WithUsername(const Aws::String& value) { SetUsername(value); return *this;}
|
||||
inline AdminSetUserSettingsRequest& WithUsername(Aws::String&& value) { SetUsername(std::move(value)); return *this;}
|
||||
inline AdminSetUserSettingsRequest& WithUsername(const char* value) { SetUsername(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>You can use this parameter only to set an SMS configuration that uses SMS for
|
||||
* delivery.</p>
|
||||
*/
|
||||
inline const Aws::Vector<MFAOptionType>& GetMFAOptions() const{ return m_mFAOptions; }
|
||||
inline bool MFAOptionsHasBeenSet() const { return m_mFAOptionsHasBeenSet; }
|
||||
inline void SetMFAOptions(const Aws::Vector<MFAOptionType>& value) { m_mFAOptionsHasBeenSet = true; m_mFAOptions = value; }
|
||||
inline void SetMFAOptions(Aws::Vector<MFAOptionType>&& value) { m_mFAOptionsHasBeenSet = true; m_mFAOptions = std::move(value); }
|
||||
inline AdminSetUserSettingsRequest& WithMFAOptions(const Aws::Vector<MFAOptionType>& value) { SetMFAOptions(value); return *this;}
|
||||
inline AdminSetUserSettingsRequest& WithMFAOptions(Aws::Vector<MFAOptionType>&& value) { SetMFAOptions(std::move(value)); return *this;}
|
||||
inline AdminSetUserSettingsRequest& AddMFAOptions(const MFAOptionType& value) { m_mFAOptionsHasBeenSet = true; m_mFAOptions.push_back(value); return *this; }
|
||||
inline AdminSetUserSettingsRequest& AddMFAOptions(MFAOptionType&& value) { m_mFAOptionsHasBeenSet = true; m_mFAOptions.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_username;
|
||||
bool m_usernameHasBeenSet = false;
|
||||
|
||||
Aws::Vector<MFAOptionType> m_mFAOptions;
|
||||
bool m_mFAOptionsHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,58 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>Represents the response from the server to set user settings as an
|
||||
* administrator.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminSetUserSettingsResponse">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminSetUserSettingsResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminSetUserSettingsResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminSetUserSettingsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminSetUserSettingsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline AdminSetUserSettingsResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline AdminSetUserSettingsResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline AdminSetUserSettingsResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,118 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cognito-idp/model/FeedbackValueType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class AdminUpdateAuthEventFeedbackRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminUpdateAuthEventFeedbackRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AdminUpdateAuthEventFeedback"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user pool ID.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AdminUpdateAuthEventFeedbackRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AdminUpdateAuthEventFeedbackRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AdminUpdateAuthEventFeedbackRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The username of the user that you want to query or modify. The value of this
|
||||
* parameter is typically your user's username, but it can be any of their alias
|
||||
* attributes. If <code>username</code> isn't an alias attribute in your user pool,
|
||||
* this value must be the <code>sub</code> of a local user or the username of a
|
||||
* user from a third-party IdP.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUsername() const{ return m_username; }
|
||||
inline bool UsernameHasBeenSet() const { return m_usernameHasBeenSet; }
|
||||
inline void SetUsername(const Aws::String& value) { m_usernameHasBeenSet = true; m_username = value; }
|
||||
inline void SetUsername(Aws::String&& value) { m_usernameHasBeenSet = true; m_username = std::move(value); }
|
||||
inline void SetUsername(const char* value) { m_usernameHasBeenSet = true; m_username.assign(value); }
|
||||
inline AdminUpdateAuthEventFeedbackRequest& WithUsername(const Aws::String& value) { SetUsername(value); return *this;}
|
||||
inline AdminUpdateAuthEventFeedbackRequest& WithUsername(Aws::String&& value) { SetUsername(std::move(value)); return *this;}
|
||||
inline AdminUpdateAuthEventFeedbackRequest& WithUsername(const char* value) { SetUsername(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The authentication event ID.</p>
|
||||
*/
|
||||
inline const Aws::String& GetEventId() const{ return m_eventId; }
|
||||
inline bool EventIdHasBeenSet() const { return m_eventIdHasBeenSet; }
|
||||
inline void SetEventId(const Aws::String& value) { m_eventIdHasBeenSet = true; m_eventId = value; }
|
||||
inline void SetEventId(Aws::String&& value) { m_eventIdHasBeenSet = true; m_eventId = std::move(value); }
|
||||
inline void SetEventId(const char* value) { m_eventIdHasBeenSet = true; m_eventId.assign(value); }
|
||||
inline AdminUpdateAuthEventFeedbackRequest& WithEventId(const Aws::String& value) { SetEventId(value); return *this;}
|
||||
inline AdminUpdateAuthEventFeedbackRequest& WithEventId(Aws::String&& value) { SetEventId(std::move(value)); return *this;}
|
||||
inline AdminUpdateAuthEventFeedbackRequest& WithEventId(const char* value) { SetEventId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The authentication event feedback value. When you provide a
|
||||
* <code>FeedbackValue</code> value of <code>valid</code>, you tell Amazon Cognito
|
||||
* that you trust a user session where Amazon Cognito has evaluated some level of
|
||||
* risk. When you provide a <code>FeedbackValue</code> value of
|
||||
* <code>invalid</code>, you tell Amazon Cognito that you don't trust a user
|
||||
* session, or you don't believe that Amazon Cognito evaluated a high-enough risk
|
||||
* level.</p>
|
||||
*/
|
||||
inline const FeedbackValueType& GetFeedbackValue() const{ return m_feedbackValue; }
|
||||
inline bool FeedbackValueHasBeenSet() const { return m_feedbackValueHasBeenSet; }
|
||||
inline void SetFeedbackValue(const FeedbackValueType& value) { m_feedbackValueHasBeenSet = true; m_feedbackValue = value; }
|
||||
inline void SetFeedbackValue(FeedbackValueType&& value) { m_feedbackValueHasBeenSet = true; m_feedbackValue = std::move(value); }
|
||||
inline AdminUpdateAuthEventFeedbackRequest& WithFeedbackValue(const FeedbackValueType& value) { SetFeedbackValue(value); return *this;}
|
||||
inline AdminUpdateAuthEventFeedbackRequest& WithFeedbackValue(FeedbackValueType&& value) { SetFeedbackValue(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_username;
|
||||
bool m_usernameHasBeenSet = false;
|
||||
|
||||
Aws::String m_eventId;
|
||||
bool m_eventIdHasBeenSet = false;
|
||||
|
||||
FeedbackValueType m_feedbackValue;
|
||||
bool m_feedbackValueHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,52 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class AdminUpdateAuthEventFeedbackResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminUpdateAuthEventFeedbackResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminUpdateAuthEventFeedbackResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminUpdateAuthEventFeedbackResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline AdminUpdateAuthEventFeedbackResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline AdminUpdateAuthEventFeedbackResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline AdminUpdateAuthEventFeedbackResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,116 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cognito-idp/model/DeviceRememberedStatusType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The request to update the device status, as an administrator.</p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminUpdateDeviceStatusRequest">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminUpdateDeviceStatusRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminUpdateDeviceStatusRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AdminUpdateDeviceStatus"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user pool ID.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AdminUpdateDeviceStatusRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AdminUpdateDeviceStatusRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AdminUpdateDeviceStatusRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The username of the user that you want to query or modify. The value of this
|
||||
* parameter is typically your user's username, but it can be any of their alias
|
||||
* attributes. If <code>username</code> isn't an alias attribute in your user pool,
|
||||
* this value must be the <code>sub</code> of a local user or the username of a
|
||||
* user from a third-party IdP.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUsername() const{ return m_username; }
|
||||
inline bool UsernameHasBeenSet() const { return m_usernameHasBeenSet; }
|
||||
inline void SetUsername(const Aws::String& value) { m_usernameHasBeenSet = true; m_username = value; }
|
||||
inline void SetUsername(Aws::String&& value) { m_usernameHasBeenSet = true; m_username = std::move(value); }
|
||||
inline void SetUsername(const char* value) { m_usernameHasBeenSet = true; m_username.assign(value); }
|
||||
inline AdminUpdateDeviceStatusRequest& WithUsername(const Aws::String& value) { SetUsername(value); return *this;}
|
||||
inline AdminUpdateDeviceStatusRequest& WithUsername(Aws::String&& value) { SetUsername(std::move(value)); return *this;}
|
||||
inline AdminUpdateDeviceStatusRequest& WithUsername(const char* value) { SetUsername(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The device key.</p>
|
||||
*/
|
||||
inline const Aws::String& GetDeviceKey() const{ return m_deviceKey; }
|
||||
inline bool DeviceKeyHasBeenSet() const { return m_deviceKeyHasBeenSet; }
|
||||
inline void SetDeviceKey(const Aws::String& value) { m_deviceKeyHasBeenSet = true; m_deviceKey = value; }
|
||||
inline void SetDeviceKey(Aws::String&& value) { m_deviceKeyHasBeenSet = true; m_deviceKey = std::move(value); }
|
||||
inline void SetDeviceKey(const char* value) { m_deviceKeyHasBeenSet = true; m_deviceKey.assign(value); }
|
||||
inline AdminUpdateDeviceStatusRequest& WithDeviceKey(const Aws::String& value) { SetDeviceKey(value); return *this;}
|
||||
inline AdminUpdateDeviceStatusRequest& WithDeviceKey(Aws::String&& value) { SetDeviceKey(std::move(value)); return *this;}
|
||||
inline AdminUpdateDeviceStatusRequest& WithDeviceKey(const char* value) { SetDeviceKey(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The status indicating whether a device has been remembered or not.</p>
|
||||
*/
|
||||
inline const DeviceRememberedStatusType& GetDeviceRememberedStatus() const{ return m_deviceRememberedStatus; }
|
||||
inline bool DeviceRememberedStatusHasBeenSet() const { return m_deviceRememberedStatusHasBeenSet; }
|
||||
inline void SetDeviceRememberedStatus(const DeviceRememberedStatusType& value) { m_deviceRememberedStatusHasBeenSet = true; m_deviceRememberedStatus = value; }
|
||||
inline void SetDeviceRememberedStatus(DeviceRememberedStatusType&& value) { m_deviceRememberedStatusHasBeenSet = true; m_deviceRememberedStatus = std::move(value); }
|
||||
inline AdminUpdateDeviceStatusRequest& WithDeviceRememberedStatus(const DeviceRememberedStatusType& value) { SetDeviceRememberedStatus(value); return *this;}
|
||||
inline AdminUpdateDeviceStatusRequest& WithDeviceRememberedStatus(DeviceRememberedStatusType&& value) { SetDeviceRememberedStatus(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_username;
|
||||
bool m_usernameHasBeenSet = false;
|
||||
|
||||
Aws::String m_deviceKey;
|
||||
bool m_deviceKeyHasBeenSet = false;
|
||||
|
||||
DeviceRememberedStatusType m_deviceRememberedStatus;
|
||||
bool m_deviceRememberedStatusHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,58 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>The status response to the request to update the device, as an
|
||||
* administrator.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminUpdateDeviceStatusResponse">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminUpdateDeviceStatusResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminUpdateDeviceStatusResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminUpdateDeviceStatusResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminUpdateDeviceStatusResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline AdminUpdateDeviceStatusResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline AdminUpdateDeviceStatusResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline AdminUpdateDeviceStatusResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,160 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/core/utils/memory/stl/AWSMap.h>
|
||||
#include <aws/cognito-idp/model/AttributeType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Represents the request to update the user's attributes as an
|
||||
* administrator.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminUpdateUserAttributesRequest">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminUpdateUserAttributesRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminUpdateUserAttributesRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AdminUpdateUserAttributes"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user pool ID for the user pool where you want to update user
|
||||
* attributes.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AdminUpdateUserAttributesRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AdminUpdateUserAttributesRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AdminUpdateUserAttributesRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The username of the user that you want to query or modify. The value of this
|
||||
* parameter is typically your user's username, but it can be any of their alias
|
||||
* attributes. If <code>username</code> isn't an alias attribute in your user pool,
|
||||
* this value must be the <code>sub</code> of a local user or the username of a
|
||||
* user from a third-party IdP.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUsername() const{ return m_username; }
|
||||
inline bool UsernameHasBeenSet() const { return m_usernameHasBeenSet; }
|
||||
inline void SetUsername(const Aws::String& value) { m_usernameHasBeenSet = true; m_username = value; }
|
||||
inline void SetUsername(Aws::String&& value) { m_usernameHasBeenSet = true; m_username = std::move(value); }
|
||||
inline void SetUsername(const char* value) { m_usernameHasBeenSet = true; m_username.assign(value); }
|
||||
inline AdminUpdateUserAttributesRequest& WithUsername(const Aws::String& value) { SetUsername(value); return *this;}
|
||||
inline AdminUpdateUserAttributesRequest& WithUsername(Aws::String&& value) { SetUsername(std::move(value)); return *this;}
|
||||
inline AdminUpdateUserAttributesRequest& WithUsername(const char* value) { SetUsername(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>An array of name-value pairs representing user attributes.</p> <p>For custom
|
||||
* attributes, you must prepend the <code>custom:</code> prefix to the attribute
|
||||
* name.</p> <p>If your user pool requires verification before Amazon Cognito
|
||||
* updates an attribute value that you specify in this request, Amazon Cognito
|
||||
* doesn’t immediately update the value of that attribute. After your user receives
|
||||
* and responds to a verification message to verify the new value, Amazon Cognito
|
||||
* updates the attribute value. Your user can sign in and receive messages with the
|
||||
* original attribute value until they verify the new value.</p> <p>To update the
|
||||
* value of an attribute that requires verification in the same API request,
|
||||
* include the <code>email_verified</code> or <code>phone_number_verified</code>
|
||||
* attribute, with a value of <code>true</code>. If you set the
|
||||
* <code>email_verified</code> or <code>phone_number_verified</code> value for an
|
||||
* <code>email</code> or <code>phone_number</code> attribute that requires
|
||||
* verification to <code>true</code>, Amazon Cognito doesn’t send a verification
|
||||
* message to your user.</p>
|
||||
*/
|
||||
inline const Aws::Vector<AttributeType>& GetUserAttributes() const{ return m_userAttributes; }
|
||||
inline bool UserAttributesHasBeenSet() const { return m_userAttributesHasBeenSet; }
|
||||
inline void SetUserAttributes(const Aws::Vector<AttributeType>& value) { m_userAttributesHasBeenSet = true; m_userAttributes = value; }
|
||||
inline void SetUserAttributes(Aws::Vector<AttributeType>&& value) { m_userAttributesHasBeenSet = true; m_userAttributes = std::move(value); }
|
||||
inline AdminUpdateUserAttributesRequest& WithUserAttributes(const Aws::Vector<AttributeType>& value) { SetUserAttributes(value); return *this;}
|
||||
inline AdminUpdateUserAttributesRequest& WithUserAttributes(Aws::Vector<AttributeType>&& value) { SetUserAttributes(std::move(value)); return *this;}
|
||||
inline AdminUpdateUserAttributesRequest& AddUserAttributes(const AttributeType& value) { m_userAttributesHasBeenSet = true; m_userAttributes.push_back(value); return *this; }
|
||||
inline AdminUpdateUserAttributesRequest& AddUserAttributes(AttributeType&& value) { m_userAttributesHasBeenSet = true; m_userAttributes.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A map of custom key-value pairs that you can provide as input for any custom
|
||||
* workflows that this action triggers.</p> <p>You create custom workflows by
|
||||
* assigning Lambda functions to user pool triggers. When you use the
|
||||
* AdminUpdateUserAttributes API action, Amazon Cognito invokes the function that
|
||||
* is assigned to the <i>custom message</i> trigger. When Amazon Cognito invokes
|
||||
* this function, it passes a JSON payload, which the function receives as input.
|
||||
* This payload contains a <code>clientMetadata</code> attribute, which provides
|
||||
* the data that you assigned to the ClientMetadata parameter in your
|
||||
* AdminUpdateUserAttributes request. In your function code in Lambda, you can
|
||||
* process the <code>clientMetadata</code> value to enhance your workflow for your
|
||||
* specific needs.</p> <p>For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html">
|
||||
* Customizing user pool Workflows with Lambda Triggers</a> in the <i>Amazon
|
||||
* Cognito Developer Guide</i>.</p> <p>When you use the ClientMetadata
|
||||
* parameter, remember that Amazon Cognito won't do the following:</p> <ul> <li>
|
||||
* <p>Store the ClientMetadata value. This data is available only to Lambda
|
||||
* triggers that are assigned to a user pool to support custom workflows. If your
|
||||
* user pool configuration doesn't include triggers, the ClientMetadata parameter
|
||||
* serves no purpose.</p> </li> <li> <p>Validate the ClientMetadata value.</p>
|
||||
* </li> <li> <p>Encrypt the ClientMetadata value. Don't use Amazon Cognito to
|
||||
* provide sensitive information.</p> </li> </ul>
|
||||
*/
|
||||
inline const Aws::Map<Aws::String, Aws::String>& GetClientMetadata() const{ return m_clientMetadata; }
|
||||
inline bool ClientMetadataHasBeenSet() const { return m_clientMetadataHasBeenSet; }
|
||||
inline void SetClientMetadata(const Aws::Map<Aws::String, Aws::String>& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata = value; }
|
||||
inline void SetClientMetadata(Aws::Map<Aws::String, Aws::String>&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata = std::move(value); }
|
||||
inline AdminUpdateUserAttributesRequest& WithClientMetadata(const Aws::Map<Aws::String, Aws::String>& value) { SetClientMetadata(value); return *this;}
|
||||
inline AdminUpdateUserAttributesRequest& WithClientMetadata(Aws::Map<Aws::String, Aws::String>&& value) { SetClientMetadata(std::move(value)); return *this;}
|
||||
inline AdminUpdateUserAttributesRequest& AddClientMetadata(const Aws::String& key, const Aws::String& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, value); return *this; }
|
||||
inline AdminUpdateUserAttributesRequest& AddClientMetadata(Aws::String&& key, const Aws::String& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(std::move(key), value); return *this; }
|
||||
inline AdminUpdateUserAttributesRequest& AddClientMetadata(const Aws::String& key, Aws::String&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, std::move(value)); return *this; }
|
||||
inline AdminUpdateUserAttributesRequest& AddClientMetadata(Aws::String&& key, Aws::String&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(std::move(key), std::move(value)); return *this; }
|
||||
inline AdminUpdateUserAttributesRequest& AddClientMetadata(const char* key, Aws::String&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, std::move(value)); return *this; }
|
||||
inline AdminUpdateUserAttributesRequest& AddClientMetadata(Aws::String&& key, const char* value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(std::move(key), value); return *this; }
|
||||
inline AdminUpdateUserAttributesRequest& AddClientMetadata(const char* key, const char* value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, value); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_username;
|
||||
bool m_usernameHasBeenSet = false;
|
||||
|
||||
Aws::Vector<AttributeType> m_userAttributes;
|
||||
bool m_userAttributesHasBeenSet = false;
|
||||
|
||||
Aws::Map<Aws::String, Aws::String> m_clientMetadata;
|
||||
bool m_clientMetadataHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,58 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>Represents the response from the server for the request to update user
|
||||
* attributes as an administrator.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminUpdateUserAttributesResponse">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminUpdateUserAttributesResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminUpdateUserAttributesResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminUpdateUserAttributesResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminUpdateUserAttributesResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline AdminUpdateUserAttributesResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline AdminUpdateUserAttributesResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline AdminUpdateUserAttributesResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,83 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The request to sign out of all devices, as an administrator.</p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminUserGlobalSignOutRequest">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminUserGlobalSignOutRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminUserGlobalSignOutRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AdminUserGlobalSignOut"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user pool ID.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline AdminUserGlobalSignOutRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline AdminUserGlobalSignOutRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline AdminUserGlobalSignOutRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The username of the user that you want to query or modify. The value of this
|
||||
* parameter is typically your user's username, but it can be any of their alias
|
||||
* attributes. If <code>username</code> isn't an alias attribute in your user pool,
|
||||
* this value must be the <code>sub</code> of a local user or the username of a
|
||||
* user from a third-party IdP.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUsername() const{ return m_username; }
|
||||
inline bool UsernameHasBeenSet() const { return m_usernameHasBeenSet; }
|
||||
inline void SetUsername(const Aws::String& value) { m_usernameHasBeenSet = true; m_username = value; }
|
||||
inline void SetUsername(Aws::String&& value) { m_usernameHasBeenSet = true; m_username = std::move(value); }
|
||||
inline void SetUsername(const char* value) { m_usernameHasBeenSet = true; m_username.assign(value); }
|
||||
inline AdminUserGlobalSignOutRequest& WithUsername(const Aws::String& value) { SetUsername(value); return *this;}
|
||||
inline AdminUserGlobalSignOutRequest& WithUsername(Aws::String&& value) { SetUsername(std::move(value)); return *this;}
|
||||
inline AdminUserGlobalSignOutRequest& WithUsername(const char* value) { SetUsername(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_username;
|
||||
bool m_usernameHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,58 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>The global sign-out response, as an administrator.</p><p><h3>See Also:</h3>
|
||||
* <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdminUserGlobalSignOutResponse">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdminUserGlobalSignOutResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminUserGlobalSignOutResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminUserGlobalSignOutResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdminUserGlobalSignOutResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline AdminUserGlobalSignOutResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline AdminUserGlobalSignOutResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline AdminUserGlobalSignOutResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,64 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/model/AdvancedSecurityEnabledModeType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Advanced security configuration options for additional authentication types
|
||||
* in your user pool, including custom authentication. </p><p><h3>See Also:</h3>
|
||||
* <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AdvancedSecurityAdditionalFlowsType">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AdvancedSecurityAdditionalFlowsType
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdvancedSecurityAdditionalFlowsType();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdvancedSecurityAdditionalFlowsType(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdvancedSecurityAdditionalFlowsType& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The operating mode of advanced security features in custom authentication
|
||||
* with <a
|
||||
* href="https://docs.aws.amazon.com/cognito/latest/developerguide/user-pool-lambda-challenge.html">
|
||||
* Custom authentication challenge Lambda triggers</a>. </p>
|
||||
*/
|
||||
inline const AdvancedSecurityEnabledModeType& GetCustomAuthMode() const{ return m_customAuthMode; }
|
||||
inline bool CustomAuthModeHasBeenSet() const { return m_customAuthModeHasBeenSet; }
|
||||
inline void SetCustomAuthMode(const AdvancedSecurityEnabledModeType& value) { m_customAuthModeHasBeenSet = true; m_customAuthMode = value; }
|
||||
inline void SetCustomAuthMode(AdvancedSecurityEnabledModeType&& value) { m_customAuthModeHasBeenSet = true; m_customAuthMode = std::move(value); }
|
||||
inline AdvancedSecurityAdditionalFlowsType& WithCustomAuthMode(const AdvancedSecurityEnabledModeType& value) { SetCustomAuthMode(value); return *this;}
|
||||
inline AdvancedSecurityAdditionalFlowsType& WithCustomAuthMode(AdvancedSecurityEnabledModeType&& value) { SetCustomAuthMode(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
AdvancedSecurityEnabledModeType m_customAuthMode;
|
||||
bool m_customAuthModeHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,31 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class AdvancedSecurityEnabledModeType
|
||||
{
|
||||
NOT_SET,
|
||||
AUDIT,
|
||||
ENFORCED
|
||||
};
|
||||
|
||||
namespace AdvancedSecurityEnabledModeTypeMapper
|
||||
{
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdvancedSecurityEnabledModeType GetAdvancedSecurityEnabledModeTypeForName(const Aws::String& name);
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String GetNameForAdvancedSecurityEnabledModeType(AdvancedSecurityEnabledModeType value);
|
||||
} // namespace AdvancedSecurityEnabledModeTypeMapper
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,32 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class AdvancedSecurityModeType
|
||||
{
|
||||
NOT_SET,
|
||||
OFF,
|
||||
AUDIT,
|
||||
ENFORCED
|
||||
};
|
||||
|
||||
namespace AdvancedSecurityModeTypeMapper
|
||||
{
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AdvancedSecurityModeType GetAdvancedSecurityModeTypeForName(const Aws::String& name);
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String GetNameForAdvancedSecurityModeType(AdvancedSecurityModeType value);
|
||||
} // namespace AdvancedSecurityModeTypeMapper
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,32 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class AliasAttributeType
|
||||
{
|
||||
NOT_SET,
|
||||
phone_number,
|
||||
email,
|
||||
preferred_username
|
||||
};
|
||||
|
||||
namespace AliasAttributeTypeMapper
|
||||
{
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AliasAttributeType GetAliasAttributeTypeForName(const Aws::String& name);
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String GetNameForAliasAttributeType(AliasAttributeType value);
|
||||
} // namespace AliasAttributeTypeMapper
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,135 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The Amazon Pinpoint analytics configuration necessary to collect metrics for
|
||||
* a user pool.</p> <p>In Regions where Amazon Pinpoint isn't available,
|
||||
* user pools only support sending events to Amazon Pinpoint projects in us-east-1.
|
||||
* In Regions where Amazon Pinpoint is available, user pools support sending events
|
||||
* to Amazon Pinpoint projects within that same Region.</p> <p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AnalyticsConfigurationType">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AnalyticsConfigurationType
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AnalyticsConfigurationType();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AnalyticsConfigurationType(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AnalyticsConfigurationType& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The application ID for an Amazon Pinpoint application.</p>
|
||||
*/
|
||||
inline const Aws::String& GetApplicationId() const{ return m_applicationId; }
|
||||
inline bool ApplicationIdHasBeenSet() const { return m_applicationIdHasBeenSet; }
|
||||
inline void SetApplicationId(const Aws::String& value) { m_applicationIdHasBeenSet = true; m_applicationId = value; }
|
||||
inline void SetApplicationId(Aws::String&& value) { m_applicationIdHasBeenSet = true; m_applicationId = std::move(value); }
|
||||
inline void SetApplicationId(const char* value) { m_applicationIdHasBeenSet = true; m_applicationId.assign(value); }
|
||||
inline AnalyticsConfigurationType& WithApplicationId(const Aws::String& value) { SetApplicationId(value); return *this;}
|
||||
inline AnalyticsConfigurationType& WithApplicationId(Aws::String&& value) { SetApplicationId(std::move(value)); return *this;}
|
||||
inline AnalyticsConfigurationType& WithApplicationId(const char* value) { SetApplicationId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (ARN) of an Amazon Pinpoint project. You can use the
|
||||
* Amazon Pinpoint project to integrate with the chosen user pool Client. Amazon
|
||||
* Cognito publishes events to the Amazon Pinpoint project that the app ARN
|
||||
* declares.</p>
|
||||
*/
|
||||
inline const Aws::String& GetApplicationArn() const{ return m_applicationArn; }
|
||||
inline bool ApplicationArnHasBeenSet() const { return m_applicationArnHasBeenSet; }
|
||||
inline void SetApplicationArn(const Aws::String& value) { m_applicationArnHasBeenSet = true; m_applicationArn = value; }
|
||||
inline void SetApplicationArn(Aws::String&& value) { m_applicationArnHasBeenSet = true; m_applicationArn = std::move(value); }
|
||||
inline void SetApplicationArn(const char* value) { m_applicationArnHasBeenSet = true; m_applicationArn.assign(value); }
|
||||
inline AnalyticsConfigurationType& WithApplicationArn(const Aws::String& value) { SetApplicationArn(value); return *this;}
|
||||
inline AnalyticsConfigurationType& WithApplicationArn(Aws::String&& value) { SetApplicationArn(std::move(value)); return *this;}
|
||||
inline AnalyticsConfigurationType& WithApplicationArn(const char* value) { SetApplicationArn(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The ARN of an Identity and Access Management role that authorizes Amazon
|
||||
* Cognito to publish events to Amazon Pinpoint analytics.</p>
|
||||
*/
|
||||
inline const Aws::String& GetRoleArn() const{ return m_roleArn; }
|
||||
inline bool RoleArnHasBeenSet() const { return m_roleArnHasBeenSet; }
|
||||
inline void SetRoleArn(const Aws::String& value) { m_roleArnHasBeenSet = true; m_roleArn = value; }
|
||||
inline void SetRoleArn(Aws::String&& value) { m_roleArnHasBeenSet = true; m_roleArn = std::move(value); }
|
||||
inline void SetRoleArn(const char* value) { m_roleArnHasBeenSet = true; m_roleArn.assign(value); }
|
||||
inline AnalyticsConfigurationType& WithRoleArn(const Aws::String& value) { SetRoleArn(value); return *this;}
|
||||
inline AnalyticsConfigurationType& WithRoleArn(Aws::String&& value) { SetRoleArn(std::move(value)); return *this;}
|
||||
inline AnalyticsConfigurationType& WithRoleArn(const char* value) { SetRoleArn(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The external ID.</p>
|
||||
*/
|
||||
inline const Aws::String& GetExternalId() const{ return m_externalId; }
|
||||
inline bool ExternalIdHasBeenSet() const { return m_externalIdHasBeenSet; }
|
||||
inline void SetExternalId(const Aws::String& value) { m_externalIdHasBeenSet = true; m_externalId = value; }
|
||||
inline void SetExternalId(Aws::String&& value) { m_externalIdHasBeenSet = true; m_externalId = std::move(value); }
|
||||
inline void SetExternalId(const char* value) { m_externalIdHasBeenSet = true; m_externalId.assign(value); }
|
||||
inline AnalyticsConfigurationType& WithExternalId(const Aws::String& value) { SetExternalId(value); return *this;}
|
||||
inline AnalyticsConfigurationType& WithExternalId(Aws::String&& value) { SetExternalId(std::move(value)); return *this;}
|
||||
inline AnalyticsConfigurationType& WithExternalId(const char* value) { SetExternalId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>If <code>UserDataShared</code> is <code>true</code>, Amazon Cognito includes
|
||||
* user data in the events that it publishes to Amazon Pinpoint analytics.</p>
|
||||
*/
|
||||
inline bool GetUserDataShared() const{ return m_userDataShared; }
|
||||
inline bool UserDataSharedHasBeenSet() const { return m_userDataSharedHasBeenSet; }
|
||||
inline void SetUserDataShared(bool value) { m_userDataSharedHasBeenSet = true; m_userDataShared = value; }
|
||||
inline AnalyticsConfigurationType& WithUserDataShared(bool value) { SetUserDataShared(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_applicationId;
|
||||
bool m_applicationIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_applicationArn;
|
||||
bool m_applicationArnHasBeenSet = false;
|
||||
|
||||
Aws::String m_roleArn;
|
||||
bool m_roleArnHasBeenSet = false;
|
||||
|
||||
Aws::String m_externalId;
|
||||
bool m_externalIdHasBeenSet = false;
|
||||
|
||||
bool m_userDataShared;
|
||||
bool m_userDataSharedHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,68 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>An Amazon Pinpoint analytics endpoint.</p> <p>An endpoint uniquely identifies
|
||||
* a mobile device, email address, or phone number that can receive messages from
|
||||
* Amazon Pinpoint analytics. For more information about Amazon Web Services
|
||||
* Regions that can contain Amazon Pinpoint resources for use with Amazon Cognito
|
||||
* user pools, see <a
|
||||
* href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-pinpoint-integration.html">Using
|
||||
* Amazon Pinpoint analytics with Amazon Cognito user pools</a>.</p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AnalyticsMetadataType">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AnalyticsMetadataType
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AnalyticsMetadataType();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AnalyticsMetadataType(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AnalyticsMetadataType& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The endpoint ID.</p>
|
||||
*/
|
||||
inline const Aws::String& GetAnalyticsEndpointId() const{ return m_analyticsEndpointId; }
|
||||
inline bool AnalyticsEndpointIdHasBeenSet() const { return m_analyticsEndpointIdHasBeenSet; }
|
||||
inline void SetAnalyticsEndpointId(const Aws::String& value) { m_analyticsEndpointIdHasBeenSet = true; m_analyticsEndpointId = value; }
|
||||
inline void SetAnalyticsEndpointId(Aws::String&& value) { m_analyticsEndpointIdHasBeenSet = true; m_analyticsEndpointId = std::move(value); }
|
||||
inline void SetAnalyticsEndpointId(const char* value) { m_analyticsEndpointIdHasBeenSet = true; m_analyticsEndpointId.assign(value); }
|
||||
inline AnalyticsMetadataType& WithAnalyticsEndpointId(const Aws::String& value) { SetAnalyticsEndpointId(value); return *this;}
|
||||
inline AnalyticsMetadataType& WithAnalyticsEndpointId(Aws::String&& value) { SetAnalyticsEndpointId(std::move(value)); return *this;}
|
||||
inline AnalyticsMetadataType& WithAnalyticsEndpointId(const char* value) { SetAnalyticsEndpointId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_analyticsEndpointId;
|
||||
bool m_analyticsEndpointIdHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,78 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class AssociateSoftwareTokenRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AssociateSoftwareTokenRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "AssociateSoftwareToken"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A valid access token that Amazon Cognito issued to the user whose software
|
||||
* token you want to generate.</p>
|
||||
*/
|
||||
inline const Aws::String& GetAccessToken() const{ return m_accessToken; }
|
||||
inline bool AccessTokenHasBeenSet() const { return m_accessTokenHasBeenSet; }
|
||||
inline void SetAccessToken(const Aws::String& value) { m_accessTokenHasBeenSet = true; m_accessToken = value; }
|
||||
inline void SetAccessToken(Aws::String&& value) { m_accessTokenHasBeenSet = true; m_accessToken = std::move(value); }
|
||||
inline void SetAccessToken(const char* value) { m_accessTokenHasBeenSet = true; m_accessToken.assign(value); }
|
||||
inline AssociateSoftwareTokenRequest& WithAccessToken(const Aws::String& value) { SetAccessToken(value); return *this;}
|
||||
inline AssociateSoftwareTokenRequest& WithAccessToken(Aws::String&& value) { SetAccessToken(std::move(value)); return *this;}
|
||||
inline AssociateSoftwareTokenRequest& WithAccessToken(const char* value) { SetAccessToken(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The session that should be passed both ways in challenge-response calls to
|
||||
* the service. This allows authentication of the user as part of the MFA setup
|
||||
* process.</p>
|
||||
*/
|
||||
inline const Aws::String& GetSession() const{ return m_session; }
|
||||
inline bool SessionHasBeenSet() const { return m_sessionHasBeenSet; }
|
||||
inline void SetSession(const Aws::String& value) { m_sessionHasBeenSet = true; m_session = value; }
|
||||
inline void SetSession(Aws::String&& value) { m_sessionHasBeenSet = true; m_session = std::move(value); }
|
||||
inline void SetSession(const char* value) { m_sessionHasBeenSet = true; m_session.assign(value); }
|
||||
inline AssociateSoftwareTokenRequest& WithSession(const Aws::String& value) { SetSession(value); return *this;}
|
||||
inline AssociateSoftwareTokenRequest& WithSession(Aws::String&& value) { SetSession(std::move(value)); return *this;}
|
||||
inline AssociateSoftwareTokenRequest& WithSession(const char* value) { SetSession(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_accessToken;
|
||||
bool m_accessTokenHasBeenSet = false;
|
||||
|
||||
Aws::String m_session;
|
||||
bool m_sessionHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,85 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class AssociateSoftwareTokenResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AssociateSoftwareTokenResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AssociateSoftwareTokenResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AssociateSoftwareTokenResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique generated shared secret code that is used in the TOTP algorithm to
|
||||
* generate a one-time code.</p>
|
||||
*/
|
||||
inline const Aws::String& GetSecretCode() const{ return m_secretCode; }
|
||||
inline void SetSecretCode(const Aws::String& value) { m_secretCode = value; }
|
||||
inline void SetSecretCode(Aws::String&& value) { m_secretCode = std::move(value); }
|
||||
inline void SetSecretCode(const char* value) { m_secretCode.assign(value); }
|
||||
inline AssociateSoftwareTokenResult& WithSecretCode(const Aws::String& value) { SetSecretCode(value); return *this;}
|
||||
inline AssociateSoftwareTokenResult& WithSecretCode(Aws::String&& value) { SetSecretCode(std::move(value)); return *this;}
|
||||
inline AssociateSoftwareTokenResult& WithSecretCode(const char* value) { SetSecretCode(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The session that should be passed both ways in challenge-response calls to
|
||||
* the service. This allows authentication of the user as part of the MFA setup
|
||||
* process.</p>
|
||||
*/
|
||||
inline const Aws::String& GetSession() const{ return m_session; }
|
||||
inline void SetSession(const Aws::String& value) { m_session = value; }
|
||||
inline void SetSession(Aws::String&& value) { m_session = std::move(value); }
|
||||
inline void SetSession(const char* value) { m_session.assign(value); }
|
||||
inline AssociateSoftwareTokenResult& WithSession(const Aws::String& value) { SetSession(value); return *this;}
|
||||
inline AssociateSoftwareTokenResult& WithSession(Aws::String&& value) { SetSession(std::move(value)); return *this;}
|
||||
inline AssociateSoftwareTokenResult& WithSession(const char* value) { SetSession(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline AssociateSoftwareTokenResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline AssociateSoftwareTokenResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline AssociateSoftwareTokenResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_secretCode;
|
||||
|
||||
Aws::String m_session;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,33 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class AttributeDataType
|
||||
{
|
||||
NOT_SET,
|
||||
String,
|
||||
Number,
|
||||
DateTime,
|
||||
Boolean
|
||||
};
|
||||
|
||||
namespace AttributeDataTypeMapper
|
||||
{
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AttributeDataType GetAttributeDataTypeForName(const Aws::String& name);
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String GetNameForAttributeDataType(AttributeDataType value);
|
||||
} // namespace AttributeDataTypeMapper
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,79 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Specifies whether the attribute is standard or custom.</p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AttributeType">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AttributeType
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AttributeType();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AttributeType(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AttributeType& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of the attribute.</p>
|
||||
*/
|
||||
inline const Aws::String& GetName() const{ return m_name; }
|
||||
inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
|
||||
inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
|
||||
inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
|
||||
inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
|
||||
inline AttributeType& WithName(const Aws::String& value) { SetName(value); return *this;}
|
||||
inline AttributeType& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
|
||||
inline AttributeType& WithName(const char* value) { SetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The value of the attribute.</p>
|
||||
*/
|
||||
inline const Aws::String& GetValue() const{ return m_value; }
|
||||
inline bool ValueHasBeenSet() const { return m_valueHasBeenSet; }
|
||||
inline void SetValue(const Aws::String& value) { m_valueHasBeenSet = true; m_value = value; }
|
||||
inline void SetValue(Aws::String&& value) { m_valueHasBeenSet = true; m_value = std::move(value); }
|
||||
inline void SetValue(const char* value) { m_valueHasBeenSet = true; m_value.assign(value); }
|
||||
inline AttributeType& WithValue(const Aws::String& value) { SetValue(value); return *this;}
|
||||
inline AttributeType& WithValue(Aws::String&& value) { SetValue(std::move(value)); return *this;}
|
||||
inline AttributeType& WithValue(const char* value) { SetValue(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_name;
|
||||
bool m_nameHasBeenSet = false;
|
||||
|
||||
Aws::String m_value;
|
||||
bool m_valueHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,181 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cognito-idp/model/EventType.h>
|
||||
#include <aws/core/utils/DateTime.h>
|
||||
#include <aws/cognito-idp/model/EventResponseType.h>
|
||||
#include <aws/cognito-idp/model/EventRiskType.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/cognito-idp/model/EventContextDataType.h>
|
||||
#include <aws/cognito-idp/model/EventFeedbackType.h>
|
||||
#include <aws/cognito-idp/model/ChallengeResponseType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The authentication event type.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AuthEventType">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AuthEventType
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AuthEventType();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AuthEventType(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AuthEventType& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The event ID.</p>
|
||||
*/
|
||||
inline const Aws::String& GetEventId() const{ return m_eventId; }
|
||||
inline bool EventIdHasBeenSet() const { return m_eventIdHasBeenSet; }
|
||||
inline void SetEventId(const Aws::String& value) { m_eventIdHasBeenSet = true; m_eventId = value; }
|
||||
inline void SetEventId(Aws::String&& value) { m_eventIdHasBeenSet = true; m_eventId = std::move(value); }
|
||||
inline void SetEventId(const char* value) { m_eventIdHasBeenSet = true; m_eventId.assign(value); }
|
||||
inline AuthEventType& WithEventId(const Aws::String& value) { SetEventId(value); return *this;}
|
||||
inline AuthEventType& WithEventId(Aws::String&& value) { SetEventId(std::move(value)); return *this;}
|
||||
inline AuthEventType& WithEventId(const char* value) { SetEventId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The event type.</p>
|
||||
*/
|
||||
inline const EventType& GetEventType() const{ return m_eventType; }
|
||||
inline bool EventTypeHasBeenSet() const { return m_eventTypeHasBeenSet; }
|
||||
inline void SetEventType(const EventType& value) { m_eventTypeHasBeenSet = true; m_eventType = value; }
|
||||
inline void SetEventType(EventType&& value) { m_eventTypeHasBeenSet = true; m_eventType = std::move(value); }
|
||||
inline AuthEventType& WithEventType(const EventType& value) { SetEventType(value); return *this;}
|
||||
inline AuthEventType& WithEventType(EventType&& value) { SetEventType(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The date and time when the item was created. Amazon Cognito returns this
|
||||
* timestamp in UNIX epoch time format. Your SDK might render the output in a
|
||||
* human-readable format like ISO 8601 or a Java <code>Date</code> object.</p>
|
||||
*/
|
||||
inline const Aws::Utils::DateTime& GetCreationDate() const{ return m_creationDate; }
|
||||
inline bool CreationDateHasBeenSet() const { return m_creationDateHasBeenSet; }
|
||||
inline void SetCreationDate(const Aws::Utils::DateTime& value) { m_creationDateHasBeenSet = true; m_creationDate = value; }
|
||||
inline void SetCreationDate(Aws::Utils::DateTime&& value) { m_creationDateHasBeenSet = true; m_creationDate = std::move(value); }
|
||||
inline AuthEventType& WithCreationDate(const Aws::Utils::DateTime& value) { SetCreationDate(value); return *this;}
|
||||
inline AuthEventType& WithCreationDate(Aws::Utils::DateTime&& value) { SetCreationDate(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The event response.</p>
|
||||
*/
|
||||
inline const EventResponseType& GetEventResponse() const{ return m_eventResponse; }
|
||||
inline bool EventResponseHasBeenSet() const { return m_eventResponseHasBeenSet; }
|
||||
inline void SetEventResponse(const EventResponseType& value) { m_eventResponseHasBeenSet = true; m_eventResponse = value; }
|
||||
inline void SetEventResponse(EventResponseType&& value) { m_eventResponseHasBeenSet = true; m_eventResponse = std::move(value); }
|
||||
inline AuthEventType& WithEventResponse(const EventResponseType& value) { SetEventResponse(value); return *this;}
|
||||
inline AuthEventType& WithEventResponse(EventResponseType&& value) { SetEventResponse(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The event risk.</p>
|
||||
*/
|
||||
inline const EventRiskType& GetEventRisk() const{ return m_eventRisk; }
|
||||
inline bool EventRiskHasBeenSet() const { return m_eventRiskHasBeenSet; }
|
||||
inline void SetEventRisk(const EventRiskType& value) { m_eventRiskHasBeenSet = true; m_eventRisk = value; }
|
||||
inline void SetEventRisk(EventRiskType&& value) { m_eventRiskHasBeenSet = true; m_eventRisk = std::move(value); }
|
||||
inline AuthEventType& WithEventRisk(const EventRiskType& value) { SetEventRisk(value); return *this;}
|
||||
inline AuthEventType& WithEventRisk(EventRiskType&& value) { SetEventRisk(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The challenge responses.</p>
|
||||
*/
|
||||
inline const Aws::Vector<ChallengeResponseType>& GetChallengeResponses() const{ return m_challengeResponses; }
|
||||
inline bool ChallengeResponsesHasBeenSet() const { return m_challengeResponsesHasBeenSet; }
|
||||
inline void SetChallengeResponses(const Aws::Vector<ChallengeResponseType>& value) { m_challengeResponsesHasBeenSet = true; m_challengeResponses = value; }
|
||||
inline void SetChallengeResponses(Aws::Vector<ChallengeResponseType>&& value) { m_challengeResponsesHasBeenSet = true; m_challengeResponses = std::move(value); }
|
||||
inline AuthEventType& WithChallengeResponses(const Aws::Vector<ChallengeResponseType>& value) { SetChallengeResponses(value); return *this;}
|
||||
inline AuthEventType& WithChallengeResponses(Aws::Vector<ChallengeResponseType>&& value) { SetChallengeResponses(std::move(value)); return *this;}
|
||||
inline AuthEventType& AddChallengeResponses(const ChallengeResponseType& value) { m_challengeResponsesHasBeenSet = true; m_challengeResponses.push_back(value); return *this; }
|
||||
inline AuthEventType& AddChallengeResponses(ChallengeResponseType&& value) { m_challengeResponsesHasBeenSet = true; m_challengeResponses.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user context data captured at the time of an event request. This value
|
||||
* provides additional information about the client from which event the request is
|
||||
* received.</p>
|
||||
*/
|
||||
inline const EventContextDataType& GetEventContextData() const{ return m_eventContextData; }
|
||||
inline bool EventContextDataHasBeenSet() const { return m_eventContextDataHasBeenSet; }
|
||||
inline void SetEventContextData(const EventContextDataType& value) { m_eventContextDataHasBeenSet = true; m_eventContextData = value; }
|
||||
inline void SetEventContextData(EventContextDataType&& value) { m_eventContextDataHasBeenSet = true; m_eventContextData = std::move(value); }
|
||||
inline AuthEventType& WithEventContextData(const EventContextDataType& value) { SetEventContextData(value); return *this;}
|
||||
inline AuthEventType& WithEventContextData(EventContextDataType&& value) { SetEventContextData(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A flag specifying the user feedback captured at the time of an event request
|
||||
* is good or bad. </p>
|
||||
*/
|
||||
inline const EventFeedbackType& GetEventFeedback() const{ return m_eventFeedback; }
|
||||
inline bool EventFeedbackHasBeenSet() const { return m_eventFeedbackHasBeenSet; }
|
||||
inline void SetEventFeedback(const EventFeedbackType& value) { m_eventFeedbackHasBeenSet = true; m_eventFeedback = value; }
|
||||
inline void SetEventFeedback(EventFeedbackType&& value) { m_eventFeedbackHasBeenSet = true; m_eventFeedback = std::move(value); }
|
||||
inline AuthEventType& WithEventFeedback(const EventFeedbackType& value) { SetEventFeedback(value); return *this;}
|
||||
inline AuthEventType& WithEventFeedback(EventFeedbackType&& value) { SetEventFeedback(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_eventId;
|
||||
bool m_eventIdHasBeenSet = false;
|
||||
|
||||
EventType m_eventType;
|
||||
bool m_eventTypeHasBeenSet = false;
|
||||
|
||||
Aws::Utils::DateTime m_creationDate;
|
||||
bool m_creationDateHasBeenSet = false;
|
||||
|
||||
EventResponseType m_eventResponse;
|
||||
bool m_eventResponseHasBeenSet = false;
|
||||
|
||||
EventRiskType m_eventRisk;
|
||||
bool m_eventRiskHasBeenSet = false;
|
||||
|
||||
Aws::Vector<ChallengeResponseType> m_challengeResponses;
|
||||
bool m_challengeResponsesHasBeenSet = false;
|
||||
|
||||
EventContextDataType m_eventContextData;
|
||||
bool m_eventContextDataHasBeenSet = false;
|
||||
|
||||
EventFeedbackType m_eventFeedback;
|
||||
bool m_eventFeedbackHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,36 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class AuthFlowType
|
||||
{
|
||||
NOT_SET,
|
||||
USER_SRP_AUTH,
|
||||
REFRESH_TOKEN_AUTH,
|
||||
REFRESH_TOKEN,
|
||||
CUSTOM_AUTH,
|
||||
ADMIN_NO_SRP_AUTH,
|
||||
USER_PASSWORD_AUTH,
|
||||
ADMIN_USER_PASSWORD_AUTH
|
||||
};
|
||||
|
||||
namespace AuthFlowTypeMapper
|
||||
{
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AuthFlowType GetAuthFlowTypeForName(const Aws::String& name);
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String GetNameForAuthFlowType(AuthFlowType value);
|
||||
} // namespace AuthFlowTypeMapper
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,142 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cognito-idp/model/NewDeviceMetadataType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The authentication result.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/AuthenticationResultType">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AuthenticationResultType
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AuthenticationResultType();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AuthenticationResultType(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API AuthenticationResultType& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A valid access token that Amazon Cognito issued to the user who you want to
|
||||
* authenticate.</p>
|
||||
*/
|
||||
inline const Aws::String& GetAccessToken() const{ return m_accessToken; }
|
||||
inline bool AccessTokenHasBeenSet() const { return m_accessTokenHasBeenSet; }
|
||||
inline void SetAccessToken(const Aws::String& value) { m_accessTokenHasBeenSet = true; m_accessToken = value; }
|
||||
inline void SetAccessToken(Aws::String&& value) { m_accessTokenHasBeenSet = true; m_accessToken = std::move(value); }
|
||||
inline void SetAccessToken(const char* value) { m_accessTokenHasBeenSet = true; m_accessToken.assign(value); }
|
||||
inline AuthenticationResultType& WithAccessToken(const Aws::String& value) { SetAccessToken(value); return *this;}
|
||||
inline AuthenticationResultType& WithAccessToken(Aws::String&& value) { SetAccessToken(std::move(value)); return *this;}
|
||||
inline AuthenticationResultType& WithAccessToken(const char* value) { SetAccessToken(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The expiration period of the authentication result in seconds.</p>
|
||||
*/
|
||||
inline int GetExpiresIn() const{ return m_expiresIn; }
|
||||
inline bool ExpiresInHasBeenSet() const { return m_expiresInHasBeenSet; }
|
||||
inline void SetExpiresIn(int value) { m_expiresInHasBeenSet = true; m_expiresIn = value; }
|
||||
inline AuthenticationResultType& WithExpiresIn(int value) { SetExpiresIn(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The token type.</p>
|
||||
*/
|
||||
inline const Aws::String& GetTokenType() const{ return m_tokenType; }
|
||||
inline bool TokenTypeHasBeenSet() const { return m_tokenTypeHasBeenSet; }
|
||||
inline void SetTokenType(const Aws::String& value) { m_tokenTypeHasBeenSet = true; m_tokenType = value; }
|
||||
inline void SetTokenType(Aws::String&& value) { m_tokenTypeHasBeenSet = true; m_tokenType = std::move(value); }
|
||||
inline void SetTokenType(const char* value) { m_tokenTypeHasBeenSet = true; m_tokenType.assign(value); }
|
||||
inline AuthenticationResultType& WithTokenType(const Aws::String& value) { SetTokenType(value); return *this;}
|
||||
inline AuthenticationResultType& WithTokenType(Aws::String&& value) { SetTokenType(std::move(value)); return *this;}
|
||||
inline AuthenticationResultType& WithTokenType(const char* value) { SetTokenType(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The refresh token.</p>
|
||||
*/
|
||||
inline const Aws::String& GetRefreshToken() const{ return m_refreshToken; }
|
||||
inline bool RefreshTokenHasBeenSet() const { return m_refreshTokenHasBeenSet; }
|
||||
inline void SetRefreshToken(const Aws::String& value) { m_refreshTokenHasBeenSet = true; m_refreshToken = value; }
|
||||
inline void SetRefreshToken(Aws::String&& value) { m_refreshTokenHasBeenSet = true; m_refreshToken = std::move(value); }
|
||||
inline void SetRefreshToken(const char* value) { m_refreshTokenHasBeenSet = true; m_refreshToken.assign(value); }
|
||||
inline AuthenticationResultType& WithRefreshToken(const Aws::String& value) { SetRefreshToken(value); return *this;}
|
||||
inline AuthenticationResultType& WithRefreshToken(Aws::String&& value) { SetRefreshToken(std::move(value)); return *this;}
|
||||
inline AuthenticationResultType& WithRefreshToken(const char* value) { SetRefreshToken(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The ID token.</p>
|
||||
*/
|
||||
inline const Aws::String& GetIdToken() const{ return m_idToken; }
|
||||
inline bool IdTokenHasBeenSet() const { return m_idTokenHasBeenSet; }
|
||||
inline void SetIdToken(const Aws::String& value) { m_idTokenHasBeenSet = true; m_idToken = value; }
|
||||
inline void SetIdToken(Aws::String&& value) { m_idTokenHasBeenSet = true; m_idToken = std::move(value); }
|
||||
inline void SetIdToken(const char* value) { m_idTokenHasBeenSet = true; m_idToken.assign(value); }
|
||||
inline AuthenticationResultType& WithIdToken(const Aws::String& value) { SetIdToken(value); return *this;}
|
||||
inline AuthenticationResultType& WithIdToken(Aws::String&& value) { SetIdToken(std::move(value)); return *this;}
|
||||
inline AuthenticationResultType& WithIdToken(const char* value) { SetIdToken(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The new device metadata from an authentication result.</p>
|
||||
*/
|
||||
inline const NewDeviceMetadataType& GetNewDeviceMetadata() const{ return m_newDeviceMetadata; }
|
||||
inline bool NewDeviceMetadataHasBeenSet() const { return m_newDeviceMetadataHasBeenSet; }
|
||||
inline void SetNewDeviceMetadata(const NewDeviceMetadataType& value) { m_newDeviceMetadataHasBeenSet = true; m_newDeviceMetadata = value; }
|
||||
inline void SetNewDeviceMetadata(NewDeviceMetadataType&& value) { m_newDeviceMetadataHasBeenSet = true; m_newDeviceMetadata = std::move(value); }
|
||||
inline AuthenticationResultType& WithNewDeviceMetadata(const NewDeviceMetadataType& value) { SetNewDeviceMetadata(value); return *this;}
|
||||
inline AuthenticationResultType& WithNewDeviceMetadata(NewDeviceMetadataType&& value) { SetNewDeviceMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_accessToken;
|
||||
bool m_accessTokenHasBeenSet = false;
|
||||
|
||||
int m_expiresIn;
|
||||
bool m_expiresInHasBeenSet = false;
|
||||
|
||||
Aws::String m_tokenType;
|
||||
bool m_tokenTypeHasBeenSet = false;
|
||||
|
||||
Aws::String m_refreshToken;
|
||||
bool m_refreshTokenHasBeenSet = false;
|
||||
|
||||
Aws::String m_idToken;
|
||||
bool m_idTokenHasBeenSet = false;
|
||||
|
||||
NewDeviceMetadataType m_newDeviceMetadata;
|
||||
bool m_newDeviceMetadataHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,31 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class ChallengeName
|
||||
{
|
||||
NOT_SET,
|
||||
Password,
|
||||
Mfa
|
||||
};
|
||||
|
||||
namespace ChallengeNameMapper
|
||||
{
|
||||
AWS_COGNITOIDENTITYPROVIDER_API ChallengeName GetChallengeNameForName(const Aws::String& name);
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String GetNameForChallengeName(ChallengeName value);
|
||||
} // namespace ChallengeNameMapper
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,40 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class ChallengeNameType
|
||||
{
|
||||
NOT_SET,
|
||||
SMS_MFA,
|
||||
EMAIL_OTP,
|
||||
SOFTWARE_TOKEN_MFA,
|
||||
SELECT_MFA_TYPE,
|
||||
MFA_SETUP,
|
||||
PASSWORD_VERIFIER,
|
||||
CUSTOM_CHALLENGE,
|
||||
DEVICE_SRP_AUTH,
|
||||
DEVICE_PASSWORD_VERIFIER,
|
||||
ADMIN_NO_SRP_AUTH,
|
||||
NEW_PASSWORD_REQUIRED
|
||||
};
|
||||
|
||||
namespace ChallengeNameTypeMapper
|
||||
{
|
||||
AWS_COGNITOIDENTITYPROVIDER_API ChallengeNameType GetChallengeNameTypeForName(const Aws::String& name);
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String GetNameForChallengeNameType(ChallengeNameType value);
|
||||
} // namespace ChallengeNameTypeMapper
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,31 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class ChallengeResponse
|
||||
{
|
||||
NOT_SET,
|
||||
Success,
|
||||
Failure
|
||||
};
|
||||
|
||||
namespace ChallengeResponseMapper
|
||||
{
|
||||
AWS_COGNITOIDENTITYPROVIDER_API ChallengeResponse GetChallengeResponseForName(const Aws::String& name);
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String GetNameForChallengeResponse(ChallengeResponse value);
|
||||
} // namespace ChallengeResponseMapper
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,75 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/model/ChallengeName.h>
|
||||
#include <aws/cognito-idp/model/ChallengeResponse.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The challenge response type.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/ChallengeResponseType">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ChallengeResponseType
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API ChallengeResponseType();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API ChallengeResponseType(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API ChallengeResponseType& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The challenge name.</p>
|
||||
*/
|
||||
inline const ChallengeName& GetChallengeName() const{ return m_challengeName; }
|
||||
inline bool ChallengeNameHasBeenSet() const { return m_challengeNameHasBeenSet; }
|
||||
inline void SetChallengeName(const ChallengeName& value) { m_challengeNameHasBeenSet = true; m_challengeName = value; }
|
||||
inline void SetChallengeName(ChallengeName&& value) { m_challengeNameHasBeenSet = true; m_challengeName = std::move(value); }
|
||||
inline ChallengeResponseType& WithChallengeName(const ChallengeName& value) { SetChallengeName(value); return *this;}
|
||||
inline ChallengeResponseType& WithChallengeName(ChallengeName&& value) { SetChallengeName(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The challenge response.</p>
|
||||
*/
|
||||
inline const ChallengeResponse& GetChallengeResponse() const{ return m_challengeResponse; }
|
||||
inline bool ChallengeResponseHasBeenSet() const { return m_challengeResponseHasBeenSet; }
|
||||
inline void SetChallengeResponse(const ChallengeResponse& value) { m_challengeResponseHasBeenSet = true; m_challengeResponse = value; }
|
||||
inline void SetChallengeResponse(ChallengeResponse&& value) { m_challengeResponseHasBeenSet = true; m_challengeResponse = std::move(value); }
|
||||
inline ChallengeResponseType& WithChallengeResponse(const ChallengeResponse& value) { SetChallengeResponse(value); return *this;}
|
||||
inline ChallengeResponseType& WithChallengeResponse(ChallengeResponse&& value) { SetChallengeResponse(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
ChallengeName m_challengeName;
|
||||
bool m_challengeNameHasBeenSet = false;
|
||||
|
||||
ChallengeResponse m_challengeResponse;
|
||||
bool m_challengeResponseHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,97 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Represents the request to change a user password.</p><p><h3>See Also:</h3>
|
||||
* <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/ChangePasswordRequest">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ChangePasswordRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API ChangePasswordRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "ChangePassword"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The old password.</p>
|
||||
*/
|
||||
inline const Aws::String& GetPreviousPassword() const{ return m_previousPassword; }
|
||||
inline bool PreviousPasswordHasBeenSet() const { return m_previousPasswordHasBeenSet; }
|
||||
inline void SetPreviousPassword(const Aws::String& value) { m_previousPasswordHasBeenSet = true; m_previousPassword = value; }
|
||||
inline void SetPreviousPassword(Aws::String&& value) { m_previousPasswordHasBeenSet = true; m_previousPassword = std::move(value); }
|
||||
inline void SetPreviousPassword(const char* value) { m_previousPasswordHasBeenSet = true; m_previousPassword.assign(value); }
|
||||
inline ChangePasswordRequest& WithPreviousPassword(const Aws::String& value) { SetPreviousPassword(value); return *this;}
|
||||
inline ChangePasswordRequest& WithPreviousPassword(Aws::String&& value) { SetPreviousPassword(std::move(value)); return *this;}
|
||||
inline ChangePasswordRequest& WithPreviousPassword(const char* value) { SetPreviousPassword(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The new password.</p>
|
||||
*/
|
||||
inline const Aws::String& GetProposedPassword() const{ return m_proposedPassword; }
|
||||
inline bool ProposedPasswordHasBeenSet() const { return m_proposedPasswordHasBeenSet; }
|
||||
inline void SetProposedPassword(const Aws::String& value) { m_proposedPasswordHasBeenSet = true; m_proposedPassword = value; }
|
||||
inline void SetProposedPassword(Aws::String&& value) { m_proposedPasswordHasBeenSet = true; m_proposedPassword = std::move(value); }
|
||||
inline void SetProposedPassword(const char* value) { m_proposedPasswordHasBeenSet = true; m_proposedPassword.assign(value); }
|
||||
inline ChangePasswordRequest& WithProposedPassword(const Aws::String& value) { SetProposedPassword(value); return *this;}
|
||||
inline ChangePasswordRequest& WithProposedPassword(Aws::String&& value) { SetProposedPassword(std::move(value)); return *this;}
|
||||
inline ChangePasswordRequest& WithProposedPassword(const char* value) { SetProposedPassword(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A valid access token that Amazon Cognito issued to the user whose password
|
||||
* you want to change.</p>
|
||||
*/
|
||||
inline const Aws::String& GetAccessToken() const{ return m_accessToken; }
|
||||
inline bool AccessTokenHasBeenSet() const { return m_accessTokenHasBeenSet; }
|
||||
inline void SetAccessToken(const Aws::String& value) { m_accessTokenHasBeenSet = true; m_accessToken = value; }
|
||||
inline void SetAccessToken(Aws::String&& value) { m_accessTokenHasBeenSet = true; m_accessToken = std::move(value); }
|
||||
inline void SetAccessToken(const char* value) { m_accessTokenHasBeenSet = true; m_accessToken.assign(value); }
|
||||
inline ChangePasswordRequest& WithAccessToken(const Aws::String& value) { SetAccessToken(value); return *this;}
|
||||
inline ChangePasswordRequest& WithAccessToken(Aws::String&& value) { SetAccessToken(std::move(value)); return *this;}
|
||||
inline ChangePasswordRequest& WithAccessToken(const char* value) { SetAccessToken(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_previousPassword;
|
||||
bool m_previousPasswordHasBeenSet = false;
|
||||
|
||||
Aws::String m_proposedPassword;
|
||||
bool m_proposedPasswordHasBeenSet = false;
|
||||
|
||||
Aws::String m_accessToken;
|
||||
bool m_accessTokenHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,58 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>The response from the server to the change password request.</p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/ChangePasswordResponse">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ChangePasswordResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API ChangePasswordResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API ChangePasswordResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API ChangePasswordResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline ChangePasswordResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline ChangePasswordResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline ChangePasswordResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,70 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Configuration for the CloudWatch log group destination of user pool detailed
|
||||
* activity logging, or of user activity log export with advanced security
|
||||
* features.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/CloudWatchLogsConfigurationType">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class CloudWatchLogsConfigurationType
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API CloudWatchLogsConfigurationType();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API CloudWatchLogsConfigurationType(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API CloudWatchLogsConfigurationType& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (arn) of a CloudWatch Logs log group where your user
|
||||
* pool sends logs. The log group must not be encrypted with Key Management Service
|
||||
* and must be in the same Amazon Web Services account as your user pool.</p> <p>To
|
||||
* send logs to log groups with a resource policy of a size greater than 5120
|
||||
* characters, configure a log group with a path that starts with
|
||||
* <code>/aws/vendedlogs</code>. For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AWS-logs-and-resource-policy.html">Enabling
|
||||
* logging from certain Amazon Web Services services</a>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetLogGroupArn() const{ return m_logGroupArn; }
|
||||
inline bool LogGroupArnHasBeenSet() const { return m_logGroupArnHasBeenSet; }
|
||||
inline void SetLogGroupArn(const Aws::String& value) { m_logGroupArnHasBeenSet = true; m_logGroupArn = value; }
|
||||
inline void SetLogGroupArn(Aws::String&& value) { m_logGroupArnHasBeenSet = true; m_logGroupArn = std::move(value); }
|
||||
inline void SetLogGroupArn(const char* value) { m_logGroupArnHasBeenSet = true; m_logGroupArn.assign(value); }
|
||||
inline CloudWatchLogsConfigurationType& WithLogGroupArn(const Aws::String& value) { SetLogGroupArn(value); return *this;}
|
||||
inline CloudWatchLogsConfigurationType& WithLogGroupArn(Aws::String&& value) { SetLogGroupArn(std::move(value)); return *this;}
|
||||
inline CloudWatchLogsConfigurationType& WithLogGroupArn(const char* value) { SetLogGroupArn(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_logGroupArn;
|
||||
bool m_logGroupArnHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,96 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cognito-idp/model/DeliveryMediumType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The delivery details for an email or SMS message that Amazon Cognito sent for
|
||||
* authentication or verification.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/CodeDeliveryDetailsType">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class CodeDeliveryDetailsType
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API CodeDeliveryDetailsType();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API CodeDeliveryDetailsType(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API CodeDeliveryDetailsType& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The email address or phone number destination where Amazon Cognito sent the
|
||||
* code.</p>
|
||||
*/
|
||||
inline const Aws::String& GetDestination() const{ return m_destination; }
|
||||
inline bool DestinationHasBeenSet() const { return m_destinationHasBeenSet; }
|
||||
inline void SetDestination(const Aws::String& value) { m_destinationHasBeenSet = true; m_destination = value; }
|
||||
inline void SetDestination(Aws::String&& value) { m_destinationHasBeenSet = true; m_destination = std::move(value); }
|
||||
inline void SetDestination(const char* value) { m_destinationHasBeenSet = true; m_destination.assign(value); }
|
||||
inline CodeDeliveryDetailsType& WithDestination(const Aws::String& value) { SetDestination(value); return *this;}
|
||||
inline CodeDeliveryDetailsType& WithDestination(Aws::String&& value) { SetDestination(std::move(value)); return *this;}
|
||||
inline CodeDeliveryDetailsType& WithDestination(const char* value) { SetDestination(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The method that Amazon Cognito used to send the code.</p>
|
||||
*/
|
||||
inline const DeliveryMediumType& GetDeliveryMedium() const{ return m_deliveryMedium; }
|
||||
inline bool DeliveryMediumHasBeenSet() const { return m_deliveryMediumHasBeenSet; }
|
||||
inline void SetDeliveryMedium(const DeliveryMediumType& value) { m_deliveryMediumHasBeenSet = true; m_deliveryMedium = value; }
|
||||
inline void SetDeliveryMedium(DeliveryMediumType&& value) { m_deliveryMediumHasBeenSet = true; m_deliveryMedium = std::move(value); }
|
||||
inline CodeDeliveryDetailsType& WithDeliveryMedium(const DeliveryMediumType& value) { SetDeliveryMedium(value); return *this;}
|
||||
inline CodeDeliveryDetailsType& WithDeliveryMedium(DeliveryMediumType&& value) { SetDeliveryMedium(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of the attribute that Amazon Cognito verifies with the code.</p>
|
||||
*/
|
||||
inline const Aws::String& GetAttributeName() const{ return m_attributeName; }
|
||||
inline bool AttributeNameHasBeenSet() const { return m_attributeNameHasBeenSet; }
|
||||
inline void SetAttributeName(const Aws::String& value) { m_attributeNameHasBeenSet = true; m_attributeName = value; }
|
||||
inline void SetAttributeName(Aws::String&& value) { m_attributeNameHasBeenSet = true; m_attributeName = std::move(value); }
|
||||
inline void SetAttributeName(const char* value) { m_attributeNameHasBeenSet = true; m_attributeName.assign(value); }
|
||||
inline CodeDeliveryDetailsType& WithAttributeName(const Aws::String& value) { SetAttributeName(value); return *this;}
|
||||
inline CodeDeliveryDetailsType& WithAttributeName(Aws::String&& value) { SetAttributeName(std::move(value)); return *this;}
|
||||
inline CodeDeliveryDetailsType& WithAttributeName(const char* value) { SetAttributeName(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_destination;
|
||||
bool m_destinationHasBeenSet = false;
|
||||
|
||||
DeliveryMediumType m_deliveryMedium;
|
||||
bool m_deliveryMediumHasBeenSet = false;
|
||||
|
||||
Aws::String m_attributeName;
|
||||
bool m_attributeNameHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,59 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/model/CompromisedCredentialsEventActionType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The compromised credentials actions type.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/CompromisedCredentialsActionsType">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class CompromisedCredentialsActionsType
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API CompromisedCredentialsActionsType();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API CompromisedCredentialsActionsType(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API CompromisedCredentialsActionsType& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The event action.</p>
|
||||
*/
|
||||
inline const CompromisedCredentialsEventActionType& GetEventAction() const{ return m_eventAction; }
|
||||
inline bool EventActionHasBeenSet() const { return m_eventActionHasBeenSet; }
|
||||
inline void SetEventAction(const CompromisedCredentialsEventActionType& value) { m_eventActionHasBeenSet = true; m_eventAction = value; }
|
||||
inline void SetEventAction(CompromisedCredentialsEventActionType&& value) { m_eventActionHasBeenSet = true; m_eventAction = std::move(value); }
|
||||
inline CompromisedCredentialsActionsType& WithEventAction(const CompromisedCredentialsEventActionType& value) { SetEventAction(value); return *this;}
|
||||
inline CompromisedCredentialsActionsType& WithEventAction(CompromisedCredentialsEventActionType&& value) { SetEventAction(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
CompromisedCredentialsEventActionType m_eventAction;
|
||||
bool m_eventActionHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,31 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class CompromisedCredentialsEventActionType
|
||||
{
|
||||
NOT_SET,
|
||||
BLOCK,
|
||||
NO_ACTION
|
||||
};
|
||||
|
||||
namespace CompromisedCredentialsEventActionTypeMapper
|
||||
{
|
||||
AWS_COGNITOIDENTITYPROVIDER_API CompromisedCredentialsEventActionType GetCompromisedCredentialsEventActionTypeForName(const Aws::String& name);
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String GetNameForCompromisedCredentialsEventActionType(CompromisedCredentialsEventActionType value);
|
||||
} // namespace CompromisedCredentialsEventActionTypeMapper
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,80 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/cognito-idp/model/CompromisedCredentialsActionsType.h>
|
||||
#include <aws/cognito-idp/model/EventFilterType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The compromised credentials risk configuration type.</p><p><h3>See Also:</h3>
|
||||
* <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/CompromisedCredentialsRiskConfigurationType">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class CompromisedCredentialsRiskConfigurationType
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API CompromisedCredentialsRiskConfigurationType();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API CompromisedCredentialsRiskConfigurationType(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API CompromisedCredentialsRiskConfigurationType& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Perform the action for these events. The default is to perform all events if
|
||||
* no event filter is specified.</p>
|
||||
*/
|
||||
inline const Aws::Vector<EventFilterType>& GetEventFilter() const{ return m_eventFilter; }
|
||||
inline bool EventFilterHasBeenSet() const { return m_eventFilterHasBeenSet; }
|
||||
inline void SetEventFilter(const Aws::Vector<EventFilterType>& value) { m_eventFilterHasBeenSet = true; m_eventFilter = value; }
|
||||
inline void SetEventFilter(Aws::Vector<EventFilterType>&& value) { m_eventFilterHasBeenSet = true; m_eventFilter = std::move(value); }
|
||||
inline CompromisedCredentialsRiskConfigurationType& WithEventFilter(const Aws::Vector<EventFilterType>& value) { SetEventFilter(value); return *this;}
|
||||
inline CompromisedCredentialsRiskConfigurationType& WithEventFilter(Aws::Vector<EventFilterType>&& value) { SetEventFilter(std::move(value)); return *this;}
|
||||
inline CompromisedCredentialsRiskConfigurationType& AddEventFilter(const EventFilterType& value) { m_eventFilterHasBeenSet = true; m_eventFilter.push_back(value); return *this; }
|
||||
inline CompromisedCredentialsRiskConfigurationType& AddEventFilter(EventFilterType&& value) { m_eventFilterHasBeenSet = true; m_eventFilter.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The compromised credentials risk configuration actions.</p>
|
||||
*/
|
||||
inline const CompromisedCredentialsActionsType& GetActions() const{ return m_actions; }
|
||||
inline bool ActionsHasBeenSet() const { return m_actionsHasBeenSet; }
|
||||
inline void SetActions(const CompromisedCredentialsActionsType& value) { m_actionsHasBeenSet = true; m_actions = value; }
|
||||
inline void SetActions(CompromisedCredentialsActionsType&& value) { m_actionsHasBeenSet = true; m_actions = std::move(value); }
|
||||
inline CompromisedCredentialsRiskConfigurationType& WithActions(const CompromisedCredentialsActionsType& value) { SetActions(value); return *this;}
|
||||
inline CompromisedCredentialsRiskConfigurationType& WithActions(CompromisedCredentialsActionsType&& value) { SetActions(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::Vector<EventFilterType> m_eventFilter;
|
||||
bool m_eventFilterHasBeenSet = false;
|
||||
|
||||
CompromisedCredentialsActionsType m_actions;
|
||||
bool m_actionsHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,112 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cognito-idp/model/DeviceSecretVerifierConfigType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Confirms the device request.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/ConfirmDeviceRequest">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ConfirmDeviceRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API ConfirmDeviceRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "ConfirmDevice"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A valid access token that Amazon Cognito issued to the user whose device you
|
||||
* want to confirm.</p>
|
||||
*/
|
||||
inline const Aws::String& GetAccessToken() const{ return m_accessToken; }
|
||||
inline bool AccessTokenHasBeenSet() const { return m_accessTokenHasBeenSet; }
|
||||
inline void SetAccessToken(const Aws::String& value) { m_accessTokenHasBeenSet = true; m_accessToken = value; }
|
||||
inline void SetAccessToken(Aws::String&& value) { m_accessTokenHasBeenSet = true; m_accessToken = std::move(value); }
|
||||
inline void SetAccessToken(const char* value) { m_accessTokenHasBeenSet = true; m_accessToken.assign(value); }
|
||||
inline ConfirmDeviceRequest& WithAccessToken(const Aws::String& value) { SetAccessToken(value); return *this;}
|
||||
inline ConfirmDeviceRequest& WithAccessToken(Aws::String&& value) { SetAccessToken(std::move(value)); return *this;}
|
||||
inline ConfirmDeviceRequest& WithAccessToken(const char* value) { SetAccessToken(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The device key.</p>
|
||||
*/
|
||||
inline const Aws::String& GetDeviceKey() const{ return m_deviceKey; }
|
||||
inline bool DeviceKeyHasBeenSet() const { return m_deviceKeyHasBeenSet; }
|
||||
inline void SetDeviceKey(const Aws::String& value) { m_deviceKeyHasBeenSet = true; m_deviceKey = value; }
|
||||
inline void SetDeviceKey(Aws::String&& value) { m_deviceKeyHasBeenSet = true; m_deviceKey = std::move(value); }
|
||||
inline void SetDeviceKey(const char* value) { m_deviceKeyHasBeenSet = true; m_deviceKey.assign(value); }
|
||||
inline ConfirmDeviceRequest& WithDeviceKey(const Aws::String& value) { SetDeviceKey(value); return *this;}
|
||||
inline ConfirmDeviceRequest& WithDeviceKey(Aws::String&& value) { SetDeviceKey(std::move(value)); return *this;}
|
||||
inline ConfirmDeviceRequest& WithDeviceKey(const char* value) { SetDeviceKey(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The configuration of the device secret verifier.</p>
|
||||
*/
|
||||
inline const DeviceSecretVerifierConfigType& GetDeviceSecretVerifierConfig() const{ return m_deviceSecretVerifierConfig; }
|
||||
inline bool DeviceSecretVerifierConfigHasBeenSet() const { return m_deviceSecretVerifierConfigHasBeenSet; }
|
||||
inline void SetDeviceSecretVerifierConfig(const DeviceSecretVerifierConfigType& value) { m_deviceSecretVerifierConfigHasBeenSet = true; m_deviceSecretVerifierConfig = value; }
|
||||
inline void SetDeviceSecretVerifierConfig(DeviceSecretVerifierConfigType&& value) { m_deviceSecretVerifierConfigHasBeenSet = true; m_deviceSecretVerifierConfig = std::move(value); }
|
||||
inline ConfirmDeviceRequest& WithDeviceSecretVerifierConfig(const DeviceSecretVerifierConfigType& value) { SetDeviceSecretVerifierConfig(value); return *this;}
|
||||
inline ConfirmDeviceRequest& WithDeviceSecretVerifierConfig(DeviceSecretVerifierConfigType&& value) { SetDeviceSecretVerifierConfig(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The device name.</p>
|
||||
*/
|
||||
inline const Aws::String& GetDeviceName() const{ return m_deviceName; }
|
||||
inline bool DeviceNameHasBeenSet() const { return m_deviceNameHasBeenSet; }
|
||||
inline void SetDeviceName(const Aws::String& value) { m_deviceNameHasBeenSet = true; m_deviceName = value; }
|
||||
inline void SetDeviceName(Aws::String&& value) { m_deviceNameHasBeenSet = true; m_deviceName = std::move(value); }
|
||||
inline void SetDeviceName(const char* value) { m_deviceNameHasBeenSet = true; m_deviceName.assign(value); }
|
||||
inline ConfirmDeviceRequest& WithDeviceName(const Aws::String& value) { SetDeviceName(value); return *this;}
|
||||
inline ConfirmDeviceRequest& WithDeviceName(Aws::String&& value) { SetDeviceName(std::move(value)); return *this;}
|
||||
inline ConfirmDeviceRequest& WithDeviceName(const char* value) { SetDeviceName(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_accessToken;
|
||||
bool m_accessTokenHasBeenSet = false;
|
||||
|
||||
Aws::String m_deviceKey;
|
||||
bool m_deviceKeyHasBeenSet = false;
|
||||
|
||||
DeviceSecretVerifierConfigType m_deviceSecretVerifierConfig;
|
||||
bool m_deviceSecretVerifierConfigHasBeenSet = false;
|
||||
|
||||
Aws::String m_deviceName;
|
||||
bool m_deviceNameHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,68 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>Confirms the device response.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/ConfirmDeviceResponse">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ConfirmDeviceResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API ConfirmDeviceResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API ConfirmDeviceResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API ConfirmDeviceResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Indicates whether the user confirmation must confirm the device response.</p>
|
||||
*/
|
||||
inline bool GetUserConfirmationNecessary() const{ return m_userConfirmationNecessary; }
|
||||
inline void SetUserConfirmationNecessary(bool value) { m_userConfirmationNecessary = value; }
|
||||
inline ConfirmDeviceResult& WithUserConfirmationNecessary(bool value) { SetUserConfirmationNecessary(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline ConfirmDeviceResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline ConfirmDeviceResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline ConfirmDeviceResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
bool m_userConfirmationNecessary;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,219 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cognito-idp/model/AnalyticsMetadataType.h>
|
||||
#include <aws/cognito-idp/model/UserContextDataType.h>
|
||||
#include <aws/core/utils/memory/stl/AWSMap.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The request representing the confirmation for a password reset.</p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/ConfirmForgotPasswordRequest">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ConfirmForgotPasswordRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API ConfirmForgotPasswordRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "ConfirmForgotPassword"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The app client ID of the app associated with the user pool.</p>
|
||||
*/
|
||||
inline const Aws::String& GetClientId() const{ return m_clientId; }
|
||||
inline bool ClientIdHasBeenSet() const { return m_clientIdHasBeenSet; }
|
||||
inline void SetClientId(const Aws::String& value) { m_clientIdHasBeenSet = true; m_clientId = value; }
|
||||
inline void SetClientId(Aws::String&& value) { m_clientIdHasBeenSet = true; m_clientId = std::move(value); }
|
||||
inline void SetClientId(const char* value) { m_clientIdHasBeenSet = true; m_clientId.assign(value); }
|
||||
inline ConfirmForgotPasswordRequest& WithClientId(const Aws::String& value) { SetClientId(value); return *this;}
|
||||
inline ConfirmForgotPasswordRequest& WithClientId(Aws::String&& value) { SetClientId(std::move(value)); return *this;}
|
||||
inline ConfirmForgotPasswordRequest& WithClientId(const char* value) { SetClientId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A keyed-hash message authentication code (HMAC) calculated using the secret
|
||||
* key of a user pool client and username plus the client ID in the message. For
|
||||
* more information about <code>SecretHash</code>, see <a
|
||||
* href="https://docs.aws.amazon.com/cognito/latest/developerguide/signing-up-users-in-your-app.html#cognito-user-pools-computing-secret-hash">Computing
|
||||
* secret hash values</a>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetSecretHash() const{ return m_secretHash; }
|
||||
inline bool SecretHashHasBeenSet() const { return m_secretHashHasBeenSet; }
|
||||
inline void SetSecretHash(const Aws::String& value) { m_secretHashHasBeenSet = true; m_secretHash = value; }
|
||||
inline void SetSecretHash(Aws::String&& value) { m_secretHashHasBeenSet = true; m_secretHash = std::move(value); }
|
||||
inline void SetSecretHash(const char* value) { m_secretHashHasBeenSet = true; m_secretHash.assign(value); }
|
||||
inline ConfirmForgotPasswordRequest& WithSecretHash(const Aws::String& value) { SetSecretHash(value); return *this;}
|
||||
inline ConfirmForgotPasswordRequest& WithSecretHash(Aws::String&& value) { SetSecretHash(std::move(value)); return *this;}
|
||||
inline ConfirmForgotPasswordRequest& WithSecretHash(const char* value) { SetSecretHash(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The username of the user that you want to query or modify. The value of this
|
||||
* parameter is typically your user's username, but it can be any of their alias
|
||||
* attributes. If <code>username</code> isn't an alias attribute in your user pool,
|
||||
* this value must be the <code>sub</code> of a local user or the username of a
|
||||
* user from a third-party IdP.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUsername() const{ return m_username; }
|
||||
inline bool UsernameHasBeenSet() const { return m_usernameHasBeenSet; }
|
||||
inline void SetUsername(const Aws::String& value) { m_usernameHasBeenSet = true; m_username = value; }
|
||||
inline void SetUsername(Aws::String&& value) { m_usernameHasBeenSet = true; m_username = std::move(value); }
|
||||
inline void SetUsername(const char* value) { m_usernameHasBeenSet = true; m_username.assign(value); }
|
||||
inline ConfirmForgotPasswordRequest& WithUsername(const Aws::String& value) { SetUsername(value); return *this;}
|
||||
inline ConfirmForgotPasswordRequest& WithUsername(Aws::String&& value) { SetUsername(std::move(value)); return *this;}
|
||||
inline ConfirmForgotPasswordRequest& WithUsername(const char* value) { SetUsername(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The confirmation code from your user's request to reset their password. For
|
||||
* more information, see <a
|
||||
* href="https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_ForgotPassword.html">ForgotPassword</a>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetConfirmationCode() const{ return m_confirmationCode; }
|
||||
inline bool ConfirmationCodeHasBeenSet() const { return m_confirmationCodeHasBeenSet; }
|
||||
inline void SetConfirmationCode(const Aws::String& value) { m_confirmationCodeHasBeenSet = true; m_confirmationCode = value; }
|
||||
inline void SetConfirmationCode(Aws::String&& value) { m_confirmationCodeHasBeenSet = true; m_confirmationCode = std::move(value); }
|
||||
inline void SetConfirmationCode(const char* value) { m_confirmationCodeHasBeenSet = true; m_confirmationCode.assign(value); }
|
||||
inline ConfirmForgotPasswordRequest& WithConfirmationCode(const Aws::String& value) { SetConfirmationCode(value); return *this;}
|
||||
inline ConfirmForgotPasswordRequest& WithConfirmationCode(Aws::String&& value) { SetConfirmationCode(std::move(value)); return *this;}
|
||||
inline ConfirmForgotPasswordRequest& WithConfirmationCode(const char* value) { SetConfirmationCode(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The new password that your user wants to set.</p>
|
||||
*/
|
||||
inline const Aws::String& GetPassword() const{ return m_password; }
|
||||
inline bool PasswordHasBeenSet() const { return m_passwordHasBeenSet; }
|
||||
inline void SetPassword(const Aws::String& value) { m_passwordHasBeenSet = true; m_password = value; }
|
||||
inline void SetPassword(Aws::String&& value) { m_passwordHasBeenSet = true; m_password = std::move(value); }
|
||||
inline void SetPassword(const char* value) { m_passwordHasBeenSet = true; m_password.assign(value); }
|
||||
inline ConfirmForgotPasswordRequest& WithPassword(const Aws::String& value) { SetPassword(value); return *this;}
|
||||
inline ConfirmForgotPasswordRequest& WithPassword(Aws::String&& value) { SetPassword(std::move(value)); return *this;}
|
||||
inline ConfirmForgotPasswordRequest& WithPassword(const char* value) { SetPassword(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Pinpoint analytics metadata for collecting metrics for
|
||||
* <code>ConfirmForgotPassword</code> calls.</p>
|
||||
*/
|
||||
inline const AnalyticsMetadataType& GetAnalyticsMetadata() const{ return m_analyticsMetadata; }
|
||||
inline bool AnalyticsMetadataHasBeenSet() const { return m_analyticsMetadataHasBeenSet; }
|
||||
inline void SetAnalyticsMetadata(const AnalyticsMetadataType& value) { m_analyticsMetadataHasBeenSet = true; m_analyticsMetadata = value; }
|
||||
inline void SetAnalyticsMetadata(AnalyticsMetadataType&& value) { m_analyticsMetadataHasBeenSet = true; m_analyticsMetadata = std::move(value); }
|
||||
inline ConfirmForgotPasswordRequest& WithAnalyticsMetadata(const AnalyticsMetadataType& value) { SetAnalyticsMetadata(value); return *this;}
|
||||
inline ConfirmForgotPasswordRequest& WithAnalyticsMetadata(AnalyticsMetadataType&& value) { SetAnalyticsMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Contextual data about your user session, such as the device fingerprint, IP
|
||||
* address, or location. Amazon Cognito advanced security evaluates the risk of an
|
||||
* authentication event based on the context that your app generates and passes to
|
||||
* Amazon Cognito when it makes API requests.</p>
|
||||
*/
|
||||
inline const UserContextDataType& GetUserContextData() const{ return m_userContextData; }
|
||||
inline bool UserContextDataHasBeenSet() const { return m_userContextDataHasBeenSet; }
|
||||
inline void SetUserContextData(const UserContextDataType& value) { m_userContextDataHasBeenSet = true; m_userContextData = value; }
|
||||
inline void SetUserContextData(UserContextDataType&& value) { m_userContextDataHasBeenSet = true; m_userContextData = std::move(value); }
|
||||
inline ConfirmForgotPasswordRequest& WithUserContextData(const UserContextDataType& value) { SetUserContextData(value); return *this;}
|
||||
inline ConfirmForgotPasswordRequest& WithUserContextData(UserContextDataType&& value) { SetUserContextData(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A map of custom key-value pairs that you can provide as input for any custom
|
||||
* workflows that this action triggers.</p> <p>You create custom workflows by
|
||||
* assigning Lambda functions to user pool triggers. When you use the
|
||||
* ConfirmForgotPassword API action, Amazon Cognito invokes the function that is
|
||||
* assigned to the <i>post confirmation</i> trigger. When Amazon Cognito invokes
|
||||
* this function, it passes a JSON payload, which the function receives as input.
|
||||
* This payload contains a <code>clientMetadata</code> attribute, which provides
|
||||
* the data that you assigned to the ClientMetadata parameter in your
|
||||
* ConfirmForgotPassword request. In your function code in Lambda, you can process
|
||||
* the <code>clientMetadata</code> value to enhance your workflow for your specific
|
||||
* needs.</p> <p>For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html">
|
||||
* Customizing user pool Workflows with Lambda Triggers</a> in the <i>Amazon
|
||||
* Cognito Developer Guide</i>.</p> <p>When you use the ClientMetadata
|
||||
* parameter, remember that Amazon Cognito won't do the following:</p> <ul> <li>
|
||||
* <p>Store the ClientMetadata value. This data is available only to Lambda
|
||||
* triggers that are assigned to a user pool to support custom workflows. If your
|
||||
* user pool configuration doesn't include triggers, the ClientMetadata parameter
|
||||
* serves no purpose.</p> </li> <li> <p>Validate the ClientMetadata value.</p>
|
||||
* </li> <li> <p>Encrypt the ClientMetadata value. Don't use Amazon Cognito to
|
||||
* provide sensitive information.</p> </li> </ul>
|
||||
*/
|
||||
inline const Aws::Map<Aws::String, Aws::String>& GetClientMetadata() const{ return m_clientMetadata; }
|
||||
inline bool ClientMetadataHasBeenSet() const { return m_clientMetadataHasBeenSet; }
|
||||
inline void SetClientMetadata(const Aws::Map<Aws::String, Aws::String>& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata = value; }
|
||||
inline void SetClientMetadata(Aws::Map<Aws::String, Aws::String>&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata = std::move(value); }
|
||||
inline ConfirmForgotPasswordRequest& WithClientMetadata(const Aws::Map<Aws::String, Aws::String>& value) { SetClientMetadata(value); return *this;}
|
||||
inline ConfirmForgotPasswordRequest& WithClientMetadata(Aws::Map<Aws::String, Aws::String>&& value) { SetClientMetadata(std::move(value)); return *this;}
|
||||
inline ConfirmForgotPasswordRequest& AddClientMetadata(const Aws::String& key, const Aws::String& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, value); return *this; }
|
||||
inline ConfirmForgotPasswordRequest& AddClientMetadata(Aws::String&& key, const Aws::String& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(std::move(key), value); return *this; }
|
||||
inline ConfirmForgotPasswordRequest& AddClientMetadata(const Aws::String& key, Aws::String&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, std::move(value)); return *this; }
|
||||
inline ConfirmForgotPasswordRequest& AddClientMetadata(Aws::String&& key, Aws::String&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(std::move(key), std::move(value)); return *this; }
|
||||
inline ConfirmForgotPasswordRequest& AddClientMetadata(const char* key, Aws::String&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, std::move(value)); return *this; }
|
||||
inline ConfirmForgotPasswordRequest& AddClientMetadata(Aws::String&& key, const char* value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(std::move(key), value); return *this; }
|
||||
inline ConfirmForgotPasswordRequest& AddClientMetadata(const char* key, const char* value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, value); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_clientId;
|
||||
bool m_clientIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_secretHash;
|
||||
bool m_secretHashHasBeenSet = false;
|
||||
|
||||
Aws::String m_username;
|
||||
bool m_usernameHasBeenSet = false;
|
||||
|
||||
Aws::String m_confirmationCode;
|
||||
bool m_confirmationCodeHasBeenSet = false;
|
||||
|
||||
Aws::String m_password;
|
||||
bool m_passwordHasBeenSet = false;
|
||||
|
||||
AnalyticsMetadataType m_analyticsMetadata;
|
||||
bool m_analyticsMetadataHasBeenSet = false;
|
||||
|
||||
UserContextDataType m_userContextData;
|
||||
bool m_userContextDataHasBeenSet = false;
|
||||
|
||||
Aws::Map<Aws::String, Aws::String> m_clientMetadata;
|
||||
bool m_clientMetadataHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,58 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>The response from the server that results from a user's request to retrieve a
|
||||
* forgotten password.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/ConfirmForgotPasswordResponse">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ConfirmForgotPasswordResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API ConfirmForgotPasswordResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API ConfirmForgotPasswordResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API ConfirmForgotPasswordResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline ConfirmForgotPasswordResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline ConfirmForgotPasswordResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline ConfirmForgotPasswordResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,215 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cognito-idp/model/AnalyticsMetadataType.h>
|
||||
#include <aws/cognito-idp/model/UserContextDataType.h>
|
||||
#include <aws/core/utils/memory/stl/AWSMap.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Represents the request to confirm registration of a user.</p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/ConfirmSignUpRequest">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ConfirmSignUpRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API ConfirmSignUpRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "ConfirmSignUp"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The ID of the app client associated with the user pool.</p>
|
||||
*/
|
||||
inline const Aws::String& GetClientId() const{ return m_clientId; }
|
||||
inline bool ClientIdHasBeenSet() const { return m_clientIdHasBeenSet; }
|
||||
inline void SetClientId(const Aws::String& value) { m_clientIdHasBeenSet = true; m_clientId = value; }
|
||||
inline void SetClientId(Aws::String&& value) { m_clientIdHasBeenSet = true; m_clientId = std::move(value); }
|
||||
inline void SetClientId(const char* value) { m_clientIdHasBeenSet = true; m_clientId.assign(value); }
|
||||
inline ConfirmSignUpRequest& WithClientId(const Aws::String& value) { SetClientId(value); return *this;}
|
||||
inline ConfirmSignUpRequest& WithClientId(Aws::String&& value) { SetClientId(std::move(value)); return *this;}
|
||||
inline ConfirmSignUpRequest& WithClientId(const char* value) { SetClientId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A keyed-hash message authentication code (HMAC) calculated using the secret
|
||||
* key of a user pool client and username plus the client ID in the message.</p>
|
||||
*/
|
||||
inline const Aws::String& GetSecretHash() const{ return m_secretHash; }
|
||||
inline bool SecretHashHasBeenSet() const { return m_secretHashHasBeenSet; }
|
||||
inline void SetSecretHash(const Aws::String& value) { m_secretHashHasBeenSet = true; m_secretHash = value; }
|
||||
inline void SetSecretHash(Aws::String&& value) { m_secretHashHasBeenSet = true; m_secretHash = std::move(value); }
|
||||
inline void SetSecretHash(const char* value) { m_secretHashHasBeenSet = true; m_secretHash.assign(value); }
|
||||
inline ConfirmSignUpRequest& WithSecretHash(const Aws::String& value) { SetSecretHash(value); return *this;}
|
||||
inline ConfirmSignUpRequest& WithSecretHash(Aws::String&& value) { SetSecretHash(std::move(value)); return *this;}
|
||||
inline ConfirmSignUpRequest& WithSecretHash(const char* value) { SetSecretHash(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The username of the user that you want to query or modify. The value of this
|
||||
* parameter is typically your user's username, but it can be any of their alias
|
||||
* attributes. If <code>username</code> isn't an alias attribute in your user pool,
|
||||
* this value must be the <code>sub</code> of a local user or the username of a
|
||||
* user from a third-party IdP.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUsername() const{ return m_username; }
|
||||
inline bool UsernameHasBeenSet() const { return m_usernameHasBeenSet; }
|
||||
inline void SetUsername(const Aws::String& value) { m_usernameHasBeenSet = true; m_username = value; }
|
||||
inline void SetUsername(Aws::String&& value) { m_usernameHasBeenSet = true; m_username = std::move(value); }
|
||||
inline void SetUsername(const char* value) { m_usernameHasBeenSet = true; m_username.assign(value); }
|
||||
inline ConfirmSignUpRequest& WithUsername(const Aws::String& value) { SetUsername(value); return *this;}
|
||||
inline ConfirmSignUpRequest& WithUsername(Aws::String&& value) { SetUsername(std::move(value)); return *this;}
|
||||
inline ConfirmSignUpRequest& WithUsername(const char* value) { SetUsername(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The confirmation code sent by a user's request to confirm registration.</p>
|
||||
*/
|
||||
inline const Aws::String& GetConfirmationCode() const{ return m_confirmationCode; }
|
||||
inline bool ConfirmationCodeHasBeenSet() const { return m_confirmationCodeHasBeenSet; }
|
||||
inline void SetConfirmationCode(const Aws::String& value) { m_confirmationCodeHasBeenSet = true; m_confirmationCode = value; }
|
||||
inline void SetConfirmationCode(Aws::String&& value) { m_confirmationCodeHasBeenSet = true; m_confirmationCode = std::move(value); }
|
||||
inline void SetConfirmationCode(const char* value) { m_confirmationCodeHasBeenSet = true; m_confirmationCode.assign(value); }
|
||||
inline ConfirmSignUpRequest& WithConfirmationCode(const Aws::String& value) { SetConfirmationCode(value); return *this;}
|
||||
inline ConfirmSignUpRequest& WithConfirmationCode(Aws::String&& value) { SetConfirmationCode(std::move(value)); return *this;}
|
||||
inline ConfirmSignUpRequest& WithConfirmationCode(const char* value) { SetConfirmationCode(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Boolean to be specified to force user confirmation irrespective of existing
|
||||
* alias. By default set to <code>False</code>. If this parameter is set to
|
||||
* <code>True</code> and the phone number/email used for sign up confirmation
|
||||
* already exists as an alias with a different user, the API call will migrate the
|
||||
* alias from the previous user to the newly created user being confirmed. If set
|
||||
* to <code>False</code>, the API will throw an <b>AliasExistsException</b>
|
||||
* error.</p>
|
||||
*/
|
||||
inline bool GetForceAliasCreation() const{ return m_forceAliasCreation; }
|
||||
inline bool ForceAliasCreationHasBeenSet() const { return m_forceAliasCreationHasBeenSet; }
|
||||
inline void SetForceAliasCreation(bool value) { m_forceAliasCreationHasBeenSet = true; m_forceAliasCreation = value; }
|
||||
inline ConfirmSignUpRequest& WithForceAliasCreation(bool value) { SetForceAliasCreation(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Pinpoint analytics metadata for collecting metrics for
|
||||
* <code>ConfirmSignUp</code> calls.</p>
|
||||
*/
|
||||
inline const AnalyticsMetadataType& GetAnalyticsMetadata() const{ return m_analyticsMetadata; }
|
||||
inline bool AnalyticsMetadataHasBeenSet() const { return m_analyticsMetadataHasBeenSet; }
|
||||
inline void SetAnalyticsMetadata(const AnalyticsMetadataType& value) { m_analyticsMetadataHasBeenSet = true; m_analyticsMetadata = value; }
|
||||
inline void SetAnalyticsMetadata(AnalyticsMetadataType&& value) { m_analyticsMetadataHasBeenSet = true; m_analyticsMetadata = std::move(value); }
|
||||
inline ConfirmSignUpRequest& WithAnalyticsMetadata(const AnalyticsMetadataType& value) { SetAnalyticsMetadata(value); return *this;}
|
||||
inline ConfirmSignUpRequest& WithAnalyticsMetadata(AnalyticsMetadataType&& value) { SetAnalyticsMetadata(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Contextual data about your user session, such as the device fingerprint, IP
|
||||
* address, or location. Amazon Cognito advanced security evaluates the risk of an
|
||||
* authentication event based on the context that your app generates and passes to
|
||||
* Amazon Cognito when it makes API requests.</p>
|
||||
*/
|
||||
inline const UserContextDataType& GetUserContextData() const{ return m_userContextData; }
|
||||
inline bool UserContextDataHasBeenSet() const { return m_userContextDataHasBeenSet; }
|
||||
inline void SetUserContextData(const UserContextDataType& value) { m_userContextDataHasBeenSet = true; m_userContextData = value; }
|
||||
inline void SetUserContextData(UserContextDataType&& value) { m_userContextDataHasBeenSet = true; m_userContextData = std::move(value); }
|
||||
inline ConfirmSignUpRequest& WithUserContextData(const UserContextDataType& value) { SetUserContextData(value); return *this;}
|
||||
inline ConfirmSignUpRequest& WithUserContextData(UserContextDataType&& value) { SetUserContextData(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A map of custom key-value pairs that you can provide as input for any custom
|
||||
* workflows that this action triggers.</p> <p>You create custom workflows by
|
||||
* assigning Lambda functions to user pool triggers. When you use the ConfirmSignUp
|
||||
* API action, Amazon Cognito invokes the function that is assigned to the <i>post
|
||||
* confirmation</i> trigger. When Amazon Cognito invokes this function, it passes a
|
||||
* JSON payload, which the function receives as input. This payload contains a
|
||||
* <code>clientMetadata</code> attribute, which provides the data that you assigned
|
||||
* to the ClientMetadata parameter in your ConfirmSignUp request. In your function
|
||||
* code in Lambda, you can process the <code>clientMetadata</code> value to enhance
|
||||
* your workflow for your specific needs.</p> <p>For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html">
|
||||
* Customizing user pool Workflows with Lambda Triggers</a> in the <i>Amazon
|
||||
* Cognito Developer Guide</i>.</p> <p>When you use the ClientMetadata
|
||||
* parameter, remember that Amazon Cognito won't do the following:</p> <ul> <li>
|
||||
* <p>Store the ClientMetadata value. This data is available only to Lambda
|
||||
* triggers that are assigned to a user pool to support custom workflows. If your
|
||||
* user pool configuration doesn't include triggers, the ClientMetadata parameter
|
||||
* serves no purpose.</p> </li> <li> <p>Validate the ClientMetadata value.</p>
|
||||
* </li> <li> <p>Encrypt the ClientMetadata value. Don't use Amazon Cognito to
|
||||
* provide sensitive information.</p> </li> </ul>
|
||||
*/
|
||||
inline const Aws::Map<Aws::String, Aws::String>& GetClientMetadata() const{ return m_clientMetadata; }
|
||||
inline bool ClientMetadataHasBeenSet() const { return m_clientMetadataHasBeenSet; }
|
||||
inline void SetClientMetadata(const Aws::Map<Aws::String, Aws::String>& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata = value; }
|
||||
inline void SetClientMetadata(Aws::Map<Aws::String, Aws::String>&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata = std::move(value); }
|
||||
inline ConfirmSignUpRequest& WithClientMetadata(const Aws::Map<Aws::String, Aws::String>& value) { SetClientMetadata(value); return *this;}
|
||||
inline ConfirmSignUpRequest& WithClientMetadata(Aws::Map<Aws::String, Aws::String>&& value) { SetClientMetadata(std::move(value)); return *this;}
|
||||
inline ConfirmSignUpRequest& AddClientMetadata(const Aws::String& key, const Aws::String& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, value); return *this; }
|
||||
inline ConfirmSignUpRequest& AddClientMetadata(Aws::String&& key, const Aws::String& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(std::move(key), value); return *this; }
|
||||
inline ConfirmSignUpRequest& AddClientMetadata(const Aws::String& key, Aws::String&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, std::move(value)); return *this; }
|
||||
inline ConfirmSignUpRequest& AddClientMetadata(Aws::String&& key, Aws::String&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(std::move(key), std::move(value)); return *this; }
|
||||
inline ConfirmSignUpRequest& AddClientMetadata(const char* key, Aws::String&& value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, std::move(value)); return *this; }
|
||||
inline ConfirmSignUpRequest& AddClientMetadata(Aws::String&& key, const char* value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(std::move(key), value); return *this; }
|
||||
inline ConfirmSignUpRequest& AddClientMetadata(const char* key, const char* value) { m_clientMetadataHasBeenSet = true; m_clientMetadata.emplace(key, value); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_clientId;
|
||||
bool m_clientIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_secretHash;
|
||||
bool m_secretHashHasBeenSet = false;
|
||||
|
||||
Aws::String m_username;
|
||||
bool m_usernameHasBeenSet = false;
|
||||
|
||||
Aws::String m_confirmationCode;
|
||||
bool m_confirmationCodeHasBeenSet = false;
|
||||
|
||||
bool m_forceAliasCreation;
|
||||
bool m_forceAliasCreationHasBeenSet = false;
|
||||
|
||||
AnalyticsMetadataType m_analyticsMetadata;
|
||||
bool m_analyticsMetadataHasBeenSet = false;
|
||||
|
||||
UserContextDataType m_userContextData;
|
||||
bool m_userContextDataHasBeenSet = false;
|
||||
|
||||
Aws::Map<Aws::String, Aws::String> m_clientMetadata;
|
||||
bool m_clientMetadataHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,58 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
/**
|
||||
* <p>Represents the response from the server for the registration
|
||||
* confirmation.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/ConfirmSignUpResponse">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ConfirmSignUpResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API ConfirmSignUpResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API ConfirmSignUpResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API ConfirmSignUpResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline ConfirmSignUpResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline ConfirmSignUpResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline ConfirmSignUpResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,135 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/cognito-idp/model/HttpHeader.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Contextual user data type used for evaluating the risk of an unexpected event
|
||||
* by Amazon Cognito advanced security.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/cognito-idp-2016-04-18/ContextDataType">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ContextDataType
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API ContextDataType();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API ContextDataType(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API ContextDataType& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The source IP address of your user's device.</p>
|
||||
*/
|
||||
inline const Aws::String& GetIpAddress() const{ return m_ipAddress; }
|
||||
inline bool IpAddressHasBeenSet() const { return m_ipAddressHasBeenSet; }
|
||||
inline void SetIpAddress(const Aws::String& value) { m_ipAddressHasBeenSet = true; m_ipAddress = value; }
|
||||
inline void SetIpAddress(Aws::String&& value) { m_ipAddressHasBeenSet = true; m_ipAddress = std::move(value); }
|
||||
inline void SetIpAddress(const char* value) { m_ipAddressHasBeenSet = true; m_ipAddress.assign(value); }
|
||||
inline ContextDataType& WithIpAddress(const Aws::String& value) { SetIpAddress(value); return *this;}
|
||||
inline ContextDataType& WithIpAddress(Aws::String&& value) { SetIpAddress(std::move(value)); return *this;}
|
||||
inline ContextDataType& WithIpAddress(const char* value) { SetIpAddress(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Your server endpoint where this API is invoked.</p>
|
||||
*/
|
||||
inline const Aws::String& GetServerName() const{ return m_serverName; }
|
||||
inline bool ServerNameHasBeenSet() const { return m_serverNameHasBeenSet; }
|
||||
inline void SetServerName(const Aws::String& value) { m_serverNameHasBeenSet = true; m_serverName = value; }
|
||||
inline void SetServerName(Aws::String&& value) { m_serverNameHasBeenSet = true; m_serverName = std::move(value); }
|
||||
inline void SetServerName(const char* value) { m_serverNameHasBeenSet = true; m_serverName.assign(value); }
|
||||
inline ContextDataType& WithServerName(const Aws::String& value) { SetServerName(value); return *this;}
|
||||
inline ContextDataType& WithServerName(Aws::String&& value) { SetServerName(std::move(value)); return *this;}
|
||||
inline ContextDataType& WithServerName(const char* value) { SetServerName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Your server path where this API is invoked.</p>
|
||||
*/
|
||||
inline const Aws::String& GetServerPath() const{ return m_serverPath; }
|
||||
inline bool ServerPathHasBeenSet() const { return m_serverPathHasBeenSet; }
|
||||
inline void SetServerPath(const Aws::String& value) { m_serverPathHasBeenSet = true; m_serverPath = value; }
|
||||
inline void SetServerPath(Aws::String&& value) { m_serverPathHasBeenSet = true; m_serverPath = std::move(value); }
|
||||
inline void SetServerPath(const char* value) { m_serverPathHasBeenSet = true; m_serverPath.assign(value); }
|
||||
inline ContextDataType& WithServerPath(const Aws::String& value) { SetServerPath(value); return *this;}
|
||||
inline ContextDataType& WithServerPath(Aws::String&& value) { SetServerPath(std::move(value)); return *this;}
|
||||
inline ContextDataType& WithServerPath(const char* value) { SetServerPath(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>HttpHeaders received on your server in same order.</p>
|
||||
*/
|
||||
inline const Aws::Vector<HttpHeader>& GetHttpHeaders() const{ return m_httpHeaders; }
|
||||
inline bool HttpHeadersHasBeenSet() const { return m_httpHeadersHasBeenSet; }
|
||||
inline void SetHttpHeaders(const Aws::Vector<HttpHeader>& value) { m_httpHeadersHasBeenSet = true; m_httpHeaders = value; }
|
||||
inline void SetHttpHeaders(Aws::Vector<HttpHeader>&& value) { m_httpHeadersHasBeenSet = true; m_httpHeaders = std::move(value); }
|
||||
inline ContextDataType& WithHttpHeaders(const Aws::Vector<HttpHeader>& value) { SetHttpHeaders(value); return *this;}
|
||||
inline ContextDataType& WithHttpHeaders(Aws::Vector<HttpHeader>&& value) { SetHttpHeaders(std::move(value)); return *this;}
|
||||
inline ContextDataType& AddHttpHeaders(const HttpHeader& value) { m_httpHeadersHasBeenSet = true; m_httpHeaders.push_back(value); return *this; }
|
||||
inline ContextDataType& AddHttpHeaders(HttpHeader&& value) { m_httpHeadersHasBeenSet = true; m_httpHeaders.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Encoded device-fingerprint details that your app collected with the Amazon
|
||||
* Cognito context data collection library. For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pool-settings-adaptive-authentication.html#user-pool-settings-adaptive-authentication-device-fingerprint">Adding
|
||||
* user device and session data to API requests</a>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetEncodedData() const{ return m_encodedData; }
|
||||
inline bool EncodedDataHasBeenSet() const { return m_encodedDataHasBeenSet; }
|
||||
inline void SetEncodedData(const Aws::String& value) { m_encodedDataHasBeenSet = true; m_encodedData = value; }
|
||||
inline void SetEncodedData(Aws::String&& value) { m_encodedDataHasBeenSet = true; m_encodedData = std::move(value); }
|
||||
inline void SetEncodedData(const char* value) { m_encodedDataHasBeenSet = true; m_encodedData.assign(value); }
|
||||
inline ContextDataType& WithEncodedData(const Aws::String& value) { SetEncodedData(value); return *this;}
|
||||
inline ContextDataType& WithEncodedData(Aws::String&& value) { SetEncodedData(std::move(value)); return *this;}
|
||||
inline ContextDataType& WithEncodedData(const char* value) { SetEncodedData(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_ipAddress;
|
||||
bool m_ipAddressHasBeenSet = false;
|
||||
|
||||
Aws::String m_serverName;
|
||||
bool m_serverNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_serverPath;
|
||||
bool m_serverPathHasBeenSet = false;
|
||||
|
||||
Aws::Vector<HttpHeader> m_httpHeaders;
|
||||
bool m_httpHeadersHasBeenSet = false;
|
||||
|
||||
Aws::String m_encodedData;
|
||||
bool m_encodedDataHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,136 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class CreateGroupRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API CreateGroupRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "CreateGroup"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of the group. Must be unique.</p>
|
||||
*/
|
||||
inline const Aws::String& GetGroupName() const{ return m_groupName; }
|
||||
inline bool GroupNameHasBeenSet() const { return m_groupNameHasBeenSet; }
|
||||
inline void SetGroupName(const Aws::String& value) { m_groupNameHasBeenSet = true; m_groupName = value; }
|
||||
inline void SetGroupName(Aws::String&& value) { m_groupNameHasBeenSet = true; m_groupName = std::move(value); }
|
||||
inline void SetGroupName(const char* value) { m_groupNameHasBeenSet = true; m_groupName.assign(value); }
|
||||
inline CreateGroupRequest& WithGroupName(const Aws::String& value) { SetGroupName(value); return *this;}
|
||||
inline CreateGroupRequest& WithGroupName(Aws::String&& value) { SetGroupName(std::move(value)); return *this;}
|
||||
inline CreateGroupRequest& WithGroupName(const char* value) { SetGroupName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user pool ID for the user pool.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline CreateGroupRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline CreateGroupRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline CreateGroupRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A string containing the description of the group.</p>
|
||||
*/
|
||||
inline const Aws::String& GetDescription() const{ return m_description; }
|
||||
inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
|
||||
inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
|
||||
inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
|
||||
inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
|
||||
inline CreateGroupRequest& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
|
||||
inline CreateGroupRequest& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
|
||||
inline CreateGroupRequest& WithDescription(const char* value) { SetDescription(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The role Amazon Resource Name (ARN) for the group.</p>
|
||||
*/
|
||||
inline const Aws::String& GetRoleArn() const{ return m_roleArn; }
|
||||
inline bool RoleArnHasBeenSet() const { return m_roleArnHasBeenSet; }
|
||||
inline void SetRoleArn(const Aws::String& value) { m_roleArnHasBeenSet = true; m_roleArn = value; }
|
||||
inline void SetRoleArn(Aws::String&& value) { m_roleArnHasBeenSet = true; m_roleArn = std::move(value); }
|
||||
inline void SetRoleArn(const char* value) { m_roleArnHasBeenSet = true; m_roleArn.assign(value); }
|
||||
inline CreateGroupRequest& WithRoleArn(const Aws::String& value) { SetRoleArn(value); return *this;}
|
||||
inline CreateGroupRequest& WithRoleArn(Aws::String&& value) { SetRoleArn(std::move(value)); return *this;}
|
||||
inline CreateGroupRequest& WithRoleArn(const char* value) { SetRoleArn(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A non-negative integer value that specifies the precedence of this group
|
||||
* relative to the other groups that a user can belong to in the user pool. Zero is
|
||||
* the highest precedence value. Groups with lower <code>Precedence</code> values
|
||||
* take precedence over groups with higher or null <code>Precedence</code> values.
|
||||
* If a user belongs to two or more groups, it is the group with the lowest
|
||||
* precedence value whose role ARN is given in the user's tokens for the
|
||||
* <code>cognito:roles</code> and <code>cognito:preferred_role</code> claims.</p>
|
||||
* <p>Two groups can have the same <code>Precedence</code> value. If this happens,
|
||||
* neither group takes precedence over the other. If two groups with the same
|
||||
* <code>Precedence</code> have the same role ARN, that role is used in the
|
||||
* <code>cognito:preferred_role</code> claim in tokens for users in each group. If
|
||||
* the two groups have different role ARNs, the <code>cognito:preferred_role</code>
|
||||
* claim isn't set in users' tokens.</p> <p>The default <code>Precedence</code>
|
||||
* value is null. The maximum <code>Precedence</code> value is
|
||||
* <code>2^31-1</code>.</p>
|
||||
*/
|
||||
inline int GetPrecedence() const{ return m_precedence; }
|
||||
inline bool PrecedenceHasBeenSet() const { return m_precedenceHasBeenSet; }
|
||||
inline void SetPrecedence(int value) { m_precedenceHasBeenSet = true; m_precedence = value; }
|
||||
inline CreateGroupRequest& WithPrecedence(int value) { SetPrecedence(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_groupName;
|
||||
bool m_groupNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_description;
|
||||
bool m_descriptionHasBeenSet = false;
|
||||
|
||||
Aws::String m_roleArn;
|
||||
bool m_roleArnHasBeenSet = false;
|
||||
|
||||
int m_precedence;
|
||||
bool m_precedenceHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,66 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/model/GroupType.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class CreateGroupResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API CreateGroupResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API CreateGroupResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API CreateGroupResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The group object for the group.</p>
|
||||
*/
|
||||
inline const GroupType& GetGroup() const{ return m_group; }
|
||||
inline void SetGroup(const GroupType& value) { m_group = value; }
|
||||
inline void SetGroup(GroupType&& value) { m_group = std::move(value); }
|
||||
inline CreateGroupResult& WithGroup(const GroupType& value) { SetGroup(value); return *this;}
|
||||
inline CreateGroupResult& WithGroup(GroupType&& value) { SetGroup(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline CreateGroupResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline CreateGroupResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline CreateGroupResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
GroupType m_group;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,235 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/cognito-idp/model/IdentityProviderTypeType.h>
|
||||
#include <aws/core/utils/memory/stl/AWSMap.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class CreateIdentityProviderRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API CreateIdentityProviderRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "CreateIdentityProvider"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user pool ID.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline CreateIdentityProviderRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline CreateIdentityProviderRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline CreateIdentityProviderRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The IdP name.</p>
|
||||
*/
|
||||
inline const Aws::String& GetProviderName() const{ return m_providerName; }
|
||||
inline bool ProviderNameHasBeenSet() const { return m_providerNameHasBeenSet; }
|
||||
inline void SetProviderName(const Aws::String& value) { m_providerNameHasBeenSet = true; m_providerName = value; }
|
||||
inline void SetProviderName(Aws::String&& value) { m_providerNameHasBeenSet = true; m_providerName = std::move(value); }
|
||||
inline void SetProviderName(const char* value) { m_providerNameHasBeenSet = true; m_providerName.assign(value); }
|
||||
inline CreateIdentityProviderRequest& WithProviderName(const Aws::String& value) { SetProviderName(value); return *this;}
|
||||
inline CreateIdentityProviderRequest& WithProviderName(Aws::String&& value) { SetProviderName(std::move(value)); return *this;}
|
||||
inline CreateIdentityProviderRequest& WithProviderName(const char* value) { SetProviderName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The IdP type.</p>
|
||||
*/
|
||||
inline const IdentityProviderTypeType& GetProviderType() const{ return m_providerType; }
|
||||
inline bool ProviderTypeHasBeenSet() const { return m_providerTypeHasBeenSet; }
|
||||
inline void SetProviderType(const IdentityProviderTypeType& value) { m_providerTypeHasBeenSet = true; m_providerType = value; }
|
||||
inline void SetProviderType(IdentityProviderTypeType&& value) { m_providerTypeHasBeenSet = true; m_providerType = std::move(value); }
|
||||
inline CreateIdentityProviderRequest& WithProviderType(const IdentityProviderTypeType& value) { SetProviderType(value); return *this;}
|
||||
inline CreateIdentityProviderRequest& WithProviderType(IdentityProviderTypeType&& value) { SetProviderType(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The scopes, URLs, and identifiers for your external identity provider. The
|
||||
* following examples describe the provider detail keys for each IdP type. These
|
||||
* values and their schema are subject to change. Social IdP
|
||||
* <code>authorize_scopes</code> values must match the values listed here.</p> <dl>
|
||||
* <dt>OpenID Connect (OIDC)</dt> <dd> <p>Amazon Cognito accepts the following
|
||||
* elements when it can't discover endpoint URLs from <code>oidc_issuer</code>:
|
||||
* <code>attributes_url</code>, <code>authorize_url</code>, <code>jwks_uri</code>,
|
||||
* <code>token_url</code>.</p> <p>Create or update request:
|
||||
* <code>"ProviderDetails": { "attributes_request_method": "GET", "attributes_url":
|
||||
* "https://auth.example.com/userInfo", "authorize_scopes": "openid profile email",
|
||||
* "authorize_url": "https://auth.example.com/authorize", "client_id":
|
||||
* "1example23456789", "client_secret": "provider-app-client-secret", "jwks_uri":
|
||||
* "https://auth.example.com/.well-known/jwks.json", "oidc_issuer":
|
||||
* "https://auth.example.com", "token_url": "https://example.com/token" }</code>
|
||||
* </p> <p>Describe response: <code>"ProviderDetails": {
|
||||
* "attributes_request_method": "GET", "attributes_url":
|
||||
* "https://auth.example.com/userInfo", "attributes_url_add_attributes": "false",
|
||||
* "authorize_scopes": "openid profile email", "authorize_url":
|
||||
* "https://auth.example.com/authorize", "client_id": "1example23456789",
|
||||
* "client_secret": "provider-app-client-secret", "jwks_uri":
|
||||
* "https://auth.example.com/.well-known/jwks.json", "oidc_issuer":
|
||||
* "https://auth.example.com", "token_url": "https://example.com/token" }</code>
|
||||
* </p> </dd> <dt>SAML</dt> <dd> <p>Create or update request with Metadata URL:
|
||||
* <code>"ProviderDetails": { "IDPInit": "true", "IDPSignout": "true",
|
||||
* "EncryptedResponses" : "true", "MetadataURL":
|
||||
* "https://auth.example.com/sso/saml/metadata", "RequestSigningAlgorithm":
|
||||
* "rsa-sha256" }</code> </p> <p>Create or update request with Metadata file:
|
||||
* <code>"ProviderDetails": { "IDPInit": "true", "IDPSignout": "true",
|
||||
* "EncryptedResponses" : "true", "MetadataFile": "[metadata XML]",
|
||||
* "RequestSigningAlgorithm": "rsa-sha256" }</code> </p> <p>The value of
|
||||
* <code>MetadataFile</code> must be the plaintext metadata document with all quote
|
||||
* (") characters escaped by backslashes.</p> <p>Describe response:
|
||||
* <code>"ProviderDetails": { "IDPInit": "true", "IDPSignout": "true",
|
||||
* "EncryptedResponses" : "true", "ActiveEncryptionCertificate": "[certificate]",
|
||||
* "MetadataURL": "https://auth.example.com/sso/saml/metadata",
|
||||
* "RequestSigningAlgorithm": "rsa-sha256", "SLORedirectBindingURI":
|
||||
* "https://auth.example.com/slo/saml", "SSORedirectBindingURI":
|
||||
* "https://auth.example.com/sso/saml" }</code> </p> </dd> <dt>LoginWithAmazon</dt>
|
||||
* <dd> <p>Create or update request: <code>"ProviderDetails": { "authorize_scopes":
|
||||
* "profile postal_code", "client_id":
|
||||
* "amzn1.application-oa2-client.1example23456789", "client_secret":
|
||||
* "provider-app-client-secret"</code> </p> <p>Describe response:
|
||||
* <code>"ProviderDetails": { "attributes_url":
|
||||
* "https://api.amazon.com/user/profile", "attributes_url_add_attributes": "false",
|
||||
* "authorize_scopes": "profile postal_code", "authorize_url":
|
||||
* "https://www.amazon.com/ap/oa", "client_id":
|
||||
* "amzn1.application-oa2-client.1example23456789", "client_secret":
|
||||
* "provider-app-client-secret", "token_request_method": "POST", "token_url":
|
||||
* "https://api.amazon.com/auth/o2/token" }</code> </p> </dd> <dt>Google</dt> <dd>
|
||||
* <p>Create or update request: <code>"ProviderDetails": { "authorize_scopes":
|
||||
* "email profile openid", "client_id":
|
||||
* "1example23456789.apps.googleusercontent.com", "client_secret":
|
||||
* "provider-app-client-secret" }</code> </p> <p>Describe response:
|
||||
* <code>"ProviderDetails": { "attributes_url":
|
||||
* "https://people.googleapis.com/v1/people/me?personFields=",
|
||||
* "attributes_url_add_attributes": "true", "authorize_scopes": "email profile
|
||||
* openid", "authorize_url": "https://accounts.google.com/o/oauth2/v2/auth",
|
||||
* "client_id": "1example23456789.apps.googleusercontent.com", "client_secret":
|
||||
* "provider-app-client-secret", "oidc_issuer": "https://accounts.google.com",
|
||||
* "token_request_method": "POST", "token_url":
|
||||
* "https://www.googleapis.com/oauth2/v4/token" }</code> </p> </dd>
|
||||
* <dt>SignInWithApple</dt> <dd> <p>Create or update request:
|
||||
* <code>"ProviderDetails": { "authorize_scopes": "email name", "client_id":
|
||||
* "com.example.cognito", "private_key": "1EXAMPLE", "key_id": "2EXAMPLE",
|
||||
* "team_id": "3EXAMPLE" }</code> </p> <p>Describe response:
|
||||
* <code>"ProviderDetails": { "attributes_url_add_attributes": "false",
|
||||
* "authorize_scopes": "email name", "authorize_url":
|
||||
* "https://appleid.apple.com/auth/authorize", "client_id": "com.example.cognito",
|
||||
* "key_id": "1EXAMPLE", "oidc_issuer": "https://appleid.apple.com", "team_id":
|
||||
* "2EXAMPLE", "token_request_method": "POST", "token_url":
|
||||
* "https://appleid.apple.com/auth/token" }</code> </p> </dd> <dt>Facebook</dt>
|
||||
* <dd> <p>Create or update request: <code>"ProviderDetails": { "api_version":
|
||||
* "v17.0", "authorize_scopes": "public_profile, email", "client_id":
|
||||
* "1example23456789", "client_secret": "provider-app-client-secret" }</code> </p>
|
||||
* <p>Describe response: <code>"ProviderDetails": { "api_version": "v17.0",
|
||||
* "attributes_url": "https://graph.facebook.com/v17.0/me?fields=",
|
||||
* "attributes_url_add_attributes": "true", "authorize_scopes": "public_profile,
|
||||
* email", "authorize_url": "https://www.facebook.com/v17.0/dialog/oauth",
|
||||
* "client_id": "1example23456789", "client_secret": "provider-app-client-secret",
|
||||
* "token_request_method": "GET", "token_url":
|
||||
* "https://graph.facebook.com/v17.0/oauth/access_token" }</code> </p> </dd> </dl>
|
||||
*/
|
||||
inline const Aws::Map<Aws::String, Aws::String>& GetProviderDetails() const{ return m_providerDetails; }
|
||||
inline bool ProviderDetailsHasBeenSet() const { return m_providerDetailsHasBeenSet; }
|
||||
inline void SetProviderDetails(const Aws::Map<Aws::String, Aws::String>& value) { m_providerDetailsHasBeenSet = true; m_providerDetails = value; }
|
||||
inline void SetProviderDetails(Aws::Map<Aws::String, Aws::String>&& value) { m_providerDetailsHasBeenSet = true; m_providerDetails = std::move(value); }
|
||||
inline CreateIdentityProviderRequest& WithProviderDetails(const Aws::Map<Aws::String, Aws::String>& value) { SetProviderDetails(value); return *this;}
|
||||
inline CreateIdentityProviderRequest& WithProviderDetails(Aws::Map<Aws::String, Aws::String>&& value) { SetProviderDetails(std::move(value)); return *this;}
|
||||
inline CreateIdentityProviderRequest& AddProviderDetails(const Aws::String& key, const Aws::String& value) { m_providerDetailsHasBeenSet = true; m_providerDetails.emplace(key, value); return *this; }
|
||||
inline CreateIdentityProviderRequest& AddProviderDetails(Aws::String&& key, const Aws::String& value) { m_providerDetailsHasBeenSet = true; m_providerDetails.emplace(std::move(key), value); return *this; }
|
||||
inline CreateIdentityProviderRequest& AddProviderDetails(const Aws::String& key, Aws::String&& value) { m_providerDetailsHasBeenSet = true; m_providerDetails.emplace(key, std::move(value)); return *this; }
|
||||
inline CreateIdentityProviderRequest& AddProviderDetails(Aws::String&& key, Aws::String&& value) { m_providerDetailsHasBeenSet = true; m_providerDetails.emplace(std::move(key), std::move(value)); return *this; }
|
||||
inline CreateIdentityProviderRequest& AddProviderDetails(const char* key, Aws::String&& value) { m_providerDetailsHasBeenSet = true; m_providerDetails.emplace(key, std::move(value)); return *this; }
|
||||
inline CreateIdentityProviderRequest& AddProviderDetails(Aws::String&& key, const char* value) { m_providerDetailsHasBeenSet = true; m_providerDetails.emplace(std::move(key), value); return *this; }
|
||||
inline CreateIdentityProviderRequest& AddProviderDetails(const char* key, const char* value) { m_providerDetailsHasBeenSet = true; m_providerDetails.emplace(key, value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A mapping of IdP attributes to standard and custom user pool attributes.</p>
|
||||
*/
|
||||
inline const Aws::Map<Aws::String, Aws::String>& GetAttributeMapping() const{ return m_attributeMapping; }
|
||||
inline bool AttributeMappingHasBeenSet() const { return m_attributeMappingHasBeenSet; }
|
||||
inline void SetAttributeMapping(const Aws::Map<Aws::String, Aws::String>& value) { m_attributeMappingHasBeenSet = true; m_attributeMapping = value; }
|
||||
inline void SetAttributeMapping(Aws::Map<Aws::String, Aws::String>&& value) { m_attributeMappingHasBeenSet = true; m_attributeMapping = std::move(value); }
|
||||
inline CreateIdentityProviderRequest& WithAttributeMapping(const Aws::Map<Aws::String, Aws::String>& value) { SetAttributeMapping(value); return *this;}
|
||||
inline CreateIdentityProviderRequest& WithAttributeMapping(Aws::Map<Aws::String, Aws::String>&& value) { SetAttributeMapping(std::move(value)); return *this;}
|
||||
inline CreateIdentityProviderRequest& AddAttributeMapping(const Aws::String& key, const Aws::String& value) { m_attributeMappingHasBeenSet = true; m_attributeMapping.emplace(key, value); return *this; }
|
||||
inline CreateIdentityProviderRequest& AddAttributeMapping(Aws::String&& key, const Aws::String& value) { m_attributeMappingHasBeenSet = true; m_attributeMapping.emplace(std::move(key), value); return *this; }
|
||||
inline CreateIdentityProviderRequest& AddAttributeMapping(const Aws::String& key, Aws::String&& value) { m_attributeMappingHasBeenSet = true; m_attributeMapping.emplace(key, std::move(value)); return *this; }
|
||||
inline CreateIdentityProviderRequest& AddAttributeMapping(Aws::String&& key, Aws::String&& value) { m_attributeMappingHasBeenSet = true; m_attributeMapping.emplace(std::move(key), std::move(value)); return *this; }
|
||||
inline CreateIdentityProviderRequest& AddAttributeMapping(const char* key, Aws::String&& value) { m_attributeMappingHasBeenSet = true; m_attributeMapping.emplace(key, std::move(value)); return *this; }
|
||||
inline CreateIdentityProviderRequest& AddAttributeMapping(Aws::String&& key, const char* value) { m_attributeMappingHasBeenSet = true; m_attributeMapping.emplace(std::move(key), value); return *this; }
|
||||
inline CreateIdentityProviderRequest& AddAttributeMapping(const char* key, const char* value) { m_attributeMappingHasBeenSet = true; m_attributeMapping.emplace(key, value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of IdP identifiers.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetIdpIdentifiers() const{ return m_idpIdentifiers; }
|
||||
inline bool IdpIdentifiersHasBeenSet() const { return m_idpIdentifiersHasBeenSet; }
|
||||
inline void SetIdpIdentifiers(const Aws::Vector<Aws::String>& value) { m_idpIdentifiersHasBeenSet = true; m_idpIdentifiers = value; }
|
||||
inline void SetIdpIdentifiers(Aws::Vector<Aws::String>&& value) { m_idpIdentifiersHasBeenSet = true; m_idpIdentifiers = std::move(value); }
|
||||
inline CreateIdentityProviderRequest& WithIdpIdentifiers(const Aws::Vector<Aws::String>& value) { SetIdpIdentifiers(value); return *this;}
|
||||
inline CreateIdentityProviderRequest& WithIdpIdentifiers(Aws::Vector<Aws::String>&& value) { SetIdpIdentifiers(std::move(value)); return *this;}
|
||||
inline CreateIdentityProviderRequest& AddIdpIdentifiers(const Aws::String& value) { m_idpIdentifiersHasBeenSet = true; m_idpIdentifiers.push_back(value); return *this; }
|
||||
inline CreateIdentityProviderRequest& AddIdpIdentifiers(Aws::String&& value) { m_idpIdentifiersHasBeenSet = true; m_idpIdentifiers.push_back(std::move(value)); return *this; }
|
||||
inline CreateIdentityProviderRequest& AddIdpIdentifiers(const char* value) { m_idpIdentifiersHasBeenSet = true; m_idpIdentifiers.push_back(value); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_providerName;
|
||||
bool m_providerNameHasBeenSet = false;
|
||||
|
||||
IdentityProviderTypeType m_providerType;
|
||||
bool m_providerTypeHasBeenSet = false;
|
||||
|
||||
Aws::Map<Aws::String, Aws::String> m_providerDetails;
|
||||
bool m_providerDetailsHasBeenSet = false;
|
||||
|
||||
Aws::Map<Aws::String, Aws::String> m_attributeMapping;
|
||||
bool m_attributeMappingHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Aws::String> m_idpIdentifiers;
|
||||
bool m_idpIdentifiersHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,66 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/model/IdentityProviderType.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class CreateIdentityProviderResult
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API CreateIdentityProviderResult();
|
||||
AWS_COGNITOIDENTITYPROVIDER_API CreateIdentityProviderResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_COGNITOIDENTITYPROVIDER_API CreateIdentityProviderResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The newly created IdP object.</p>
|
||||
*/
|
||||
inline const IdentityProviderType& GetIdentityProvider() const{ return m_identityProvider; }
|
||||
inline void SetIdentityProvider(const IdentityProviderType& value) { m_identityProvider = value; }
|
||||
inline void SetIdentityProvider(IdentityProviderType&& value) { m_identityProvider = std::move(value); }
|
||||
inline CreateIdentityProviderResult& WithIdentityProvider(const IdentityProviderType& value) { SetIdentityProvider(value); return *this;}
|
||||
inline CreateIdentityProviderResult& WithIdentityProvider(IdentityProviderType&& value) { SetIdentityProvider(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline CreateIdentityProviderResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline CreateIdentityProviderResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline CreateIdentityProviderResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
IdentityProviderType m_identityProvider;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,117 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/cognito-idp/CognitoIdentityProvider_EXPORTS.h>
|
||||
#include <aws/cognito-idp/CognitoIdentityProviderRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/cognito-idp/model/ResourceServerScopeType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace CognitoIdentityProvider
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class CreateResourceServerRequest : public CognitoIdentityProviderRequest
|
||||
{
|
||||
public:
|
||||
AWS_COGNITOIDENTITYPROVIDER_API CreateResourceServerRequest();
|
||||
|
||||
// Service request name is the Operation name which will send this request out,
|
||||
// each operation should has unique request name, so that we can get operation's name from this request.
|
||||
// Note: this is not true for response, multiple operations may have the same response name,
|
||||
// so we can not get operation's name from response.
|
||||
inline virtual const char* GetServiceRequestName() const override { return "CreateResourceServer"; }
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_COGNITOIDENTITYPROVIDER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The user pool ID for the user pool.</p>
|
||||
*/
|
||||
inline const Aws::String& GetUserPoolId() const{ return m_userPoolId; }
|
||||
inline bool UserPoolIdHasBeenSet() const { return m_userPoolIdHasBeenSet; }
|
||||
inline void SetUserPoolId(const Aws::String& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = value; }
|
||||
inline void SetUserPoolId(Aws::String&& value) { m_userPoolIdHasBeenSet = true; m_userPoolId = std::move(value); }
|
||||
inline void SetUserPoolId(const char* value) { m_userPoolIdHasBeenSet = true; m_userPoolId.assign(value); }
|
||||
inline CreateResourceServerRequest& WithUserPoolId(const Aws::String& value) { SetUserPoolId(value); return *this;}
|
||||
inline CreateResourceServerRequest& WithUserPoolId(Aws::String&& value) { SetUserPoolId(std::move(value)); return *this;}
|
||||
inline CreateResourceServerRequest& WithUserPoolId(const char* value) { SetUserPoolId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique resource server identifier for the resource server. The identifier
|
||||
* can be an API friendly name like <code>solar-system-data</code>. You can also
|
||||
* set an API URL like <code>https://solar-system-data-api.example.com</code> as
|
||||
* your identifier.</p> <p>Amazon Cognito represents scopes in the access token in
|
||||
* the format <code>$resource-server-identifier/$scope</code>. Longer
|
||||
* scope-identifier strings increase the size of your access tokens.</p>
|
||||
*/
|
||||
inline const Aws::String& GetIdentifier() const{ return m_identifier; }
|
||||
inline bool IdentifierHasBeenSet() const { return m_identifierHasBeenSet; }
|
||||
inline void SetIdentifier(const Aws::String& value) { m_identifierHasBeenSet = true; m_identifier = value; }
|
||||
inline void SetIdentifier(Aws::String&& value) { m_identifierHasBeenSet = true; m_identifier = std::move(value); }
|
||||
inline void SetIdentifier(const char* value) { m_identifierHasBeenSet = true; m_identifier.assign(value); }
|
||||
inline CreateResourceServerRequest& WithIdentifier(const Aws::String& value) { SetIdentifier(value); return *this;}
|
||||
inline CreateResourceServerRequest& WithIdentifier(Aws::String&& value) { SetIdentifier(std::move(value)); return *this;}
|
||||
inline CreateResourceServerRequest& WithIdentifier(const char* value) { SetIdentifier(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A friendly name for the resource server.</p>
|
||||
*/
|
||||
inline const Aws::String& GetName() const{ return m_name; }
|
||||
inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
|
||||
inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
|
||||
inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
|
||||
inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
|
||||
inline CreateResourceServerRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
|
||||
inline CreateResourceServerRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
|
||||
inline CreateResourceServerRequest& WithName(const char* value) { SetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of scopes. Each scope is a key-value map with the keys
|
||||
* <code>name</code> and <code>description</code>.</p>
|
||||
*/
|
||||
inline const Aws::Vector<ResourceServerScopeType>& GetScopes() const{ return m_scopes; }
|
||||
inline bool ScopesHasBeenSet() const { return m_scopesHasBeenSet; }
|
||||
inline void SetScopes(const Aws::Vector<ResourceServerScopeType>& value) { m_scopesHasBeenSet = true; m_scopes = value; }
|
||||
inline void SetScopes(Aws::Vector<ResourceServerScopeType>&& value) { m_scopesHasBeenSet = true; m_scopes = std::move(value); }
|
||||
inline CreateResourceServerRequest& WithScopes(const Aws::Vector<ResourceServerScopeType>& value) { SetScopes(value); return *this;}
|
||||
inline CreateResourceServerRequest& WithScopes(Aws::Vector<ResourceServerScopeType>&& value) { SetScopes(std::move(value)); return *this;}
|
||||
inline CreateResourceServerRequest& AddScopes(const ResourceServerScopeType& value) { m_scopesHasBeenSet = true; m_scopes.push_back(value); return *this; }
|
||||
inline CreateResourceServerRequest& AddScopes(ResourceServerScopeType&& value) { m_scopesHasBeenSet = true; m_scopes.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_userPoolId;
|
||||
bool m_userPoolIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_identifier;
|
||||
bool m_identifierHasBeenSet = false;
|
||||
|
||||
Aws::String m_name;
|
||||
bool m_nameHasBeenSet = false;
|
||||
|
||||
Aws::Vector<ResourceServerScopeType> m_scopes;
|
||||
bool m_scopesHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace CognitoIdentityProvider
|
||||
} // namespace Aws
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user