SupplyChainClient.h

 
#pragma once
#include <aws/supplychain/SupplyChain_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/supplychain/SupplyChainServiceClientModel.h>
 
namespace Aws
{
namespace SupplyChain
{
  class AWS_SUPPLYCHAIN_API SupplyChainClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<SupplyChainClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef SupplyChainClientConfiguration ClientConfigurationType;
      typedef SupplyChainEndpointProvider EndpointProviderType;
 
        SupplyChainClient(const Aws::SupplyChain::SupplyChainClientConfiguration& clientConfiguration = Aws::SupplyChain::SupplyChainClientConfiguration(),
                          std::shared_ptr<SupplyChainEndpointProviderBase> endpointProvider = nullptr);
 
        SupplyChainClient(const Aws::Auth::AWSCredentials& credentials,
                          std::shared_ptr<SupplyChainEndpointProviderBase> endpointProvider = nullptr,
                          const Aws::SupplyChain::SupplyChainClientConfiguration& clientConfiguration = Aws::SupplyChain::SupplyChainClientConfiguration());
 
        SupplyChainClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                          std::shared_ptr<SupplyChainEndpointProviderBase> endpointProvider = nullptr,
                          const Aws::SupplyChain::SupplyChainClientConfiguration& clientConfiguration = Aws::SupplyChain::SupplyChainClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        SupplyChainClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SupplyChainClient(const Aws::Auth::AWSCredentials& credentials,
                          const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SupplyChainClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                          const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~SupplyChainClient();
 
        virtual Model::CreateBillOfMaterialsImportJobOutcome CreateBillOfMaterialsImportJob(const Model::CreateBillOfMaterialsImportJobRequest& request) const;
 
        template<typename CreateBillOfMaterialsImportJobRequestT = Model::CreateBillOfMaterialsImportJobRequest>
        Model::CreateBillOfMaterialsImportJobOutcomeCallable CreateBillOfMaterialsImportJobCallable(const CreateBillOfMaterialsImportJobRequestT& request) const
        {
            return SubmitCallable(&SupplyChainClient::CreateBillOfMaterialsImportJob, request);
        }
 
        template<typename CreateBillOfMaterialsImportJobRequestT = Model::CreateBillOfMaterialsImportJobRequest>
        void CreateBillOfMaterialsImportJobAsync(const CreateBillOfMaterialsImportJobRequestT& request, const CreateBillOfMaterialsImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupplyChainClient::CreateBillOfMaterialsImportJob, request, handler, context);
        }
 
        virtual Model::CreateDataIntegrationFlowOutcome CreateDataIntegrationFlow(const Model::CreateDataIntegrationFlowRequest& request) const;
 
        template<typename CreateDataIntegrationFlowRequestT = Model::CreateDataIntegrationFlowRequest>
        Model::CreateDataIntegrationFlowOutcomeCallable CreateDataIntegrationFlowCallable(const CreateDataIntegrationFlowRequestT& request) const
        {
            return SubmitCallable(&SupplyChainClient::CreateDataIntegrationFlow, request);
        }
 
        template<typename CreateDataIntegrationFlowRequestT = Model::CreateDataIntegrationFlowRequest>
        void CreateDataIntegrationFlowAsync(const CreateDataIntegrationFlowRequestT& request, const CreateDataIntegrationFlowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupplyChainClient::CreateDataIntegrationFlow, request, handler, context);
        }
 
        virtual Model::CreateDataLakeDatasetOutcome CreateDataLakeDataset(const Model::CreateDataLakeDatasetRequest& request) const;
 
        template<typename CreateDataLakeDatasetRequestT = Model::CreateDataLakeDatasetRequest>
        Model::CreateDataLakeDatasetOutcomeCallable CreateDataLakeDatasetCallable(const CreateDataLakeDatasetRequestT& request) const
        {
            return SubmitCallable(&SupplyChainClient::CreateDataLakeDataset, request);
        }
 
