CognitoSyncClient.h

 
#pragma once
#include <aws/cognito-sync/CognitoSync_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-sync/CognitoSyncServiceClientModel.h>
 
namespace Aws
{
namespace CognitoSync
{
  class AWS_COGNITOSYNC_API CognitoSyncClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<CognitoSyncClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef CognitoSyncClientConfiguration ClientConfigurationType;
      typedef CognitoSyncEndpointProvider EndpointProviderType;
 
        CognitoSyncClient(const Aws::CognitoSync::CognitoSyncClientConfiguration& clientConfiguration = Aws::CognitoSync::CognitoSyncClientConfiguration(),
                          std::shared_ptr<CognitoSyncEndpointProviderBase> endpointProvider = nullptr);
 
        CognitoSyncClient(const Aws::Auth::AWSCredentials& credentials,
                          std::shared_ptr<CognitoSyncEndpointProviderBase> endpointProvider = nullptr,
                          const Aws::CognitoSync::CognitoSyncClientConfiguration& clientConfiguration = Aws::CognitoSync::CognitoSyncClientConfiguration());
 
        CognitoSyncClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                          std::shared_ptr<CognitoSyncEndpointProviderBase> endpointProvider = nullptr,
                          const Aws::CognitoSync::CognitoSyncClientConfiguration& clientConfiguration = Aws::CognitoSync::CognitoSyncClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        CognitoSyncClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        CognitoSyncClient(const Aws::Auth::AWSCredentials& credentials,
                          const Aws::Client::ClientConfiguration& clientConfiguration);
 
        CognitoSyncClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                          const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~CognitoSyncClient();
 
        virtual Model::BulkPublishOutcome BulkPublish(const Model::BulkPublishRequest& request) const;
 
        template<typename BulkPublishRequestT = Model::BulkPublishRequest>
        Model::BulkPublishOutcomeCallable BulkPublishCallable(const BulkPublishRequestT& request) const
        {
            return SubmitCallable(&CognitoSyncClient::BulkPublish, request);
        }
 
        template<typename BulkPublishRequestT = Model::BulkPublishRequest>
        void BulkPublishAsync(const BulkPublishRequestT& request, const BulkPublishResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoSyncClient::BulkPublish, request, handler, context);
        }
 
        virtual Model::DeleteDatasetOutcome DeleteDataset(const Model::DeleteDatasetRequest& request) const;
 
        template<typename DeleteDatasetRequestT = Model::DeleteDatasetRequest>
        Model::DeleteDatasetOutcomeCallable DeleteDatasetCallable(const DeleteDatasetRequestT& request) const
        {
            return SubmitCallable(&CognitoSyncClient::DeleteDataset, request);
        }
 
