CognitoIdentityClient.h

 
#pragma once
#include <aws/cognito-identity/CognitoIdentity_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/cognito-identity/CognitoIdentityServiceClientModel.h>
 
namespace Aws
{
namespace CognitoIdentity
{
  class AWS_COGNITOIDENTITY_API CognitoIdentityClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<CognitoIdentityClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef CognitoIdentityClientConfiguration ClientConfigurationType;
      typedef CognitoIdentityEndpointProvider EndpointProviderType;
 
        CognitoIdentityClient(const Aws::CognitoIdentity::CognitoIdentityClientConfiguration& clientConfiguration = Aws::CognitoIdentity::CognitoIdentityClientConfiguration(),
                              std::shared_ptr<CognitoIdentityEndpointProviderBase> endpointProvider = nullptr);
 
        CognitoIdentityClient(const Aws::Auth::AWSCredentials& credentials,
                              std::shared_ptr<CognitoIdentityEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::CognitoIdentity::CognitoIdentityClientConfiguration& clientConfiguration = Aws::CognitoIdentity::CognitoIdentityClientConfiguration());
 
        CognitoIdentityClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              std::shared_ptr<CognitoIdentityEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::CognitoIdentity::CognitoIdentityClientConfiguration& clientConfiguration = Aws::CognitoIdentity::CognitoIdentityClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        CognitoIdentityClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        CognitoIdentityClient(const Aws::Auth::AWSCredentials& credentials,
                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
        CognitoIdentityClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~CognitoIdentityClient();
 
        virtual Model::CreateIdentityPoolOutcome CreateIdentityPool(const Model::CreateIdentityPoolRequest& request) const;
 
        template<typename CreateIdentityPoolRequestT = Model::CreateIdentityPoolRequest>
        Model::CreateIdentityPoolOutcomeCallable CreateIdentityPoolCallable(const CreateIdentityPoolRequestT& request) const
        {
            return SubmitCallable(&CognitoIdentityClient::CreateIdentityPool, request);
        }
 
        template<typename CreateIdentityPoolRequestT = Model::CreateIdentityPoolRequest>
        void CreateIdentityPoolAsync(const CreateIdentityPoolRequestT& request, const CreateIdentityPoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoIdentityClient::CreateIdentityPool, request, handler, context);
        }
 
        virtual Model::DeleteIdentitiesOutcome DeleteIdentities(const Model::DeleteIdentitiesRequest& request) const;
 
        template<typename DeleteIdentitiesRequestT = Model::DeleteIdentitiesRequest>
        Model::DeleteIdentitiesOutcomeCallable DeleteIdentitiesCallable(const DeleteIdentitiesRequestT& request) const
        {
            return SubmitCallable(&CognitoIdentityClient::DeleteIdentities, request);
        }
 
        template<typename DeleteIdentitiesRequestT = Model::DeleteIdentitiesRequest>
        void DeleteIdentitiesAsync(const DeleteIdentitiesRequestT& request, const DeleteIdentitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoIdentityClient::DeleteIdentities, request, handler, context);
        }
 
        virtual Model::DeleteIdentityPoolOutcome DeleteIdentityPool(const Model::DeleteIdentityPoolRequest& request) const;
 
        template<typename DeleteIdentityPoolRequestT = Model::DeleteIdentityPoolRequest>
        Model::DeleteIdentityPoolOutcomeCallable DeleteIdentityPoolCallable(const DeleteIdentityPoolRequestT& request) const
        {
            return SubmitCallable(&CognitoIdentityClient::DeleteIdentityPool, request);
        }
 
