RedshiftServerlessClient.h

 
#pragma once
#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>
#include <aws/redshift-serverless/RedshiftServerlessServiceClientModel.h>
#include <aws/redshift-serverless/RedshiftServerless_EXPORTS.h>
 
namespace Aws {
namespace RedshiftServerless {
class AWS_REDSHIFTSERVERLESS_API RedshiftServerlessClient : public Aws::Client::AWSJsonClient,
                                                            public Aws::Client::ClientWithAsyncTemplateMethods<RedshiftServerlessClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef RedshiftServerlessClientConfiguration ClientConfigurationType;
  typedef RedshiftServerlessEndpointProvider EndpointProviderType;
 
  RedshiftServerlessClient(const Aws::RedshiftServerless::RedshiftServerlessClientConfiguration& clientConfiguration =
                               Aws::RedshiftServerless::RedshiftServerlessClientConfiguration(),
                           std::shared_ptr<RedshiftServerlessEndpointProviderBase> endpointProvider = nullptr);
 
  RedshiftServerlessClient(const Aws::Auth::AWSCredentials& credentials,
                           std::shared_ptr<RedshiftServerlessEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::RedshiftServerless::RedshiftServerlessClientConfiguration& clientConfiguration =
                               Aws::RedshiftServerless::RedshiftServerlessClientConfiguration());
 
  RedshiftServerlessClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           std::shared_ptr<RedshiftServerlessEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::RedshiftServerless::RedshiftServerlessClientConfiguration& clientConfiguration =
                               Aws::RedshiftServerless::RedshiftServerlessClientConfiguration());
 
  /* Legacy constructors due deprecation */
  RedshiftServerlessClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  RedshiftServerlessClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  RedshiftServerlessClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~RedshiftServerlessClient();
 
  virtual Model::ConvertRecoveryPointToSnapshotOutcome ConvertRecoveryPointToSnapshot(
      const Model::ConvertRecoveryPointToSnapshotRequest& request) const;
 
