BedrockDataAutomationClient.h

 
#pragma once
#include <aws/bedrock-data-automation/BedrockDataAutomationErrorMarshaller.h>
#include <aws/bedrock-data-automation/BedrockDataAutomationPaginationBase.h>
#include <aws/bedrock-data-automation/BedrockDataAutomationServiceClientModel.h>
#include <aws/bedrock-data-automation/BedrockDataAutomationWaiter.h>
#include <aws/bedrock-data-automation/BedrockDataAutomation_EXPORTS.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <smithy/client/AwsSmithyClient.h>
#include <smithy/client/serializer/JsonOutcomeSerializer.h>
#include <smithy/identity/auth/built-in/GenericAuthSchemeResolver.h>
#include <smithy/identity/auth/built-in/SigV4AuthScheme.h>
 
namespace Aws {
namespace BedrockDataAutomation {
AWS_BEDROCKDATAAUTOMATION_API extern const char SERVICE_NAME[];
class AWS_BEDROCKDATAAUTOMATION_API BedrockDataAutomationClient
    : Aws::Client::ClientWithAsyncTemplateMethods<BedrockDataAutomationClient>,
      public smithy::client::AwsSmithyClientT<
          Aws::BedrockDataAutomation::SERVICE_NAME, Aws::BedrockDataAutomation::BedrockDataAutomationClientConfiguration,
          smithy::AuthSchemeResolverBase<>, Aws::Crt::Variant<smithy::SigV4AuthScheme>, BedrockDataAutomationEndpointProviderBase,
          smithy::client::JsonOutcomeSerializer, smithy::client::JsonOutcome, Aws::Client::BedrockDataAutomationErrorMarshaller>,
      public BedrockDataAutomationPaginationBase<BedrockDataAutomationClient>,
      public BedrockDataAutomationWaiter<BedrockDataAutomationClient> {
 public:
  static const char* GetServiceName();
  static const char* GetAllocationTag();
  inline const char* GetServiceClientName() const override { return "Bedrock Data Automation"; }
 
  typedef BedrockDataAutomationClientConfiguration ClientConfigurationType;
  typedef BedrockDataAutomationEndpointProvider EndpointProviderType;
 
  BedrockDataAutomationClient(const Aws::BedrockDataAutomation::BedrockDataAutomationClientConfiguration& clientConfiguration =
                                  Aws::BedrockDataAutomation::BedrockDataAutomationClientConfiguration(),
                              std::shared_ptr<BedrockDataAutomationEndpointProviderBase> endpointProvider = nullptr);
 
  BedrockDataAutomationClient(const Aws::Auth::AWSCredentials& credentials,
                              std::shared_ptr<BedrockDataAutomationEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::BedrockDataAutomation::BedrockDataAutomationClientConfiguration& clientConfiguration =
                                  Aws::BedrockDataAutomation::BedrockDataAutomationClientConfiguration());
 
  BedrockDataAutomationClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              std::shared_ptr<BedrockDataAutomationEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::BedrockDataAutomation::BedrockDataAutomationClientConfiguration& clientConfiguration =
                                  Aws::BedrockDataAutomation::BedrockDataAutomationClientConfiguration());
 
  /* Legacy constructors due deprecation */
  BedrockDataAutomationClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  BedrockDataAutomationClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  BedrockDataAutomationClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~BedrockDataAutomationClient();
 
  virtual Model::CopyBlueprintStageOutcome CopyBlueprintStage(const Model::CopyBlueprintStageRequest& request) const;
 
  template <typename CopyBlueprintStageRequestT = Model::CopyBlueprintStageRequest>
  Model::CopyBlueprintStageOutcomeCallable CopyBlueprintStageCallable(const CopyBlueprintStageRequestT& request) const {
    return SubmitCallable(&BedrockDataAutomationClient::CopyBlueprintStage, request);
  }
 
  template <typename CopyBlueprintStageRequestT = Model::CopyBlueprintStageRequest>
  void CopyBlueprintStageAsync(const CopyBlueprintStageRequestT& request, const CopyBlueprintStageResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockDataAutomationClient::CopyBlueprintStage, request, handler, context);
  }
 
  virtual Model::CreateBlueprintOutcome CreateBlueprint(const Model::CreateBlueprintRequest& request) const;
 
