DataExchangeClient.h

 
#pragma once
#include <aws/dataexchange/DataExchange_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/dataexchange/DataExchangeServiceClientModel.h>
 
namespace Aws
{
namespace DataExchange
{
  class AWS_DATAEXCHANGE_API DataExchangeClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<DataExchangeEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<DataExchangeClient>;
      void init(const DataExchangeClientConfiguration& clientConfiguration);
 
      DataExchangeClientConfiguration m_clientConfiguration;
      std::shared_ptr<DataExchangeEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace DataExchange
} // namespace Aws