BedrockRuntimeClient.h

 
#pragma once
#include <aws/bedrock-runtime/BedrockRuntime_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-runtime/BedrockRuntimeServiceClientModel.h>
 
namespace Aws
{
namespace BedrockRuntime
{
  class AWS_BEDROCKRUNTIME_API BedrockRuntimeClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<BedrockRuntimeClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef BedrockRuntimeClientConfiguration ClientConfigurationType;
      typedef BedrockRuntimeEndpointProvider EndpointProviderType;
 
        BedrockRuntimeClient(const Aws::BedrockRuntime::BedrockRuntimeClientConfiguration& clientConfiguration = Aws::BedrockRuntime::BedrockRuntimeClientConfiguration(),
                             std::shared_ptr<BedrockRuntimeEndpointProviderBase> endpointProvider = nullptr);
 
        BedrockRuntimeClient(const Aws::Auth::AWSCredentials& credentials,
                             std::shared_ptr<BedrockRuntimeEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::BedrockRuntime::BedrockRuntimeClientConfiguration& clientConfiguration = Aws::BedrockRuntime::BedrockRuntimeClientConfiguration());
 
        BedrockRuntimeClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             std::shared_ptr<BedrockRuntimeEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::BedrockRuntime::BedrockRuntimeClientConfiguration& clientConfiguration = Aws::BedrockRuntime::BedrockRuntimeClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        BedrockRuntimeClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        BedrockRuntimeClient(const Aws::Auth::AWSCredentials& credentials,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
        BedrockRuntimeClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~BedrockRuntimeClient();
 
        virtual Model::ApplyGuardrailOutcome ApplyGuardrail(const Model::ApplyGuardrailRequest& request) const;
 
        template<typename ApplyGuardrailRequestT = Model::ApplyGuardrailRequest>
        Model::ApplyGuardrailOutcomeCallable ApplyGuardrailCallable(const ApplyGuardrailRequestT& request) const
        {
            return SubmitCallable(&BedrockRuntimeClient::ApplyGuardrail, request);
        }
 
        template<typename ApplyGuardrailRequestT = Model::ApplyGuardrailRequest>
        void ApplyGuardrailAsync(const ApplyGuardrailRequestT& request, const ApplyGuardrailResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockRuntimeClient::ApplyGuardrail, request, handler, context);
        }
 
        virtual Model::ConverseOutcome Converse(const Model::ConverseRequest& request) const;
 
        template<typename ConverseRequestT = Model::ConverseRequest>
        Model::ConverseOutcomeCallable ConverseCallable(const ConverseRequestT& request) const
        {
            return SubmitCallable(&BedrockRuntimeClient::Converse, request);
        }
 
        template<typename ConverseRequestT = Model::ConverseRequest>
        void ConverseAsync(const ConverseRequestT& request, const ConverseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockRuntimeClient::Converse, request, handler, context);
        }
 
        virtual Model::ConverseStreamOutcome ConverseStream(Model::ConverseStreamRequest& request) const;
 
        template<typename ConverseStreamRequestT = Model::ConverseStreamRequest>
        Model::ConverseStreamOutcomeCallable ConverseStreamCallable(ConverseStreamRequestT& request) const
        {
            return SubmitCallable(&BedrockRuntimeClient::ConverseStream, request);
        }
 
