BedrockRuntimeClient.h

 
#pragma once
#include <aws/bedrock-runtime/BedrockRuntimeErrorMarshaller.h>
#include <aws/bedrock-runtime/BedrockRuntimeServiceClientModel.h>
#include <aws/bedrock-runtime/BedrockRuntime_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/BearerTokenAuthScheme.h>
#include <smithy/identity/auth/built-in/GenericAuthSchemeResolver.h>
#include <smithy/identity/auth/built-in/SigV4AuthScheme.h>
 
namespace Aws {
namespace BedrockRuntime {
AWS_BEDROCKRUNTIME_API extern const char SERVICE_NAME[];
class AWS_BEDROCKRUNTIME_API BedrockRuntimeClient
    : Aws::Client::ClientWithAsyncTemplateMethods<BedrockRuntimeClient>,
      public smithy::client::AwsSmithyClientT<
          Aws::BedrockRuntime::SERVICE_NAME, Aws::BedrockRuntime::BedrockRuntimeClientConfiguration, smithy::AuthSchemeResolverBase<>,
          Aws::Crt::Variant<smithy::SigV4AuthScheme, smithy::BearerTokenAuthScheme>, BedrockRuntimeEndpointProviderBase,
          smithy::client::JsonOutcomeSerializer, smithy::client::JsonOutcome, Aws::Client::BedrockRuntimeErrorMarshaller> {
 public:
  static const char* GetServiceName();
  static const char* GetAllocationTag();
  inline const char* GetServiceClientName() const override { return "Bedrock Runtime"; }
 
  typedef BedrockRuntimeClientConfiguration ClientConfigurationType;
  typedef BedrockRuntimeEndpointProvider EndpointProviderType;
 
  BedrockRuntimeClient(
      const Aws::UnorderedMap<Aws::String, Aws::Crt::Variant<smithy::SigV4AuthScheme, smithy::BearerTokenAuthScheme>> authSchemeMap,
      std::shared_ptr<BedrockRuntimeEndpointProviderBase> endpointProvider = nullptr,
      const Aws::BedrockRuntime::BedrockRuntimeClientConfiguration& clientConfiguration =
          Aws::BedrockRuntime::BedrockRuntimeClientConfiguration());
  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>;
};
 
}  // namespace BedrockRuntime
}  // namespace Aws