SupplyChainClient.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/supplychain/SupplyChainPaginationBase.h>
#include <aws/supplychain/SupplyChainServiceClientModel.h>
#include <aws/supplychain/SupplyChain_EXPORTS.h>
 
namespace Aws {
namespace SupplyChain {
class AWS_SUPPLYCHAIN_API SupplyChainClient : public Aws::Client::AWSJsonClient,
                                              public Aws::Client::ClientWithAsyncTemplateMethods<SupplyChainClient>,
                                              public SupplyChainPaginationBase<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual 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