CognitoSyncClient.h

 
#pragma once
#include <aws/cognito-sync/CognitoSyncPaginationBase.h>
#include <aws/cognito-sync/CognitoSyncServiceClientModel.h>
#include <aws/cognito-sync/CognitoSyncWaiter.h>
#include <aws/cognito-sync/CognitoSync_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 CognitoSync {
class AWS_COGNITOSYNC_API CognitoSyncClient : public Aws::Client::AWSJsonClient,
                                              public Aws::Client::ClientWithAsyncTemplateMethods<CognitoSyncClient>,
                                              public CognitoSyncPaginationBase<CognitoSyncClient>,
                                              public CognitoSyncWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<CognitoSyncEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<CognitoSyncClient>;
  void init(const CognitoSyncClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, CognitoSyncError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  CognitoSyncClientConfiguration m_clientConfiguration;
  std::shared_ptr<CognitoSyncEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace CognitoSync
}  // namespace Aws