        template<typename DeleteIdentityPoolRequestT = Model::DeleteIdentityPoolRequest>
        void DeleteIdentityPoolAsync(const DeleteIdentityPoolRequestT& request, const DeleteIdentityPoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoIdentityClient::DeleteIdentityPool, request, handler, context);
        }
 
        virtual Model::DescribeIdentityOutcome DescribeIdentity(const Model::DescribeIdentityRequest& request) const;
 
        template<typename DescribeIdentityRequestT = Model::DescribeIdentityRequest>
        Model::DescribeIdentityOutcomeCallable DescribeIdentityCallable(const DescribeIdentityRequestT& request) const
        {
            return SubmitCallable(&CognitoIdentityClient::DescribeIdentity, request);
        }
 
        template<typename DescribeIdentityRequestT = Model::DescribeIdentityRequest>
        void DescribeIdentityAsync(const DescribeIdentityRequestT& request, const DescribeIdentityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoIdentityClient::DescribeIdentity, request, handler, context);
        }
 
        virtual Model::DescribeIdentityPoolOutcome DescribeIdentityPool(const Model::DescribeIdentityPoolRequest& request) const;
 
        template<typename DescribeIdentityPoolRequestT = Model::DescribeIdentityPoolRequest>
        Model::DescribeIdentityPoolOutcomeCallable DescribeIdentityPoolCallable(const DescribeIdentityPoolRequestT& request) const
        {
            return SubmitCallable(&CognitoIdentityClient::DescribeIdentityPool, request);
        }
 
        template<typename DescribeIdentityPoolRequestT = Model::DescribeIdentityPoolRequest>
        void DescribeIdentityPoolAsync(const DescribeIdentityPoolRequestT& request, const DescribeIdentityPoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoIdentityClient::DescribeIdentityPool, request, handler, context);
        }
 
        virtual Model::GetCredentialsForIdentityOutcome GetCredentialsForIdentity(const Model::GetCredentialsForIdentityRequest& request) const;
 
        template<typename GetCredentialsForIdentityRequestT = Model::GetCredentialsForIdentityRequest>
        Model::GetCredentialsForIdentityOutcomeCallable GetCredentialsForIdentityCallable(const GetCredentialsForIdentityRequestT& request) const
        {
            return SubmitCallable(&CognitoIdentityClient::GetCredentialsForIdentity, request);
        }
 
        template<typename GetCredentialsForIdentityRequestT = Model::GetCredentialsForIdentityRequest>
        void GetCredentialsForIdentityAsync(const GetCredentialsForIdentityRequestT& request, const GetCredentialsForIdentityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoIdentityClient::GetCredentialsForIdentity, request, handler, context);
        }
 
        virtual Model::GetIdOutcome GetId(const Model::GetIdRequest& request) const;
 
        template<typename GetIdRequestT = Model::GetIdRequest>
        Model::GetIdOutcomeCallable GetIdCallable(const GetIdRequestT& request) const
        {
            return SubmitCallable(&CognitoIdentityClient::GetId, request);
        }
 
        template<typename GetIdRequestT = Model::GetIdRequest>
        void GetIdAsync(const GetIdRequestT& request, const GetIdResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoIdentityClient::GetId, request, handler, context);
        }
 
        virtual Model::GetIdentityPoolRolesOutcome GetIdentityPoolRoles(const Model::GetIdentityPoolRolesRequest& request) const;
 
        template<typename GetIdentityPoolRolesRequestT = Model::GetIdentityPoolRolesRequest>
        Model::GetIdentityPoolRolesOutcomeCallable GetIdentityPoolRolesCallable(const GetIdentityPoolRolesRequestT& request) const
        {
            return SubmitCallable(&CognitoIdentityClient::GetIdentityPoolRoles, request);
        }
 
        template<typename GetIdentityPoolRolesRequestT = Model::GetIdentityPoolRolesRequest>
        void GetIdentityPoolRolesAsync(const GetIdentityPoolRolesRequestT& request, const GetIdentityPoolRolesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoIdentityClient::GetIdentityPoolRoles, request, handler, context);
        }
 
        virtual Model::GetOpenIdTokenOutcome GetOpenIdToken(const Model::GetOpenIdTokenRequest& request) const;
 
        template<typename GetOpenIdTokenRequestT = Model::GetOpenIdTokenRequest>
        Model::GetOpenIdTokenOutcomeCallable GetOpenIdTokenCallable(const GetOpenIdTokenRequestT& request) const
        {
            return SubmitCallable(&CognitoIdentityClient::GetOpenIdToken, request);
        }
 
        template<typename GetOpenIdTokenRequestT = Model::GetOpenIdTokenRequest>
        void GetOpenIdTokenAsync(const GetOpenIdTokenRequestT& request, const GetOpenIdTokenResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoIdentityClient::GetOpenIdToken, request, handler, context);
        }
 
        virtual Model::GetOpenIdTokenForDeveloperIdentityOutcome GetOpenIdTokenForDeveloperIdentity(const Model::GetOpenIdTokenForDeveloperIdentityRequest& request) const;
 
        template<typename GetOpenIdTokenForDeveloperIdentityRequestT = Model::GetOpenIdTokenForDeveloperIdentityRequest>
        Model::GetOpenIdTokenForDeveloperIdentityOutcomeCallable GetOpenIdTokenForDeveloperIdentityCallable(const GetOpenIdTokenForDeveloperIdentityRequestT& request) const
        {
            return SubmitCallable(&CognitoIdentityClient::GetOpenIdTokenForDeveloperIdentity, request);
        }
 
        template<typename GetOpenIdTokenForDeveloperIdentityRequestT = Model::GetOpenIdTokenForDeveloperIdentityRequest>
        void GetOpenIdTokenForDeveloperIdentityAsync(const GetOpenIdTokenForDeveloperIdentityRequestT& request, const GetOpenIdTokenForDeveloperIdentityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoIdentityClient::GetOpenIdTokenForDeveloperIdentity, request, handler, context);
        }
 
        virtual Model::GetPrincipalTagAttributeMapOutcome GetPrincipalTagAttributeMap(const Model::GetPrincipalTagAttributeMapRequest& request) const;
 
        template<typename GetPrincipalTagAttributeMapRequestT = Model::GetPrincipalTagAttributeMapRequest>
        Model::GetPrincipalTagAttributeMapOutcomeCallable GetPrincipalTagAttributeMapCallable(const GetPrincipalTagAttributeMapRequestT& request) const
        {
            return SubmitCallable(&CognitoIdentityClient::GetPrincipalTagAttributeMap, request);
        }
 
        template<typename GetPrincipalTagAttributeMapRequestT = Model::GetPrincipalTagAttributeMapRequest>
        void GetPrincipalTagAttributeMapAsync(const GetPrincipalTagAttributeMapRequestT& request, const GetPrincipalTagAttributeMapResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoIdentityClient::GetPrincipalTagAttributeMap, request, handler, context);
        }
 
        virtual Model::ListIdentitiesOutcome ListIdentities(const Model::ListIdentitiesRequest& request) const;
 
        template<typename ListIdentitiesRequestT = Model::ListIdentitiesRequest>
        Model::ListIdentitiesOutcomeCallable ListIdentitiesCallable(const ListIdentitiesRequestT& request) const
        {
            return SubmitCallable(&CognitoIdentityClient::ListIdentities, request);
        }
 
        template<typename ListIdentitiesRequestT = Model::ListIdentitiesRequest>
        void ListIdentitiesAsync(const ListIdentitiesRequestT& request, const ListIdentitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoIdentityClient::ListIdentities, request, handler, context);
        }
 
        virtual Model::ListIdentityPoolsOutcome ListIdentityPools(const Model::ListIdentityPoolsRequest& request) const;
 
        template<typename ListIdentityPoolsRequestT = Model::ListIdentityPoolsRequest>
        Model::ListIdentityPoolsOutcomeCallable ListIdentityPoolsCallable(const ListIdentityPoolsRequestT& request) const
        {
            return SubmitCallable(&CognitoIdentityClient::ListIdentityPools, request);
        }
 
        template<typename ListIdentityPoolsRequestT = Model::ListIdentityPoolsRequest>
        void ListIdentityPoolsAsync(const ListIdentityPoolsRequestT& request, const ListIdentityPoolsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoIdentityClient::ListIdentityPools, request, handler, context);
        }
 
        virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const
        {
            return SubmitCallable(&CognitoIdentityClient::ListTagsForResource, request);
        }
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoIdentityClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::LookupDeveloperIdentityOutcome LookupDeveloperIdentity(const Model::LookupDeveloperIdentityRequest& request) const;
 
        template<typename LookupDeveloperIdentityRequestT = Model::LookupDeveloperIdentityRequest>
        Model::LookupDeveloperIdentityOutcomeCallable LookupDeveloperIdentityCallable(const LookupDeveloperIdentityRequestT& request) const
        {
            return SubmitCallable(&CognitoIdentityClient::LookupDeveloperIdentity, request);
        }
 
        template<typename LookupDeveloperIdentityRequestT = Model::LookupDeveloperIdentityRequest>
        void LookupDeveloperIdentityAsync(const LookupDeveloperIdentityRequestT& request, const LookupDeveloperIdentityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoIdentityClient::LookupDeveloperIdentity, request, handler, context);
        }
 
        virtual Model::MergeDeveloperIdentitiesOutcome MergeDeveloperIdentities(const Model::MergeDeveloperIdentitiesRequest& request) const;
 
        template<typename MergeDeveloperIdentitiesRequestT = Model::MergeDeveloperIdentitiesRequest>
        Model::MergeDeveloperIdentitiesOutcomeCallable MergeDeveloperIdentitiesCallable(const MergeDeveloperIdentitiesRequestT& request) const
        {
            return SubmitCallable(&CognitoIdentityClient::MergeDeveloperIdentities, request);
        }
 
        template<typename MergeDeveloperIdentitiesRequestT = Model::MergeDeveloperIdentitiesRequest>
        void MergeDeveloperIdentitiesAsync(const MergeDeveloperIdentitiesRequestT& request, const MergeDeveloperIdentitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoIdentityClient::MergeDeveloperIdentities, request, handler, context);
        }
 
        virtual Model::SetIdentityPoolRolesOutcome SetIdentityPoolRoles(const Model::SetIdentityPoolRolesRequest& request) const;
 
        template<typename SetIdentityPoolRolesRequestT = Model::SetIdentityPoolRolesRequest>
        Model::SetIdentityPoolRolesOutcomeCallable SetIdentityPoolRolesCallable(const SetIdentityPoolRolesRequestT& request) const
        {
            return SubmitCallable(&CognitoIdentityClient::SetIdentityPoolRoles, request);
        }
 
        template<typename SetIdentityPoolRolesRequestT = Model::SetIdentityPoolRolesRequest>
        void SetIdentityPoolRolesAsync(const SetIdentityPoolRolesRequestT& request, const SetIdentityPoolRolesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoIdentityClient::SetIdentityPoolRoles, request, handler, context);
        }
 
        virtual Model::SetPrincipalTagAttributeMapOutcome SetPrincipalTagAttributeMap(const Model::SetPrincipalTagAttributeMapRequest& request) const;
 
        template<typename SetPrincipalTagAttributeMapRequestT = Model::SetPrincipalTagAttributeMapRequest>
        Model::SetPrincipalTagAttributeMapOutcomeCallable SetPrincipalTagAttributeMapCallable(const SetPrincipalTagAttributeMapRequestT& request) const
        {
            return SubmitCallable(&CognitoIdentityClient::SetPrincipalTagAttributeMap, request);
        }
 
        template<typename SetPrincipalTagAttributeMapRequestT = Model::SetPrincipalTagAttributeMapRequest>
        void SetPrincipalTagAttributeMapAsync(const SetPrincipalTagAttributeMapRequestT& request, const SetPrincipalTagAttributeMapResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoIdentityClient::SetPrincipalTagAttributeMap, request, handler, context);
        }
 
        virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
        template<typename TagResourceRequestT = Model::TagResourceRequest>
        Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const
        {
            return SubmitCallable(&CognitoIdentityClient::TagResource, request);
        }
 
        template<typename TagResourceRequestT = Model::TagResourceRequest>
        void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoIdentityClient::TagResource, request, handler, context);
        }
 
        virtual Model::UnlinkDeveloperIdentityOutcome UnlinkDeveloperIdentity(const Model::UnlinkDeveloperIdentityRequest& request) const;
 
        template<typename UnlinkDeveloperIdentityRequestT = Model::UnlinkDeveloperIdentityRequest>
        Model::UnlinkDeveloperIdentityOutcomeCallable UnlinkDeveloperIdentityCallable(const UnlinkDeveloperIdentityRequestT& request) const
        {
            return SubmitCallable(&CognitoIdentityClient::UnlinkDeveloperIdentity, request);
        }
 
        template<typename UnlinkDeveloperIdentityRequestT = Model::UnlinkDeveloperIdentityRequest>
        void UnlinkDeveloperIdentityAsync(const UnlinkDeveloperIdentityRequestT& request, const UnlinkDeveloperIdentityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoIdentityClient::UnlinkDeveloperIdentity, request, handler, context);
        }
 
        virtual Model::UnlinkIdentityOutcome UnlinkIdentity(const Model::UnlinkIdentityRequest& request) const;
 
        template<typename UnlinkIdentityRequestT = Model::UnlinkIdentityRequest>
        Model::UnlinkIdentityOutcomeCallable UnlinkIdentityCallable(const UnlinkIdentityRequestT& request) const
        {
            return SubmitCallable(&CognitoIdentityClient::UnlinkIdentity, request);
        }
 
        template<typename UnlinkIdentityRequestT = Model::UnlinkIdentityRequest>
        void UnlinkIdentityAsync(const UnlinkIdentityRequestT& request, const UnlinkIdentityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoIdentityClient::UnlinkIdentity, request, handler, context);
        }
 
        virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const
        {
            return SubmitCallable(&CognitoIdentityClient::UntagResource, request);
        }
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoIdentityClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateIdentityPoolOutcome UpdateIdentityPool(const Model::UpdateIdentityPoolRequest& request) const;
 
        template<typename UpdateIdentityPoolRequestT = Model::UpdateIdentityPoolRequest>
        Model::UpdateIdentityPoolOutcomeCallable UpdateIdentityPoolCallable(const UpdateIdentityPoolRequestT& request) const
        {
            return SubmitCallable(&CognitoIdentityClient::UpdateIdentityPool, request);
        }
 
        template<typename UpdateIdentityPoolRequestT = Model::UpdateIdentityPoolRequest>
        void UpdateIdentityPoolAsync(const UpdateIdentityPoolRequestT& request, const UpdateIdentityPoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoIdentityClient::UpdateIdentityPool, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<CognitoIdentityEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<CognitoIdentityClient>;
      void init(const CognitoIdentityClientConfiguration& clientConfiguration);
 
      CognitoIdentityClientConfiguration m_clientConfiguration;
      std::shared_ptr<CognitoIdentityEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace CognitoIdentity
} // namespace Aws