RedshiftServerlessClient.h

 
#pragma once
#include <aws/redshift-serverless/RedshiftServerless_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/redshift-serverless/RedshiftServerlessServiceClientModel.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::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::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