        template<typename ConverseStreamRequestT = Model::ConverseStreamRequest>
        void ConverseStreamAsync(ConverseStreamRequestT& request, const ConverseStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockRuntimeClient::ConverseStream, request, handler, context);
        }
 
        virtual Model::CountTokensOutcome CountTokens(const Model::CountTokensRequest& request) const;
 
        template<typename CountTokensRequestT = Model::CountTokensRequest>
        Model::CountTokensOutcomeCallable CountTokensCallable(const CountTokensRequestT& request) const
        {
            return SubmitCallable(&BedrockRuntimeClient::CountTokens, request);
        }
 
        template<typename CountTokensRequestT = Model::CountTokensRequest>
        void CountTokensAsync(const CountTokensRequestT& request, const CountTokensResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockRuntimeClient::CountTokens, request, handler, context);
        }
 
        virtual Model::GetAsyncInvokeOutcome GetAsyncInvoke(const Model::GetAsyncInvokeRequest& request) const;
 
        template<typename GetAsyncInvokeRequestT = Model::GetAsyncInvokeRequest>
        Model::GetAsyncInvokeOutcomeCallable GetAsyncInvokeCallable(const GetAsyncInvokeRequestT& request) const
        {
            return SubmitCallable(&BedrockRuntimeClient::GetAsyncInvoke, request);
        }
 
        template<typename GetAsyncInvokeRequestT = Model::GetAsyncInvokeRequest>
        void GetAsyncInvokeAsync(const GetAsyncInvokeRequestT& request, const GetAsyncInvokeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockRuntimeClient::GetAsyncInvoke, request, handler, context);
        }
 
        virtual Model::InvokeModelOutcome InvokeModel(const Model::InvokeModelRequest& request) const;
 
        template<typename InvokeModelRequestT = Model::InvokeModelRequest>
        Model::InvokeModelOutcomeCallable InvokeModelCallable(const InvokeModelRequestT& request) const
        {
            return SubmitCallable(&BedrockRuntimeClient::InvokeModel, request);
        }
 
        template<typename InvokeModelRequestT = Model::InvokeModelRequest>
        void InvokeModelAsync(const InvokeModelRequestT& request, const InvokeModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockRuntimeClient::InvokeModel, request, handler, context);
        }
 
        virtual void InvokeModelWithBidirectionalStreamAsync(Model::InvokeModelWithBidirectionalStreamRequest& request,
                const InvokeModelWithBidirectionalStreamStreamReadyHandler& streamReadyHandler,
                const InvokeModelWithBidirectionalStreamResponseReceivedHandler& handler,
                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& handlerContext = nullptr) const;
 
        virtual Model::InvokeModelWithResponseStreamOutcome InvokeModelWithResponseStream(Model::InvokeModelWithResponseStreamRequest& request) const;
 
        template<typename InvokeModelWithResponseStreamRequestT = Model::InvokeModelWithResponseStreamRequest>
        Model::InvokeModelWithResponseStreamOutcomeCallable InvokeModelWithResponseStreamCallable(InvokeModelWithResponseStreamRequestT& request) const
        {
            return SubmitCallable(&BedrockRuntimeClient::InvokeModelWithResponseStream, request);
        }
 
        template<typename InvokeModelWithResponseStreamRequestT = Model::InvokeModelWithResponseStreamRequest>
        void InvokeModelWithResponseStreamAsync(InvokeModelWithResponseStreamRequestT& request, const InvokeModelWithResponseStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockRuntimeClient::InvokeModelWithResponseStream, request, handler, context);
        }
 
        virtual Model::ListAsyncInvokesOutcome ListAsyncInvokes(const Model::ListAsyncInvokesRequest& request = {}) const;
 
        template<typename ListAsyncInvokesRequestT = Model::ListAsyncInvokesRequest>
        Model::ListAsyncInvokesOutcomeCallable ListAsyncInvokesCallable(const ListAsyncInvokesRequestT& request = {}) const
        {
            return SubmitCallable(&BedrockRuntimeClient::ListAsyncInvokes, request);
        }
 
        template<typename ListAsyncInvokesRequestT = Model::ListAsyncInvokesRequest>
        void ListAsyncInvokesAsync(const ListAsyncInvokesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAsyncInvokesRequestT& request = {}) const
        {
            return SubmitAsync(&BedrockRuntimeClient::ListAsyncInvokes, request, handler, context);
        }
 
        virtual Model::StartAsyncInvokeOutcome StartAsyncInvoke(const Model::StartAsyncInvokeRequest& request) const;
 
        template<typename StartAsyncInvokeRequestT = Model::StartAsyncInvokeRequest>
        Model::StartAsyncInvokeOutcomeCallable StartAsyncInvokeCallable(const StartAsyncInvokeRequestT& request) const
        {
            return SubmitCallable(&BedrockRuntimeClient::StartAsyncInvoke, request);
        }
 
        template<typename StartAsyncInvokeRequestT = Model::StartAsyncInvokeRequest>
        void StartAsyncInvokeAsync(const StartAsyncInvokeRequestT& request, const StartAsyncInvokeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockRuntimeClient::StartAsyncInvoke, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<BedrockRuntimeEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<BedrockRuntimeClient>;
      void init(const BedrockRuntimeClientConfiguration& clientConfiguration);
 
      BedrockRuntimeClientConfiguration m_clientConfiguration;
      std::shared_ptr<BedrockRuntimeEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace BedrockRuntime
} // namespace Aws