pxz-hos-client-cpp-module/support/aws-sdk-cpp-master/aws-cpp-sdk-cognito-identity/include/aws/cognito-identity/CognitoIdentityClient.h

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

#pragma once
#include <aws/cognito-identity/CognitoIdentity_EXPORTS.h>
#include <aws/cognito-identity/CognitoIdentityErrors.h>
#include <aws/core/client/AWSError.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/cognito-identity/model/CreateIdentityPoolResult.h>
#include <aws/cognito-identity/model/DeleteIdentitiesResult.h>
#include <aws/cognito-identity/model/DescribeIdentityResult.h>
#include <aws/cognito-identity/model/DescribeIdentityPoolResult.h>
#include <aws/cognito-identity/model/GetCredentialsForIdentityResult.h>
#include <aws/cognito-identity/model/GetIdResult.h>
#include <aws/cognito-identity/model/GetIdentityPoolRolesResult.h>
#include <aws/cognito-identity/model/GetOpenIdTokenResult.h>
#include <aws/cognito-identity/model/GetOpenIdTokenForDeveloperIdentityResult.h>
#include <aws/cognito-identity/model/ListIdentitiesResult.h>
#include <aws/cognito-identity/model/ListIdentityPoolsResult.h>
#include <aws/cognito-identity/model/ListTagsForResourceResult.h>
#include <aws/cognito-identity/model/LookupDeveloperIdentityResult.h>
#include <aws/cognito-identity/model/MergeDeveloperIdentitiesResult.h>
#include <aws/cognito-identity/model/TagResourceResult.h>
#include <aws/cognito-identity/model/UntagResourceResult.h>
#include <aws/cognito-identity/model/UpdateIdentityPoolResult.h>
#include <aws/core/NoResult.h>
#include <aws/core/client/AsyncCallerContext.h>
#include <aws/core/http/HttpTypes.h>
#include <future>
#include <functional>

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 CognitoIdentity
{

namespace Model
{
        class CreateIdentityPoolRequest;
        class DeleteIdentitiesRequest;
        class DeleteIdentityPoolRequest;
        class DescribeIdentityRequest;
        class DescribeIdentityPoolRequest;
        class GetCredentialsForIdentityRequest;
        class GetIdRequest;
        class GetIdentityPoolRolesRequest;
        class GetOpenIdTokenRequest;
        class GetOpenIdTokenForDeveloperIdentityRequest;
        class ListIdentitiesRequest;
        class ListIdentityPoolsRequest;
        class ListTagsForResourceRequest;
        class LookupDeveloperIdentityRequest;
        class MergeDeveloperIdentitiesRequest;
        class SetIdentityPoolRolesRequest;
        class TagResourceRequest;
        class UnlinkDeveloperIdentityRequest;
        class UnlinkIdentityRequest;
        class UntagResourceRequest;
        class UpdateIdentityPoolRequest;

        typedef Aws::Utils::Outcome<CreateIdentityPoolResult, CognitoIdentityError> CreateIdentityPoolOutcome;
        typedef Aws::Utils::Outcome<DeleteIdentitiesResult, CognitoIdentityError> DeleteIdentitiesOutcome;
        typedef Aws::Utils::Outcome<Aws::NoResult, CognitoIdentityError> DeleteIdentityPoolOutcome;
        typedef Aws::Utils::Outcome<DescribeIdentityResult, CognitoIdentityError> DescribeIdentityOutcome;
        typedef Aws::Utils::Outcome<DescribeIdentityPoolResult, CognitoIdentityError> DescribeIdentityPoolOutcome;
        typedef Aws::Utils::Outcome<GetCredentialsForIdentityResult, CognitoIdentityError> GetCredentialsForIdentityOutcome;
        typedef Aws::Utils::Outcome<GetIdResult, CognitoIdentityError> GetIdOutcome;
        typedef Aws::Utils::Outcome<GetIdentityPoolRolesResult, CognitoIdentityError> GetIdentityPoolRolesOutcome;
        typedef Aws::Utils::Outcome<GetOpenIdTokenResult, CognitoIdentityError> GetOpenIdTokenOutcome;
        typedef Aws::Utils::Outcome<GetOpenIdTokenForDeveloperIdentityResult, CognitoIdentityError> GetOpenIdTokenForDeveloperIdentityOutcome;
        typedef Aws::Utils::Outcome<ListIdentitiesResult, CognitoIdentityError> ListIdentitiesOutcome;
        typedef Aws::Utils::Outcome<ListIdentityPoolsResult, CognitoIdentityError> ListIdentityPoolsOutcome;
        typedef Aws::Utils::Outcome<ListTagsForResourceResult, CognitoIdentityError> ListTagsForResourceOutcome;
        typedef Aws::Utils::Outcome<LookupDeveloperIdentityResult, CognitoIdentityError> LookupDeveloperIdentityOutcome;
        typedef Aws::Utils::Outcome<MergeDeveloperIdentitiesResult, CognitoIdentityError> MergeDeveloperIdentitiesOutcome;
        typedef Aws::Utils::Outcome<Aws::NoResult, CognitoIdentityError> SetIdentityPoolRolesOutcome;
        typedef Aws::Utils::Outcome<TagResourceResult, CognitoIdentityError> TagResourceOutcome;
        typedef Aws::Utils::Outcome<Aws::NoResult, CognitoIdentityError> UnlinkDeveloperIdentityOutcome;
        typedef Aws::Utils::Outcome<Aws::NoResult, CognitoIdentityError> UnlinkIdentityOutcome;
        typedef Aws::Utils::Outcome<UntagResourceResult, CognitoIdentityError> UntagResourceOutcome;
        typedef Aws::Utils::Outcome<UpdateIdentityPoolResult, CognitoIdentityError> UpdateIdentityPoolOutcome;

        typedef std::future<CreateIdentityPoolOutcome> CreateIdentityPoolOutcomeCallable;
        typedef std::future<DeleteIdentitiesOutcome> DeleteIdentitiesOutcomeCallable;
        typedef std::future<DeleteIdentityPoolOutcome> DeleteIdentityPoolOutcomeCallable;
        typedef std::future<DescribeIdentityOutcome> DescribeIdentityOutcomeCallable;
        typedef std::future<DescribeIdentityPoolOutcome> DescribeIdentityPoolOutcomeCallable;
        typedef std::future<GetCredentialsForIdentityOutcome> GetCredentialsForIdentityOutcomeCallable;
        typedef std::future<GetIdOutcome> GetIdOutcomeCallable;
        typedef std::future<GetIdentityPoolRolesOutcome> GetIdentityPoolRolesOutcomeCallable;
        typedef std::future<GetOpenIdTokenOutcome> GetOpenIdTokenOutcomeCallable;
        typedef std::future<GetOpenIdTokenForDeveloperIdentityOutcome> GetOpenIdTokenForDeveloperIdentityOutcomeCallable;
        typedef std::future<ListIdentitiesOutcome> ListIdentitiesOutcomeCallable;
        typedef std::future<ListIdentityPoolsOutcome> ListIdentityPoolsOutcomeCallable;
        typedef std::future<ListTagsForResourceOutcome> ListTagsForResourceOutcomeCallable;
        typedef std::future<LookupDeveloperIdentityOutcome> LookupDeveloperIdentityOutcomeCallable;
        typedef std::future<MergeDeveloperIdentitiesOutcome> MergeDeveloperIdentitiesOutcomeCallable;
        typedef std::future<SetIdentityPoolRolesOutcome> SetIdentityPoolRolesOutcomeCallable;
        typedef std::future<TagResourceOutcome> TagResourceOutcomeCallable;
        typedef std::future<UnlinkDeveloperIdentityOutcome> UnlinkDeveloperIdentityOutcomeCallable;
        typedef std::future<UnlinkIdentityOutcome> UnlinkIdentityOutcomeCallable;
        typedef std::future<UntagResourceOutcome> UntagResourceOutcomeCallable;
        typedef std::future<UpdateIdentityPoolOutcome> UpdateIdentityPoolOutcomeCallable;
} // namespace Model

  class CognitoIdentityClient;

    typedef std::function<void(const CognitoIdentityClient*, const Model::CreateIdentityPoolRequest&, const Model::CreateIdentityPoolOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateIdentityPoolResponseReceivedHandler;
    typedef std::function<void(const CognitoIdentityClient*, const Model::DeleteIdentitiesRequest&, const Model::DeleteIdentitiesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteIdentitiesResponseReceivedHandler;
    typedef std::function<void(const CognitoIdentityClient*, const Model::DeleteIdentityPoolRequest&, const Model::DeleteIdentityPoolOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteIdentityPoolResponseReceivedHandler;
    typedef std::function<void(const CognitoIdentityClient*, const Model::DescribeIdentityRequest&, const Model::DescribeIdentityOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeIdentityResponseReceivedHandler;
    typedef std::function<void(const CognitoIdentityClient*, const Model::DescribeIdentityPoolRequest&, const Model::DescribeIdentityPoolOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeIdentityPoolResponseReceivedHandler;
    typedef std::function<void(const CognitoIdentityClient*, const Model::GetCredentialsForIdentityRequest&, const Model::GetCredentialsForIdentityOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetCredentialsForIdentityResponseReceivedHandler;
    typedef std::function<void(const CognitoIdentityClient*, const Model::GetIdRequest&, const Model::GetIdOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetIdResponseReceivedHandler;
    typedef std::function<void(const CognitoIdentityClient*, const Model::GetIdentityPoolRolesRequest&, const Model::GetIdentityPoolRolesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetIdentityPoolRolesResponseReceivedHandler;
    typedef std::function<void(const CognitoIdentityClient*, const Model::GetOpenIdTokenRequest&, const Model::GetOpenIdTokenOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetOpenIdTokenResponseReceivedHandler;
    typedef std::function<void(const CognitoIdentityClient*, const Model::GetOpenIdTokenForDeveloperIdentityRequest&, const Model::GetOpenIdTokenForDeveloperIdentityOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetOpenIdTokenForDeveloperIdentityResponseReceivedHandler;
    typedef std::function<void(const CognitoIdentityClient*, const Model::ListIdentitiesRequest&, const Model::ListIdentitiesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListIdentitiesResponseReceivedHandler;
    typedef std::function<void(const CognitoIdentityClient*, const Model::ListIdentityPoolsRequest&, const Model::ListIdentityPoolsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListIdentityPoolsResponseReceivedHandler;
    typedef std::function<void(const CognitoIdentityClient*, const Model::ListTagsForResourceRequest&, const Model::ListTagsForResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListTagsForResourceResponseReceivedHandler;
    typedef std::function<void(const CognitoIdentityClient*, const Model::LookupDeveloperIdentityRequest&, const Model::LookupDeveloperIdentityOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > LookupDeveloperIdentityResponseReceivedHandler;
    typedef std::function<void(const CognitoIdentityClient*, const Model::MergeDeveloperIdentitiesRequest&, const Model::MergeDeveloperIdentitiesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > MergeDeveloperIdentitiesResponseReceivedHandler;
    typedef std::function<void(const CognitoIdentityClient*, const Model::SetIdentityPoolRolesRequest&, const Model::SetIdentityPoolRolesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SetIdentityPoolRolesResponseReceivedHandler;
    typedef std::function<void(const CognitoIdentityClient*, const Model::TagResourceRequest&, const Model::TagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > TagResourceResponseReceivedHandler;
    typedef std::function<void(const CognitoIdentityClient*, const Model::UnlinkDeveloperIdentityRequest&, const Model::UnlinkDeveloperIdentityOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UnlinkDeveloperIdentityResponseReceivedHandler;
    typedef std::function<void(const CognitoIdentityClient*, const Model::UnlinkIdentityRequest&, const Model::UnlinkIdentityOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UnlinkIdentityResponseReceivedHandler;
    typedef std::function<void(const CognitoIdentityClient*, const Model::UntagResourceRequest&, const Model::UntagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UntagResourceResponseReceivedHandler;
    typedef std::function<void(const CognitoIdentityClient*, const Model::UpdateIdentityPoolRequest&, const Model::UpdateIdentityPoolOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateIdentityPoolResponseReceivedHandler;

  /**
   * <fullname>Amazon Cognito Federated Identities</fullname> <p>Amazon Cognito
   * Federated Identities is a web service that delivers scoped temporary credentials
   * to mobile devices and other untrusted environments. It uniquely identifies a
   * device and supplies the user with a consistent identity over the lifetime of an
   * application.</p> <p>Using Amazon Cognito Federated Identities, you can enable
   * authentication with one or more third-party identity providers (Facebook,
   * Google, or Login with Amazon) or an Amazon Cognito user pool, and you can also
   * choose to support unauthenticated access from your app. Cognito delivers a
   * unique identifier for each user and acts as an OpenID token provider trusted by
   * AWS Security Token Service (STS) to access temporary, limited-privilege AWS
   * credentials.</p> <p>For a description of the authentication flow from the Amazon
   * Cognito Developer Guide see <a
   * href="https://docs.aws.amazon.com/cognito/latest/developerguide/authentication-flow.html">Authentication
   * Flow</a>.</p> <p>For more information see <a
   * href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-identity.html">Amazon
   * Cognito Federated Identities</a>.</p>
   */
  class AWS_COGNITOIDENTITY_API CognitoIdentityClient : public Aws::Client::AWSJsonClient
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;

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

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

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

        virtual ~CognitoIdentityClient();


        /**
         * <p>Creates a new identity pool. The identity pool is a store of user identity
         * information that is specific to your AWS account. The keys for
         * <code>SupportedLoginProviders</code> are as follows:</p> <ul> <li> <p>Facebook:
         * <code>graph.facebook.com</code> </p> </li> <li> <p>Google:
         * <code>accounts.google.com</code> </p> </li> <li> <p>Amazon:
         * <code>www.amazon.com</code> </p> </li> <li> <p>Twitter:
         * <code>api.twitter.com</code> </p> </li> <li> <p>Digits:
         * <code>www.digits.com</code> </p> </li> </ul> <p>You must use AWS Developer
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/CreateIdentityPool">AWS
         * API Reference</a></p>
         */
        virtual Model::CreateIdentityPoolOutcome CreateIdentityPool(const Model::CreateIdentityPoolRequest& request) const;

        /**
         * <p>Creates a new identity pool. The identity pool is a store of user identity
         * information that is specific to your AWS account. The keys for
         * <code>SupportedLoginProviders</code> are as follows:</p> <ul> <li> <p>Facebook:
         * <code>graph.facebook.com</code> </p> </li> <li> <p>Google:
         * <code>accounts.google.com</code> </p> </li> <li> <p>Amazon:
         * <code>www.amazon.com</code> </p> </li> <li> <p>Twitter:
         * <code>api.twitter.com</code> </p> </li> <li> <p>Digits:
         * <code>www.digits.com</code> </p> </li> </ul> <p>You must use AWS Developer
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/CreateIdentityPool">AWS
         * API Reference</a></p>
         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::CreateIdentityPoolOutcomeCallable CreateIdentityPoolCallable(const Model::CreateIdentityPoolRequest& request) const;

        /**
         * <p>Creates a new identity pool. The identity pool is a store of user identity
         * information that is specific to your AWS account. The keys for
         * <code>SupportedLoginProviders</code> are as follows:</p> <ul> <li> <p>Facebook:
         * <code>graph.facebook.com</code> </p> </li> <li> <p>Google:
         * <code>accounts.google.com</code> </p> </li> <li> <p>Amazon:
         * <code>www.amazon.com</code> </p> </li> <li> <p>Twitter:
         * <code>api.twitter.com</code> </p> </li> <li> <p>Digits:
         * <code>www.digits.com</code> </p> </li> </ul> <p>You must use AWS Developer
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/CreateIdentityPool">AWS
         * API Reference</a></p>
         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void CreateIdentityPoolAsync(const Model::CreateIdentityPoolRequest& request, const CreateIdentityPoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         * <p>Deletes identities from an identity pool. You can specify a list of 1-60
         * identities that you want to delete.</p> <p>You must use AWS Developer
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/DeleteIdentities">AWS
         * API Reference</a></p>
         */
        virtual Model::DeleteIdentitiesOutcome DeleteIdentities(const Model::DeleteIdentitiesRequest& request) const;

        /**
         * <p>Deletes identities from an identity pool. You can specify a list of 1-60
         * identities that you want to delete.</p> <p>You must use AWS Developer
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/DeleteIdentities">AWS
         * API Reference</a></p>
         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DeleteIdentitiesOutcomeCallable DeleteIdentitiesCallable(const Model::DeleteIdentitiesRequest& request) const;

        /**
         * <p>Deletes identities from an identity pool. You can specify a list of 1-60
         * identities that you want to delete.</p> <p>You must use AWS Developer
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/DeleteIdentities">AWS
         * API Reference</a></p>
         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DeleteIdentitiesAsync(const Model::DeleteIdentitiesRequest& request, const DeleteIdentitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         * <p>Deletes an identity pool. Once a pool is deleted, users will not be able to
         * authenticate with the pool.</p> <p>You must use AWS Developer credentials to
         * call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/DeleteIdentityPool">AWS
         * API Reference</a></p>
         */
        virtual Model::DeleteIdentityPoolOutcome DeleteIdentityPool(const Model::DeleteIdentityPoolRequest& request) const;

        /**
         * <p>Deletes an identity pool. Once a pool is deleted, users will not be able to
         * authenticate with the pool.</p> <p>You must use AWS Developer credentials to
         * call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/DeleteIdentityPool">AWS
         * API Reference</a></p>
         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DeleteIdentityPoolOutcomeCallable DeleteIdentityPoolCallable(const Model::DeleteIdentityPoolRequest& request) const;

        /**
         * <p>Deletes an identity pool. Once a pool is deleted, users will not be able to
         * authenticate with the pool.</p> <p>You must use AWS Developer credentials to
         * call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/DeleteIdentityPool">AWS
         * API Reference</a></p>
         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DeleteIdentityPoolAsync(const Model::DeleteIdentityPoolRequest& request, const DeleteIdentityPoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         * <p>Returns metadata related to the given identity, including when the identity
         * was created and any associated linked logins.</p> <p>You must use AWS Developer
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/DescribeIdentity">AWS
         * API Reference</a></p>
         */
        virtual Model::DescribeIdentityOutcome DescribeIdentity(const Model::DescribeIdentityRequest& request) const;

        /**
         * <p>Returns metadata related to the given identity, including when the identity
         * was created and any associated linked logins.</p> <p>You must use AWS Developer
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/DescribeIdentity">AWS
         * API Reference</a></p>
         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DescribeIdentityOutcomeCallable DescribeIdentityCallable(const Model::DescribeIdentityRequest& request) const;

        /**
         * <p>Returns metadata related to the given identity, including when the identity
         * was created and any associated linked logins.</p> <p>You must use AWS Developer
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/DescribeIdentity">AWS
         * API Reference</a></p>
         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DescribeIdentityAsync(const Model::DescribeIdentityRequest& request, const DescribeIdentityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         * <p>Gets details about a particular identity pool, including the pool name, ID
         * description, creation date, and current number of users.</p> <p>You must use AWS
         * Developer credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/DescribeIdentityPool">AWS
         * API Reference</a></p>
         */
        virtual Model::DescribeIdentityPoolOutcome DescribeIdentityPool(const Model::DescribeIdentityPoolRequest& request) const;

        /**
         * <p>Gets details about a particular identity pool, including the pool name, ID
         * description, creation date, and current number of users.</p> <p>You must use AWS
         * Developer credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/DescribeIdentityPool">AWS
         * API Reference</a></p>
         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DescribeIdentityPoolOutcomeCallable DescribeIdentityPoolCallable(const Model::DescribeIdentityPoolRequest& request) const;

        /**
         * <p>Gets details about a particular identity pool, including the pool name, ID
         * description, creation date, and current number of users.</p> <p>You must use AWS
         * Developer credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/DescribeIdentityPool">AWS
         * API Reference</a></p>
         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DescribeIdentityPoolAsync(const Model::DescribeIdentityPoolRequest& request, const DescribeIdentityPoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         * <p>Returns credentials for the provided identity ID. Any provided logins will be
         * validated against supported login providers. If the token is for
         * cognito-identity.amazonaws.com, it will be passed through to AWS Security Token
         * Service with the appropriate role for the token.</p> <p>This is a public API.
         * You do not need any credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/GetCredentialsForIdentity">AWS
         * API Reference</a></p>
         */
        virtual Model::GetCredentialsForIdentityOutcome GetCredentialsForIdentity(const Model::GetCredentialsForIdentityRequest& request) const;

        /**
         * <p>Returns credentials for the provided identity ID. Any provided logins will be
         * validated against supported login providers. If the token is for
         * cognito-identity.amazonaws.com, it will be passed through to AWS Security Token
         * Service with the appropriate role for the token.</p> <p>This is a public API.
         * You do not need any credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/GetCredentialsForIdentity">AWS
         * API Reference</a></p>
         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::GetCredentialsForIdentityOutcomeCallable GetCredentialsForIdentityCallable(const Model::GetCredentialsForIdentityRequest& request) const;

        /**
         * <p>Returns credentials for the provided identity ID. Any provided logins will be
         * validated against supported login providers. If the token is for
         * cognito-identity.amazonaws.com, it will be passed through to AWS Security Token
         * Service with the appropriate role for the token.</p> <p>This is a public API.
         * You do not need any credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/GetCredentialsForIdentity">AWS
         * API Reference</a></p>
         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void GetCredentialsForIdentityAsync(const Model::GetCredentialsForIdentityRequest& request, const GetCredentialsForIdentityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         * <p>Generates (or retrieves) a Cognito ID. Supplying multiple logins will create
         * an implicit linked account.</p> <p>This is a public API. You do not need any
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/GetId">AWS
         * API Reference</a></p>
         */
        virtual Model::GetIdOutcome GetId(const Model::GetIdRequest& request) const;

        /**
         * <p>Generates (or retrieves) a Cognito ID. Supplying multiple logins will create
         * an implicit linked account.</p> <p>This is a public API. You do not need any
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/GetId">AWS
         * API Reference</a></p>
         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::GetIdOutcomeCallable GetIdCallable(const Model::GetIdRequest& request) const;

        /**
         * <p>Generates (or retrieves) a Cognito ID. Supplying multiple logins will create
         * an implicit linked account.</p> <p>This is a public API. You do not need any
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/GetId">AWS
         * API Reference</a></p>
         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void GetIdAsync(const Model::GetIdRequest& request, const GetIdResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         * <p>Gets the roles for an identity pool.</p> <p>You must use AWS Developer
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/GetIdentityPoolRoles">AWS
         * API Reference</a></p>
         */
        virtual Model::GetIdentityPoolRolesOutcome GetIdentityPoolRoles(const Model::GetIdentityPoolRolesRequest& request) const;

        /**
         * <p>Gets the roles for an identity pool.</p> <p>You must use AWS Developer
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/GetIdentityPoolRoles">AWS
         * API Reference</a></p>
         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::GetIdentityPoolRolesOutcomeCallable GetIdentityPoolRolesCallable(const Model::GetIdentityPoolRolesRequest& request) const;

        /**
         * <p>Gets the roles for an identity pool.</p> <p>You must use AWS Developer
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/GetIdentityPoolRoles">AWS
         * API Reference</a></p>
         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void GetIdentityPoolRolesAsync(const Model::GetIdentityPoolRolesRequest& request, const GetIdentityPoolRolesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         * <p>Gets an OpenID token, using a known Cognito ID. This known Cognito ID is
         * returned by <a>GetId</a>. You can optionally add additional logins for the
         * identity. Supplying multiple logins creates an implicit link.</p> <p>The OpenId
         * token is valid for 10 minutes.</p> <p>This is a public API. You do not need any
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/GetOpenIdToken">AWS
         * API Reference</a></p>
         */
        virtual Model::GetOpenIdTokenOutcome GetOpenIdToken(const Model::GetOpenIdTokenRequest& request) const;

        /**
         * <p>Gets an OpenID token, using a known Cognito ID. This known Cognito ID is
         * returned by <a>GetId</a>. You can optionally add additional logins for the
         * identity. Supplying multiple logins creates an implicit link.</p> <p>The OpenId
         * token is valid for 10 minutes.</p> <p>This is a public API. You do not need any
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/GetOpenIdToken">AWS
         * API Reference</a></p>
         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::GetOpenIdTokenOutcomeCallable GetOpenIdTokenCallable(const Model::GetOpenIdTokenRequest& request) const;

        /**
         * <p>Gets an OpenID token, using a known Cognito ID. This known Cognito ID is
         * returned by <a>GetId</a>. You can optionally add additional logins for the
         * identity. Supplying multiple logins creates an implicit link.</p> <p>The OpenId
         * token is valid for 10 minutes.</p> <p>This is a public API. You do not need any
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/GetOpenIdToken">AWS
         * API Reference</a></p>
         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void GetOpenIdTokenAsync(const Model::GetOpenIdTokenRequest& request, const GetOpenIdTokenResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         * <p>Registers (or retrieves) a Cognito <code>IdentityId</code> and an OpenID
         * Connect token for a user authenticated by your backend authentication process.
         * Supplying multiple logins will create an implicit linked account. You can only
         * specify one developer provider as part of the <code>Logins</code> map, which is
         * linked to the identity pool. The developer provider is the "domain" by which
         * Cognito will refer to your users.</p> <p>You can use
         * <code>GetOpenIdTokenForDeveloperIdentity</code> to create a new identity and to
         * link new logins (that is, user credentials issued by a public provider or
         * developer provider) to an existing identity. When you want to create a new
         * identity, the <code>IdentityId</code> should be null. When you want to associate
         * a new login with an existing authenticated/unauthenticated identity, you can do
         * so by providing the existing <code>IdentityId</code>. This API will create the
         * identity in the specified <code>IdentityPoolId</code>.</p> <p>You must use AWS
         * Developer credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/GetOpenIdTokenForDeveloperIdentity">AWS
         * API Reference</a></p>
         */
        virtual Model::GetOpenIdTokenForDeveloperIdentityOutcome GetOpenIdTokenForDeveloperIdentity(const Model::GetOpenIdTokenForDeveloperIdentityRequest& request) const;

        /**
         * <p>Registers (or retrieves) a Cognito <code>IdentityId</code> and an OpenID
         * Connect token for a user authenticated by your backend authentication process.
         * Supplying multiple logins will create an implicit linked account. You can only
         * specify one developer provider as part of the <code>Logins</code> map, which is
         * linked to the identity pool. The developer provider is the "domain" by which
         * Cognito will refer to your users.</p> <p>You can use
         * <code>GetOpenIdTokenForDeveloperIdentity</code> to create a new identity and to
         * link new logins (that is, user credentials issued by a public provider or
         * developer provider) to an existing identity. When you want to create a new
         * identity, the <code>IdentityId</code> should be null. When you want to associate
         * a new login with an existing authenticated/unauthenticated identity, you can do
         * so by providing the existing <code>IdentityId</code>. This API will create the
         * identity in the specified <code>IdentityPoolId</code>.</p> <p>You must use AWS
         * Developer credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/GetOpenIdTokenForDeveloperIdentity">AWS
         * API Reference</a></p>
         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::GetOpenIdTokenForDeveloperIdentityOutcomeCallable GetOpenIdTokenForDeveloperIdentityCallable(const Model::GetOpenIdTokenForDeveloperIdentityRequest& request) const;

        /**
         * <p>Registers (or retrieves) a Cognito <code>IdentityId</code> and an OpenID
         * Connect token for a user authenticated by your backend authentication process.
         * Supplying multiple logins will create an implicit linked account. You can only
         * specify one developer provider as part of the <code>Logins</code> map, which is
         * linked to the identity pool. The developer provider is the "domain" by which
         * Cognito will refer to your users.</p> <p>You can use
         * <code>GetOpenIdTokenForDeveloperIdentity</code> to create a new identity and to
         * link new logins (that is, user credentials issued by a public provider or
         * developer provider) to an existing identity. When you want to create a new
         * identity, the <code>IdentityId</code> should be null. When you want to associate
         * a new login with an existing authenticated/unauthenticated identity, you can do
         * so by providing the existing <code>IdentityId</code>. This API will create the
         * identity in the specified <code>IdentityPoolId</code>.</p> <p>You must use AWS
         * Developer credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/GetOpenIdTokenForDeveloperIdentity">AWS
         * API Reference</a></p>
         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void GetOpenIdTokenForDeveloperIdentityAsync(const Model::GetOpenIdTokenForDeveloperIdentityRequest& request, const GetOpenIdTokenForDeveloperIdentityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         * <p>Lists the identities in an identity pool.</p> <p>You must use AWS Developer
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/ListIdentities">AWS
         * API Reference</a></p>
         */
        virtual Model::ListIdentitiesOutcome ListIdentities(const Model::ListIdentitiesRequest& request) const;

        /**
         * <p>Lists the identities in an identity pool.</p> <p>You must use AWS Developer
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/ListIdentities">AWS
         * API Reference</a></p>
         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::ListIdentitiesOutcomeCallable ListIdentitiesCallable(const Model::ListIdentitiesRequest& request) const;

        /**
         * <p>Lists the identities in an identity pool.</p> <p>You must use AWS Developer
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/ListIdentities">AWS
         * API Reference</a></p>
         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void ListIdentitiesAsync(const Model::ListIdentitiesRequest& request, const ListIdentitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         * <p>Lists all of the Cognito identity pools registered for your account.</p>
         * <p>You must use AWS Developer credentials to call this API.</p><p><h3>See
         * Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/ListIdentityPools">AWS
         * API Reference</a></p>
         */
        virtual Model::ListIdentityPoolsOutcome ListIdentityPools(const Model::ListIdentityPoolsRequest& request) const;

        /**
         * <p>Lists all of the Cognito identity pools registered for your account.</p>
         * <p>You must use AWS Developer credentials to call this API.</p><p><h3>See
         * Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/ListIdentityPools">AWS
         * API Reference</a></p>
         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::ListIdentityPoolsOutcomeCallable ListIdentityPoolsCallable(const Model::ListIdentityPoolsRequest& request) const;

        /**
         * <p>Lists all of the Cognito identity pools registered for your account.</p>
         * <p>You must use AWS Developer credentials to call this API.</p><p><h3>See
         * Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/ListIdentityPools">AWS
         * API Reference</a></p>
         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void ListIdentityPoolsAsync(const Model::ListIdentityPoolsRequest& request, const ListIdentityPoolsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         * <p>Lists the tags that are assigned to an Amazon Cognito identity pool.</p> <p>A
         * tag is a label that you can apply to identity pools to categorize and manage
         * them in different ways, such as by purpose, owner, environment, or other
         * criteria.</p> <p>You can use this action up to 10 times per second, per
         * account.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/ListTagsForResource">AWS
         * API Reference</a></p>
         */
        virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;

        /**
         * <p>Lists the tags that are assigned to an Amazon Cognito identity pool.</p> <p>A
         * tag is a label that you can apply to identity pools to categorize and manage
         * them in different ways, such as by purpose, owner, environment, or other
         * criteria.</p> <p>You can use this action up to 10 times per second, per
         * account.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/ListTagsForResource">AWS
         * API Reference</a></p>
         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const Model::ListTagsForResourceRequest& request) const;

        /**
         * <p>Lists the tags that are assigned to an Amazon Cognito identity pool.</p> <p>A
         * tag is a label that you can apply to identity pools to categorize and manage
         * them in different ways, such as by purpose, owner, environment, or other
         * criteria.</p> <p>You can use this action up to 10 times per second, per
         * account.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/ListTagsForResource">AWS
         * API Reference</a></p>
         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void ListTagsForResourceAsync(const Model::ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         * <p>Retrieves the <code>IdentityID</code> associated with a
         * <code>DeveloperUserIdentifier</code> or the list of
         * <code>DeveloperUserIdentifier</code> values associated with an
         * <code>IdentityId</code> for an existing identity. Either <code>IdentityID</code>
         * or <code>DeveloperUserIdentifier</code> must not be null. If you supply only one
         * of these values, the other value will be searched in the database and returned
         * as a part of the response. If you supply both,
         * <code>DeveloperUserIdentifier</code> will be matched against
         * <code>IdentityID</code>. If the values are verified against the database, the
         * response returns both values and is the same as the request. Otherwise a
         * <code>ResourceConflictException</code> is thrown.</p> <p>
         * <code>LookupDeveloperIdentity</code> is intended for low-throughput control
         * plane operations: for example, to enable customer service to locate an identity
         * ID by username. If you are using it for higher-volume operations such as user
         * authentication, your requests are likely to be throttled.
         * <a>GetOpenIdTokenForDeveloperIdentity</a> is a better option for higher-volume
         * operations for user authentication.</p> <p>You must use AWS Developer
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/LookupDeveloperIdentity">AWS
         * API Reference</a></p>
         */
        virtual Model::LookupDeveloperIdentityOutcome LookupDeveloperIdentity(const Model::LookupDeveloperIdentityRequest& request) const;

        /**
         * <p>Retrieves the <code>IdentityID</code> associated with a
         * <code>DeveloperUserIdentifier</code> or the list of
         * <code>DeveloperUserIdentifier</code> values associated with an
         * <code>IdentityId</code> for an existing identity. Either <code>IdentityID</code>
         * or <code>DeveloperUserIdentifier</code> must not be null. If you supply only one
         * of these values, the other value will be searched in the database and returned
         * as a part of the response. If you supply both,
         * <code>DeveloperUserIdentifier</code> will be matched against
         * <code>IdentityID</code>. If the values are verified against the database, the
         * response returns both values and is the same as the request. Otherwise a
         * <code>ResourceConflictException</code> is thrown.</p> <p>
         * <code>LookupDeveloperIdentity</code> is intended for low-throughput control
         * plane operations: for example, to enable customer service to locate an identity
         * ID by username. If you are using it for higher-volume operations such as user
         * authentication, your requests are likely to be throttled.
         * <a>GetOpenIdTokenForDeveloperIdentity</a> is a better option for higher-volume
         * operations for user authentication.</p> <p>You must use AWS Developer
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/LookupDeveloperIdentity">AWS
         * API Reference</a></p>
         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::LookupDeveloperIdentityOutcomeCallable LookupDeveloperIdentityCallable(const Model::LookupDeveloperIdentityRequest& request) const;

        /**
         * <p>Retrieves the <code>IdentityID</code> associated with a
         * <code>DeveloperUserIdentifier</code> or the list of
         * <code>DeveloperUserIdentifier</code> values associated with an
         * <code>IdentityId</code> for an existing identity. Either <code>IdentityID</code>
         * or <code>DeveloperUserIdentifier</code> must not be null. If you supply only one
         * of these values, the other value will be searched in the database and returned
         * as a part of the response. If you supply both,
         * <code>DeveloperUserIdentifier</code> will be matched against
         * <code>IdentityID</code>. If the values are verified against the database, the
         * response returns both values and is the same as the request. Otherwise a
         * <code>ResourceConflictException</code> is thrown.</p> <p>
         * <code>LookupDeveloperIdentity</code> is intended for low-throughput control
         * plane operations: for example, to enable customer service to locate an identity
         * ID by username. If you are using it for higher-volume operations such as user
         * authentication, your requests are likely to be throttled.
         * <a>GetOpenIdTokenForDeveloperIdentity</a> is a better option for higher-volume
         * operations for user authentication.</p> <p>You must use AWS Developer
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/LookupDeveloperIdentity">AWS
         * API Reference</a></p>
         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void LookupDeveloperIdentityAsync(const Model::LookupDeveloperIdentityRequest& request, const LookupDeveloperIdentityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         * <p>Merges two users having different <code>IdentityId</code>s, existing in the
         * same identity pool, and identified by the same developer provider. You can use
         * this action to request that discrete users be merged and identified as a single
         * user in the Cognito environment. Cognito associates the given source user
         * (<code>SourceUserIdentifier</code>) with the <code>IdentityId</code> of the
         * <code>DestinationUserIdentifier</code>. Only developer-authenticated users can
         * be merged. If the users to be merged are associated with the same public
         * provider, but as two different users, an exception will be thrown.</p> <p>The
         * number of linked logins is limited to 20. So, the number of linked logins for
         * the source user, <code>SourceUserIdentifier</code>, and the destination user,
         * <code>DestinationUserIdentifier</code>, together should not be larger than 20.
         * Otherwise, an exception will be thrown.</p> <p>You must use AWS Developer
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/MergeDeveloperIdentities">AWS
         * API Reference</a></p>
         */
        virtual Model::MergeDeveloperIdentitiesOutcome MergeDeveloperIdentities(const Model::MergeDeveloperIdentitiesRequest& request) const;

        /**
         * <p>Merges two users having different <code>IdentityId</code>s, existing in the
         * same identity pool, and identified by the same developer provider. You can use
         * this action to request that discrete users be merged and identified as a single
         * user in the Cognito environment. Cognito associates the given source user
         * (<code>SourceUserIdentifier</code>) with the <code>IdentityId</code> of the
         * <code>DestinationUserIdentifier</code>. Only developer-authenticated users can
         * be merged. If the users to be merged are associated with the same public
         * provider, but as two different users, an exception will be thrown.</p> <p>The
         * number of linked logins is limited to 20. So, the number of linked logins for
         * the source user, <code>SourceUserIdentifier</code>, and the destination user,
         * <code>DestinationUserIdentifier</code>, together should not be larger than 20.
         * Otherwise, an exception will be thrown.</p> <p>You must use AWS Developer
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/MergeDeveloperIdentities">AWS
         * API Reference</a></p>
         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::MergeDeveloperIdentitiesOutcomeCallable MergeDeveloperIdentitiesCallable(const Model::MergeDeveloperIdentitiesRequest& request) const;

        /**
         * <p>Merges two users having different <code>IdentityId</code>s, existing in the
         * same identity pool, and identified by the same developer provider. You can use
         * this action to request that discrete users be merged and identified as a single
         * user in the Cognito environment. Cognito associates the given source user
         * (<code>SourceUserIdentifier</code>) with the <code>IdentityId</code> of the
         * <code>DestinationUserIdentifier</code>. Only developer-authenticated users can
         * be merged. If the users to be merged are associated with the same public
         * provider, but as two different users, an exception will be thrown.</p> <p>The
         * number of linked logins is limited to 20. So, the number of linked logins for
         * the source user, <code>SourceUserIdentifier</code>, and the destination user,
         * <code>DestinationUserIdentifier</code>, together should not be larger than 20.
         * Otherwise, an exception will be thrown.</p> <p>You must use AWS Developer
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/MergeDeveloperIdentities">AWS
         * API Reference</a></p>
         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void MergeDeveloperIdentitiesAsync(const Model::MergeDeveloperIdentitiesRequest& request, const MergeDeveloperIdentitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         * <p>Sets the roles for an identity pool. These roles are used when making calls
         * to <a>GetCredentialsForIdentity</a> action.</p> <p>You must use AWS Developer
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/SetIdentityPoolRoles">AWS
         * API Reference</a></p>
         */
        virtual Model::SetIdentityPoolRolesOutcome SetIdentityPoolRoles(const Model::SetIdentityPoolRolesRequest& request) const;

        /**
         * <p>Sets the roles for an identity pool. These roles are used when making calls
         * to <a>GetCredentialsForIdentity</a> action.</p> <p>You must use AWS Developer
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/SetIdentityPoolRoles">AWS
         * API Reference</a></p>
         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::SetIdentityPoolRolesOutcomeCallable SetIdentityPoolRolesCallable(const Model::SetIdentityPoolRolesRequest& request) const;

        /**
         * <p>Sets the roles for an identity pool. These roles are used when making calls
         * to <a>GetCredentialsForIdentity</a> action.</p> <p>You must use AWS Developer
         * credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/SetIdentityPoolRoles">AWS
         * API Reference</a></p>
         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void SetIdentityPoolRolesAsync(const Model::SetIdentityPoolRolesRequest& request, const SetIdentityPoolRolesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         * <p>Assigns a set of tags to an Amazon Cognito identity pool. A tag is a label
         * that you can use to categorize and manage identity pools in different ways, such
         * as by purpose, owner, environment, or other criteria.</p> <p>Each tag consists
         * of a key and value, both of which you define. A key is a general category for
         * more specific values. For example, if you have two versions of an identity pool,
         * one for testing and another for production, you might assign an
         * <code>Environment</code> tag key to both identity pools. The value of this key
         * might be <code>Test</code> for one identity pool and <code>Production</code> for
         * the other.</p> <p>Tags are useful for cost tracking and access control. You can
         * activate your tags so that they appear on the Billing and Cost Management
         * console, where you can track the costs associated with your identity pools. In
         * an IAM policy, you can constrain permissions for identity pools based on
         * specific tags or tag values.</p> <p>You can use this action up to 5 times per
         * second, per account. An identity pool can have as many as 50 tags.</p><p><h3>See
         * Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/TagResource">AWS
         * API Reference</a></p>
         */
        virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;

        /**
         * <p>Assigns a set of tags to an Amazon Cognito identity pool. A tag is a label
         * that you can use to categorize and manage identity pools in different ways, such
         * as by purpose, owner, environment, or other criteria.</p> <p>Each tag consists
         * of a key and value, both of which you define. A key is a general category for
         * more specific values. For example, if you have two versions of an identity pool,
         * one for testing and another for production, you might assign an
         * <code>Environment</code> tag key to both identity pools. The value of this key
         * might be <code>Test</code> for one identity pool and <code>Production</code> for
         * the other.</p> <p>Tags are useful for cost tracking and access control. You can
         * activate your tags so that they appear on the Billing and Cost Management
         * console, where you can track the costs associated with your identity pools. In
         * an IAM policy, you can constrain permissions for identity pools based on
         * specific tags or tag values.</p> <p>You can use this action up to 5 times per
         * second, per account. An identity pool can have as many as 50 tags.</p><p><h3>See
         * Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/TagResource">AWS
         * API Reference</a></p>
         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::TagResourceOutcomeCallable TagResourceCallable(const Model::TagResourceRequest& request) const;

        /**
         * <p>Assigns a set of tags to an Amazon Cognito identity pool. A tag is a label
         * that you can use to categorize and manage identity pools in different ways, such
         * as by purpose, owner, environment, or other criteria.</p> <p>Each tag consists
         * of a key and value, both of which you define. A key is a general category for
         * more specific values. For example, if you have two versions of an identity pool,
         * one for testing and another for production, you might assign an
         * <code>Environment</code> tag key to both identity pools. The value of this key
         * might be <code>Test</code> for one identity pool and <code>Production</code> for
         * the other.</p> <p>Tags are useful for cost tracking and access control. You can
         * activate your tags so that they appear on the Billing and Cost Management
         * console, where you can track the costs associated with your identity pools. In
         * an IAM policy, you can constrain permissions for identity pools based on
         * specific tags or tag values.</p> <p>You can use this action up to 5 times per
         * second, per account. An identity pool can have as many as 50 tags.</p><p><h3>See
         * Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/TagResource">AWS
         * API Reference</a></p>
         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void TagResourceAsync(const Model::TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         * <p>Unlinks a <code>DeveloperUserIdentifier</code> from an existing identity.
         * Unlinked developer users will be considered new identities next time they are
         * seen. If, for a given Cognito identity, you remove all federated identities as
         * well as the developer user identifier, the Cognito identity becomes
         * inaccessible.</p> <p>You must use AWS Developer credentials to call this
         * API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/UnlinkDeveloperIdentity">AWS
         * API Reference</a></p>
         */
        virtual Model::UnlinkDeveloperIdentityOutcome UnlinkDeveloperIdentity(const Model::UnlinkDeveloperIdentityRequest& request) const;

        /**
         * <p>Unlinks a <code>DeveloperUserIdentifier</code> from an existing identity.
         * Unlinked developer users will be considered new identities next time they are
         * seen. If, for a given Cognito identity, you remove all federated identities as
         * well as the developer user identifier, the Cognito identity becomes
         * inaccessible.</p> <p>You must use AWS Developer credentials to call this
         * API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/UnlinkDeveloperIdentity">AWS
         * API Reference</a></p>
         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::UnlinkDeveloperIdentityOutcomeCallable UnlinkDeveloperIdentityCallable(const Model::UnlinkDeveloperIdentityRequest& request) const;

        /**
         * <p>Unlinks a <code>DeveloperUserIdentifier</code> from an existing identity.
         * Unlinked developer users will be considered new identities next time they are
         * seen. If, for a given Cognito identity, you remove all federated identities as
         * well as the developer user identifier, the Cognito identity becomes
         * inaccessible.</p> <p>You must use AWS Developer credentials to call this
         * API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/UnlinkDeveloperIdentity">AWS
         * API Reference</a></p>
         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void UnlinkDeveloperIdentityAsync(const Model::UnlinkDeveloperIdentityRequest& request, const UnlinkDeveloperIdentityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         * <p>Unlinks a federated identity from an existing account. Unlinked logins will
         * be considered new identities next time they are seen. Removing the last linked
         * login will make this identity inaccessible.</p> <p>This is a public API. You do
         * not need any credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/UnlinkIdentity">AWS
         * API Reference</a></p>
         */
        virtual Model::UnlinkIdentityOutcome UnlinkIdentity(const Model::UnlinkIdentityRequest& request) const;

        /**
         * <p>Unlinks a federated identity from an existing account. Unlinked logins will
         * be considered new identities next time they are seen. Removing the last linked
         * login will make this identity inaccessible.</p> <p>This is a public API. You do
         * not need any credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/UnlinkIdentity">AWS
         * API Reference</a></p>
         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::UnlinkIdentityOutcomeCallable UnlinkIdentityCallable(const Model::UnlinkIdentityRequest& request) const;

        /**
         * <p>Unlinks a federated identity from an existing account. Unlinked logins will
         * be considered new identities next time they are seen. Removing the last linked
         * login will make this identity inaccessible.</p> <p>This is a public API. You do
         * not need any credentials to call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/UnlinkIdentity">AWS
         * API Reference</a></p>
         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void UnlinkIdentityAsync(const Model::UnlinkIdentityRequest& request, const UnlinkIdentityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         * <p>Removes the specified tags from an Amazon Cognito identity pool. You can use
         * this action up to 5 times per second, per account</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/UntagResource">AWS
         * API Reference</a></p>
         */
        virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;

        /**
         * <p>Removes the specified tags from an Amazon Cognito identity pool. You can use
         * this action up to 5 times per second, per account</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/UntagResource">AWS
         * API Reference</a></p>
         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::UntagResourceOutcomeCallable UntagResourceCallable(const Model::UntagResourceRequest& request) const;

        /**
         * <p>Removes the specified tags from an Amazon Cognito identity pool. You can use
         * this action up to 5 times per second, per account</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/UntagResource">AWS
         * API Reference</a></p>
         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void UntagResourceAsync(const Model::UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         * <p>Updates an identity pool.</p> <p>You must use AWS Developer credentials to
         * call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/UpdateIdentityPool">AWS
         * API Reference</a></p>
         */
        virtual Model::UpdateIdentityPoolOutcome UpdateIdentityPool(const Model::UpdateIdentityPoolRequest& request) const;

        /**
         * <p>Updates an identity pool.</p> <p>You must use AWS Developer credentials to
         * call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/UpdateIdentityPool">AWS
         * API Reference</a></p>
         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::UpdateIdentityPoolOutcomeCallable UpdateIdentityPoolCallable(const Model::UpdateIdentityPoolRequest& request) const;

        /**
         * <p>Updates an identity pool.</p> <p>You must use AWS Developer credentials to
         * call this API.</p><p><h3>See Also:</h3>   <a
         * href="http://docs.aws.amazon.com/goto/WebAPI/cognito-identity-2014-06-30/UpdateIdentityPool">AWS
         * API Reference</a></p>
         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void UpdateIdentityPoolAsync(const Model::UpdateIdentityPoolRequest& request, const UpdateIdentityPoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;


      void OverrideEndpoint(const Aws::String& endpoint);
    private:
      void init(const Aws::Client::ClientConfiguration& clientConfiguration);
        void CreateIdentityPoolAsyncHelper(const Model::CreateIdentityPoolRequest& request, const CreateIdentityPoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DeleteIdentitiesAsyncHelper(const Model::DeleteIdentitiesRequest& request, const DeleteIdentitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DeleteIdentityPoolAsyncHelper(const Model::DeleteIdentityPoolRequest& request, const DeleteIdentityPoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DescribeIdentityAsyncHelper(const Model::DescribeIdentityRequest& request, const DescribeIdentityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DescribeIdentityPoolAsyncHelper(const Model::DescribeIdentityPoolRequest& request, const DescribeIdentityPoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void GetCredentialsForIdentityAsyncHelper(const Model::GetCredentialsForIdentityRequest& request, const GetCredentialsForIdentityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void GetIdAsyncHelper(const Model::GetIdRequest& request, const GetIdResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void GetIdentityPoolRolesAsyncHelper(const Model::GetIdentityPoolRolesRequest& request, const GetIdentityPoolRolesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void GetOpenIdTokenAsyncHelper(const Model::GetOpenIdTokenRequest& request, const GetOpenIdTokenResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void GetOpenIdTokenForDeveloperIdentityAsyncHelper(const Model::GetOpenIdTokenForDeveloperIdentityRequest& request, const GetOpenIdTokenForDeveloperIdentityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void ListIdentitiesAsyncHelper(const Model::ListIdentitiesRequest& request, const ListIdentitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void ListIdentityPoolsAsyncHelper(const Model::ListIdentityPoolsRequest& request, const ListIdentityPoolsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void ListTagsForResourceAsyncHelper(const Model::ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void LookupDeveloperIdentityAsyncHelper(const Model::LookupDeveloperIdentityRequest& request, const LookupDeveloperIdentityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void MergeDeveloperIdentitiesAsyncHelper(const Model::MergeDeveloperIdentitiesRequest& request, const MergeDeveloperIdentitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void SetIdentityPoolRolesAsyncHelper(const Model::SetIdentityPoolRolesRequest& request, const SetIdentityPoolRolesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void TagResourceAsyncHelper(const Model::TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void UnlinkDeveloperIdentityAsyncHelper(const Model::UnlinkDeveloperIdentityRequest& request, const UnlinkDeveloperIdentityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void UnlinkIdentityAsyncHelper(const Model::UnlinkIdentityRequest& request, const UnlinkIdentityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void UntagResourceAsyncHelper(const Model::UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void UpdateIdentityPoolAsyncHelper(const Model::UpdateIdentityPoolRequest& request, const UpdateIdentityPoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;

      Aws::String m_uri;
      Aws::String m_configScheme;
      std::shared_ptr<Aws::Utils::Threading::Executor> m_executor;
  };

} // namespace CognitoIdentity
} // namespace Aws