BedrockDataAutomationClient.h

 
#pragma once
#include <aws/bedrock-data-automation/BedrockDataAutomation_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/bedrock-data-automation/BedrockDataAutomationServiceClientModel.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::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::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::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