CognitoIdentityClient.h

 
#pragma once
#include <aws/cognito-identity/CognitoIdentityPaginationBase.h>
#include <aws/cognito-identity/CognitoIdentityServiceClientModel.h>
#include <aws/cognito-identity/CognitoIdentityWaiter.h>
#include <aws/cognito-identity/CognitoIdentity_EXPORTS.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
 
namespace Aws {
namespace CognitoIdentity {
class AWS_COGNITOIDENTITY_API CognitoIdentityClient : public Aws::Client::AWSJsonClient,
                                                      public Aws::Client::ClientWithAsyncTemplateMethods<CognitoIdentityClient>,
                                                      public CognitoIdentityPaginationBase<CognitoIdentityClient>,
                                                      public CognitoIdentityWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<CognitoIdentityEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<CognitoIdentityClient>;
  void init(const CognitoIdentityClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, CognitoIdentityError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  CognitoIdentityClientConfiguration m_clientConfiguration;
  std::shared_ptr<CognitoIdentityEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace CognitoIdentity
}  // namespace Aws