        template<typename DeleteDatasetRequestT = Model::DeleteDatasetRequest>
        void DeleteDatasetAsync(const DeleteDatasetRequestT& request, const DeleteDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoSyncClient::DeleteDataset, request, handler, context);
        }
 
        virtual Model::DescribeDatasetOutcome DescribeDataset(const Model::DescribeDatasetRequest& request) const;
 
        template<typename DescribeDatasetRequestT = Model::DescribeDatasetRequest>
        Model::DescribeDatasetOutcomeCallable DescribeDatasetCallable(const DescribeDatasetRequestT& request) const
        {
            return SubmitCallable(&CognitoSyncClient::DescribeDataset, request);
        }
 
        template<typename DescribeDatasetRequestT = Model::DescribeDatasetRequest>
        void DescribeDatasetAsync(const DescribeDatasetRequestT& request, const DescribeDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoSyncClient::DescribeDataset, request, handler, context);
        }
 
        virtual Model::DescribeIdentityPoolUsageOutcome DescribeIdentityPoolUsage(const Model::DescribeIdentityPoolUsageRequest& request) const;
 
        template<typename DescribeIdentityPoolUsageRequestT = Model::DescribeIdentityPoolUsageRequest>
        Model::DescribeIdentityPoolUsageOutcomeCallable DescribeIdentityPoolUsageCallable(const DescribeIdentityPoolUsageRequestT& request) const
        {
            return SubmitCallable(&CognitoSyncClient::DescribeIdentityPoolUsage, request);
        }
 
        template<typename DescribeIdentityPoolUsageRequestT = Model::DescribeIdentityPoolUsageRequest>
        void DescribeIdentityPoolUsageAsync(const DescribeIdentityPoolUsageRequestT& request, const DescribeIdentityPoolUsageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoSyncClient::DescribeIdentityPoolUsage, request, handler, context);
        }
 
        virtual Model::DescribeIdentityUsageOutcome DescribeIdentityUsage(const Model::DescribeIdentityUsageRequest& request) const;
 
        template<typename DescribeIdentityUsageRequestT = Model::DescribeIdentityUsageRequest>
        Model::DescribeIdentityUsageOutcomeCallable DescribeIdentityUsageCallable(const DescribeIdentityUsageRequestT& request) const
        {
            return SubmitCallable(&CognitoSyncClient::DescribeIdentityUsage, request);
        }
 
        template<typename DescribeIdentityUsageRequestT = Model::DescribeIdentityUsageRequest>
        void DescribeIdentityUsageAsync(const DescribeIdentityUsageRequestT& request, const DescribeIdentityUsageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoSyncClient::DescribeIdentityUsage, request, handler, context);
        }
 
        virtual Model::GetBulkPublishDetailsOutcome GetBulkPublishDetails(const Model::GetBulkPublishDetailsRequest& request) const;
 
        template<typename GetBulkPublishDetailsRequestT = Model::GetBulkPublishDetailsRequest>
        Model::GetBulkPublishDetailsOutcomeCallable GetBulkPublishDetailsCallable(const GetBulkPublishDetailsRequestT& request) const
        {
            return SubmitCallable(&CognitoSyncClient::GetBulkPublishDetails, request);
        }
 
        template<typename GetBulkPublishDetailsRequestT = Model::GetBulkPublishDetailsRequest>
        void GetBulkPublishDetailsAsync(const GetBulkPublishDetailsRequestT& request, const GetBulkPublishDetailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoSyncClient::GetBulkPublishDetails, request, handler, context);
        }
 
        virtual Model::GetCognitoEventsOutcome GetCognitoEvents(const Model::GetCognitoEventsRequest& request) const;
 
        template<typename GetCognitoEventsRequestT = Model::GetCognitoEventsRequest>
        Model::GetCognitoEventsOutcomeCallable GetCognitoEventsCallable(const GetCognitoEventsRequestT& request) const
        {
            return SubmitCallable(&CognitoSyncClient::GetCognitoEvents, request);
        }
 
        template<typename GetCognitoEventsRequestT = Model::GetCognitoEventsRequest>
        void GetCognitoEventsAsync(const GetCognitoEventsRequestT& request, const GetCognitoEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoSyncClient::GetCognitoEvents, request, handler, context);
        }
 
        virtual Model::GetIdentityPoolConfigurationOutcome GetIdentityPoolConfiguration(const Model::GetIdentityPoolConfigurationRequest& request) const;
 
        template<typename GetIdentityPoolConfigurationRequestT = Model::GetIdentityPoolConfigurationRequest>
        Model::GetIdentityPoolConfigurationOutcomeCallable GetIdentityPoolConfigurationCallable(const GetIdentityPoolConfigurationRequestT& request) const
        {
            return SubmitCallable(&CognitoSyncClient::GetIdentityPoolConfiguration, request);
        }
 
        template<typename GetIdentityPoolConfigurationRequestT = Model::GetIdentityPoolConfigurationRequest>
        void GetIdentityPoolConfigurationAsync(const GetIdentityPoolConfigurationRequestT& request, const GetIdentityPoolConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoSyncClient::GetIdentityPoolConfiguration, request, handler, context);
        }
 
        virtual Model::ListDatasetsOutcome ListDatasets(const Model::ListDatasetsRequest& request) const;
 
        template<typename ListDatasetsRequestT = Model::ListDatasetsRequest>
        Model::ListDatasetsOutcomeCallable ListDatasetsCallable(const ListDatasetsRequestT& request) const
        {
            return SubmitCallable(&CognitoSyncClient::ListDatasets, request);
        }
 
        template<typename ListDatasetsRequestT = Model::ListDatasetsRequest>
        void ListDatasetsAsync(const ListDatasetsRequestT& request, const ListDatasetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoSyncClient::ListDatasets, request, handler, context);
        }
 
        virtual Model::ListIdentityPoolUsageOutcome ListIdentityPoolUsage(const Model::ListIdentityPoolUsageRequest& request = {}) const;
 
        template<typename ListIdentityPoolUsageRequestT = Model::ListIdentityPoolUsageRequest>
        Model::ListIdentityPoolUsageOutcomeCallable ListIdentityPoolUsageCallable(const ListIdentityPoolUsageRequestT& request = {}) const
        {
            return SubmitCallable(&CognitoSyncClient::ListIdentityPoolUsage, request);
        }
 
        template<typename ListIdentityPoolUsageRequestT = Model::ListIdentityPoolUsageRequest>
        void ListIdentityPoolUsageAsync(const ListIdentityPoolUsageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListIdentityPoolUsageRequestT& request = {}) const
        {
            return SubmitAsync(&CognitoSyncClient::ListIdentityPoolUsage, request, handler, context);
        }
 
        virtual Model::ListRecordsOutcome ListRecords(const Model::ListRecordsRequest& request) const;
 
        template<typename ListRecordsRequestT = Model::ListRecordsRequest>
        Model::ListRecordsOutcomeCallable ListRecordsCallable(const ListRecordsRequestT& request) const
        {
            return SubmitCallable(&CognitoSyncClient::ListRecords, request);
        }
 
        template<typename ListRecordsRequestT = Model::ListRecordsRequest>
        void ListRecordsAsync(const ListRecordsRequestT& request, const ListRecordsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoSyncClient::ListRecords, request, handler, context);
        }
 
        virtual Model::RegisterDeviceOutcome RegisterDevice(const Model::RegisterDeviceRequest& request) const;
 
        template<typename RegisterDeviceRequestT = Model::RegisterDeviceRequest>
        Model::RegisterDeviceOutcomeCallable RegisterDeviceCallable(const RegisterDeviceRequestT& request) const
        {
            return SubmitCallable(&CognitoSyncClient::RegisterDevice, request);
        }
 
        template<typename RegisterDeviceRequestT = Model::RegisterDeviceRequest>
        void RegisterDeviceAsync(const RegisterDeviceRequestT& request, const RegisterDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoSyncClient::RegisterDevice, request, handler, context);
        }
 
        virtual Model::SetCognitoEventsOutcome SetCognitoEvents(const Model::SetCognitoEventsRequest& request) const;
 
        template<typename SetCognitoEventsRequestT = Model::SetCognitoEventsRequest>
        Model::SetCognitoEventsOutcomeCallable SetCognitoEventsCallable(const SetCognitoEventsRequestT& request) const
        {
            return SubmitCallable(&CognitoSyncClient::SetCognitoEvents, request);
        }
 
        template<typename SetCognitoEventsRequestT = Model::SetCognitoEventsRequest>
        void SetCognitoEventsAsync(const SetCognitoEventsRequestT& request, const SetCognitoEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoSyncClient::SetCognitoEvents, request, handler, context);
        }
 
        virtual Model::SetIdentityPoolConfigurationOutcome SetIdentityPoolConfiguration(const Model::SetIdentityPoolConfigurationRequest& request) const;
 
        template<typename SetIdentityPoolConfigurationRequestT = Model::SetIdentityPoolConfigurationRequest>
        Model::SetIdentityPoolConfigurationOutcomeCallable SetIdentityPoolConfigurationCallable(const SetIdentityPoolConfigurationRequestT& request) const
        {
            return SubmitCallable(&CognitoSyncClient::SetIdentityPoolConfiguration, request);
        }
 
        template<typename SetIdentityPoolConfigurationRequestT = Model::SetIdentityPoolConfigurationRequest>
        void SetIdentityPoolConfigurationAsync(const SetIdentityPoolConfigurationRequestT& request, const SetIdentityPoolConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoSyncClient::SetIdentityPoolConfiguration, request, handler, context);
        }
 
        virtual Model::SubscribeToDatasetOutcome SubscribeToDataset(const Model::SubscribeToDatasetRequest& request) const;
 
        template<typename SubscribeToDatasetRequestT = Model::SubscribeToDatasetRequest>
        Model::SubscribeToDatasetOutcomeCallable SubscribeToDatasetCallable(const SubscribeToDatasetRequestT& request) const
        {
            return SubmitCallable(&CognitoSyncClient::SubscribeToDataset, request);
        }
 
        template<typename SubscribeToDatasetRequestT = Model::SubscribeToDatasetRequest>
        void SubscribeToDatasetAsync(const SubscribeToDatasetRequestT& request, const SubscribeToDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoSyncClient::SubscribeToDataset, request, handler, context);
        }
 
        virtual Model::UnsubscribeFromDatasetOutcome UnsubscribeFromDataset(const Model::UnsubscribeFromDatasetRequest& request) const;
 
        template<typename UnsubscribeFromDatasetRequestT = Model::UnsubscribeFromDatasetRequest>
        Model::UnsubscribeFromDatasetOutcomeCallable UnsubscribeFromDatasetCallable(const UnsubscribeFromDatasetRequestT& request) const
        {
            return SubmitCallable(&CognitoSyncClient::UnsubscribeFromDataset, request);
        }
 
        template<typename UnsubscribeFromDatasetRequestT = Model::UnsubscribeFromDatasetRequest>
        void UnsubscribeFromDatasetAsync(const UnsubscribeFromDatasetRequestT& request, const UnsubscribeFromDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoSyncClient::UnsubscribeFromDataset, request, handler, context);
        }
 
        virtual Model::UpdateRecordsOutcome UpdateRecords(const Model::UpdateRecordsRequest& request) const;
 
        template<typename UpdateRecordsRequestT = Model::UpdateRecordsRequest>
        Model::UpdateRecordsOutcomeCallable UpdateRecordsCallable(const UpdateRecordsRequestT& request) const
        {
            return SubmitCallable(&CognitoSyncClient::UpdateRecords, request);
        }
 
        template<typename UpdateRecordsRequestT = Model::UpdateRecordsRequest>
        void UpdateRecordsAsync(const UpdateRecordsRequestT& request, const UpdateRecordsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CognitoSyncClient::UpdateRecords, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<CognitoSyncEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<CognitoSyncClient>;
      void init(const CognitoSyncClientConfiguration& clientConfiguration);
 
      CognitoSyncClientConfiguration m_clientConfiguration;
      std::shared_ptr<CognitoSyncEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace CognitoSync
} // namespace Aws