        template<typename CreateDataLakeDatasetRequestT = Model::CreateDataLakeDatasetRequest>
        void CreateDataLakeDatasetAsync(const CreateDataLakeDatasetRequestT& request, const CreateDataLakeDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupplyChainClient::CreateDataLakeDataset, request, handler, context);
        }
 
        virtual Model::CreateDataLakeNamespaceOutcome CreateDataLakeNamespace(const Model::CreateDataLakeNamespaceRequest& request) const;
 
        template<typename CreateDataLakeNamespaceRequestT = Model::CreateDataLakeNamespaceRequest>
        Model::CreateDataLakeNamespaceOutcomeCallable CreateDataLakeNamespaceCallable(const CreateDataLakeNamespaceRequestT& request) const
        {
            return SubmitCallable(&SupplyChainClient::CreateDataLakeNamespace, request);
        }
 
        template<typename CreateDataLakeNamespaceRequestT = Model::CreateDataLakeNamespaceRequest>
        void CreateDataLakeNamespaceAsync(const CreateDataLakeNamespaceRequestT& request, const CreateDataLakeNamespaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupplyChainClient::CreateDataLakeNamespace, request, handler, context);
        }
 
        virtual Model::CreateInstanceOutcome CreateInstance(const Model::CreateInstanceRequest& request = {}) const;
 
        template<typename CreateInstanceRequestT = Model::CreateInstanceRequest>
        Model::CreateInstanceOutcomeCallable CreateInstanceCallable(const CreateInstanceRequestT& request = {}) const
        {
            return SubmitCallable(&SupplyChainClient::CreateInstance, request);
        }
 
        template<typename CreateInstanceRequestT = Model::CreateInstanceRequest>
        void CreateInstanceAsync(const CreateInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateInstanceRequestT& request = {}) const
        {
            return SubmitAsync(&SupplyChainClient::CreateInstance, request, handler, context);
        }
 
        virtual Model::DeleteDataIntegrationFlowOutcome DeleteDataIntegrationFlow(const Model::DeleteDataIntegrationFlowRequest& request) const;
 
        template<typename DeleteDataIntegrationFlowRequestT = Model::DeleteDataIntegrationFlowRequest>
        Model::DeleteDataIntegrationFlowOutcomeCallable DeleteDataIntegrationFlowCallable(const DeleteDataIntegrationFlowRequestT& request) const
        {
            return SubmitCallable(&SupplyChainClient::DeleteDataIntegrationFlow, request);
        }
 
        template<typename DeleteDataIntegrationFlowRequestT = Model::DeleteDataIntegrationFlowRequest>
        void DeleteDataIntegrationFlowAsync(const DeleteDataIntegrationFlowRequestT& request, const DeleteDataIntegrationFlowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupplyChainClient::DeleteDataIntegrationFlow, request, handler, context);
        }
 
        virtual Model::DeleteDataLakeDatasetOutcome DeleteDataLakeDataset(const Model::DeleteDataLakeDatasetRequest& request) const;
 
        template<typename DeleteDataLakeDatasetRequestT = Model::DeleteDataLakeDatasetRequest>
        Model::DeleteDataLakeDatasetOutcomeCallable DeleteDataLakeDatasetCallable(const DeleteDataLakeDatasetRequestT& request) const
        {
            return SubmitCallable(&SupplyChainClient::DeleteDataLakeDataset, request);
        }
 
        template<typename DeleteDataLakeDatasetRequestT = Model::DeleteDataLakeDatasetRequest>
        void DeleteDataLakeDatasetAsync(const DeleteDataLakeDatasetRequestT& request, const DeleteDataLakeDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupplyChainClient::DeleteDataLakeDataset, request, handler, context);
        }
 
        virtual Model::DeleteDataLakeNamespaceOutcome DeleteDataLakeNamespace(const Model::DeleteDataLakeNamespaceRequest& request) const;
 
        template<typename DeleteDataLakeNamespaceRequestT = Model::DeleteDataLakeNamespaceRequest>
        Model::DeleteDataLakeNamespaceOutcomeCallable DeleteDataLakeNamespaceCallable(const DeleteDataLakeNamespaceRequestT& request) const
        {
            return SubmitCallable(&SupplyChainClient::DeleteDataLakeNamespace, request);
        }
 
        template<typename DeleteDataLakeNamespaceRequestT = Model::DeleteDataLakeNamespaceRequest>
        void DeleteDataLakeNamespaceAsync(const DeleteDataLakeNamespaceRequestT& request, const DeleteDataLakeNamespaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupplyChainClient::DeleteDataLakeNamespace, request, handler, context);
        }
 
        virtual Model::DeleteInstanceOutcome DeleteInstance(const Model::DeleteInstanceRequest& request) const;
 
        template<typename DeleteInstanceRequestT = Model::DeleteInstanceRequest>
        Model::DeleteInstanceOutcomeCallable DeleteInstanceCallable(const DeleteInstanceRequestT& request) const
        {
            return SubmitCallable(&SupplyChainClient::DeleteInstance, request);
        }
 
        template<typename DeleteInstanceRequestT = Model::DeleteInstanceRequest>
        void DeleteInstanceAsync(const DeleteInstanceRequestT& request, const DeleteInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupplyChainClient::DeleteInstance, request, handler, context);
        }
 
        virtual Model::GetBillOfMaterialsImportJobOutcome GetBillOfMaterialsImportJob(const Model::GetBillOfMaterialsImportJobRequest& request) const;
 
        template<typename GetBillOfMaterialsImportJobRequestT = Model::GetBillOfMaterialsImportJobRequest>
        Model::GetBillOfMaterialsImportJobOutcomeCallable GetBillOfMaterialsImportJobCallable(const GetBillOfMaterialsImportJobRequestT& request) const
        {
            return SubmitCallable(&SupplyChainClient::GetBillOfMaterialsImportJob, request);
        }
 
        template<typename GetBillOfMaterialsImportJobRequestT = Model::GetBillOfMaterialsImportJobRequest>
        void GetBillOfMaterialsImportJobAsync(const GetBillOfMaterialsImportJobRequestT& request, const GetBillOfMaterialsImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupplyChainClient::GetBillOfMaterialsImportJob, request, handler, context);
        }
 
        virtual Model::GetDataIntegrationEventOutcome GetDataIntegrationEvent(const Model::GetDataIntegrationEventRequest& request) const;
 
        template<typename GetDataIntegrationEventRequestT = Model::GetDataIntegrationEventRequest>
        Model::GetDataIntegrationEventOutcomeCallable GetDataIntegrationEventCallable(const GetDataIntegrationEventRequestT& request) const
        {
            return SubmitCallable(&SupplyChainClient::GetDataIntegrationEvent, request);
        }
 
        template<typename GetDataIntegrationEventRequestT = Model::GetDataIntegrationEventRequest>
        void GetDataIntegrationEventAsync(const GetDataIntegrationEventRequestT& request, const GetDataIntegrationEventResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupplyChainClient::GetDataIntegrationEvent, request, handler, context);
        }
 
        virtual Model::GetDataIntegrationFlowOutcome GetDataIntegrationFlow(const Model::GetDataIntegrationFlowRequest& request) const;
 
        template<typename GetDataIntegrationFlowRequestT = Model::GetDataIntegrationFlowRequest>
        Model::GetDataIntegrationFlowOutcomeCallable GetDataIntegrationFlowCallable(const GetDataIntegrationFlowRequestT& request) const
        {
            return SubmitCallable(&SupplyChainClient::GetDataIntegrationFlow, request);
        }
 
        template<typename GetDataIntegrationFlowRequestT = Model::GetDataIntegrationFlowRequest>
        void GetDataIntegrationFlowAsync(const GetDataIntegrationFlowRequestT& request, const GetDataIntegrationFlowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupplyChainClient::GetDataIntegrationFlow, request, handler, context);
        }
 
        virtual Model::GetDataIntegrationFlowExecutionOutcome GetDataIntegrationFlowExecution(const Model::GetDataIntegrationFlowExecutionRequest& request) const;
 
        template<typename GetDataIntegrationFlowExecutionRequestT = Model::GetDataIntegrationFlowExecutionRequest>
        Model::GetDataIntegrationFlowExecutionOutcomeCallable GetDataIntegrationFlowExecutionCallable(const GetDataIntegrationFlowExecutionRequestT& request) const
        {
            return SubmitCallable(&SupplyChainClient::GetDataIntegrationFlowExecution, request);
        }
 
        template<typename GetDataIntegrationFlowExecutionRequestT = Model::GetDataIntegrationFlowExecutionRequest>
        void GetDataIntegrationFlowExecutionAsync(const GetDataIntegrationFlowExecutionRequestT& request, const GetDataIntegrationFlowExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupplyChainClient::GetDataIntegrationFlowExecution, request, handler, context);
        }
 
        virtual Model::GetDataLakeDatasetOutcome GetDataLakeDataset(const Model::GetDataLakeDatasetRequest& request) const;
 
        template<typename GetDataLakeDatasetRequestT = Model::GetDataLakeDatasetRequest>
        Model::GetDataLakeDatasetOutcomeCallable GetDataLakeDatasetCallable(const GetDataLakeDatasetRequestT& request) const
        {
            return SubmitCallable(&SupplyChainClient::GetDataLakeDataset, request);
        }
 
        template<typename GetDataLakeDatasetRequestT = Model::GetDataLakeDatasetRequest>
        void GetDataLakeDatasetAsync(const GetDataLakeDatasetRequestT& request, const GetDataLakeDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupplyChainClient::GetDataLakeDataset, request, handler, context);
        }
 
        virtual Model::GetDataLakeNamespaceOutcome GetDataLakeNamespace(const Model::GetDataLakeNamespaceRequest& request) const;
 
        template<typename GetDataLakeNamespaceRequestT = Model::GetDataLakeNamespaceRequest>
        Model::GetDataLakeNamespaceOutcomeCallable GetDataLakeNamespaceCallable(const GetDataLakeNamespaceRequestT& request) const
        {
            return SubmitCallable(&SupplyChainClient::GetDataLakeNamespace, request);
        }
 
        template<typename GetDataLakeNamespaceRequestT = Model::GetDataLakeNamespaceRequest>
        void GetDataLakeNamespaceAsync(const GetDataLakeNamespaceRequestT& request, const GetDataLakeNamespaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupplyChainClient::GetDataLakeNamespace, request, handler, context);
        }
 
        virtual Model::GetInstanceOutcome GetInstance(const Model::GetInstanceRequest& request) const;
 
        template<typename GetInstanceRequestT = Model::GetInstanceRequest>
        Model::GetInstanceOutcomeCallable GetInstanceCallable(const GetInstanceRequestT& request) const
        {
            return SubmitCallable(&SupplyChainClient::GetInstance, request);
        }
 
        template<typename GetInstanceRequestT = Model::GetInstanceRequest>
        void GetInstanceAsync(const GetInstanceRequestT& request, const GetInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupplyChainClient::GetInstance, request, handler, context);
        }
 
        virtual Model::ListDataIntegrationEventsOutcome ListDataIntegrationEvents(const Model::ListDataIntegrationEventsRequest& request) const;
 
        template<typename ListDataIntegrationEventsRequestT = Model::ListDataIntegrationEventsRequest>
        Model::ListDataIntegrationEventsOutcomeCallable ListDataIntegrationEventsCallable(const ListDataIntegrationEventsRequestT& request) const
        {
            return SubmitCallable(&SupplyChainClient::ListDataIntegrationEvents, request);
        }
 
        template<typename ListDataIntegrationEventsRequestT = Model::ListDataIntegrationEventsRequest>
        void ListDataIntegrationEventsAsync(const ListDataIntegrationEventsRequestT& request, const ListDataIntegrationEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupplyChainClient::ListDataIntegrationEvents, request, handler, context);
        }
 
        virtual Model::ListDataIntegrationFlowExecutionsOutcome ListDataIntegrationFlowExecutions(const Model::ListDataIntegrationFlowExecutionsRequest& request) const;
 
        template<typename ListDataIntegrationFlowExecutionsRequestT = Model::ListDataIntegrationFlowExecutionsRequest>
        Model::ListDataIntegrationFlowExecutionsOutcomeCallable ListDataIntegrationFlowExecutionsCallable(const ListDataIntegrationFlowExecutionsRequestT& request) const
        {
            return SubmitCallable(&SupplyChainClient::ListDataIntegrationFlowExecutions, request);
        }
 
        template<typename ListDataIntegrationFlowExecutionsRequestT = Model::ListDataIntegrationFlowExecutionsRequest>
        void ListDataIntegrationFlowExecutionsAsync(const ListDataIntegrationFlowExecutionsRequestT& request, const ListDataIntegrationFlowExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupplyChainClient::ListDataIntegrationFlowExecutions, request, handler, context);
        }
 
        virtual Model::ListDataIntegrationFlowsOutcome ListDataIntegrationFlows(const Model::ListDataIntegrationFlowsRequest& request) const;
 
        template<typename ListDataIntegrationFlowsRequestT = Model::ListDataIntegrationFlowsRequest>
        Model::ListDataIntegrationFlowsOutcomeCallable ListDataIntegrationFlowsCallable(const ListDataIntegrationFlowsRequestT& request) const
        {
            return SubmitCallable(&SupplyChainClient::ListDataIntegrationFlows, request);
        }
 
        template<typename ListDataIntegrationFlowsRequestT = Model::ListDataIntegrationFlowsRequest>
        void ListDataIntegrationFlowsAsync(const ListDataIntegrationFlowsRequestT& request, const ListDataIntegrationFlowsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupplyChainClient::ListDataIntegrationFlows, request, handler, context);
        }
 
        virtual Model::ListDataLakeDatasetsOutcome ListDataLakeDatasets(const Model::ListDataLakeDatasetsRequest& request) const;
 
        template<typename ListDataLakeDatasetsRequestT = Model::ListDataLakeDatasetsRequest>
        Model::ListDataLakeDatasetsOutcomeCallable ListDataLakeDatasetsCallable(const ListDataLakeDatasetsRequestT& request) const
        {
            return SubmitCallable(&SupplyChainClient::ListDataLakeDatasets, request);
        }
 
        template<typename ListDataLakeDatasetsRequestT = Model::ListDataLakeDatasetsRequest>
        void ListDataLakeDatasetsAsync(const ListDataLakeDatasetsRequestT& request, const ListDataLakeDatasetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupplyChainClient::ListDataLakeDatasets, request, handler, context);
        }
 
        virtual Model::ListDataLakeNamespacesOutcome ListDataLakeNamespaces(const Model::ListDataLakeNamespacesRequest& request) const;
 
        template<typename ListDataLakeNamespacesRequestT = Model::ListDataLakeNamespacesRequest>
        Model::ListDataLakeNamespacesOutcomeCallable ListDataLakeNamespacesCallable(const ListDataLakeNamespacesRequestT& request) const
        {
            return SubmitCallable(&SupplyChainClient::ListDataLakeNamespaces, request);
        }
 
        template<typename ListDataLakeNamespacesRequestT = Model::ListDataLakeNamespacesRequest>
        void ListDataLakeNamespacesAsync(const ListDataLakeNamespacesRequestT& request, const ListDataLakeNamespacesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupplyChainClient::ListDataLakeNamespaces, request, handler, context);
        }
 
        virtual Model::ListInstancesOutcome ListInstances(const Model::ListInstancesRequest& request = {}) const;
 
        template<typename ListInstancesRequestT = Model::ListInstancesRequest>
        Model::ListInstancesOutcomeCallable ListInstancesCallable(const ListInstancesRequestT& request = {}) const
        {
            return SubmitCallable(&SupplyChainClient::ListInstances, request);
        }
 
        template<typename ListInstancesRequestT = Model::ListInstancesRequest>
        void ListInstancesAsync(const ListInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListInstancesRequestT& request = {}) const
        {
            return SubmitAsync(&SupplyChainClient::ListInstances, 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(&SupplyChainClient::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(&SupplyChainClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::SendDataIntegrationEventOutcome SendDataIntegrationEvent(const Model::SendDataIntegrationEventRequest& request) const;
 
        template<typename SendDataIntegrationEventRequestT = Model::SendDataIntegrationEventRequest>
        Model::SendDataIntegrationEventOutcomeCallable SendDataIntegrationEventCallable(const SendDataIntegrationEventRequestT& request) const
        {
            return SubmitCallable(&SupplyChainClient::SendDataIntegrationEvent, request);
        }
 
        template<typename SendDataIntegrationEventRequestT = Model::SendDataIntegrationEventRequest>
        void SendDataIntegrationEventAsync(const SendDataIntegrationEventRequestT& request, const SendDataIntegrationEventResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupplyChainClient::SendDataIntegrationEvent, 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(&SupplyChainClient::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(&SupplyChainClient::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(&SupplyChainClient::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(&SupplyChainClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateDataIntegrationFlowOutcome UpdateDataIntegrationFlow(const Model::UpdateDataIntegrationFlowRequest& request) const;
 
        template<typename UpdateDataIntegrationFlowRequestT = Model::UpdateDataIntegrationFlowRequest>
        Model::UpdateDataIntegrationFlowOutcomeCallable UpdateDataIntegrationFlowCallable(const UpdateDataIntegrationFlowRequestT& request) const
        {
            return SubmitCallable(&SupplyChainClient::UpdateDataIntegrationFlow, request);
        }
 
        template<typename UpdateDataIntegrationFlowRequestT = Model::UpdateDataIntegrationFlowRequest>
        void UpdateDataIntegrationFlowAsync(const UpdateDataIntegrationFlowRequestT& request, const UpdateDataIntegrationFlowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupplyChainClient::UpdateDataIntegrationFlow, request, handler, context);
        }
 
        virtual Model::UpdateDataLakeDatasetOutcome UpdateDataLakeDataset(const Model::UpdateDataLakeDatasetRequest& request) const;
 
        template<typename UpdateDataLakeDatasetRequestT = Model::UpdateDataLakeDatasetRequest>
        Model::UpdateDataLakeDatasetOutcomeCallable UpdateDataLakeDatasetCallable(const UpdateDataLakeDatasetRequestT& request) const
        {
            return SubmitCallable(&SupplyChainClient::UpdateDataLakeDataset, request);
        }
 
        template<typename UpdateDataLakeDatasetRequestT = Model::UpdateDataLakeDatasetRequest>
        void UpdateDataLakeDatasetAsync(const UpdateDataLakeDatasetRequestT& request, const UpdateDataLakeDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupplyChainClient::UpdateDataLakeDataset, request, handler, context);
        }
 
        virtual Model::UpdateDataLakeNamespaceOutcome UpdateDataLakeNamespace(const Model::UpdateDataLakeNamespaceRequest& request) const;
 
        template<typename UpdateDataLakeNamespaceRequestT = Model::UpdateDataLakeNamespaceRequest>
        Model::UpdateDataLakeNamespaceOutcomeCallable UpdateDataLakeNamespaceCallable(const UpdateDataLakeNamespaceRequestT& request) const
        {
            return SubmitCallable(&SupplyChainClient::UpdateDataLakeNamespace, request);
        }
 
        template<typename UpdateDataLakeNamespaceRequestT = Model::UpdateDataLakeNamespaceRequest>
        void UpdateDataLakeNamespaceAsync(const UpdateDataLakeNamespaceRequestT& request, const UpdateDataLakeNamespaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupplyChainClient::UpdateDataLakeNamespace, request, handler, context);
        }
 
        virtual Model::UpdateInstanceOutcome UpdateInstance(const Model::UpdateInstanceRequest& request) const;
 
        template<typename UpdateInstanceRequestT = Model::UpdateInstanceRequest>
        Model::UpdateInstanceOutcomeCallable UpdateInstanceCallable(const UpdateInstanceRequestT& request) const
        {
            return SubmitCallable(&SupplyChainClient::UpdateInstance, request);
        }
 
        template<typename UpdateInstanceRequestT = Model::UpdateInstanceRequest>
        void UpdateInstanceAsync(const UpdateInstanceRequestT& request, const UpdateInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SupplyChainClient::UpdateInstance, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<SupplyChainEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<SupplyChainClient>;
      void init(const SupplyChainClientConfiguration& clientConfiguration);
 
      SupplyChainClientConfiguration m_clientConfiguration;
      std::shared_ptr<SupplyChainEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace SupplyChain
} // namespace Aws