DataExchangeClient.h

 
#pragma once
#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>
#include <aws/dataexchange/DataExchangePaginationBase.h>
#include <aws/dataexchange/DataExchangeServiceClientModel.h>
#include <aws/dataexchange/DataExchangeWaiter.h>
#include <aws/dataexchange/DataExchange_EXPORTS.h>
 
namespace Aws {
namespace DataExchange {
class AWS_DATAEXCHANGE_API DataExchangeClient : public Aws::Client::AWSJsonClient,
                                                public Aws::Client::ClientWithAsyncTemplateMethods<DataExchangeClient>,
                                                public DataExchangePaginationBase<DataExchangeClient>,
                                                public DataExchangeWaiter<DataExchangeClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef DataExchangeClientConfiguration ClientConfigurationType;
  typedef DataExchangeEndpointProvider EndpointProviderType;
 
  DataExchangeClient(
      const Aws::DataExchange::DataExchangeClientConfiguration& clientConfiguration = Aws::DataExchange::DataExchangeClientConfiguration(),
      std::shared_ptr<DataExchangeEndpointProviderBase> endpointProvider = nullptr);
 
  DataExchangeClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<DataExchangeEndpointProviderBase> endpointProvider = nullptr,
      const Aws::DataExchange::DataExchangeClientConfiguration& clientConfiguration = Aws::DataExchange::DataExchangeClientConfiguration());
 
  DataExchangeClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<DataExchangeEndpointProviderBase> endpointProvider = nullptr,
      const Aws::DataExchange::DataExchangeClientConfiguration& clientConfiguration = Aws::DataExchange::DataExchangeClientConfiguration());
 
  /* Legacy constructors due deprecation */
  DataExchangeClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  DataExchangeClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  DataExchangeClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~DataExchangeClient();
 
  virtual Model::AcceptDataGrantOutcome AcceptDataGrant(const Model::AcceptDataGrantRequest& request) const;
 
  template <typename AcceptDataGrantRequestT = Model::AcceptDataGrantRequest>
  Model::AcceptDataGrantOutcomeCallable AcceptDataGrantCallable(const AcceptDataGrantRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::AcceptDataGrant, request);
  }
 
  template <typename AcceptDataGrantRequestT = Model::AcceptDataGrantRequest>
  void AcceptDataGrantAsync(const AcceptDataGrantRequestT& request, const AcceptDataGrantResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::AcceptDataGrant, request, handler, context);
  }
 
  virtual Model::CancelJobOutcome CancelJob(const Model::CancelJobRequest& request) const;
 
  template <typename CancelJobRequestT = Model::CancelJobRequest>
  Model::CancelJobOutcomeCallable CancelJobCallable(const CancelJobRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::CancelJob, request);
  }
 
  template <typename CancelJobRequestT = Model::CancelJobRequest>
  void CancelJobAsync(const CancelJobRequestT& request, const CancelJobResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::CancelJob, request, handler, context);
  }
 
  virtual Model::CreateDataGrantOutcome CreateDataGrant(const Model::CreateDataGrantRequest& request) const;
 
  template <typename CreateDataGrantRequestT = Model::CreateDataGrantRequest>
  Model::CreateDataGrantOutcomeCallable CreateDataGrantCallable(const CreateDataGrantRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::CreateDataGrant, request);
  }
 
  template <typename CreateDataGrantRequestT = Model::CreateDataGrantRequest>
  void CreateDataGrantAsync(const CreateDataGrantRequestT& request, const CreateDataGrantResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::CreateDataGrant, request, handler, context);
  }
 
  virtual Model::CreateDataSetOutcome CreateDataSet(const Model::CreateDataSetRequest& request) const;
 
  template <typename CreateDataSetRequestT = Model::CreateDataSetRequest>
  Model::CreateDataSetOutcomeCallable CreateDataSetCallable(const CreateDataSetRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::CreateDataSet, request);
  }
 
  template <typename CreateDataSetRequestT = Model::CreateDataSetRequest>
  void CreateDataSetAsync(const CreateDataSetRequestT& request, const CreateDataSetResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::CreateDataSet, request, handler, context);
  }
 
  virtual Model::CreateEventActionOutcome CreateEventAction(const Model::CreateEventActionRequest& request) const;
 
  template <typename CreateEventActionRequestT = Model::CreateEventActionRequest>
  Model::CreateEventActionOutcomeCallable CreateEventActionCallable(const CreateEventActionRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::CreateEventAction, request);
  }
 
  template <typename CreateEventActionRequestT = Model::CreateEventActionRequest>
  void CreateEventActionAsync(const CreateEventActionRequestT& request, const CreateEventActionResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::CreateEventAction, request, handler, context);
  }
 
  virtual Model::CreateJobOutcome CreateJob(const Model::CreateJobRequest& request) const;
 
  template <typename CreateJobRequestT = Model::CreateJobRequest>
  Model::CreateJobOutcomeCallable CreateJobCallable(const CreateJobRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::CreateJob, request);
  }
 
  template <typename CreateJobRequestT = Model::CreateJobRequest>
  void CreateJobAsync(const CreateJobRequestT& request, const CreateJobResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::CreateJob, request, handler, context);
  }
 
  virtual Model::CreateRevisionOutcome CreateRevision(const Model::CreateRevisionRequest& request) const;
 
  template <typename CreateRevisionRequestT = Model::CreateRevisionRequest>
  Model::CreateRevisionOutcomeCallable CreateRevisionCallable(const CreateRevisionRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::CreateRevision, request);
  }
 
  template <typename CreateRevisionRequestT = Model::CreateRevisionRequest>
  void CreateRevisionAsync(const CreateRevisionRequestT& request, const CreateRevisionResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::CreateRevision, request, handler, context);
  }
 
  virtual Model::DeleteAssetOutcome DeleteAsset(const Model::DeleteAssetRequest& request) const;
 
  template <typename DeleteAssetRequestT = Model::DeleteAssetRequest>
  Model::DeleteAssetOutcomeCallable DeleteAssetCallable(const DeleteAssetRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::DeleteAsset, request);
  }
 
  template <typename DeleteAssetRequestT = Model::DeleteAssetRequest>
  void DeleteAssetAsync(const DeleteAssetRequestT& request, const DeleteAssetResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::DeleteAsset, request, handler, context);
  }
 
  virtual Model::DeleteDataGrantOutcome DeleteDataGrant(const Model::DeleteDataGrantRequest& request) const;
 
  template <typename DeleteDataGrantRequestT = Model::DeleteDataGrantRequest>
  Model::DeleteDataGrantOutcomeCallable DeleteDataGrantCallable(const DeleteDataGrantRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::DeleteDataGrant, request);
  }
 
  template <typename DeleteDataGrantRequestT = Model::DeleteDataGrantRequest>
  void DeleteDataGrantAsync(const DeleteDataGrantRequestT& request, const DeleteDataGrantResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::DeleteDataGrant, 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(&DataExchangeClient::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(&DataExchangeClient::DeleteDataSet, request, handler, context);
  }
 
  virtual Model::DeleteEventActionOutcome DeleteEventAction(const Model::DeleteEventActionRequest& request) const;
 
  template <typename DeleteEventActionRequestT = Model::DeleteEventActionRequest>
  Model::DeleteEventActionOutcomeCallable DeleteEventActionCallable(const DeleteEventActionRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::DeleteEventAction, request);
  }
 
  template <typename DeleteEventActionRequestT = Model::DeleteEventActionRequest>
  void DeleteEventActionAsync(const DeleteEventActionRequestT& request, const DeleteEventActionResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::DeleteEventAction, request, handler, context);
  }
 
  virtual Model::DeleteRevisionOutcome DeleteRevision(const Model::DeleteRevisionRequest& request) const;
 
  template <typename DeleteRevisionRequestT = Model::DeleteRevisionRequest>
  Model::DeleteRevisionOutcomeCallable DeleteRevisionCallable(const DeleteRevisionRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::DeleteRevision, request);
  }
 
  template <typename DeleteRevisionRequestT = Model::DeleteRevisionRequest>
  void DeleteRevisionAsync(const DeleteRevisionRequestT& request, const DeleteRevisionResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::DeleteRevision, request, handler, context);
  }
 
  virtual Model::GetAssetOutcome GetAsset(const Model::GetAssetRequest& request) const;
 
  template <typename GetAssetRequestT = Model::GetAssetRequest>
  Model::GetAssetOutcomeCallable GetAssetCallable(const GetAssetRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::GetAsset, request);
  }
 
  template <typename GetAssetRequestT = Model::GetAssetRequest>
  void GetAssetAsync(const GetAssetRequestT& request, const GetAssetResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::GetAsset, request, handler, context);
  }
 
  virtual Model::GetDataGrantOutcome GetDataGrant(const Model::GetDataGrantRequest& request) const;
 
  template <typename GetDataGrantRequestT = Model::GetDataGrantRequest>
  Model::GetDataGrantOutcomeCallable GetDataGrantCallable(const GetDataGrantRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::GetDataGrant, request);
  }
 
  template <typename GetDataGrantRequestT = Model::GetDataGrantRequest>
  void GetDataGrantAsync(const GetDataGrantRequestT& request, const GetDataGrantResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::GetDataGrant, request, handler, context);
  }
 
  virtual Model::GetDataSetOutcome GetDataSet(const Model::GetDataSetRequest& request) const;
 
  template <typename GetDataSetRequestT = Model::GetDataSetRequest>
  Model::GetDataSetOutcomeCallable GetDataSetCallable(const GetDataSetRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::GetDataSet, request);
  }
 
  template <typename GetDataSetRequestT = Model::GetDataSetRequest>
  void GetDataSetAsync(const GetDataSetRequestT& request, const GetDataSetResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::GetDataSet, request, handler, context);
  }
 
  virtual Model::GetEventActionOutcome GetEventAction(const Model::GetEventActionRequest& request) const;
 
  template <typename GetEventActionRequestT = Model::GetEventActionRequest>
  Model::GetEventActionOutcomeCallable GetEventActionCallable(const GetEventActionRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::GetEventAction, request);
  }
 
  template <typename GetEventActionRequestT = Model::GetEventActionRequest>
  void GetEventActionAsync(const GetEventActionRequestT& request, const GetEventActionResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::GetEventAction, request, handler, context);
  }
 
  virtual Model::GetJobOutcome GetJob(const Model::GetJobRequest& request) const;
 
  template <typename GetJobRequestT = Model::GetJobRequest>
  Model::GetJobOutcomeCallable GetJobCallable(const GetJobRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::GetJob, request);
  }
 
  template <typename GetJobRequestT = Model::GetJobRequest>
  void GetJobAsync(const GetJobRequestT& request, const GetJobResponseReceivedHandler& handler,
                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::GetJob, request, handler, context);
  }
 
  virtual Model::GetReceivedDataGrantOutcome GetReceivedDataGrant(const Model::GetReceivedDataGrantRequest& request) const;
 
  template <typename GetReceivedDataGrantRequestT = Model::GetReceivedDataGrantRequest>
  Model::GetReceivedDataGrantOutcomeCallable GetReceivedDataGrantCallable(const GetReceivedDataGrantRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::GetReceivedDataGrant, request);
  }
 
  template <typename GetReceivedDataGrantRequestT = Model::GetReceivedDataGrantRequest>
  void GetReceivedDataGrantAsync(const GetReceivedDataGrantRequestT& request, const GetReceivedDataGrantResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::GetReceivedDataGrant, request, handler, context);
  }
 
  virtual Model::GetRevisionOutcome GetRevision(const Model::GetRevisionRequest& request) const;
 
  template <typename GetRevisionRequestT = Model::GetRevisionRequest>
  Model::GetRevisionOutcomeCallable GetRevisionCallable(const GetRevisionRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::GetRevision, request);
  }
 
  template <typename GetRevisionRequestT = Model::GetRevisionRequest>
  void GetRevisionAsync(const GetRevisionRequestT& request, const GetRevisionResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::GetRevision, request, handler, context);
  }
 
  virtual Model::ListDataGrantsOutcome ListDataGrants(const Model::ListDataGrantsRequest& request = {}) const;
 
  template <typename ListDataGrantsRequestT = Model::ListDataGrantsRequest>
  Model::ListDataGrantsOutcomeCallable ListDataGrantsCallable(const ListDataGrantsRequestT& request = {}) const {
    return SubmitCallable(&DataExchangeClient::ListDataGrants, request);
  }
 
  template <typename ListDataGrantsRequestT = Model::ListDataGrantsRequest>
  void ListDataGrantsAsync(const ListDataGrantsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListDataGrantsRequestT& request = {}) const {
    return SubmitAsync(&DataExchangeClient::ListDataGrants, request, handler, context);
  }
 
  virtual Model::ListDataSetRevisionsOutcome ListDataSetRevisions(const Model::ListDataSetRevisionsRequest& request) const;
 
  template <typename ListDataSetRevisionsRequestT = Model::ListDataSetRevisionsRequest>
  Model::ListDataSetRevisionsOutcomeCallable ListDataSetRevisionsCallable(const ListDataSetRevisionsRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::ListDataSetRevisions, request);
  }
 
  template <typename ListDataSetRevisionsRequestT = Model::ListDataSetRevisionsRequest>
  void ListDataSetRevisionsAsync(const ListDataSetRevisionsRequestT& request, const ListDataSetRevisionsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::ListDataSetRevisions, 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(&DataExchangeClient::ListDataSets, request);
  }
 
  template <typename ListDataSetsRequestT = Model::ListDataSetsRequest>
  void ListDataSetsAsync(const ListDataSetsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListDataSetsRequestT& request = {}) const {
    return SubmitAsync(&DataExchangeClient::ListDataSets, request, handler, context);
  }
 
  virtual Model::ListEventActionsOutcome ListEventActions(const Model::ListEventActionsRequest& request = {}) const;
 
  template <typename ListEventActionsRequestT = Model::ListEventActionsRequest>
  Model::ListEventActionsOutcomeCallable ListEventActionsCallable(const ListEventActionsRequestT& request = {}) const {
    return SubmitCallable(&DataExchangeClient::ListEventActions, request);
  }
 
  template <typename ListEventActionsRequestT = Model::ListEventActionsRequest>
  void ListEventActionsAsync(const ListEventActionsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListEventActionsRequestT& request = {}) const {
    return SubmitAsync(&DataExchangeClient::ListEventActions, request, handler, context);
  }
 
  virtual Model::ListJobsOutcome ListJobs(const Model::ListJobsRequest& request = {}) const;
 
  template <typename ListJobsRequestT = Model::ListJobsRequest>
  Model::ListJobsOutcomeCallable ListJobsCallable(const ListJobsRequestT& request = {}) const {
    return SubmitCallable(&DataExchangeClient::ListJobs, request);
  }
 
  template <typename ListJobsRequestT = Model::ListJobsRequest>
  void ListJobsAsync(const ListJobsResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                     const ListJobsRequestT& request = {}) const {
    return SubmitAsync(&DataExchangeClient::ListJobs, request, handler, context);
  }
 
  virtual Model::ListReceivedDataGrantsOutcome ListReceivedDataGrants(const Model::ListReceivedDataGrantsRequest& request = {}) const;
 
  template <typename ListReceivedDataGrantsRequestT = Model::ListReceivedDataGrantsRequest>
  Model::ListReceivedDataGrantsOutcomeCallable ListReceivedDataGrantsCallable(const ListReceivedDataGrantsRequestT& request = {}) const {
    return SubmitCallable(&DataExchangeClient::ListReceivedDataGrants, request);
  }
 
  template <typename ListReceivedDataGrantsRequestT = Model::ListReceivedDataGrantsRequest>
  void ListReceivedDataGrantsAsync(const ListReceivedDataGrantsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListReceivedDataGrantsRequestT& request = {}) const {
    return SubmitAsync(&DataExchangeClient::ListReceivedDataGrants, request, handler, context);
  }
 
  virtual Model::ListRevisionAssetsOutcome ListRevisionAssets(const Model::ListRevisionAssetsRequest& request) const;
 
  template <typename ListRevisionAssetsRequestT = Model::ListRevisionAssetsRequest>
  Model::ListRevisionAssetsOutcomeCallable ListRevisionAssetsCallable(const ListRevisionAssetsRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::ListRevisionAssets, request);
  }
 
  template <typename ListRevisionAssetsRequestT = Model::ListRevisionAssetsRequest>
  void ListRevisionAssetsAsync(const ListRevisionAssetsRequestT& request, const ListRevisionAssetsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::ListRevisionAssets, 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(&DataExchangeClient::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(&DataExchangeClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::RevokeRevisionOutcome RevokeRevision(const Model::RevokeRevisionRequest& request) const;
 
  template <typename RevokeRevisionRequestT = Model::RevokeRevisionRequest>
  Model::RevokeRevisionOutcomeCallable RevokeRevisionCallable(const RevokeRevisionRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::RevokeRevision, request);
  }
 
  template <typename RevokeRevisionRequestT = Model::RevokeRevisionRequest>
  void RevokeRevisionAsync(const RevokeRevisionRequestT& request, const RevokeRevisionResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::RevokeRevision, request, handler, context);
  }
 
  virtual Model::SendApiAssetOutcome SendApiAsset(const Model::SendApiAssetRequest& request) const;
 
  template <typename SendApiAssetRequestT = Model::SendApiAssetRequest>
  Model::SendApiAssetOutcomeCallable SendApiAssetCallable(const SendApiAssetRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::SendApiAsset, request);
  }
 
  template <typename SendApiAssetRequestT = Model::SendApiAssetRequest>
  void SendApiAssetAsync(const SendApiAssetRequestT& request, const SendApiAssetResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::SendApiAsset, request, handler, context);
  }
 
  virtual Model::SendDataSetNotificationOutcome SendDataSetNotification(const Model::SendDataSetNotificationRequest& request) const;
 
  template <typename SendDataSetNotificationRequestT = Model::SendDataSetNotificationRequest>
  Model::SendDataSetNotificationOutcomeCallable SendDataSetNotificationCallable(const SendDataSetNotificationRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::SendDataSetNotification, request);
  }
 
  template <typename SendDataSetNotificationRequestT = Model::SendDataSetNotificationRequest>
  void SendDataSetNotificationAsync(const SendDataSetNotificationRequestT& request,
                                    const SendDataSetNotificationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::SendDataSetNotification, request, handler, context);
  }
 
  virtual Model::StartJobOutcome StartJob(const Model::StartJobRequest& request) const;
 
  template <typename StartJobRequestT = Model::StartJobRequest>
  Model::StartJobOutcomeCallable StartJobCallable(const StartJobRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::StartJob, request);
  }
 
  template <typename StartJobRequestT = Model::StartJobRequest>
  void StartJobAsync(const StartJobRequestT& request, const StartJobResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::StartJob, 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(&DataExchangeClient::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(&DataExchangeClient::TagResource, 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(&DataExchangeClient::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(&DataExchangeClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateAssetOutcome UpdateAsset(const Model::UpdateAssetRequest& request) const;
 
  template <typename UpdateAssetRequestT = Model::UpdateAssetRequest>
  Model::UpdateAssetOutcomeCallable UpdateAssetCallable(const UpdateAssetRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::UpdateAsset, request);
  }
 
  template <typename UpdateAssetRequestT = Model::UpdateAssetRequest>
  void UpdateAssetAsync(const UpdateAssetRequestT& request, const UpdateAssetResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::UpdateAsset, request, handler, context);
  }
 
  virtual Model::UpdateDataSetOutcome UpdateDataSet(const Model::UpdateDataSetRequest& request) const;
 
  template <typename UpdateDataSetRequestT = Model::UpdateDataSetRequest>
  Model::UpdateDataSetOutcomeCallable UpdateDataSetCallable(const UpdateDataSetRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::UpdateDataSet, request);
  }
 
  template <typename UpdateDataSetRequestT = Model::UpdateDataSetRequest>
  void UpdateDataSetAsync(const UpdateDataSetRequestT& request, const UpdateDataSetResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::UpdateDataSet, request, handler, context);
  }
 
  virtual Model::UpdateEventActionOutcome UpdateEventAction(const Model::UpdateEventActionRequest& request) const;
 
  template <typename UpdateEventActionRequestT = Model::UpdateEventActionRequest>
  Model::UpdateEventActionOutcomeCallable UpdateEventActionCallable(const UpdateEventActionRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::UpdateEventAction, request);
  }
 
  template <typename UpdateEventActionRequestT = Model::UpdateEventActionRequest>
  void UpdateEventActionAsync(const UpdateEventActionRequestT& request, const UpdateEventActionResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::UpdateEventAction, request, handler, context);
  }
 
  virtual Model::UpdateRevisionOutcome UpdateRevision(const Model::UpdateRevisionRequest& request) const;
 
  template <typename UpdateRevisionRequestT = Model::UpdateRevisionRequest>
  Model::UpdateRevisionOutcomeCallable UpdateRevisionCallable(const UpdateRevisionRequestT& request) const {
    return SubmitCallable(&DataExchangeClient::UpdateRevision, request);
  }
 
  template <typename UpdateRevisionRequestT = Model::UpdateRevisionRequest>
  void UpdateRevisionAsync(const UpdateRevisionRequestT& request, const UpdateRevisionResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataExchangeClient::UpdateRevision, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<DataExchangeEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<DataExchangeClient>;
  void init(const DataExchangeClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, DataExchangeError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  DataExchangeClientConfiguration m_clientConfiguration;
  std::shared_ptr<DataExchangeEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace DataExchange
}  // namespace Aws