  template <typename ConvertRecoveryPointToSnapshotRequestT = Model::ConvertRecoveryPointToSnapshotRequest>
  Model::ConvertRecoveryPointToSnapshotOutcomeCallable ConvertRecoveryPointToSnapshotCallable(
      const ConvertRecoveryPointToSnapshotRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::ConvertRecoveryPointToSnapshot, request);
  }
 
  template <typename ConvertRecoveryPointToSnapshotRequestT = Model::ConvertRecoveryPointToSnapshotRequest>
  void ConvertRecoveryPointToSnapshotAsync(const ConvertRecoveryPointToSnapshotRequestT& request,
                                           const ConvertRecoveryPointToSnapshotResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::ConvertRecoveryPointToSnapshot, request, handler, context);
  }
 
  virtual Model::CreateCustomDomainAssociationOutcome CreateCustomDomainAssociation(
      const Model::CreateCustomDomainAssociationRequest& request) const;
 
  template <typename CreateCustomDomainAssociationRequestT = Model::CreateCustomDomainAssociationRequest>
  Model::CreateCustomDomainAssociationOutcomeCallable CreateCustomDomainAssociationCallable(
      const CreateCustomDomainAssociationRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::CreateCustomDomainAssociation, request);
  }
 
  template <typename CreateCustomDomainAssociationRequestT = Model::CreateCustomDomainAssociationRequest>
  void CreateCustomDomainAssociationAsync(const CreateCustomDomainAssociationRequestT& request,
                                          const CreateCustomDomainAssociationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::CreateCustomDomainAssociation, request, handler, context);
  }
 
  virtual Model::CreateEndpointAccessOutcome CreateEndpointAccess(const Model::CreateEndpointAccessRequest& request) const;
 
  template <typename CreateEndpointAccessRequestT = Model::CreateEndpointAccessRequest>
  Model::CreateEndpointAccessOutcomeCallable CreateEndpointAccessCallable(const CreateEndpointAccessRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::CreateEndpointAccess, request);
  }
 
  template <typename CreateEndpointAccessRequestT = Model::CreateEndpointAccessRequest>
  void CreateEndpointAccessAsync(const CreateEndpointAccessRequestT& request, const CreateEndpointAccessResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::CreateEndpointAccess, request, handler, context);
  }
 
  virtual Model::CreateNamespaceOutcome CreateNamespace(const Model::CreateNamespaceRequest& request) const;
 
  template <typename CreateNamespaceRequestT = Model::CreateNamespaceRequest>
  Model::CreateNamespaceOutcomeCallable CreateNamespaceCallable(const CreateNamespaceRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::CreateNamespace, request);
  }
 
  template <typename CreateNamespaceRequestT = Model::CreateNamespaceRequest>
  void CreateNamespaceAsync(const CreateNamespaceRequestT& request, const CreateNamespaceResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::CreateNamespace, request, handler, context);
  }
 
  virtual Model::CreateReservationOutcome CreateReservation(const Model::CreateReservationRequest& request) const;
 
  template <typename CreateReservationRequestT = Model::CreateReservationRequest>
  Model::CreateReservationOutcomeCallable CreateReservationCallable(const CreateReservationRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::CreateReservation, request);
  }
 
  template <typename CreateReservationRequestT = Model::CreateReservationRequest>
  void CreateReservationAsync(const CreateReservationRequestT& request, const CreateReservationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::CreateReservation, request, handler, context);
  }
 
  virtual Model::CreateScheduledActionOutcome CreateScheduledAction(const Model::CreateScheduledActionRequest& request) const;
 
  template <typename CreateScheduledActionRequestT = Model::CreateScheduledActionRequest>
  Model::CreateScheduledActionOutcomeCallable CreateScheduledActionCallable(const CreateScheduledActionRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::CreateScheduledAction, request);
  }
 
  template <typename CreateScheduledActionRequestT = Model::CreateScheduledActionRequest>
  void CreateScheduledActionAsync(const CreateScheduledActionRequestT& request, const CreateScheduledActionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::CreateScheduledAction, request, handler, context);
  }
 
  virtual Model::CreateSnapshotOutcome CreateSnapshot(const Model::CreateSnapshotRequest& request) const;
 
  template <typename CreateSnapshotRequestT = Model::CreateSnapshotRequest>
  Model::CreateSnapshotOutcomeCallable CreateSnapshotCallable(const CreateSnapshotRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::CreateSnapshot, request);
  }
 
  template <typename CreateSnapshotRequestT = Model::CreateSnapshotRequest>
  void CreateSnapshotAsync(const CreateSnapshotRequestT& request, const CreateSnapshotResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::CreateSnapshot, request, handler, context);
  }
 
  virtual Model::CreateSnapshotCopyConfigurationOutcome CreateSnapshotCopyConfiguration(
      const Model::CreateSnapshotCopyConfigurationRequest& request) const;
 
  template <typename CreateSnapshotCopyConfigurationRequestT = Model::CreateSnapshotCopyConfigurationRequest>
  Model::CreateSnapshotCopyConfigurationOutcomeCallable CreateSnapshotCopyConfigurationCallable(
      const CreateSnapshotCopyConfigurationRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::CreateSnapshotCopyConfiguration, request);
  }
 
  template <typename CreateSnapshotCopyConfigurationRequestT = Model::CreateSnapshotCopyConfigurationRequest>
  void CreateSnapshotCopyConfigurationAsync(const CreateSnapshotCopyConfigurationRequestT& request,
                                            const CreateSnapshotCopyConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::CreateSnapshotCopyConfiguration, request, handler, context);
  }
 
  virtual Model::CreateUsageLimitOutcome CreateUsageLimit(const Model::CreateUsageLimitRequest& request) const;
 
  template <typename CreateUsageLimitRequestT = Model::CreateUsageLimitRequest>
  Model::CreateUsageLimitOutcomeCallable CreateUsageLimitCallable(const CreateUsageLimitRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::CreateUsageLimit, request);
  }
 
  template <typename CreateUsageLimitRequestT = Model::CreateUsageLimitRequest>
  void CreateUsageLimitAsync(const CreateUsageLimitRequestT& request, const CreateUsageLimitResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::CreateUsageLimit, request, handler, context);
  }
 
  virtual Model::CreateWorkgroupOutcome CreateWorkgroup(const Model::CreateWorkgroupRequest& request) const;
 
  template <typename CreateWorkgroupRequestT = Model::CreateWorkgroupRequest>
  Model::CreateWorkgroupOutcomeCallable CreateWorkgroupCallable(const CreateWorkgroupRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::CreateWorkgroup, request);
  }
 
  template <typename CreateWorkgroupRequestT = Model::CreateWorkgroupRequest>
  void CreateWorkgroupAsync(const CreateWorkgroupRequestT& request, const CreateWorkgroupResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::CreateWorkgroup, request, handler, context);
  }
 
  virtual Model::DeleteCustomDomainAssociationOutcome DeleteCustomDomainAssociation(
      const Model::DeleteCustomDomainAssociationRequest& request) const;
 
  template <typename DeleteCustomDomainAssociationRequestT = Model::DeleteCustomDomainAssociationRequest>
  Model::DeleteCustomDomainAssociationOutcomeCallable DeleteCustomDomainAssociationCallable(
      const DeleteCustomDomainAssociationRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::DeleteCustomDomainAssociation, request);
  }
 
  template <typename DeleteCustomDomainAssociationRequestT = Model::DeleteCustomDomainAssociationRequest>
  void DeleteCustomDomainAssociationAsync(const DeleteCustomDomainAssociationRequestT& request,
                                          const DeleteCustomDomainAssociationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::DeleteCustomDomainAssociation, request, handler, context);
  }
 
  virtual Model::DeleteEndpointAccessOutcome DeleteEndpointAccess(const Model::DeleteEndpointAccessRequest& request) const;
 
  template <typename DeleteEndpointAccessRequestT = Model::DeleteEndpointAccessRequest>
  Model::DeleteEndpointAccessOutcomeCallable DeleteEndpointAccessCallable(const DeleteEndpointAccessRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::DeleteEndpointAccess, request);
  }
 
  template <typename DeleteEndpointAccessRequestT = Model::DeleteEndpointAccessRequest>
  void DeleteEndpointAccessAsync(const DeleteEndpointAccessRequestT& request, const DeleteEndpointAccessResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::DeleteEndpointAccess, request, handler, context);
  }
 
  virtual Model::DeleteNamespaceOutcome DeleteNamespace(const Model::DeleteNamespaceRequest& request) const;
 
  template <typename DeleteNamespaceRequestT = Model::DeleteNamespaceRequest>
  Model::DeleteNamespaceOutcomeCallable DeleteNamespaceCallable(const DeleteNamespaceRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::DeleteNamespace, request);
  }
 
  template <typename DeleteNamespaceRequestT = Model::DeleteNamespaceRequest>
  void DeleteNamespaceAsync(const DeleteNamespaceRequestT& request, const DeleteNamespaceResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::DeleteNamespace, request, handler, context);
  }
 
  virtual Model::DeleteResourcePolicyOutcome DeleteResourcePolicy(const Model::DeleteResourcePolicyRequest& request) const;
 
  template <typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
  Model::DeleteResourcePolicyOutcomeCallable DeleteResourcePolicyCallable(const DeleteResourcePolicyRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::DeleteResourcePolicy, request);
  }
 
  template <typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
  void DeleteResourcePolicyAsync(const DeleteResourcePolicyRequestT& request, const DeleteResourcePolicyResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::DeleteResourcePolicy, request, handler, context);
  }
 
  virtual Model::DeleteScheduledActionOutcome DeleteScheduledAction(const Model::DeleteScheduledActionRequest& request) const;
 
  template <typename DeleteScheduledActionRequestT = Model::DeleteScheduledActionRequest>
  Model::DeleteScheduledActionOutcomeCallable DeleteScheduledActionCallable(const DeleteScheduledActionRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::DeleteScheduledAction, request);
  }
 
  template <typename DeleteScheduledActionRequestT = Model::DeleteScheduledActionRequest>
  void DeleteScheduledActionAsync(const DeleteScheduledActionRequestT& request, const DeleteScheduledActionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::DeleteScheduledAction, request, handler, context);
  }
 
  virtual Model::DeleteSnapshotOutcome DeleteSnapshot(const Model::DeleteSnapshotRequest& request) const;
 
  template <typename DeleteSnapshotRequestT = Model::DeleteSnapshotRequest>
  Model::DeleteSnapshotOutcomeCallable DeleteSnapshotCallable(const DeleteSnapshotRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::DeleteSnapshot, request);
  }
 
  template <typename DeleteSnapshotRequestT = Model::DeleteSnapshotRequest>
  void DeleteSnapshotAsync(const DeleteSnapshotRequestT& request, const DeleteSnapshotResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::DeleteSnapshot, request, handler, context);
  }
 
  virtual Model::DeleteSnapshotCopyConfigurationOutcome DeleteSnapshotCopyConfiguration(
      const Model::DeleteSnapshotCopyConfigurationRequest& request) const;
 
  template <typename DeleteSnapshotCopyConfigurationRequestT = Model::DeleteSnapshotCopyConfigurationRequest>
  Model::DeleteSnapshotCopyConfigurationOutcomeCallable DeleteSnapshotCopyConfigurationCallable(
      const DeleteSnapshotCopyConfigurationRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::DeleteSnapshotCopyConfiguration, request);
  }
 
  template <typename DeleteSnapshotCopyConfigurationRequestT = Model::DeleteSnapshotCopyConfigurationRequest>
  void DeleteSnapshotCopyConfigurationAsync(const DeleteSnapshotCopyConfigurationRequestT& request,
                                            const DeleteSnapshotCopyConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::DeleteSnapshotCopyConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteUsageLimitOutcome DeleteUsageLimit(const Model::DeleteUsageLimitRequest& request) const;
 
  template <typename DeleteUsageLimitRequestT = Model::DeleteUsageLimitRequest>
  Model::DeleteUsageLimitOutcomeCallable DeleteUsageLimitCallable(const DeleteUsageLimitRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::DeleteUsageLimit, request);
  }
 
  template <typename DeleteUsageLimitRequestT = Model::DeleteUsageLimitRequest>
  void DeleteUsageLimitAsync(const DeleteUsageLimitRequestT& request, const DeleteUsageLimitResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::DeleteUsageLimit, request, handler, context);
  }
 
  virtual Model::DeleteWorkgroupOutcome DeleteWorkgroup(const Model::DeleteWorkgroupRequest& request) const;
 
  template <typename DeleteWorkgroupRequestT = Model::DeleteWorkgroupRequest>
  Model::DeleteWorkgroupOutcomeCallable DeleteWorkgroupCallable(const DeleteWorkgroupRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::DeleteWorkgroup, request);
  }
 
  template <typename DeleteWorkgroupRequestT = Model::DeleteWorkgroupRequest>
  void DeleteWorkgroupAsync(const DeleteWorkgroupRequestT& request, const DeleteWorkgroupResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::DeleteWorkgroup, request, handler, context);
  }
 
  virtual Model::GetCredentialsOutcome GetCredentials(const Model::GetCredentialsRequest& request = {}) const;
 
  template <typename GetCredentialsRequestT = Model::GetCredentialsRequest>
  Model::GetCredentialsOutcomeCallable GetCredentialsCallable(const GetCredentialsRequestT& request = {}) const {
    return SubmitCallable(&RedshiftServerlessClient::GetCredentials, request);
  }
 
  template <typename GetCredentialsRequestT = Model::GetCredentialsRequest>
  void GetCredentialsAsync(const GetCredentialsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const GetCredentialsRequestT& request = {}) const {
    return SubmitAsync(&RedshiftServerlessClient::GetCredentials, request, handler, context);
  }
 
  virtual Model::GetCustomDomainAssociationOutcome GetCustomDomainAssociation(
      const Model::GetCustomDomainAssociationRequest& request) const;
 
  template <typename GetCustomDomainAssociationRequestT = Model::GetCustomDomainAssociationRequest>
  Model::GetCustomDomainAssociationOutcomeCallable GetCustomDomainAssociationCallable(
      const GetCustomDomainAssociationRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::GetCustomDomainAssociation, request);
  }
 
  template <typename GetCustomDomainAssociationRequestT = Model::GetCustomDomainAssociationRequest>
  void GetCustomDomainAssociationAsync(const GetCustomDomainAssociationRequestT& request,
                                       const GetCustomDomainAssociationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::GetCustomDomainAssociation, request, handler, context);
  }
 
  virtual Model::GetEndpointAccessOutcome GetEndpointAccess(const Model::GetEndpointAccessRequest& request) const;
 
  template <typename GetEndpointAccessRequestT = Model::GetEndpointAccessRequest>
  Model::GetEndpointAccessOutcomeCallable GetEndpointAccessCallable(const GetEndpointAccessRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::GetEndpointAccess, request);
  }
 
  template <typename GetEndpointAccessRequestT = Model::GetEndpointAccessRequest>
  void GetEndpointAccessAsync(const GetEndpointAccessRequestT& request, const GetEndpointAccessResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::GetEndpointAccess, request, handler, context);
  }
 
  virtual Model::GetIdentityCenterAuthTokenOutcome GetIdentityCenterAuthToken(
      const Model::GetIdentityCenterAuthTokenRequest& request) const;
 
  template <typename GetIdentityCenterAuthTokenRequestT = Model::GetIdentityCenterAuthTokenRequest>
  Model::GetIdentityCenterAuthTokenOutcomeCallable GetIdentityCenterAuthTokenCallable(
      const GetIdentityCenterAuthTokenRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::GetIdentityCenterAuthToken, request);
  }
 
  template <typename GetIdentityCenterAuthTokenRequestT = Model::GetIdentityCenterAuthTokenRequest>
  void GetIdentityCenterAuthTokenAsync(const GetIdentityCenterAuthTokenRequestT& request,
                                       const GetIdentityCenterAuthTokenResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::GetIdentityCenterAuthToken, request, handler, context);
  }
 
  virtual Model::GetNamespaceOutcome GetNamespace(const Model::GetNamespaceRequest& request) const;
 
  template <typename GetNamespaceRequestT = Model::GetNamespaceRequest>
  Model::GetNamespaceOutcomeCallable GetNamespaceCallable(const GetNamespaceRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::GetNamespace, request);
  }
 
  template <typename GetNamespaceRequestT = Model::GetNamespaceRequest>
  void GetNamespaceAsync(const GetNamespaceRequestT& request, const GetNamespaceResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::GetNamespace, request, handler, context);
  }
 
  virtual Model::GetRecoveryPointOutcome GetRecoveryPoint(const Model::GetRecoveryPointRequest& request) const;
 
  template <typename GetRecoveryPointRequestT = Model::GetRecoveryPointRequest>
  Model::GetRecoveryPointOutcomeCallable GetRecoveryPointCallable(const GetRecoveryPointRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::GetRecoveryPoint, request);
  }
 
  template <typename GetRecoveryPointRequestT = Model::GetRecoveryPointRequest>
  void GetRecoveryPointAsync(const GetRecoveryPointRequestT& request, const GetRecoveryPointResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::GetRecoveryPoint, request, handler, context);
  }
 
  virtual Model::GetReservationOutcome GetReservation(const Model::GetReservationRequest& request) const;
 
  template <typename GetReservationRequestT = Model::GetReservationRequest>
  Model::GetReservationOutcomeCallable GetReservationCallable(const GetReservationRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::GetReservation, request);
  }
 
  template <typename GetReservationRequestT = Model::GetReservationRequest>
  void GetReservationAsync(const GetReservationRequestT& request, const GetReservationResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::GetReservation, request, handler, context);
  }
 
  virtual Model::GetReservationOfferingOutcome GetReservationOffering(const Model::GetReservationOfferingRequest& request) const;
 
  template <typename GetReservationOfferingRequestT = Model::GetReservationOfferingRequest>
  Model::GetReservationOfferingOutcomeCallable GetReservationOfferingCallable(const GetReservationOfferingRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::GetReservationOffering, request);
  }
 
  template <typename GetReservationOfferingRequestT = Model::GetReservationOfferingRequest>
  void GetReservationOfferingAsync(const GetReservationOfferingRequestT& request,
                                   const GetReservationOfferingResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::GetReservationOffering, request, handler, context);
  }
 
  virtual Model::GetResourcePolicyOutcome GetResourcePolicy(const Model::GetResourcePolicyRequest& request) const;
 
  template <typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
  Model::GetResourcePolicyOutcomeCallable GetResourcePolicyCallable(const GetResourcePolicyRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::GetResourcePolicy, request);
  }
 
  template <typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
  void GetResourcePolicyAsync(const GetResourcePolicyRequestT& request, const GetResourcePolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::GetResourcePolicy, request, handler, context);
  }
 
  virtual Model::GetScheduledActionOutcome GetScheduledAction(const Model::GetScheduledActionRequest& request) const;
 
  template <typename GetScheduledActionRequestT = Model::GetScheduledActionRequest>
  Model::GetScheduledActionOutcomeCallable GetScheduledActionCallable(const GetScheduledActionRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::GetScheduledAction, request);
  }
 
  template <typename GetScheduledActionRequestT = Model::GetScheduledActionRequest>
  void GetScheduledActionAsync(const GetScheduledActionRequestT& request, const GetScheduledActionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::GetScheduledAction, request, handler, context);
  }
 
  virtual Model::GetSnapshotOutcome GetSnapshot(const Model::GetSnapshotRequest& request = {}) const;
 
  template <typename GetSnapshotRequestT = Model::GetSnapshotRequest>
  Model::GetSnapshotOutcomeCallable GetSnapshotCallable(const GetSnapshotRequestT& request = {}) const {
    return SubmitCallable(&RedshiftServerlessClient::GetSnapshot, request);
  }
 
  template <typename GetSnapshotRequestT = Model::GetSnapshotRequest>
  void GetSnapshotAsync(const GetSnapshotResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const GetSnapshotRequestT& request = {}) const {
    return SubmitAsync(&RedshiftServerlessClient::GetSnapshot, request, handler, context);
  }
 
  virtual Model::GetTableRestoreStatusOutcome GetTableRestoreStatus(const Model::GetTableRestoreStatusRequest& request) const;
 
  template <typename GetTableRestoreStatusRequestT = Model::GetTableRestoreStatusRequest>
  Model::GetTableRestoreStatusOutcomeCallable GetTableRestoreStatusCallable(const GetTableRestoreStatusRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::GetTableRestoreStatus, request);
  }
 
  template <typename GetTableRestoreStatusRequestT = Model::GetTableRestoreStatusRequest>
  void GetTableRestoreStatusAsync(const GetTableRestoreStatusRequestT& request, const GetTableRestoreStatusResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::GetTableRestoreStatus, request, handler, context);
  }
 
  virtual Model::GetTrackOutcome GetTrack(const Model::GetTrackRequest& request) const;
 
  template <typename GetTrackRequestT = Model::GetTrackRequest>
  Model::GetTrackOutcomeCallable GetTrackCallable(const GetTrackRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::GetTrack, request);
  }
 
  template <typename GetTrackRequestT = Model::GetTrackRequest>
  void GetTrackAsync(const GetTrackRequestT& request, const GetTrackResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::GetTrack, request, handler, context);
  }
 
  virtual Model::GetUsageLimitOutcome GetUsageLimit(const Model::GetUsageLimitRequest& request) const;
 
  template <typename GetUsageLimitRequestT = Model::GetUsageLimitRequest>
  Model::GetUsageLimitOutcomeCallable GetUsageLimitCallable(const GetUsageLimitRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::GetUsageLimit, request);
  }
 
  template <typename GetUsageLimitRequestT = Model::GetUsageLimitRequest>
  void GetUsageLimitAsync(const GetUsageLimitRequestT& request, const GetUsageLimitResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::GetUsageLimit, request, handler, context);
  }
 
  virtual Model::GetWorkgroupOutcome GetWorkgroup(const Model::GetWorkgroupRequest& request) const;
 
  template <typename GetWorkgroupRequestT = Model::GetWorkgroupRequest>
  Model::GetWorkgroupOutcomeCallable GetWorkgroupCallable(const GetWorkgroupRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::GetWorkgroup, request);
  }
 
  template <typename GetWorkgroupRequestT = Model::GetWorkgroupRequest>
  void GetWorkgroupAsync(const GetWorkgroupRequestT& request, const GetWorkgroupResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::GetWorkgroup, request, handler, context);
  }
 
  virtual Model::ListCustomDomainAssociationsOutcome ListCustomDomainAssociations(
      const Model::ListCustomDomainAssociationsRequest& request = {}) const;
 
  template <typename ListCustomDomainAssociationsRequestT = Model::ListCustomDomainAssociationsRequest>
  Model::ListCustomDomainAssociationsOutcomeCallable ListCustomDomainAssociationsCallable(
      const ListCustomDomainAssociationsRequestT& request = {}) const {
    return SubmitCallable(&RedshiftServerlessClient::ListCustomDomainAssociations, request);
  }
 
  template <typename ListCustomDomainAssociationsRequestT = Model::ListCustomDomainAssociationsRequest>
  void ListCustomDomainAssociationsAsync(const ListCustomDomainAssociationsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const ListCustomDomainAssociationsRequestT& request = {}) const {
    return SubmitAsync(&RedshiftServerlessClient::ListCustomDomainAssociations, request, handler, context);
  }
 
  virtual Model::ListEndpointAccessOutcome ListEndpointAccess(const Model::ListEndpointAccessRequest& request = {}) const;
 
  template <typename ListEndpointAccessRequestT = Model::ListEndpointAccessRequest>
  Model::ListEndpointAccessOutcomeCallable ListEndpointAccessCallable(const ListEndpointAccessRequestT& request = {}) const {
    return SubmitCallable(&RedshiftServerlessClient::ListEndpointAccess, request);
  }
 
  template <typename ListEndpointAccessRequestT = Model::ListEndpointAccessRequest>
  void ListEndpointAccessAsync(const ListEndpointAccessResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListEndpointAccessRequestT& request = {}) const {
    return SubmitAsync(&RedshiftServerlessClient::ListEndpointAccess, request, handler, context);
  }
 
  virtual Model::ListManagedWorkgroupsOutcome ListManagedWorkgroups(const Model::ListManagedWorkgroupsRequest& request = {}) const;
 
  template <typename ListManagedWorkgroupsRequestT = Model::ListManagedWorkgroupsRequest>
  Model::ListManagedWorkgroupsOutcomeCallable ListManagedWorkgroupsCallable(const ListManagedWorkgroupsRequestT& request = {}) const {
    return SubmitCallable(&RedshiftServerlessClient::ListManagedWorkgroups, request);
  }
 
  template <typename ListManagedWorkgroupsRequestT = Model::ListManagedWorkgroupsRequest>
  void ListManagedWorkgroupsAsync(const ListManagedWorkgroupsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const ListManagedWorkgroupsRequestT& request = {}) const {
    return SubmitAsync(&RedshiftServerlessClient::ListManagedWorkgroups, request, handler, context);
  }
 
  virtual Model::ListNamespacesOutcome ListNamespaces(const Model::ListNamespacesRequest& request = {}) const;
 
  template <typename ListNamespacesRequestT = Model::ListNamespacesRequest>
  Model::ListNamespacesOutcomeCallable ListNamespacesCallable(const ListNamespacesRequestT& request = {}) const {
    return SubmitCallable(&RedshiftServerlessClient::ListNamespaces, request);
  }
 
  template <typename ListNamespacesRequestT = Model::ListNamespacesRequest>
  void ListNamespacesAsync(const ListNamespacesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListNamespacesRequestT& request = {}) const {
    return SubmitAsync(&RedshiftServerlessClient::ListNamespaces, request, handler, context);
  }
 
  virtual Model::ListRecoveryPointsOutcome ListRecoveryPoints(const Model::ListRecoveryPointsRequest& request = {}) const;
 
  template <typename ListRecoveryPointsRequestT = Model::ListRecoveryPointsRequest>
  Model::ListRecoveryPointsOutcomeCallable ListRecoveryPointsCallable(const ListRecoveryPointsRequestT& request = {}) const {
    return SubmitCallable(&RedshiftServerlessClient::ListRecoveryPoints, request);
  }
 
  template <typename ListRecoveryPointsRequestT = Model::ListRecoveryPointsRequest>
  void ListRecoveryPointsAsync(const ListRecoveryPointsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListRecoveryPointsRequestT& request = {}) const {
    return SubmitAsync(&RedshiftServerlessClient::ListRecoveryPoints, request, handler, context);
  }
 
  virtual Model::ListReservationOfferingsOutcome ListReservationOfferings(const Model::ListReservationOfferingsRequest& request = {}) const;
 
  template <typename ListReservationOfferingsRequestT = Model::ListReservationOfferingsRequest>
  Model::ListReservationOfferingsOutcomeCallable ListReservationOfferingsCallable(
      const ListReservationOfferingsRequestT& request = {}) const {
    return SubmitCallable(&RedshiftServerlessClient::ListReservationOfferings, request);
  }
 
  template <typename ListReservationOfferingsRequestT = Model::ListReservationOfferingsRequest>
  void ListReservationOfferingsAsync(const ListReservationOfferingsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListReservationOfferingsRequestT& request = {}) const {
    return SubmitAsync(&RedshiftServerlessClient::ListReservationOfferings, request, handler, context);
  }
 
  virtual Model::ListReservationsOutcome ListReservations(const Model::ListReservationsRequest& request = {}) const;
 
  template <typename ListReservationsRequestT = Model::ListReservationsRequest>
  Model::ListReservationsOutcomeCallable ListReservationsCallable(const ListReservationsRequestT& request = {}) const {
    return SubmitCallable(&RedshiftServerlessClient::ListReservations, request);
  }
 
  template <typename ListReservationsRequestT = Model::ListReservationsRequest>
  void ListReservationsAsync(const ListReservationsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListReservationsRequestT& request = {}) const {
    return SubmitAsync(&RedshiftServerlessClient::ListReservations, request, handler, context);
  }
 
  virtual Model::ListScheduledActionsOutcome ListScheduledActions(const Model::ListScheduledActionsRequest& request = {}) const;
 
  template <typename ListScheduledActionsRequestT = Model::ListScheduledActionsRequest>
  Model::ListScheduledActionsOutcomeCallable ListScheduledActionsCallable(const ListScheduledActionsRequestT& request = {}) const {
    return SubmitCallable(&RedshiftServerlessClient::ListScheduledActions, request);
  }
 
  template <typename ListScheduledActionsRequestT = Model::ListScheduledActionsRequest>
  void ListScheduledActionsAsync(const ListScheduledActionsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListScheduledActionsRequestT& request = {}) const {
    return SubmitAsync(&RedshiftServerlessClient::ListScheduledActions, request, handler, context);
  }
 
  virtual Model::ListSnapshotCopyConfigurationsOutcome ListSnapshotCopyConfigurations(
      const Model::ListSnapshotCopyConfigurationsRequest& request = {}) const;
 
  template <typename ListSnapshotCopyConfigurationsRequestT = Model::ListSnapshotCopyConfigurationsRequest>
  Model::ListSnapshotCopyConfigurationsOutcomeCallable ListSnapshotCopyConfigurationsCallable(
      const ListSnapshotCopyConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&RedshiftServerlessClient::ListSnapshotCopyConfigurations, request);
  }
 
  template <typename ListSnapshotCopyConfigurationsRequestT = Model::ListSnapshotCopyConfigurationsRequest>
  void ListSnapshotCopyConfigurationsAsync(const ListSnapshotCopyConfigurationsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const ListSnapshotCopyConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&RedshiftServerlessClient::ListSnapshotCopyConfigurations, request, handler, context);
  }
 
  virtual Model::ListSnapshotsOutcome ListSnapshots(const Model::ListSnapshotsRequest& request = {}) const;
 
  template <typename ListSnapshotsRequestT = Model::ListSnapshotsRequest>
  Model::ListSnapshotsOutcomeCallable ListSnapshotsCallable(const ListSnapshotsRequestT& request = {}) const {
    return SubmitCallable(&RedshiftServerlessClient::ListSnapshots, request);
  }
 
  template <typename ListSnapshotsRequestT = Model::ListSnapshotsRequest>
  void ListSnapshotsAsync(const ListSnapshotsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const ListSnapshotsRequestT& request = {}) const {
    return SubmitAsync(&RedshiftServerlessClient::ListSnapshots, request, handler, context);
  }
 
  virtual Model::ListTableRestoreStatusOutcome ListTableRestoreStatus(const Model::ListTableRestoreStatusRequest& request = {}) const;
 
  template <typename ListTableRestoreStatusRequestT = Model::ListTableRestoreStatusRequest>
  Model::ListTableRestoreStatusOutcomeCallable ListTableRestoreStatusCallable(const ListTableRestoreStatusRequestT& request = {}) const {
    return SubmitCallable(&RedshiftServerlessClient::ListTableRestoreStatus, request);
  }
 
  template <typename ListTableRestoreStatusRequestT = Model::ListTableRestoreStatusRequest>
  void ListTableRestoreStatusAsync(const ListTableRestoreStatusResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListTableRestoreStatusRequestT& request = {}) const {
    return SubmitAsync(&RedshiftServerlessClient::ListTableRestoreStatus, 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(&RedshiftServerlessClient::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(&RedshiftServerlessClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTracksOutcome ListTracks(const Model::ListTracksRequest& request = {}) const;
 
  template <typename ListTracksRequestT = Model::ListTracksRequest>
  Model::ListTracksOutcomeCallable ListTracksCallable(const ListTracksRequestT& request = {}) const {
    return SubmitCallable(&RedshiftServerlessClient::ListTracks, request);
  }
 
  template <typename ListTracksRequestT = Model::ListTracksRequest>
  void ListTracksAsync(const ListTracksResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const ListTracksRequestT& request = {}) const {
    return SubmitAsync(&RedshiftServerlessClient::ListTracks, request, handler, context);
  }
 
  virtual Model::ListUsageLimitsOutcome ListUsageLimits(const Model::ListUsageLimitsRequest& request = {}) const;
 
  template <typename ListUsageLimitsRequestT = Model::ListUsageLimitsRequest>
  Model::ListUsageLimitsOutcomeCallable ListUsageLimitsCallable(const ListUsageLimitsRequestT& request = {}) const {
    return SubmitCallable(&RedshiftServerlessClient::ListUsageLimits, request);
  }
 
  template <typename ListUsageLimitsRequestT = Model::ListUsageLimitsRequest>
  void ListUsageLimitsAsync(const ListUsageLimitsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const ListUsageLimitsRequestT& request = {}) const {
    return SubmitAsync(&RedshiftServerlessClient::ListUsageLimits, request, handler, context);
  }
 
  virtual Model::ListWorkgroupsOutcome ListWorkgroups(const Model::ListWorkgroupsRequest& request = {}) const;
 
  template <typename ListWorkgroupsRequestT = Model::ListWorkgroupsRequest>
  Model::ListWorkgroupsOutcomeCallable ListWorkgroupsCallable(const ListWorkgroupsRequestT& request = {}) const {
    return SubmitCallable(&RedshiftServerlessClient::ListWorkgroups, request);
  }
 
  template <typename ListWorkgroupsRequestT = Model::ListWorkgroupsRequest>
  void ListWorkgroupsAsync(const ListWorkgroupsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListWorkgroupsRequestT& request = {}) const {
    return SubmitAsync(&RedshiftServerlessClient::ListWorkgroups, request, handler, context);
  }
 
  virtual Model::PutResourcePolicyOutcome PutResourcePolicy(const Model::PutResourcePolicyRequest& request) const;
 
  template <typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
  Model::PutResourcePolicyOutcomeCallable PutResourcePolicyCallable(const PutResourcePolicyRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::PutResourcePolicy, request);
  }
 
  template <typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
  void PutResourcePolicyAsync(const PutResourcePolicyRequestT& request, const PutResourcePolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::PutResourcePolicy, request, handler, context);
  }
 
  virtual Model::RestoreFromRecoveryPointOutcome RestoreFromRecoveryPoint(const Model::RestoreFromRecoveryPointRequest& request) const;
 
  template <typename RestoreFromRecoveryPointRequestT = Model::RestoreFromRecoveryPointRequest>
  Model::RestoreFromRecoveryPointOutcomeCallable RestoreFromRecoveryPointCallable(const RestoreFromRecoveryPointRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::RestoreFromRecoveryPoint, request);
  }
 
  template <typename RestoreFromRecoveryPointRequestT = Model::RestoreFromRecoveryPointRequest>
  void RestoreFromRecoveryPointAsync(const RestoreFromRecoveryPointRequestT& request,
                                     const RestoreFromRecoveryPointResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::RestoreFromRecoveryPoint, request, handler, context);
  }
 
  virtual Model::RestoreFromSnapshotOutcome RestoreFromSnapshot(const Model::RestoreFromSnapshotRequest& request) const;
 
  template <typename RestoreFromSnapshotRequestT = Model::RestoreFromSnapshotRequest>
  Model::RestoreFromSnapshotOutcomeCallable RestoreFromSnapshotCallable(const RestoreFromSnapshotRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::RestoreFromSnapshot, request);
  }
 
  template <typename RestoreFromSnapshotRequestT = Model::RestoreFromSnapshotRequest>
  void RestoreFromSnapshotAsync(const RestoreFromSnapshotRequestT& request, const RestoreFromSnapshotResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::RestoreFromSnapshot, request, handler, context);
  }
 
  virtual Model::RestoreTableFromRecoveryPointOutcome RestoreTableFromRecoveryPoint(
      const Model::RestoreTableFromRecoveryPointRequest& request) const;
 
  template <typename RestoreTableFromRecoveryPointRequestT = Model::RestoreTableFromRecoveryPointRequest>
  Model::RestoreTableFromRecoveryPointOutcomeCallable RestoreTableFromRecoveryPointCallable(
      const RestoreTableFromRecoveryPointRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::RestoreTableFromRecoveryPoint, request);
  }
 
  template <typename RestoreTableFromRecoveryPointRequestT = Model::RestoreTableFromRecoveryPointRequest>
  void RestoreTableFromRecoveryPointAsync(const RestoreTableFromRecoveryPointRequestT& request,
                                          const RestoreTableFromRecoveryPointResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::RestoreTableFromRecoveryPoint, request, handler, context);
  }
 
  virtual Model::RestoreTableFromSnapshotOutcome RestoreTableFromSnapshot(const Model::RestoreTableFromSnapshotRequest& request) const;
 
  template <typename RestoreTableFromSnapshotRequestT = Model::RestoreTableFromSnapshotRequest>
  Model::RestoreTableFromSnapshotOutcomeCallable RestoreTableFromSnapshotCallable(const RestoreTableFromSnapshotRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::RestoreTableFromSnapshot, request);
  }
 
  template <typename RestoreTableFromSnapshotRequestT = Model::RestoreTableFromSnapshotRequest>
  void RestoreTableFromSnapshotAsync(const RestoreTableFromSnapshotRequestT& request,
                                     const RestoreTableFromSnapshotResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::RestoreTableFromSnapshot, 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(&RedshiftServerlessClient::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(&RedshiftServerlessClient::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(&RedshiftServerlessClient::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(&RedshiftServerlessClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateCustomDomainAssociationOutcome UpdateCustomDomainAssociation(
      const Model::UpdateCustomDomainAssociationRequest& request) const;
 
  template <typename UpdateCustomDomainAssociationRequestT = Model::UpdateCustomDomainAssociationRequest>
  Model::UpdateCustomDomainAssociationOutcomeCallable UpdateCustomDomainAssociationCallable(
      const UpdateCustomDomainAssociationRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::UpdateCustomDomainAssociation, request);
  }
 
  template <typename UpdateCustomDomainAssociationRequestT = Model::UpdateCustomDomainAssociationRequest>
  void UpdateCustomDomainAssociationAsync(const UpdateCustomDomainAssociationRequestT& request,
                                          const UpdateCustomDomainAssociationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::UpdateCustomDomainAssociation, request, handler, context);
  }
 
  virtual Model::UpdateEndpointAccessOutcome UpdateEndpointAccess(const Model::UpdateEndpointAccessRequest& request) const;
 
  template <typename UpdateEndpointAccessRequestT = Model::UpdateEndpointAccessRequest>
  Model::UpdateEndpointAccessOutcomeCallable UpdateEndpointAccessCallable(const UpdateEndpointAccessRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::UpdateEndpointAccess, request);
  }
 
  template <typename UpdateEndpointAccessRequestT = Model::UpdateEndpointAccessRequest>
  void UpdateEndpointAccessAsync(const UpdateEndpointAccessRequestT& request, const UpdateEndpointAccessResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::UpdateEndpointAccess, request, handler, context);
  }
 
  virtual Model::UpdateLakehouseConfigurationOutcome UpdateLakehouseConfiguration(
      const Model::UpdateLakehouseConfigurationRequest& request) const;
 
  template <typename UpdateLakehouseConfigurationRequestT = Model::UpdateLakehouseConfigurationRequest>
  Model::UpdateLakehouseConfigurationOutcomeCallable UpdateLakehouseConfigurationCallable(
      const UpdateLakehouseConfigurationRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::UpdateLakehouseConfiguration, request);
  }
 
  template <typename UpdateLakehouseConfigurationRequestT = Model::UpdateLakehouseConfigurationRequest>
  void UpdateLakehouseConfigurationAsync(const UpdateLakehouseConfigurationRequestT& request,
                                         const UpdateLakehouseConfigurationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::UpdateLakehouseConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateNamespaceOutcome UpdateNamespace(const Model::UpdateNamespaceRequest& request) const;
 
  template <typename UpdateNamespaceRequestT = Model::UpdateNamespaceRequest>
  Model::UpdateNamespaceOutcomeCallable UpdateNamespaceCallable(const UpdateNamespaceRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::UpdateNamespace, request);
  }
 
  template <typename UpdateNamespaceRequestT = Model::UpdateNamespaceRequest>
  void UpdateNamespaceAsync(const UpdateNamespaceRequestT& request, const UpdateNamespaceResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::UpdateNamespace, request, handler, context);
  }
 
  virtual Model::UpdateScheduledActionOutcome UpdateScheduledAction(const Model::UpdateScheduledActionRequest& request) const;
 
  template <typename UpdateScheduledActionRequestT = Model::UpdateScheduledActionRequest>
  Model::UpdateScheduledActionOutcomeCallable UpdateScheduledActionCallable(const UpdateScheduledActionRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::UpdateScheduledAction, request);
  }
 
  template <typename UpdateScheduledActionRequestT = Model::UpdateScheduledActionRequest>
  void UpdateScheduledActionAsync(const UpdateScheduledActionRequestT& request, const UpdateScheduledActionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::UpdateScheduledAction, request, handler, context);
  }
 
  virtual Model::UpdateSnapshotOutcome UpdateSnapshot(const Model::UpdateSnapshotRequest& request) const;
 
  template <typename UpdateSnapshotRequestT = Model::UpdateSnapshotRequest>
  Model::UpdateSnapshotOutcomeCallable UpdateSnapshotCallable(const UpdateSnapshotRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::UpdateSnapshot, request);
  }
 
  template <typename UpdateSnapshotRequestT = Model::UpdateSnapshotRequest>
  void UpdateSnapshotAsync(const UpdateSnapshotRequestT& request, const UpdateSnapshotResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::UpdateSnapshot, request, handler, context);
  }
 
  virtual Model::UpdateSnapshotCopyConfigurationOutcome UpdateSnapshotCopyConfiguration(
      const Model::UpdateSnapshotCopyConfigurationRequest& request) const;
 
  template <typename UpdateSnapshotCopyConfigurationRequestT = Model::UpdateSnapshotCopyConfigurationRequest>
  Model::UpdateSnapshotCopyConfigurationOutcomeCallable UpdateSnapshotCopyConfigurationCallable(
      const UpdateSnapshotCopyConfigurationRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::UpdateSnapshotCopyConfiguration, request);
  }
 
  template <typename UpdateSnapshotCopyConfigurationRequestT = Model::UpdateSnapshotCopyConfigurationRequest>
  void UpdateSnapshotCopyConfigurationAsync(const UpdateSnapshotCopyConfigurationRequestT& request,
                                            const UpdateSnapshotCopyConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::UpdateSnapshotCopyConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateUsageLimitOutcome UpdateUsageLimit(const Model::UpdateUsageLimitRequest& request) const;
 
  template <typename UpdateUsageLimitRequestT = Model::UpdateUsageLimitRequest>
  Model::UpdateUsageLimitOutcomeCallable UpdateUsageLimitCallable(const UpdateUsageLimitRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::UpdateUsageLimit, request);
  }
 
  template <typename UpdateUsageLimitRequestT = Model::UpdateUsageLimitRequest>
  void UpdateUsageLimitAsync(const UpdateUsageLimitRequestT& request, const UpdateUsageLimitResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::UpdateUsageLimit, request, handler, context);
  }
 
  virtual Model::UpdateWorkgroupOutcome UpdateWorkgroup(const Model::UpdateWorkgroupRequest& request) const;
 
  template <typename UpdateWorkgroupRequestT = Model::UpdateWorkgroupRequest>
  Model::UpdateWorkgroupOutcomeCallable UpdateWorkgroupCallable(const UpdateWorkgroupRequestT& request) const {
    return SubmitCallable(&RedshiftServerlessClient::UpdateWorkgroup, request);
  }
 
  template <typename UpdateWorkgroupRequestT = Model::UpdateWorkgroupRequest>
  void UpdateWorkgroupAsync(const UpdateWorkgroupRequestT& request, const UpdateWorkgroupResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftServerlessClient::UpdateWorkgroup, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<RedshiftServerlessEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<RedshiftServerlessClient>;
  void init(const RedshiftServerlessClientConfiguration& clientConfiguration);
 
  RedshiftServerlessClientConfiguration m_clientConfiguration;
  std::shared_ptr<RedshiftServerlessEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace RedshiftServerless
}  // namespace Aws