  template <typename CreateBlueprintRequestT = Model::CreateBlueprintRequest>
  Model::CreateBlueprintOutcomeCallable CreateBlueprintCallable(const CreateBlueprintRequestT& request) const {
    return SubmitCallable(&BedrockDataAutomationClient::CreateBlueprint, request);
  }
 
  template <typename CreateBlueprintRequestT = Model::CreateBlueprintRequest>
  void CreateBlueprintAsync(const CreateBlueprintRequestT& request, const CreateBlueprintResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockDataAutomationClient::CreateBlueprint, request, handler, context);
  }
 
  virtual Model::CreateBlueprintVersionOutcome CreateBlueprintVersion(const Model::CreateBlueprintVersionRequest& request) const;
 
  template <typename CreateBlueprintVersionRequestT = Model::CreateBlueprintVersionRequest>
  Model::CreateBlueprintVersionOutcomeCallable CreateBlueprintVersionCallable(const CreateBlueprintVersionRequestT& request) const {
    return SubmitCallable(&BedrockDataAutomationClient::CreateBlueprintVersion, request);
  }
 
  template <typename CreateBlueprintVersionRequestT = Model::CreateBlueprintVersionRequest>
  void CreateBlueprintVersionAsync(const CreateBlueprintVersionRequestT& request,
                                   const CreateBlueprintVersionResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockDataAutomationClient::CreateBlueprintVersion, request, handler, context);
  }
 
  virtual Model::CreateDataAutomationLibraryOutcome CreateDataAutomationLibrary(
      const Model::CreateDataAutomationLibraryRequest& request) const;
 
  template <typename CreateDataAutomationLibraryRequestT = Model::CreateDataAutomationLibraryRequest>
  Model::CreateDataAutomationLibraryOutcomeCallable CreateDataAutomationLibraryCallable(
      const CreateDataAutomationLibraryRequestT& request) const {
    return SubmitCallable(&BedrockDataAutomationClient::CreateDataAutomationLibrary, request);
  }
 
  template <typename CreateDataAutomationLibraryRequestT = Model::CreateDataAutomationLibraryRequest>
  void CreateDataAutomationLibraryAsync(const CreateDataAutomationLibraryRequestT& request,
                                        const CreateDataAutomationLibraryResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockDataAutomationClient::CreateDataAutomationLibrary, request, handler, context);
  }
 
  virtual Model::CreateDataAutomationProjectOutcome CreateDataAutomationProject(
      const Model::CreateDataAutomationProjectRequest& request) const;
 
  template <typename CreateDataAutomationProjectRequestT = Model::CreateDataAutomationProjectRequest>
  Model::CreateDataAutomationProjectOutcomeCallable CreateDataAutomationProjectCallable(
      const CreateDataAutomationProjectRequestT& request) const {
    return SubmitCallable(&BedrockDataAutomationClient::CreateDataAutomationProject, request);
  }
 
  template <typename CreateDataAutomationProjectRequestT = Model::CreateDataAutomationProjectRequest>
  void CreateDataAutomationProjectAsync(const CreateDataAutomationProjectRequestT& request,
                                        const CreateDataAutomationProjectResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockDataAutomationClient::CreateDataAutomationProject, request, handler, context);
  }
 
  virtual Model::DeleteBlueprintOutcome DeleteBlueprint(const Model::DeleteBlueprintRequest& request) const;
 
  template <typename DeleteBlueprintRequestT = Model::DeleteBlueprintRequest>
  Model::DeleteBlueprintOutcomeCallable DeleteBlueprintCallable(const DeleteBlueprintRequestT& request) const {
    return SubmitCallable(&BedrockDataAutomationClient::DeleteBlueprint, request);
  }
 
  template <typename DeleteBlueprintRequestT = Model::DeleteBlueprintRequest>
  void DeleteBlueprintAsync(const DeleteBlueprintRequestT& request, const DeleteBlueprintResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockDataAutomationClient::DeleteBlueprint, request, handler, context);
  }
 
  virtual Model::DeleteDataAutomationLibraryOutcome DeleteDataAutomationLibrary(
      const Model::DeleteDataAutomationLibraryRequest& request) const;
 
  template <typename DeleteDataAutomationLibraryRequestT = Model::DeleteDataAutomationLibraryRequest>
  Model::DeleteDataAutomationLibraryOutcomeCallable DeleteDataAutomationLibraryCallable(
      const DeleteDataAutomationLibraryRequestT& request) const {
    return SubmitCallable(&BedrockDataAutomationClient::DeleteDataAutomationLibrary, request);
  }
 
  template <typename DeleteDataAutomationLibraryRequestT = Model::DeleteDataAutomationLibraryRequest>
  void DeleteDataAutomationLibraryAsync(const DeleteDataAutomationLibraryRequestT& request,
                                        const DeleteDataAutomationLibraryResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockDataAutomationClient::DeleteDataAutomationLibrary, request, handler, context);
  }
 
  virtual Model::DeleteDataAutomationProjectOutcome DeleteDataAutomationProject(
      const Model::DeleteDataAutomationProjectRequest& request) const;
 
  template <typename DeleteDataAutomationProjectRequestT = Model::DeleteDataAutomationProjectRequest>
  Model::DeleteDataAutomationProjectOutcomeCallable DeleteDataAutomationProjectCallable(
      const DeleteDataAutomationProjectRequestT& request) const {
    return SubmitCallable(&BedrockDataAutomationClient::DeleteDataAutomationProject, request);
  }
 
  template <typename DeleteDataAutomationProjectRequestT = Model::DeleteDataAutomationProjectRequest>
  void DeleteDataAutomationProjectAsync(const DeleteDataAutomationProjectRequestT& request,
                                        const DeleteDataAutomationProjectResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockDataAutomationClient::DeleteDataAutomationProject, request, handler, context);
  }
 
  virtual Model::GetBlueprintOutcome GetBlueprint(const Model::GetBlueprintRequest& request) const;
 
  template <typename GetBlueprintRequestT = Model::GetBlueprintRequest>
  Model::GetBlueprintOutcomeCallable GetBlueprintCallable(const GetBlueprintRequestT& request) const {
    return SubmitCallable(&BedrockDataAutomationClient::GetBlueprint, request);
  }
 
  template <typename GetBlueprintRequestT = Model::GetBlueprintRequest>
  void GetBlueprintAsync(const GetBlueprintRequestT& request, const GetBlueprintResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockDataAutomationClient::GetBlueprint, request, handler, context);
  }
 
  virtual Model::GetBlueprintOptimizationStatusOutcome GetBlueprintOptimizationStatus(
      const Model::GetBlueprintOptimizationStatusRequest& request) const;
 
  template <typename GetBlueprintOptimizationStatusRequestT = Model::GetBlueprintOptimizationStatusRequest>
  Model::GetBlueprintOptimizationStatusOutcomeCallable GetBlueprintOptimizationStatusCallable(
      const GetBlueprintOptimizationStatusRequestT& request) const {
    return SubmitCallable(&BedrockDataAutomationClient::GetBlueprintOptimizationStatus, request);
  }
 
  template <typename GetBlueprintOptimizationStatusRequestT = Model::GetBlueprintOptimizationStatusRequest>
  void GetBlueprintOptimizationStatusAsync(const GetBlueprintOptimizationStatusRequestT& request,
                                           const GetBlueprintOptimizationStatusResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockDataAutomationClient::GetBlueprintOptimizationStatus, request, handler, context);
  }
 
  virtual Model::GetDataAutomationLibraryOutcome GetDataAutomationLibrary(const Model::GetDataAutomationLibraryRequest& request) const;
 
  template <typename GetDataAutomationLibraryRequestT = Model::GetDataAutomationLibraryRequest>
  Model::GetDataAutomationLibraryOutcomeCallable GetDataAutomationLibraryCallable(const GetDataAutomationLibraryRequestT& request) const {
    return SubmitCallable(&BedrockDataAutomationClient::GetDataAutomationLibrary, request);
  }
 
  template <typename GetDataAutomationLibraryRequestT = Model::GetDataAutomationLibraryRequest>
  void GetDataAutomationLibraryAsync(const GetDataAutomationLibraryRequestT& request,
                                     const GetDataAutomationLibraryResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockDataAutomationClient::GetDataAutomationLibrary, request, handler, context);
  }
 
  virtual Model::GetDataAutomationLibraryEntityOutcome GetDataAutomationLibraryEntity(
      const Model::GetDataAutomationLibraryEntityRequest& request) const;
 
  template <typename GetDataAutomationLibraryEntityRequestT = Model::GetDataAutomationLibraryEntityRequest>
  Model::GetDataAutomationLibraryEntityOutcomeCallable GetDataAutomationLibraryEntityCallable(
      const GetDataAutomationLibraryEntityRequestT& request) const {
    return SubmitCallable(&BedrockDataAutomationClient::GetDataAutomationLibraryEntity, request);
  }
 
  template <typename GetDataAutomationLibraryEntityRequestT = Model::GetDataAutomationLibraryEntityRequest>
  void GetDataAutomationLibraryEntityAsync(const GetDataAutomationLibraryEntityRequestT& request,
                                           const GetDataAutomationLibraryEntityResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockDataAutomationClient::GetDataAutomationLibraryEntity, request, handler, context);
  }
 
  virtual Model::GetDataAutomationLibraryIngestionJobOutcome GetDataAutomationLibraryIngestionJob(
      const Model::GetDataAutomationLibraryIngestionJobRequest& request) const;
 
  template <typename GetDataAutomationLibraryIngestionJobRequestT = Model::GetDataAutomationLibraryIngestionJobRequest>
  Model::GetDataAutomationLibraryIngestionJobOutcomeCallable GetDataAutomationLibraryIngestionJobCallable(
      const GetDataAutomationLibraryIngestionJobRequestT& request) const {
    return SubmitCallable(&BedrockDataAutomationClient::GetDataAutomationLibraryIngestionJob, request);
  }
 
  template <typename GetDataAutomationLibraryIngestionJobRequestT = Model::GetDataAutomationLibraryIngestionJobRequest>
  void GetDataAutomationLibraryIngestionJobAsync(const GetDataAutomationLibraryIngestionJobRequestT& request,
                                                 const GetDataAutomationLibraryIngestionJobResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockDataAutomationClient::GetDataAutomationLibraryIngestionJob, request, handler, context);
  }
 
  virtual Model::GetDataAutomationProjectOutcome GetDataAutomationProject(const Model::GetDataAutomationProjectRequest& request) const;
 
  template <typename GetDataAutomationProjectRequestT = Model::GetDataAutomationProjectRequest>
  Model::GetDataAutomationProjectOutcomeCallable GetDataAutomationProjectCallable(const GetDataAutomationProjectRequestT& request) const {
    return SubmitCallable(&BedrockDataAutomationClient::GetDataAutomationProject, request);
  }
 
  template <typename GetDataAutomationProjectRequestT = Model::GetDataAutomationProjectRequest>
  void GetDataAutomationProjectAsync(const GetDataAutomationProjectRequestT& request,
                                     const GetDataAutomationProjectResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockDataAutomationClient::GetDataAutomationProject, request, handler, context);
  }
 
  virtual Model::InvokeBlueprintOptimizationAsyncOutcome InvokeBlueprintOptimizationAsync(
      const Model::InvokeBlueprintOptimizationAsyncRequest& request) const;
 
  template <typename InvokeBlueprintOptimizationAsyncRequestT = Model::InvokeBlueprintOptimizationAsyncRequest>
  Model::InvokeBlueprintOptimizationAsyncOutcomeCallable InvokeBlueprintOptimizationAsyncCallable(
      const InvokeBlueprintOptimizationAsyncRequestT& request) const {
    return SubmitCallable(&BedrockDataAutomationClient::InvokeBlueprintOptimizationAsync, request);
  }
 
  template <typename InvokeBlueprintOptimizationAsyncRequestT = Model::InvokeBlueprintOptimizationAsyncRequest>
  void InvokeBlueprintOptimizationAsyncAsync(const InvokeBlueprintOptimizationAsyncRequestT& request,
                                             const InvokeBlueprintOptimizationAsyncResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockDataAutomationClient::InvokeBlueprintOptimizationAsync, request, handler, context);
  }
 
  virtual Model::InvokeDataAutomationLibraryIngestionJobOutcome InvokeDataAutomationLibraryIngestionJob(
      const Model::InvokeDataAutomationLibraryIngestionJobRequest& request) const;
 
  template <typename InvokeDataAutomationLibraryIngestionJobRequestT = Model::InvokeDataAutomationLibraryIngestionJobRequest>
  Model::InvokeDataAutomationLibraryIngestionJobOutcomeCallable InvokeDataAutomationLibraryIngestionJobCallable(
      const InvokeDataAutomationLibraryIngestionJobRequestT& request) const {
    return SubmitCallable(&BedrockDataAutomationClient::InvokeDataAutomationLibraryIngestionJob, request);
  }
 
  template <typename InvokeDataAutomationLibraryIngestionJobRequestT = Model::InvokeDataAutomationLibraryIngestionJobRequest>
  void InvokeDataAutomationLibraryIngestionJobAsync(const InvokeDataAutomationLibraryIngestionJobRequestT& request,
                                                    const InvokeDataAutomationLibraryIngestionJobResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockDataAutomationClient::InvokeDataAutomationLibraryIngestionJob, request, handler, context);
  }
 
  virtual Model::ListBlueprintsOutcome ListBlueprints(const Model::ListBlueprintsRequest& request = {}) const;
 
  template <typename ListBlueprintsRequestT = Model::ListBlueprintsRequest>
  Model::ListBlueprintsOutcomeCallable ListBlueprintsCallable(const ListBlueprintsRequestT& request = {}) const {
    return SubmitCallable(&BedrockDataAutomationClient::ListBlueprints, request);
  }
 
  template <typename ListBlueprintsRequestT = Model::ListBlueprintsRequest>
  void ListBlueprintsAsync(const ListBlueprintsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListBlueprintsRequestT& request = {}) const {
    return SubmitAsync(&BedrockDataAutomationClient::ListBlueprints, request, handler, context);
  }
 
  virtual Model::ListDataAutomationLibrariesOutcome ListDataAutomationLibraries(
      const Model::ListDataAutomationLibrariesRequest& request = {}) const;
 
  template <typename ListDataAutomationLibrariesRequestT = Model::ListDataAutomationLibrariesRequest>
  Model::ListDataAutomationLibrariesOutcomeCallable ListDataAutomationLibrariesCallable(
      const ListDataAutomationLibrariesRequestT& request = {}) const {
    return SubmitCallable(&BedrockDataAutomationClient::ListDataAutomationLibraries, request);
  }
 
  template <typename ListDataAutomationLibrariesRequestT = Model::ListDataAutomationLibrariesRequest>
  void ListDataAutomationLibrariesAsync(const ListDataAutomationLibrariesResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const ListDataAutomationLibrariesRequestT& request = {}) const {
    return SubmitAsync(&BedrockDataAutomationClient::ListDataAutomationLibraries, request, handler, context);
  }
 
  virtual Model::ListDataAutomationLibraryEntitiesOutcome ListDataAutomationLibraryEntities(
      const Model::ListDataAutomationLibraryEntitiesRequest& request) const;
 
  template <typename ListDataAutomationLibraryEntitiesRequestT = Model::ListDataAutomationLibraryEntitiesRequest>
  Model::ListDataAutomationLibraryEntitiesOutcomeCallable ListDataAutomationLibraryEntitiesCallable(
      const ListDataAutomationLibraryEntitiesRequestT& request) const {
    return SubmitCallable(&BedrockDataAutomationClient::ListDataAutomationLibraryEntities, request);
  }
 
  template <typename ListDataAutomationLibraryEntitiesRequestT = Model::ListDataAutomationLibraryEntitiesRequest>
  void ListDataAutomationLibraryEntitiesAsync(const ListDataAutomationLibraryEntitiesRequestT& request,
                                              const ListDataAutomationLibraryEntitiesResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockDataAutomationClient::ListDataAutomationLibraryEntities, request, handler, context);
  }
 
  virtual Model::ListDataAutomationLibraryIngestionJobsOutcome ListDataAutomationLibraryIngestionJobs(
      const Model::ListDataAutomationLibraryIngestionJobsRequest& request) const;
 
  template <typename ListDataAutomationLibraryIngestionJobsRequestT = Model::ListDataAutomationLibraryIngestionJobsRequest>
  Model::ListDataAutomationLibraryIngestionJobsOutcomeCallable ListDataAutomationLibraryIngestionJobsCallable(
      const ListDataAutomationLibraryIngestionJobsRequestT& request) const {
    return SubmitCallable(&BedrockDataAutomationClient::ListDataAutomationLibraryIngestionJobs, request);
  }
 
  template <typename ListDataAutomationLibraryIngestionJobsRequestT = Model::ListDataAutomationLibraryIngestionJobsRequest>
  void ListDataAutomationLibraryIngestionJobsAsync(const ListDataAutomationLibraryIngestionJobsRequestT& request,
                                                   const ListDataAutomationLibraryIngestionJobsResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockDataAutomationClient::ListDataAutomationLibraryIngestionJobs, request, handler, context);
  }
 
  virtual Model::ListDataAutomationProjectsOutcome ListDataAutomationProjects(
      const Model::ListDataAutomationProjectsRequest& request = {}) const;
 
  template <typename ListDataAutomationProjectsRequestT = Model::ListDataAutomationProjectsRequest>
  Model::ListDataAutomationProjectsOutcomeCallable ListDataAutomationProjectsCallable(
      const ListDataAutomationProjectsRequestT& request = {}) const {
    return SubmitCallable(&BedrockDataAutomationClient::ListDataAutomationProjects, request);
  }
 
  template <typename ListDataAutomationProjectsRequestT = Model::ListDataAutomationProjectsRequest>
  void ListDataAutomationProjectsAsync(const ListDataAutomationProjectsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const ListDataAutomationProjectsRequestT& request = {}) const {
    return SubmitAsync(&BedrockDataAutomationClient::ListDataAutomationProjects, 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(&BedrockDataAutomationClient::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(&BedrockDataAutomationClient::ListTagsForResource, 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(&BedrockDataAutomationClient::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(&BedrockDataAutomationClient::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(&BedrockDataAutomationClient::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(&BedrockDataAutomationClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateBlueprintOutcome UpdateBlueprint(const Model::UpdateBlueprintRequest& request) const;
 
  template <typename UpdateBlueprintRequestT = Model::UpdateBlueprintRequest>
  Model::UpdateBlueprintOutcomeCallable UpdateBlueprintCallable(const UpdateBlueprintRequestT& request) const {
    return SubmitCallable(&BedrockDataAutomationClient::UpdateBlueprint, request);
  }
 
  template <typename UpdateBlueprintRequestT = Model::UpdateBlueprintRequest>
  void UpdateBlueprintAsync(const UpdateBlueprintRequestT& request, const UpdateBlueprintResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockDataAutomationClient::UpdateBlueprint, request, handler, context);
  }
 
  virtual Model::UpdateDataAutomationLibraryOutcome UpdateDataAutomationLibrary(
      const Model::UpdateDataAutomationLibraryRequest& request) const;
 
  template <typename UpdateDataAutomationLibraryRequestT = Model::UpdateDataAutomationLibraryRequest>
  Model::UpdateDataAutomationLibraryOutcomeCallable UpdateDataAutomationLibraryCallable(
      const UpdateDataAutomationLibraryRequestT& request) const {
    return SubmitCallable(&BedrockDataAutomationClient::UpdateDataAutomationLibrary, request);
  }
 
  template <typename UpdateDataAutomationLibraryRequestT = Model::UpdateDataAutomationLibraryRequest>
  void UpdateDataAutomationLibraryAsync(const UpdateDataAutomationLibraryRequestT& request,
                                        const UpdateDataAutomationLibraryResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockDataAutomationClient::UpdateDataAutomationLibrary, request, handler, context);
  }
 
  virtual Model::UpdateDataAutomationProjectOutcome UpdateDataAutomationProject(
      const Model::UpdateDataAutomationProjectRequest& request) const;
 
  template <typename UpdateDataAutomationProjectRequestT = Model::UpdateDataAutomationProjectRequest>
  Model::UpdateDataAutomationProjectOutcomeCallable UpdateDataAutomationProjectCallable(
      const UpdateDataAutomationProjectRequestT& request) const {
    return SubmitCallable(&BedrockDataAutomationClient::UpdateDataAutomationProject, request);
  }
 
  template <typename UpdateDataAutomationProjectRequestT = Model::UpdateDataAutomationProjectRequest>
  void UpdateDataAutomationProjectAsync(const UpdateDataAutomationProjectRequestT& request,
                                        const UpdateDataAutomationProjectResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockDataAutomationClient::UpdateDataAutomationProject, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<BedrockDataAutomationEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<BedrockDataAutomationClient>;
};
 
}  // namespace BedrockDataAutomation
}  // namespace Aws