BedrockDataAutomationClient.h

 
#pragma once
#include <aws/bedrock-data-automation/BedrockDataAutomationServiceClientModel.h>
#include <aws/bedrock-data-automation/BedrockDataAutomation_EXPORTS.h>
#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>
 
namespace Aws {
namespace BedrockDataAutomation {
class AWS_BEDROCKDATAAUTOMATION_API BedrockDataAutomationClient
    : public Aws::Client::AWSJsonClient,
      public Aws::Client::ClientWithAsyncTemplateMethods<BedrockDataAutomationClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  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::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::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::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::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::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::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);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<BedrockDataAutomationEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<BedrockDataAutomationClient>;
  void init(const BedrockDataAutomationClientConfiguration& clientConfiguration);
 
  BedrockDataAutomationClientConfiguration m_clientConfiguration;
  std::shared_ptr<BedrockDataAutomationEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace BedrockDataAutomation
}  // namespace Aws