RedshiftClient.h

 
#pragma once
#include <aws/redshift/Redshift_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/redshift/RedshiftServiceClientModel.h>
 
namespace Aws
{
namespace Redshift
{
  class AWS_REDSHIFT_API RedshiftClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods<RedshiftClient>
  {
    public:
      typedef Aws::Client::AWSXMLClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef RedshiftClientConfiguration ClientConfigurationType;
      typedef RedshiftEndpointProvider EndpointProviderType;
 
        RedshiftClient(const Aws::Redshift::RedshiftClientConfiguration& clientConfiguration = Aws::Redshift::RedshiftClientConfiguration(),
                       std::shared_ptr<RedshiftEndpointProviderBase> endpointProvider = nullptr);
 
        RedshiftClient(const Aws::Auth::AWSCredentials& credentials,
                       std::shared_ptr<RedshiftEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::Redshift::RedshiftClientConfiguration& clientConfiguration = Aws::Redshift::RedshiftClientConfiguration());
 
        RedshiftClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       std::shared_ptr<RedshiftEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::Redshift::RedshiftClientConfiguration& clientConfiguration = Aws::Redshift::RedshiftClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        RedshiftClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        RedshiftClient(const Aws::Auth::AWSCredentials& credentials,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        RedshiftClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~RedshiftClient();
 
 
        Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const;
 
 
        virtual Model::AcceptReservedNodeExchangeOutcome AcceptReservedNodeExchange(const Model::AcceptReservedNodeExchangeRequest& request) const;
 
        template<typename AcceptReservedNodeExchangeRequestT = Model::AcceptReservedNodeExchangeRequest>
        Model::AcceptReservedNodeExchangeOutcomeCallable AcceptReservedNodeExchangeCallable(const AcceptReservedNodeExchangeRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::AcceptReservedNodeExchange, request);
        }
 
        template<typename AcceptReservedNodeExchangeRequestT = Model::AcceptReservedNodeExchangeRequest>
        void AcceptReservedNodeExchangeAsync(const AcceptReservedNodeExchangeRequestT& request, const AcceptReservedNodeExchangeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::AcceptReservedNodeExchange, request, handler, context);
        }
 
        virtual Model::AddPartnerOutcome AddPartner(const Model::AddPartnerRequest& request) const;
 
        template<typename AddPartnerRequestT = Model::AddPartnerRequest>
        Model::AddPartnerOutcomeCallable AddPartnerCallable(const AddPartnerRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::AddPartner, request);
        }
 
        template<typename AddPartnerRequestT = Model::AddPartnerRequest>
        void AddPartnerAsync(const AddPartnerRequestT& request, const AddPartnerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::AddPartner, request, handler, context);
        }
 
        virtual Model::AssociateDataShareConsumerOutcome AssociateDataShareConsumer(const Model::AssociateDataShareConsumerRequest& request) const;
 
        template<typename AssociateDataShareConsumerRequestT = Model::AssociateDataShareConsumerRequest>
        Model::AssociateDataShareConsumerOutcomeCallable AssociateDataShareConsumerCallable(const AssociateDataShareConsumerRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::AssociateDataShareConsumer, request);
        }
 
        template<typename AssociateDataShareConsumerRequestT = Model::AssociateDataShareConsumerRequest>
        void AssociateDataShareConsumerAsync(const AssociateDataShareConsumerRequestT& request, const AssociateDataShareConsumerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::AssociateDataShareConsumer, request, handler, context);
        }
 
        virtual Model::AuthorizeClusterSecurityGroupIngressOutcome AuthorizeClusterSecurityGroupIngress(const Model::AuthorizeClusterSecurityGroupIngressRequest& request) const;
 
        template<typename AuthorizeClusterSecurityGroupIngressRequestT = Model::AuthorizeClusterSecurityGroupIngressRequest>
        Model::AuthorizeClusterSecurityGroupIngressOutcomeCallable AuthorizeClusterSecurityGroupIngressCallable(const AuthorizeClusterSecurityGroupIngressRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::AuthorizeClusterSecurityGroupIngress, request);
        }
 
        template<typename AuthorizeClusterSecurityGroupIngressRequestT = Model::AuthorizeClusterSecurityGroupIngressRequest>
        void AuthorizeClusterSecurityGroupIngressAsync(const AuthorizeClusterSecurityGroupIngressRequestT& request, const AuthorizeClusterSecurityGroupIngressResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::AuthorizeClusterSecurityGroupIngress, request, handler, context);
        }
 
        virtual Model::AuthorizeDataShareOutcome AuthorizeDataShare(const Model::AuthorizeDataShareRequest& request) const;
 
        template<typename AuthorizeDataShareRequestT = Model::AuthorizeDataShareRequest>
        Model::AuthorizeDataShareOutcomeCallable AuthorizeDataShareCallable(const AuthorizeDataShareRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::AuthorizeDataShare, request);
        }
 
        template<typename AuthorizeDataShareRequestT = Model::AuthorizeDataShareRequest>
        void AuthorizeDataShareAsync(const AuthorizeDataShareRequestT& request, const AuthorizeDataShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::AuthorizeDataShare, request, handler, context);
        }
 
        virtual Model::AuthorizeEndpointAccessOutcome AuthorizeEndpointAccess(const Model::AuthorizeEndpointAccessRequest& request) const;
 
        template<typename AuthorizeEndpointAccessRequestT = Model::AuthorizeEndpointAccessRequest>
        Model::AuthorizeEndpointAccessOutcomeCallable AuthorizeEndpointAccessCallable(const AuthorizeEndpointAccessRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::AuthorizeEndpointAccess, request);
        }
 
        template<typename AuthorizeEndpointAccessRequestT = Model::AuthorizeEndpointAccessRequest>
        void AuthorizeEndpointAccessAsync(const AuthorizeEndpointAccessRequestT& request, const AuthorizeEndpointAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::AuthorizeEndpointAccess, request, handler, context);
        }
 
        virtual Model::AuthorizeSnapshotAccessOutcome AuthorizeSnapshotAccess(const Model::AuthorizeSnapshotAccessRequest& request) const;
 
        template<typename AuthorizeSnapshotAccessRequestT = Model::AuthorizeSnapshotAccessRequest>
        Model::AuthorizeSnapshotAccessOutcomeCallable AuthorizeSnapshotAccessCallable(const AuthorizeSnapshotAccessRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::AuthorizeSnapshotAccess, request);
        }
 
        template<typename AuthorizeSnapshotAccessRequestT = Model::AuthorizeSnapshotAccessRequest>
        void AuthorizeSnapshotAccessAsync(const AuthorizeSnapshotAccessRequestT& request, const AuthorizeSnapshotAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::AuthorizeSnapshotAccess, request, handler, context);
        }
 
        virtual Model::BatchDeleteClusterSnapshotsOutcome BatchDeleteClusterSnapshots(const Model::BatchDeleteClusterSnapshotsRequest& request) const;
 
        template<typename BatchDeleteClusterSnapshotsRequestT = Model::BatchDeleteClusterSnapshotsRequest>
        Model::BatchDeleteClusterSnapshotsOutcomeCallable BatchDeleteClusterSnapshotsCallable(const BatchDeleteClusterSnapshotsRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::BatchDeleteClusterSnapshots, request);
        }
 
        template<typename BatchDeleteClusterSnapshotsRequestT = Model::BatchDeleteClusterSnapshotsRequest>
        void BatchDeleteClusterSnapshotsAsync(const BatchDeleteClusterSnapshotsRequestT& request, const BatchDeleteClusterSnapshotsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::BatchDeleteClusterSnapshots, request, handler, context);
        }
 
        virtual Model::BatchModifyClusterSnapshotsOutcome BatchModifyClusterSnapshots(const Model::BatchModifyClusterSnapshotsRequest& request) const;
 
        template<typename BatchModifyClusterSnapshotsRequestT = Model::BatchModifyClusterSnapshotsRequest>
        Model::BatchModifyClusterSnapshotsOutcomeCallable BatchModifyClusterSnapshotsCallable(const BatchModifyClusterSnapshotsRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::BatchModifyClusterSnapshots, request);
        }
 
        template<typename BatchModifyClusterSnapshotsRequestT = Model::BatchModifyClusterSnapshotsRequest>
        void BatchModifyClusterSnapshotsAsync(const BatchModifyClusterSnapshotsRequestT& request, const BatchModifyClusterSnapshotsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::BatchModifyClusterSnapshots, request, handler, context);
        }
 
        virtual Model::CancelResizeOutcome CancelResize(const Model::CancelResizeRequest& request) const;
 
        template<typename CancelResizeRequestT = Model::CancelResizeRequest>
        Model::CancelResizeOutcomeCallable CancelResizeCallable(const CancelResizeRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::CancelResize, request);
        }
 
        template<typename CancelResizeRequestT = Model::CancelResizeRequest>
        void CancelResizeAsync(const CancelResizeRequestT& request, const CancelResizeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::CancelResize, request, handler, context);
        }
 
        virtual Model::CopyClusterSnapshotOutcome CopyClusterSnapshot(const Model::CopyClusterSnapshotRequest& request) const;
 
        template<typename CopyClusterSnapshotRequestT = Model::CopyClusterSnapshotRequest>
        Model::CopyClusterSnapshotOutcomeCallable CopyClusterSnapshotCallable(const CopyClusterSnapshotRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::CopyClusterSnapshot, request);
        }
 
        template<typename CopyClusterSnapshotRequestT = Model::CopyClusterSnapshotRequest>
        void CopyClusterSnapshotAsync(const CopyClusterSnapshotRequestT& request, const CopyClusterSnapshotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::CopyClusterSnapshot, request, handler, context);
        }
 
        virtual Model::CreateAuthenticationProfileOutcome CreateAuthenticationProfile(const Model::CreateAuthenticationProfileRequest& request) const;
 
        template<typename CreateAuthenticationProfileRequestT = Model::CreateAuthenticationProfileRequest>
        Model::CreateAuthenticationProfileOutcomeCallable CreateAuthenticationProfileCallable(const CreateAuthenticationProfileRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::CreateAuthenticationProfile, request);
        }
 
        template<typename CreateAuthenticationProfileRequestT = Model::CreateAuthenticationProfileRequest>
        void CreateAuthenticationProfileAsync(const CreateAuthenticationProfileRequestT& request, const CreateAuthenticationProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::CreateAuthenticationProfile, request, handler, context);
        }
 
        virtual Model::CreateClusterOutcome CreateCluster(const Model::CreateClusterRequest& request) const;
 
        template<typename CreateClusterRequestT = Model::CreateClusterRequest>
        Model::CreateClusterOutcomeCallable CreateClusterCallable(const CreateClusterRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::CreateCluster, request);
        }
 
        template<typename CreateClusterRequestT = Model::CreateClusterRequest>
        void CreateClusterAsync(const CreateClusterRequestT& request, const CreateClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::CreateCluster, request, handler, context);
        }
 
        virtual Model::CreateClusterParameterGroupOutcome CreateClusterParameterGroup(const Model::CreateClusterParameterGroupRequest& request) const;
 
        template<typename CreateClusterParameterGroupRequestT = Model::CreateClusterParameterGroupRequest>
        Model::CreateClusterParameterGroupOutcomeCallable CreateClusterParameterGroupCallable(const CreateClusterParameterGroupRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::CreateClusterParameterGroup, request);
        }
 
        template<typename CreateClusterParameterGroupRequestT = Model::CreateClusterParameterGroupRequest>
        void CreateClusterParameterGroupAsync(const CreateClusterParameterGroupRequestT& request, const CreateClusterParameterGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::CreateClusterParameterGroup, request, handler, context);
        }
 
        virtual Model::CreateClusterSecurityGroupOutcome CreateClusterSecurityGroup(const Model::CreateClusterSecurityGroupRequest& request) const;
 
        template<typename CreateClusterSecurityGroupRequestT = Model::CreateClusterSecurityGroupRequest>
        Model::CreateClusterSecurityGroupOutcomeCallable CreateClusterSecurityGroupCallable(const CreateClusterSecurityGroupRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::CreateClusterSecurityGroup, request);
        }
 
        template<typename CreateClusterSecurityGroupRequestT = Model::CreateClusterSecurityGroupRequest>
        void CreateClusterSecurityGroupAsync(const CreateClusterSecurityGroupRequestT& request, const CreateClusterSecurityGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::CreateClusterSecurityGroup, request, handler, context);
        }
 
        virtual Model::CreateClusterSnapshotOutcome CreateClusterSnapshot(const Model::CreateClusterSnapshotRequest& request) const;
 
        template<typename CreateClusterSnapshotRequestT = Model::CreateClusterSnapshotRequest>
        Model::CreateClusterSnapshotOutcomeCallable CreateClusterSnapshotCallable(const CreateClusterSnapshotRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::CreateClusterSnapshot, request);
        }
 
        template<typename CreateClusterSnapshotRequestT = Model::CreateClusterSnapshotRequest>
        void CreateClusterSnapshotAsync(const CreateClusterSnapshotRequestT& request, const CreateClusterSnapshotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::CreateClusterSnapshot, request, handler, context);
        }
 
        virtual Model::CreateClusterSubnetGroupOutcome CreateClusterSubnetGroup(const Model::CreateClusterSubnetGroupRequest& request) const;
 
        template<typename CreateClusterSubnetGroupRequestT = Model::CreateClusterSubnetGroupRequest>
        Model::CreateClusterSubnetGroupOutcomeCallable CreateClusterSubnetGroupCallable(const CreateClusterSubnetGroupRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::CreateClusterSubnetGroup, request);
        }
 
        template<typename CreateClusterSubnetGroupRequestT = Model::CreateClusterSubnetGroupRequest>
        void CreateClusterSubnetGroupAsync(const CreateClusterSubnetGroupRequestT& request, const CreateClusterSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::CreateClusterSubnetGroup, 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(&RedshiftClient::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(&RedshiftClient::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(&RedshiftClient::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(&RedshiftClient::CreateEndpointAccess, request, handler, context);
        }
 
        virtual Model::CreateEventSubscriptionOutcome CreateEventSubscription(const Model::CreateEventSubscriptionRequest& request) const;
 
        template<typename CreateEventSubscriptionRequestT = Model::CreateEventSubscriptionRequest>
        Model::CreateEventSubscriptionOutcomeCallable CreateEventSubscriptionCallable(const CreateEventSubscriptionRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::CreateEventSubscription, request);
        }
 
        template<typename CreateEventSubscriptionRequestT = Model::CreateEventSubscriptionRequest>
        void CreateEventSubscriptionAsync(const CreateEventSubscriptionRequestT& request, const CreateEventSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::CreateEventSubscription, request, handler, context);
        }
 
        virtual Model::CreateHsmClientCertificateOutcome CreateHsmClientCertificate(const Model::CreateHsmClientCertificateRequest& request) const;
 
        template<typename CreateHsmClientCertificateRequestT = Model::CreateHsmClientCertificateRequest>
        Model::CreateHsmClientCertificateOutcomeCallable CreateHsmClientCertificateCallable(const CreateHsmClientCertificateRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::CreateHsmClientCertificate, request);
        }
 
        template<typename CreateHsmClientCertificateRequestT = Model::CreateHsmClientCertificateRequest>
        void CreateHsmClientCertificateAsync(const CreateHsmClientCertificateRequestT& request, const CreateHsmClientCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::CreateHsmClientCertificate, request, handler, context);
        }
 
        virtual Model::CreateHsmConfigurationOutcome CreateHsmConfiguration(const Model::CreateHsmConfigurationRequest& request) const;
 
        template<typename CreateHsmConfigurationRequestT = Model::CreateHsmConfigurationRequest>
        Model::CreateHsmConfigurationOutcomeCallable CreateHsmConfigurationCallable(const CreateHsmConfigurationRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::CreateHsmConfiguration, request);
        }
 
        template<typename CreateHsmConfigurationRequestT = Model::CreateHsmConfigurationRequest>
        void CreateHsmConfigurationAsync(const CreateHsmConfigurationRequestT& request, const CreateHsmConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::CreateHsmConfiguration, request, handler, context);
        }
 
        virtual Model::CreateIntegrationOutcome CreateIntegration(const Model::CreateIntegrationRequest& request) const;
 
        template<typename CreateIntegrationRequestT = Model::CreateIntegrationRequest>
        Model::CreateIntegrationOutcomeCallable CreateIntegrationCallable(const CreateIntegrationRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::CreateIntegration, request);
        }
 
        template<typename CreateIntegrationRequestT = Model::CreateIntegrationRequest>
        void CreateIntegrationAsync(const CreateIntegrationRequestT& request, const CreateIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::CreateIntegration, request, handler, context);
        }
 
        virtual Model::CreateRedshiftIdcApplicationOutcome CreateRedshiftIdcApplication(const Model::CreateRedshiftIdcApplicationRequest& request) const;
 
        template<typename CreateRedshiftIdcApplicationRequestT = Model::CreateRedshiftIdcApplicationRequest>
        Model::CreateRedshiftIdcApplicationOutcomeCallable CreateRedshiftIdcApplicationCallable(const CreateRedshiftIdcApplicationRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::CreateRedshiftIdcApplication, request);
        }
 
        template<typename CreateRedshiftIdcApplicationRequestT = Model::CreateRedshiftIdcApplicationRequest>
        void CreateRedshiftIdcApplicationAsync(const CreateRedshiftIdcApplicationRequestT& request, const CreateRedshiftIdcApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::CreateRedshiftIdcApplication, 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(&RedshiftClient::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(&RedshiftClient::CreateScheduledAction, request, handler, context);
        }
 
        virtual Model::CreateSnapshotCopyGrantOutcome CreateSnapshotCopyGrant(const Model::CreateSnapshotCopyGrantRequest& request) const;
 
        template<typename CreateSnapshotCopyGrantRequestT = Model::CreateSnapshotCopyGrantRequest>
        Model::CreateSnapshotCopyGrantOutcomeCallable CreateSnapshotCopyGrantCallable(const CreateSnapshotCopyGrantRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::CreateSnapshotCopyGrant, request);
        }
 
        template<typename CreateSnapshotCopyGrantRequestT = Model::CreateSnapshotCopyGrantRequest>
        void CreateSnapshotCopyGrantAsync(const CreateSnapshotCopyGrantRequestT& request, const CreateSnapshotCopyGrantResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::CreateSnapshotCopyGrant, request, handler, context);
        }
 
        virtual Model::CreateSnapshotScheduleOutcome CreateSnapshotSchedule(const Model::CreateSnapshotScheduleRequest& request = {}) const;
 
        template<typename CreateSnapshotScheduleRequestT = Model::CreateSnapshotScheduleRequest>
        Model::CreateSnapshotScheduleOutcomeCallable CreateSnapshotScheduleCallable(const CreateSnapshotScheduleRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::CreateSnapshotSchedule, request);
        }
 
        template<typename CreateSnapshotScheduleRequestT = Model::CreateSnapshotScheduleRequest>
        void CreateSnapshotScheduleAsync(const CreateSnapshotScheduleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateSnapshotScheduleRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::CreateSnapshotSchedule, request, handler, context);
        }
 
        virtual Model::CreateTagsOutcome CreateTags(const Model::CreateTagsRequest& request) const;
 
        template<typename CreateTagsRequestT = Model::CreateTagsRequest>
        Model::CreateTagsOutcomeCallable CreateTagsCallable(const CreateTagsRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::CreateTags, request);
        }
 
        template<typename CreateTagsRequestT = Model::CreateTagsRequest>
        void CreateTagsAsync(const CreateTagsRequestT& request, const CreateTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::CreateTags, 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(&RedshiftClient::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(&RedshiftClient::CreateUsageLimit, request, handler, context);
        }
 
        virtual Model::DeauthorizeDataShareOutcome DeauthorizeDataShare(const Model::DeauthorizeDataShareRequest& request) const;
 
        template<typename DeauthorizeDataShareRequestT = Model::DeauthorizeDataShareRequest>
        Model::DeauthorizeDataShareOutcomeCallable DeauthorizeDataShareCallable(const DeauthorizeDataShareRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::DeauthorizeDataShare, request);
        }
 
        template<typename DeauthorizeDataShareRequestT = Model::DeauthorizeDataShareRequest>
        void DeauthorizeDataShareAsync(const DeauthorizeDataShareRequestT& request, const DeauthorizeDataShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::DeauthorizeDataShare, request, handler, context);
        }
 
        virtual Model::DeleteAuthenticationProfileOutcome DeleteAuthenticationProfile(const Model::DeleteAuthenticationProfileRequest& request) const;
 
        template<typename DeleteAuthenticationProfileRequestT = Model::DeleteAuthenticationProfileRequest>
        Model::DeleteAuthenticationProfileOutcomeCallable DeleteAuthenticationProfileCallable(const DeleteAuthenticationProfileRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::DeleteAuthenticationProfile, request);
        }
 
        template<typename DeleteAuthenticationProfileRequestT = Model::DeleteAuthenticationProfileRequest>
        void DeleteAuthenticationProfileAsync(const DeleteAuthenticationProfileRequestT& request, const DeleteAuthenticationProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::DeleteAuthenticationProfile, request, handler, context);
        }
 
        virtual Model::DeleteClusterOutcome DeleteCluster(const Model::DeleteClusterRequest& request) const;
 
        template<typename DeleteClusterRequestT = Model::DeleteClusterRequest>
        Model::DeleteClusterOutcomeCallable DeleteClusterCallable(const DeleteClusterRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::DeleteCluster, request);
        }
 
        template<typename DeleteClusterRequestT = Model::DeleteClusterRequest>
        void DeleteClusterAsync(const DeleteClusterRequestT& request, const DeleteClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::DeleteCluster, request, handler, context);
        }
 
        virtual Model::DeleteClusterParameterGroupOutcome DeleteClusterParameterGroup(const Model::DeleteClusterParameterGroupRequest& request) const;
 
        template<typename DeleteClusterParameterGroupRequestT = Model::DeleteClusterParameterGroupRequest>
        Model::DeleteClusterParameterGroupOutcomeCallable DeleteClusterParameterGroupCallable(const DeleteClusterParameterGroupRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::DeleteClusterParameterGroup, request);
        }
 
        template<typename DeleteClusterParameterGroupRequestT = Model::DeleteClusterParameterGroupRequest>
        void DeleteClusterParameterGroupAsync(const DeleteClusterParameterGroupRequestT& request, const DeleteClusterParameterGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::DeleteClusterParameterGroup, request, handler, context);
        }
 
        virtual Model::DeleteClusterSecurityGroupOutcome DeleteClusterSecurityGroup(const Model::DeleteClusterSecurityGroupRequest& request) const;
 
        template<typename DeleteClusterSecurityGroupRequestT = Model::DeleteClusterSecurityGroupRequest>
        Model::DeleteClusterSecurityGroupOutcomeCallable DeleteClusterSecurityGroupCallable(const DeleteClusterSecurityGroupRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::DeleteClusterSecurityGroup, request);
        }
 
        template<typename DeleteClusterSecurityGroupRequestT = Model::DeleteClusterSecurityGroupRequest>
        void DeleteClusterSecurityGroupAsync(const DeleteClusterSecurityGroupRequestT& request, const DeleteClusterSecurityGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::DeleteClusterSecurityGroup, request, handler, context);
        }
 
        virtual Model::DeleteClusterSnapshotOutcome DeleteClusterSnapshot(const Model::DeleteClusterSnapshotRequest& request) const;
 
        template<typename DeleteClusterSnapshotRequestT = Model::DeleteClusterSnapshotRequest>
        Model::DeleteClusterSnapshotOutcomeCallable DeleteClusterSnapshotCallable(const DeleteClusterSnapshotRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::DeleteClusterSnapshot, request);
        }
 
        template<typename DeleteClusterSnapshotRequestT = Model::DeleteClusterSnapshotRequest>
        void DeleteClusterSnapshotAsync(const DeleteClusterSnapshotRequestT& request, const DeleteClusterSnapshotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::DeleteClusterSnapshot, request, handler, context);
        }
 
        virtual Model::DeleteClusterSubnetGroupOutcome DeleteClusterSubnetGroup(const Model::DeleteClusterSubnetGroupRequest& request) const;
 
        template<typename DeleteClusterSubnetGroupRequestT = Model::DeleteClusterSubnetGroupRequest>
        Model::DeleteClusterSubnetGroupOutcomeCallable DeleteClusterSubnetGroupCallable(const DeleteClusterSubnetGroupRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::DeleteClusterSubnetGroup, request);
        }
 
        template<typename DeleteClusterSubnetGroupRequestT = Model::DeleteClusterSubnetGroupRequest>
        void DeleteClusterSubnetGroupAsync(const DeleteClusterSubnetGroupRequestT& request, const DeleteClusterSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::DeleteClusterSubnetGroup, 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(&RedshiftClient::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(&RedshiftClient::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(&RedshiftClient::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(&RedshiftClient::DeleteEndpointAccess, request, handler, context);
        }
 
        virtual Model::DeleteEventSubscriptionOutcome DeleteEventSubscription(const Model::DeleteEventSubscriptionRequest& request) const;
 
        template<typename DeleteEventSubscriptionRequestT = Model::DeleteEventSubscriptionRequest>
        Model::DeleteEventSubscriptionOutcomeCallable DeleteEventSubscriptionCallable(const DeleteEventSubscriptionRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::DeleteEventSubscription, request);
        }
 
        template<typename DeleteEventSubscriptionRequestT = Model::DeleteEventSubscriptionRequest>
        void DeleteEventSubscriptionAsync(const DeleteEventSubscriptionRequestT& request, const DeleteEventSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::DeleteEventSubscription, request, handler, context);
        }
 
        virtual Model::DeleteHsmClientCertificateOutcome DeleteHsmClientCertificate(const Model::DeleteHsmClientCertificateRequest& request) const;
 
        template<typename DeleteHsmClientCertificateRequestT = Model::DeleteHsmClientCertificateRequest>
        Model::DeleteHsmClientCertificateOutcomeCallable DeleteHsmClientCertificateCallable(const DeleteHsmClientCertificateRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::DeleteHsmClientCertificate, request);
        }
 
        template<typename DeleteHsmClientCertificateRequestT = Model::DeleteHsmClientCertificateRequest>
        void DeleteHsmClientCertificateAsync(const DeleteHsmClientCertificateRequestT& request, const DeleteHsmClientCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::DeleteHsmClientCertificate, request, handler, context);
        }
 
        virtual Model::DeleteHsmConfigurationOutcome DeleteHsmConfiguration(const Model::DeleteHsmConfigurationRequest& request) const;
 
        template<typename DeleteHsmConfigurationRequestT = Model::DeleteHsmConfigurationRequest>
        Model::DeleteHsmConfigurationOutcomeCallable DeleteHsmConfigurationCallable(const DeleteHsmConfigurationRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::DeleteHsmConfiguration, request);
        }
 
        template<typename DeleteHsmConfigurationRequestT = Model::DeleteHsmConfigurationRequest>
        void DeleteHsmConfigurationAsync(const DeleteHsmConfigurationRequestT& request, const DeleteHsmConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::DeleteHsmConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteIntegrationOutcome DeleteIntegration(const Model::DeleteIntegrationRequest& request) const;
 
        template<typename DeleteIntegrationRequestT = Model::DeleteIntegrationRequest>
        Model::DeleteIntegrationOutcomeCallable DeleteIntegrationCallable(const DeleteIntegrationRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::DeleteIntegration, request);
        }
 
        template<typename DeleteIntegrationRequestT = Model::DeleteIntegrationRequest>
        void DeleteIntegrationAsync(const DeleteIntegrationRequestT& request, const DeleteIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::DeleteIntegration, request, handler, context);
        }
 
        virtual Model::DeletePartnerOutcome DeletePartner(const Model::DeletePartnerRequest& request) const;
 
        template<typename DeletePartnerRequestT = Model::DeletePartnerRequest>
        Model::DeletePartnerOutcomeCallable DeletePartnerCallable(const DeletePartnerRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::DeletePartner, request);
        }
 
        template<typename DeletePartnerRequestT = Model::DeletePartnerRequest>
        void DeletePartnerAsync(const DeletePartnerRequestT& request, const DeletePartnerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::DeletePartner, request, handler, context);
        }
 
        virtual Model::DeleteRedshiftIdcApplicationOutcome DeleteRedshiftIdcApplication(const Model::DeleteRedshiftIdcApplicationRequest& request) const;
 
        template<typename DeleteRedshiftIdcApplicationRequestT = Model::DeleteRedshiftIdcApplicationRequest>
        Model::DeleteRedshiftIdcApplicationOutcomeCallable DeleteRedshiftIdcApplicationCallable(const DeleteRedshiftIdcApplicationRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::DeleteRedshiftIdcApplication, request);
        }
 
        template<typename DeleteRedshiftIdcApplicationRequestT = Model::DeleteRedshiftIdcApplicationRequest>
        void DeleteRedshiftIdcApplicationAsync(const DeleteRedshiftIdcApplicationRequestT& request, const DeleteRedshiftIdcApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::DeleteRedshiftIdcApplication, 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(&RedshiftClient::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(&RedshiftClient::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(&RedshiftClient::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(&RedshiftClient::DeleteScheduledAction, request, handler, context);
        }
 
        virtual Model::DeleteSnapshotCopyGrantOutcome DeleteSnapshotCopyGrant(const Model::DeleteSnapshotCopyGrantRequest& request) const;
 
        template<typename DeleteSnapshotCopyGrantRequestT = Model::DeleteSnapshotCopyGrantRequest>
        Model::DeleteSnapshotCopyGrantOutcomeCallable DeleteSnapshotCopyGrantCallable(const DeleteSnapshotCopyGrantRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::DeleteSnapshotCopyGrant, request);
        }
 
        template<typename DeleteSnapshotCopyGrantRequestT = Model::DeleteSnapshotCopyGrantRequest>
        void DeleteSnapshotCopyGrantAsync(const DeleteSnapshotCopyGrantRequestT& request, const DeleteSnapshotCopyGrantResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::DeleteSnapshotCopyGrant, request, handler, context);
        }
 
        virtual Model::DeleteSnapshotScheduleOutcome DeleteSnapshotSchedule(const Model::DeleteSnapshotScheduleRequest& request) const;
 
        template<typename DeleteSnapshotScheduleRequestT = Model::DeleteSnapshotScheduleRequest>
        Model::DeleteSnapshotScheduleOutcomeCallable DeleteSnapshotScheduleCallable(const DeleteSnapshotScheduleRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::DeleteSnapshotSchedule, request);
        }
 
        template<typename DeleteSnapshotScheduleRequestT = Model::DeleteSnapshotScheduleRequest>
        void DeleteSnapshotScheduleAsync(const DeleteSnapshotScheduleRequestT& request, const DeleteSnapshotScheduleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::DeleteSnapshotSchedule, request, handler, context);
        }
 
        virtual Model::DeleteTagsOutcome DeleteTags(const Model::DeleteTagsRequest& request) const;
 
        template<typename DeleteTagsRequestT = Model::DeleteTagsRequest>
        Model::DeleteTagsOutcomeCallable DeleteTagsCallable(const DeleteTagsRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::DeleteTags, request);
        }
 
        template<typename DeleteTagsRequestT = Model::DeleteTagsRequest>
        void DeleteTagsAsync(const DeleteTagsRequestT& request, const DeleteTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::DeleteTags, 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(&RedshiftClient::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(&RedshiftClient::DeleteUsageLimit, request, handler, context);
        }
 
        virtual Model::DescribeAccountAttributesOutcome DescribeAccountAttributes(const Model::DescribeAccountAttributesRequest& request = {}) const;
 
        template<typename DescribeAccountAttributesRequestT = Model::DescribeAccountAttributesRequest>
        Model::DescribeAccountAttributesOutcomeCallable DescribeAccountAttributesCallable(const DescribeAccountAttributesRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeAccountAttributes, request);
        }
 
        template<typename DescribeAccountAttributesRequestT = Model::DescribeAccountAttributesRequest>
        void DescribeAccountAttributesAsync(const DescribeAccountAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeAccountAttributesRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeAccountAttributes, request, handler, context);
        }
 
        virtual Model::DescribeAuthenticationProfilesOutcome DescribeAuthenticationProfiles(const Model::DescribeAuthenticationProfilesRequest& request = {}) const;
 
        template<typename DescribeAuthenticationProfilesRequestT = Model::DescribeAuthenticationProfilesRequest>
        Model::DescribeAuthenticationProfilesOutcomeCallable DescribeAuthenticationProfilesCallable(const DescribeAuthenticationProfilesRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeAuthenticationProfiles, request);
        }
 
        template<typename DescribeAuthenticationProfilesRequestT = Model::DescribeAuthenticationProfilesRequest>
        void DescribeAuthenticationProfilesAsync(const DescribeAuthenticationProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeAuthenticationProfilesRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeAuthenticationProfiles, request, handler, context);
        }
 
        virtual Model::DescribeClusterDbRevisionsOutcome DescribeClusterDbRevisions(const Model::DescribeClusterDbRevisionsRequest& request = {}) const;
 
        template<typename DescribeClusterDbRevisionsRequestT = Model::DescribeClusterDbRevisionsRequest>
        Model::DescribeClusterDbRevisionsOutcomeCallable DescribeClusterDbRevisionsCallable(const DescribeClusterDbRevisionsRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeClusterDbRevisions, request);
        }
 
        template<typename DescribeClusterDbRevisionsRequestT = Model::DescribeClusterDbRevisionsRequest>
        void DescribeClusterDbRevisionsAsync(const DescribeClusterDbRevisionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeClusterDbRevisionsRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeClusterDbRevisions, request, handler, context);
        }
 
        virtual Model::DescribeClusterParameterGroupsOutcome DescribeClusterParameterGroups(const Model::DescribeClusterParameterGroupsRequest& request = {}) const;
 
        template<typename DescribeClusterParameterGroupsRequestT = Model::DescribeClusterParameterGroupsRequest>
        Model::DescribeClusterParameterGroupsOutcomeCallable DescribeClusterParameterGroupsCallable(const DescribeClusterParameterGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeClusterParameterGroups, request);
        }
 
        template<typename DescribeClusterParameterGroupsRequestT = Model::DescribeClusterParameterGroupsRequest>
        void DescribeClusterParameterGroupsAsync(const DescribeClusterParameterGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeClusterParameterGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeClusterParameterGroups, request, handler, context);
        }
 
        virtual Model::DescribeClusterParametersOutcome DescribeClusterParameters(const Model::DescribeClusterParametersRequest& request) const;
 
        template<typename DescribeClusterParametersRequestT = Model::DescribeClusterParametersRequest>
        Model::DescribeClusterParametersOutcomeCallable DescribeClusterParametersCallable(const DescribeClusterParametersRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::DescribeClusterParameters, request);
        }
 
        template<typename DescribeClusterParametersRequestT = Model::DescribeClusterParametersRequest>
        void DescribeClusterParametersAsync(const DescribeClusterParametersRequestT& request, const DescribeClusterParametersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::DescribeClusterParameters, request, handler, context);
        }
 
        virtual Model::DescribeClusterSecurityGroupsOutcome DescribeClusterSecurityGroups(const Model::DescribeClusterSecurityGroupsRequest& request = {}) const;
 
        template<typename DescribeClusterSecurityGroupsRequestT = Model::DescribeClusterSecurityGroupsRequest>
        Model::DescribeClusterSecurityGroupsOutcomeCallable DescribeClusterSecurityGroupsCallable(const DescribeClusterSecurityGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeClusterSecurityGroups, request);
        }
 
        template<typename DescribeClusterSecurityGroupsRequestT = Model::DescribeClusterSecurityGroupsRequest>
        void DescribeClusterSecurityGroupsAsync(const DescribeClusterSecurityGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeClusterSecurityGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeClusterSecurityGroups, request, handler, context);
        }
 
        virtual Model::DescribeClusterSnapshotsOutcome DescribeClusterSnapshots(const Model::DescribeClusterSnapshotsRequest& request = {}) const;
 
        template<typename DescribeClusterSnapshotsRequestT = Model::DescribeClusterSnapshotsRequest>
        Model::DescribeClusterSnapshotsOutcomeCallable DescribeClusterSnapshotsCallable(const DescribeClusterSnapshotsRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeClusterSnapshots, request);
        }
 
        template<typename DescribeClusterSnapshotsRequestT = Model::DescribeClusterSnapshotsRequest>
        void DescribeClusterSnapshotsAsync(const DescribeClusterSnapshotsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeClusterSnapshotsRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeClusterSnapshots, request, handler, context);
        }
 
        virtual Model::DescribeClusterSubnetGroupsOutcome DescribeClusterSubnetGroups(const Model::DescribeClusterSubnetGroupsRequest& request = {}) const;
 
        template<typename DescribeClusterSubnetGroupsRequestT = Model::DescribeClusterSubnetGroupsRequest>
        Model::DescribeClusterSubnetGroupsOutcomeCallable DescribeClusterSubnetGroupsCallable(const DescribeClusterSubnetGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeClusterSubnetGroups, request);
        }
 
        template<typename DescribeClusterSubnetGroupsRequestT = Model::DescribeClusterSubnetGroupsRequest>
        void DescribeClusterSubnetGroupsAsync(const DescribeClusterSubnetGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeClusterSubnetGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeClusterSubnetGroups, request, handler, context);
        }
 
        virtual Model::DescribeClusterTracksOutcome DescribeClusterTracks(const Model::DescribeClusterTracksRequest& request = {}) const;
 
        template<typename DescribeClusterTracksRequestT = Model::DescribeClusterTracksRequest>
        Model::DescribeClusterTracksOutcomeCallable DescribeClusterTracksCallable(const DescribeClusterTracksRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeClusterTracks, request);
        }
 
        template<typename DescribeClusterTracksRequestT = Model::DescribeClusterTracksRequest>
        void DescribeClusterTracksAsync(const DescribeClusterTracksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeClusterTracksRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeClusterTracks, request, handler, context);
        }
 
        virtual Model::DescribeClusterVersionsOutcome DescribeClusterVersions(const Model::DescribeClusterVersionsRequest& request = {}) const;
 
        template<typename DescribeClusterVersionsRequestT = Model::DescribeClusterVersionsRequest>
        Model::DescribeClusterVersionsOutcomeCallable DescribeClusterVersionsCallable(const DescribeClusterVersionsRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeClusterVersions, request);
        }
 
        template<typename DescribeClusterVersionsRequestT = Model::DescribeClusterVersionsRequest>
        void DescribeClusterVersionsAsync(const DescribeClusterVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeClusterVersionsRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeClusterVersions, request, handler, context);
        }
 
        virtual Model::DescribeClustersOutcome DescribeClusters(const Model::DescribeClustersRequest& request = {}) const;
 
        template<typename DescribeClustersRequestT = Model::DescribeClustersRequest>
        Model::DescribeClustersOutcomeCallable DescribeClustersCallable(const DescribeClustersRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeClusters, request);
        }
 
        template<typename DescribeClustersRequestT = Model::DescribeClustersRequest>
        void DescribeClustersAsync(const DescribeClustersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeClustersRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeClusters, request, handler, context);
        }
 
        virtual Model::DescribeCustomDomainAssociationsOutcome DescribeCustomDomainAssociations(const Model::DescribeCustomDomainAssociationsRequest& request = {}) const;
 
        template<typename DescribeCustomDomainAssociationsRequestT = Model::DescribeCustomDomainAssociationsRequest>
        Model::DescribeCustomDomainAssociationsOutcomeCallable DescribeCustomDomainAssociationsCallable(const DescribeCustomDomainAssociationsRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeCustomDomainAssociations, request);
        }
 
        template<typename DescribeCustomDomainAssociationsRequestT = Model::DescribeCustomDomainAssociationsRequest>
        void DescribeCustomDomainAssociationsAsync(const DescribeCustomDomainAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeCustomDomainAssociationsRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeCustomDomainAssociations, request, handler, context);
        }
 
        virtual Model::DescribeDataSharesOutcome DescribeDataShares(const Model::DescribeDataSharesRequest& request = {}) const;
 
        template<typename DescribeDataSharesRequestT = Model::DescribeDataSharesRequest>
        Model::DescribeDataSharesOutcomeCallable DescribeDataSharesCallable(const DescribeDataSharesRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeDataShares, request);
        }
 
        template<typename DescribeDataSharesRequestT = Model::DescribeDataSharesRequest>
        void DescribeDataSharesAsync(const DescribeDataSharesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeDataSharesRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeDataShares, request, handler, context);
        }
 
        virtual Model::DescribeDataSharesForConsumerOutcome DescribeDataSharesForConsumer(const Model::DescribeDataSharesForConsumerRequest& request = {}) const;
 
        template<typename DescribeDataSharesForConsumerRequestT = Model::DescribeDataSharesForConsumerRequest>
        Model::DescribeDataSharesForConsumerOutcomeCallable DescribeDataSharesForConsumerCallable(const DescribeDataSharesForConsumerRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeDataSharesForConsumer, request);
        }
 
        template<typename DescribeDataSharesForConsumerRequestT = Model::DescribeDataSharesForConsumerRequest>
        void DescribeDataSharesForConsumerAsync(const DescribeDataSharesForConsumerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeDataSharesForConsumerRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeDataSharesForConsumer, request, handler, context);
        }
 
        virtual Model::DescribeDataSharesForProducerOutcome DescribeDataSharesForProducer(const Model::DescribeDataSharesForProducerRequest& request = {}) const;
 
        template<typename DescribeDataSharesForProducerRequestT = Model::DescribeDataSharesForProducerRequest>
        Model::DescribeDataSharesForProducerOutcomeCallable DescribeDataSharesForProducerCallable(const DescribeDataSharesForProducerRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeDataSharesForProducer, request);
        }
 
        template<typename DescribeDataSharesForProducerRequestT = Model::DescribeDataSharesForProducerRequest>
        void DescribeDataSharesForProducerAsync(const DescribeDataSharesForProducerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeDataSharesForProducerRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeDataSharesForProducer, request, handler, context);
        }
 
        virtual Model::DescribeDefaultClusterParametersOutcome DescribeDefaultClusterParameters(const Model::DescribeDefaultClusterParametersRequest& request) const;
 
        template<typename DescribeDefaultClusterParametersRequestT = Model::DescribeDefaultClusterParametersRequest>
        Model::DescribeDefaultClusterParametersOutcomeCallable DescribeDefaultClusterParametersCallable(const DescribeDefaultClusterParametersRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::DescribeDefaultClusterParameters, request);
        }
 
        template<typename DescribeDefaultClusterParametersRequestT = Model::DescribeDefaultClusterParametersRequest>
        void DescribeDefaultClusterParametersAsync(const DescribeDefaultClusterParametersRequestT& request, const DescribeDefaultClusterParametersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::DescribeDefaultClusterParameters, request, handler, context);
        }
 
        virtual Model::DescribeEndpointAccessOutcome DescribeEndpointAccess(const Model::DescribeEndpointAccessRequest& request = {}) const;
 
        template<typename DescribeEndpointAccessRequestT = Model::DescribeEndpointAccessRequest>
        Model::DescribeEndpointAccessOutcomeCallable DescribeEndpointAccessCallable(const DescribeEndpointAccessRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeEndpointAccess, request);
        }
 
        template<typename DescribeEndpointAccessRequestT = Model::DescribeEndpointAccessRequest>
        void DescribeEndpointAccessAsync(const DescribeEndpointAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeEndpointAccessRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeEndpointAccess, request, handler, context);
        }
 
        virtual Model::DescribeEndpointAuthorizationOutcome DescribeEndpointAuthorization(const Model::DescribeEndpointAuthorizationRequest& request = {}) const;
 
        template<typename DescribeEndpointAuthorizationRequestT = Model::DescribeEndpointAuthorizationRequest>
        Model::DescribeEndpointAuthorizationOutcomeCallable DescribeEndpointAuthorizationCallable(const DescribeEndpointAuthorizationRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeEndpointAuthorization, request);
        }
 
        template<typename DescribeEndpointAuthorizationRequestT = Model::DescribeEndpointAuthorizationRequest>
        void DescribeEndpointAuthorizationAsync(const DescribeEndpointAuthorizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeEndpointAuthorizationRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeEndpointAuthorization, request, handler, context);
        }
 
        virtual Model::DescribeEventCategoriesOutcome DescribeEventCategories(const Model::DescribeEventCategoriesRequest& request = {}) const;
 
        template<typename DescribeEventCategoriesRequestT = Model::DescribeEventCategoriesRequest>
        Model::DescribeEventCategoriesOutcomeCallable DescribeEventCategoriesCallable(const DescribeEventCategoriesRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeEventCategories, request);
        }
 
        template<typename DescribeEventCategoriesRequestT = Model::DescribeEventCategoriesRequest>
        void DescribeEventCategoriesAsync(const DescribeEventCategoriesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeEventCategoriesRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeEventCategories, request, handler, context);
        }
 
        virtual Model::DescribeEventSubscriptionsOutcome DescribeEventSubscriptions(const Model::DescribeEventSubscriptionsRequest& request = {}) const;
 
        template<typename DescribeEventSubscriptionsRequestT = Model::DescribeEventSubscriptionsRequest>
        Model::DescribeEventSubscriptionsOutcomeCallable DescribeEventSubscriptionsCallable(const DescribeEventSubscriptionsRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeEventSubscriptions, request);
        }
 
        template<typename DescribeEventSubscriptionsRequestT = Model::DescribeEventSubscriptionsRequest>
        void DescribeEventSubscriptionsAsync(const DescribeEventSubscriptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeEventSubscriptionsRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeEventSubscriptions, request, handler, context);
        }
 
        virtual Model::DescribeEventsOutcome DescribeEvents(const Model::DescribeEventsRequest& request = {}) const;
 
        template<typename DescribeEventsRequestT = Model::DescribeEventsRequest>
        Model::DescribeEventsOutcomeCallable DescribeEventsCallable(const DescribeEventsRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeEvents, request);
        }
 
        template<typename DescribeEventsRequestT = Model::DescribeEventsRequest>
        void DescribeEventsAsync(const DescribeEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeEventsRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeEvents, request, handler, context);
        }
 
        virtual Model::DescribeHsmClientCertificatesOutcome DescribeHsmClientCertificates(const Model::DescribeHsmClientCertificatesRequest& request = {}) const;
 
        template<typename DescribeHsmClientCertificatesRequestT = Model::DescribeHsmClientCertificatesRequest>
        Model::DescribeHsmClientCertificatesOutcomeCallable DescribeHsmClientCertificatesCallable(const DescribeHsmClientCertificatesRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeHsmClientCertificates, request);
        }
 
        template<typename DescribeHsmClientCertificatesRequestT = Model::DescribeHsmClientCertificatesRequest>
        void DescribeHsmClientCertificatesAsync(const DescribeHsmClientCertificatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeHsmClientCertificatesRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeHsmClientCertificates, request, handler, context);
        }
 
        virtual Model::DescribeHsmConfigurationsOutcome DescribeHsmConfigurations(const Model::DescribeHsmConfigurationsRequest& request = {}) const;
 
        template<typename DescribeHsmConfigurationsRequestT = Model::DescribeHsmConfigurationsRequest>
        Model::DescribeHsmConfigurationsOutcomeCallable DescribeHsmConfigurationsCallable(const DescribeHsmConfigurationsRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeHsmConfigurations, request);
        }
 
        template<typename DescribeHsmConfigurationsRequestT = Model::DescribeHsmConfigurationsRequest>
        void DescribeHsmConfigurationsAsync(const DescribeHsmConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeHsmConfigurationsRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeHsmConfigurations, request, handler, context);
        }
 
        virtual Model::DescribeInboundIntegrationsOutcome DescribeInboundIntegrations(const Model::DescribeInboundIntegrationsRequest& request = {}) const;
 
        template<typename DescribeInboundIntegrationsRequestT = Model::DescribeInboundIntegrationsRequest>
        Model::DescribeInboundIntegrationsOutcomeCallable DescribeInboundIntegrationsCallable(const DescribeInboundIntegrationsRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeInboundIntegrations, request);
        }
 
        template<typename DescribeInboundIntegrationsRequestT = Model::DescribeInboundIntegrationsRequest>
        void DescribeInboundIntegrationsAsync(const DescribeInboundIntegrationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeInboundIntegrationsRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeInboundIntegrations, request, handler, context);
        }
 
        virtual Model::DescribeIntegrationsOutcome DescribeIntegrations(const Model::DescribeIntegrationsRequest& request = {}) const;
 
        template<typename DescribeIntegrationsRequestT = Model::DescribeIntegrationsRequest>
        Model::DescribeIntegrationsOutcomeCallable DescribeIntegrationsCallable(const DescribeIntegrationsRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeIntegrations, request);
        }
 
        template<typename DescribeIntegrationsRequestT = Model::DescribeIntegrationsRequest>
        void DescribeIntegrationsAsync(const DescribeIntegrationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeIntegrationsRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeIntegrations, request, handler, context);
        }
 
        virtual Model::DescribeLoggingStatusOutcome DescribeLoggingStatus(const Model::DescribeLoggingStatusRequest& request) const;
 
        template<typename DescribeLoggingStatusRequestT = Model::DescribeLoggingStatusRequest>
        Model::DescribeLoggingStatusOutcomeCallable DescribeLoggingStatusCallable(const DescribeLoggingStatusRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::DescribeLoggingStatus, request);
        }
 
        template<typename DescribeLoggingStatusRequestT = Model::DescribeLoggingStatusRequest>
        void DescribeLoggingStatusAsync(const DescribeLoggingStatusRequestT& request, const DescribeLoggingStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::DescribeLoggingStatus, request, handler, context);
        }
 
        virtual Model::DescribeNodeConfigurationOptionsOutcome DescribeNodeConfigurationOptions(const Model::DescribeNodeConfigurationOptionsRequest& request) const;
 
        template<typename DescribeNodeConfigurationOptionsRequestT = Model::DescribeNodeConfigurationOptionsRequest>
        Model::DescribeNodeConfigurationOptionsOutcomeCallable DescribeNodeConfigurationOptionsCallable(const DescribeNodeConfigurationOptionsRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::DescribeNodeConfigurationOptions, request);
        }
 
        template<typename DescribeNodeConfigurationOptionsRequestT = Model::DescribeNodeConfigurationOptionsRequest>
        void DescribeNodeConfigurationOptionsAsync(const DescribeNodeConfigurationOptionsRequestT& request, const DescribeNodeConfigurationOptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::DescribeNodeConfigurationOptions, request, handler, context);
        }
 
        virtual Model::DescribeOrderableClusterOptionsOutcome DescribeOrderableClusterOptions(const Model::DescribeOrderableClusterOptionsRequest& request = {}) const;
 
        template<typename DescribeOrderableClusterOptionsRequestT = Model::DescribeOrderableClusterOptionsRequest>
        Model::DescribeOrderableClusterOptionsOutcomeCallable DescribeOrderableClusterOptionsCallable(const DescribeOrderableClusterOptionsRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeOrderableClusterOptions, request);
        }
 
        template<typename DescribeOrderableClusterOptionsRequestT = Model::DescribeOrderableClusterOptionsRequest>
        void DescribeOrderableClusterOptionsAsync(const DescribeOrderableClusterOptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeOrderableClusterOptionsRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeOrderableClusterOptions, request, handler, context);
        }
 
        virtual Model::DescribePartnersOutcome DescribePartners(const Model::DescribePartnersRequest& request) const;
 
        template<typename DescribePartnersRequestT = Model::DescribePartnersRequest>
        Model::DescribePartnersOutcomeCallable DescribePartnersCallable(const DescribePartnersRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::DescribePartners, request);
        }
 
        template<typename DescribePartnersRequestT = Model::DescribePartnersRequest>
        void DescribePartnersAsync(const DescribePartnersRequestT& request, const DescribePartnersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::DescribePartners, request, handler, context);
        }
 
        virtual Model::DescribeRedshiftIdcApplicationsOutcome DescribeRedshiftIdcApplications(const Model::DescribeRedshiftIdcApplicationsRequest& request = {}) const;
 
        template<typename DescribeRedshiftIdcApplicationsRequestT = Model::DescribeRedshiftIdcApplicationsRequest>
        Model::DescribeRedshiftIdcApplicationsOutcomeCallable DescribeRedshiftIdcApplicationsCallable(const DescribeRedshiftIdcApplicationsRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeRedshiftIdcApplications, request);
        }
 
        template<typename DescribeRedshiftIdcApplicationsRequestT = Model::DescribeRedshiftIdcApplicationsRequest>
        void DescribeRedshiftIdcApplicationsAsync(const DescribeRedshiftIdcApplicationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeRedshiftIdcApplicationsRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeRedshiftIdcApplications, request, handler, context);
        }
 
        virtual Model::DescribeReservedNodeExchangeStatusOutcome DescribeReservedNodeExchangeStatus(const Model::DescribeReservedNodeExchangeStatusRequest& request = {}) const;
 
        template<typename DescribeReservedNodeExchangeStatusRequestT = Model::DescribeReservedNodeExchangeStatusRequest>
        Model::DescribeReservedNodeExchangeStatusOutcomeCallable DescribeReservedNodeExchangeStatusCallable(const DescribeReservedNodeExchangeStatusRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeReservedNodeExchangeStatus, request);
        }
 
        template<typename DescribeReservedNodeExchangeStatusRequestT = Model::DescribeReservedNodeExchangeStatusRequest>
        void DescribeReservedNodeExchangeStatusAsync(const DescribeReservedNodeExchangeStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeReservedNodeExchangeStatusRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeReservedNodeExchangeStatus, request, handler, context);
        }
 
        virtual Model::DescribeReservedNodeOfferingsOutcome DescribeReservedNodeOfferings(const Model::DescribeReservedNodeOfferingsRequest& request = {}) const;
 
        template<typename DescribeReservedNodeOfferingsRequestT = Model::DescribeReservedNodeOfferingsRequest>
        Model::DescribeReservedNodeOfferingsOutcomeCallable DescribeReservedNodeOfferingsCallable(const DescribeReservedNodeOfferingsRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeReservedNodeOfferings, request);
        }
 
        template<typename DescribeReservedNodeOfferingsRequestT = Model::DescribeReservedNodeOfferingsRequest>
        void DescribeReservedNodeOfferingsAsync(const DescribeReservedNodeOfferingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeReservedNodeOfferingsRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeReservedNodeOfferings, request, handler, context);
        }
 
        virtual Model::DescribeReservedNodesOutcome DescribeReservedNodes(const Model::DescribeReservedNodesRequest& request = {}) const;
 
        template<typename DescribeReservedNodesRequestT = Model::DescribeReservedNodesRequest>
        Model::DescribeReservedNodesOutcomeCallable DescribeReservedNodesCallable(const DescribeReservedNodesRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeReservedNodes, request);
        }
 
        template<typename DescribeReservedNodesRequestT = Model::DescribeReservedNodesRequest>
        void DescribeReservedNodesAsync(const DescribeReservedNodesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeReservedNodesRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeReservedNodes, request, handler, context);
        }
 
        virtual Model::DescribeResizeOutcome DescribeResize(const Model::DescribeResizeRequest& request) const;
 
        template<typename DescribeResizeRequestT = Model::DescribeResizeRequest>
        Model::DescribeResizeOutcomeCallable DescribeResizeCallable(const DescribeResizeRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::DescribeResize, request);
        }
 
        template<typename DescribeResizeRequestT = Model::DescribeResizeRequest>
        void DescribeResizeAsync(const DescribeResizeRequestT& request, const DescribeResizeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::DescribeResize, request, handler, context);
        }
 
        virtual Model::DescribeScheduledActionsOutcome DescribeScheduledActions(const Model::DescribeScheduledActionsRequest& request = {}) const;
 
        template<typename DescribeScheduledActionsRequestT = Model::DescribeScheduledActionsRequest>
        Model::DescribeScheduledActionsOutcomeCallable DescribeScheduledActionsCallable(const DescribeScheduledActionsRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeScheduledActions, request);
        }
 
        template<typename DescribeScheduledActionsRequestT = Model::DescribeScheduledActionsRequest>
        void DescribeScheduledActionsAsync(const DescribeScheduledActionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeScheduledActionsRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeScheduledActions, request, handler, context);
        }
 
        virtual Model::DescribeSnapshotCopyGrantsOutcome DescribeSnapshotCopyGrants(const Model::DescribeSnapshotCopyGrantsRequest& request = {}) const;
 
        template<typename DescribeSnapshotCopyGrantsRequestT = Model::DescribeSnapshotCopyGrantsRequest>
        Model::DescribeSnapshotCopyGrantsOutcomeCallable DescribeSnapshotCopyGrantsCallable(const DescribeSnapshotCopyGrantsRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeSnapshotCopyGrants, request);
        }
 
        template<typename DescribeSnapshotCopyGrantsRequestT = Model::DescribeSnapshotCopyGrantsRequest>
        void DescribeSnapshotCopyGrantsAsync(const DescribeSnapshotCopyGrantsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeSnapshotCopyGrantsRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeSnapshotCopyGrants, request, handler, context);
        }
 
        virtual Model::DescribeSnapshotSchedulesOutcome DescribeSnapshotSchedules(const Model::DescribeSnapshotSchedulesRequest& request = {}) const;
 
        template<typename DescribeSnapshotSchedulesRequestT = Model::DescribeSnapshotSchedulesRequest>
        Model::DescribeSnapshotSchedulesOutcomeCallable DescribeSnapshotSchedulesCallable(const DescribeSnapshotSchedulesRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeSnapshotSchedules, request);
        }
 
        template<typename DescribeSnapshotSchedulesRequestT = Model::DescribeSnapshotSchedulesRequest>
        void DescribeSnapshotSchedulesAsync(const DescribeSnapshotSchedulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeSnapshotSchedulesRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeSnapshotSchedules, request, handler, context);
        }
 
        virtual Model::DescribeStorageOutcome DescribeStorage(const Model::DescribeStorageRequest& request = {}) const;
 
        template<typename DescribeStorageRequestT = Model::DescribeStorageRequest>
        Model::DescribeStorageOutcomeCallable DescribeStorageCallable(const DescribeStorageRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeStorage, request);
        }
 
        template<typename DescribeStorageRequestT = Model::DescribeStorageRequest>
        void DescribeStorageAsync(const DescribeStorageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeStorageRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeStorage, request, handler, context);
        }
 
        virtual Model::DescribeTableRestoreStatusOutcome DescribeTableRestoreStatus(const Model::DescribeTableRestoreStatusRequest& request = {}) const;
 
        template<typename DescribeTableRestoreStatusRequestT = Model::DescribeTableRestoreStatusRequest>
        Model::DescribeTableRestoreStatusOutcomeCallable DescribeTableRestoreStatusCallable(const DescribeTableRestoreStatusRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeTableRestoreStatus, request);
        }
 
        template<typename DescribeTableRestoreStatusRequestT = Model::DescribeTableRestoreStatusRequest>
        void DescribeTableRestoreStatusAsync(const DescribeTableRestoreStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeTableRestoreStatusRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeTableRestoreStatus, request, handler, context);
        }
 
        virtual Model::DescribeTagsOutcome DescribeTags(const Model::DescribeTagsRequest& request = {}) const;
 
        template<typename DescribeTagsRequestT = Model::DescribeTagsRequest>
        Model::DescribeTagsOutcomeCallable DescribeTagsCallable(const DescribeTagsRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeTags, request);
        }
 
        template<typename DescribeTagsRequestT = Model::DescribeTagsRequest>
        void DescribeTagsAsync(const DescribeTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeTagsRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeTags, request, handler, context);
        }
 
        virtual Model::DescribeUsageLimitsOutcome DescribeUsageLimits(const Model::DescribeUsageLimitsRequest& request = {}) const;
 
        template<typename DescribeUsageLimitsRequestT = Model::DescribeUsageLimitsRequest>
        Model::DescribeUsageLimitsOutcomeCallable DescribeUsageLimitsCallable(const DescribeUsageLimitsRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::DescribeUsageLimits, request);
        }
 
        template<typename DescribeUsageLimitsRequestT = Model::DescribeUsageLimitsRequest>
        void DescribeUsageLimitsAsync(const DescribeUsageLimitsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeUsageLimitsRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::DescribeUsageLimits, request, handler, context);
        }
 
        virtual Model::DisableLoggingOutcome DisableLogging(const Model::DisableLoggingRequest& request) const;
 
        template<typename DisableLoggingRequestT = Model::DisableLoggingRequest>
        Model::DisableLoggingOutcomeCallable DisableLoggingCallable(const DisableLoggingRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::DisableLogging, request);
        }
 
        template<typename DisableLoggingRequestT = Model::DisableLoggingRequest>
        void DisableLoggingAsync(const DisableLoggingRequestT& request, const DisableLoggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::DisableLogging, request, handler, context);
        }
 
        virtual Model::DisableSnapshotCopyOutcome DisableSnapshotCopy(const Model::DisableSnapshotCopyRequest& request) const;
 
        template<typename DisableSnapshotCopyRequestT = Model::DisableSnapshotCopyRequest>
        Model::DisableSnapshotCopyOutcomeCallable DisableSnapshotCopyCallable(const DisableSnapshotCopyRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::DisableSnapshotCopy, request);
        }
 
        template<typename DisableSnapshotCopyRequestT = Model::DisableSnapshotCopyRequest>
        void DisableSnapshotCopyAsync(const DisableSnapshotCopyRequestT& request, const DisableSnapshotCopyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::DisableSnapshotCopy, request, handler, context);
        }
 
        virtual Model::DisassociateDataShareConsumerOutcome DisassociateDataShareConsumer(const Model::DisassociateDataShareConsumerRequest& request) const;
 
        template<typename DisassociateDataShareConsumerRequestT = Model::DisassociateDataShareConsumerRequest>
        Model::DisassociateDataShareConsumerOutcomeCallable DisassociateDataShareConsumerCallable(const DisassociateDataShareConsumerRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::DisassociateDataShareConsumer, request);
        }
 
        template<typename DisassociateDataShareConsumerRequestT = Model::DisassociateDataShareConsumerRequest>
        void DisassociateDataShareConsumerAsync(const DisassociateDataShareConsumerRequestT& request, const DisassociateDataShareConsumerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::DisassociateDataShareConsumer, request, handler, context);
        }
 
        virtual Model::EnableLoggingOutcome EnableLogging(const Model::EnableLoggingRequest& request) const;
 
        template<typename EnableLoggingRequestT = Model::EnableLoggingRequest>
        Model::EnableLoggingOutcomeCallable EnableLoggingCallable(const EnableLoggingRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::EnableLogging, request);
        }
 
        template<typename EnableLoggingRequestT = Model::EnableLoggingRequest>
        void EnableLoggingAsync(const EnableLoggingRequestT& request, const EnableLoggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::EnableLogging, request, handler, context);
        }
 
        virtual Model::EnableSnapshotCopyOutcome EnableSnapshotCopy(const Model::EnableSnapshotCopyRequest& request) const;
 
        template<typename EnableSnapshotCopyRequestT = Model::EnableSnapshotCopyRequest>
        Model::EnableSnapshotCopyOutcomeCallable EnableSnapshotCopyCallable(const EnableSnapshotCopyRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::EnableSnapshotCopy, request);
        }
 
        template<typename EnableSnapshotCopyRequestT = Model::EnableSnapshotCopyRequest>
        void EnableSnapshotCopyAsync(const EnableSnapshotCopyRequestT& request, const EnableSnapshotCopyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::EnableSnapshotCopy, request, handler, context);
        }
 
        virtual Model::FailoverPrimaryComputeOutcome FailoverPrimaryCompute(const Model::FailoverPrimaryComputeRequest& request) const;
 
        template<typename FailoverPrimaryComputeRequestT = Model::FailoverPrimaryComputeRequest>
        Model::FailoverPrimaryComputeOutcomeCallable FailoverPrimaryComputeCallable(const FailoverPrimaryComputeRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::FailoverPrimaryCompute, request);
        }
 
        template<typename FailoverPrimaryComputeRequestT = Model::FailoverPrimaryComputeRequest>
        void FailoverPrimaryComputeAsync(const FailoverPrimaryComputeRequestT& request, const FailoverPrimaryComputeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::FailoverPrimaryCompute, request, handler, context);
        }
 
        virtual Model::GetClusterCredentialsOutcome GetClusterCredentials(const Model::GetClusterCredentialsRequest& request) const;
 
        template<typename GetClusterCredentialsRequestT = Model::GetClusterCredentialsRequest>
        Model::GetClusterCredentialsOutcomeCallable GetClusterCredentialsCallable(const GetClusterCredentialsRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::GetClusterCredentials, request);
        }
 
        template<typename GetClusterCredentialsRequestT = Model::GetClusterCredentialsRequest>
        void GetClusterCredentialsAsync(const GetClusterCredentialsRequestT& request, const GetClusterCredentialsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::GetClusterCredentials, request, handler, context);
        }
 
        virtual Model::GetClusterCredentialsWithIAMOutcome GetClusterCredentialsWithIAM(const Model::GetClusterCredentialsWithIAMRequest& request = {}) const;
 
        template<typename GetClusterCredentialsWithIAMRequestT = Model::GetClusterCredentialsWithIAMRequest>
        Model::GetClusterCredentialsWithIAMOutcomeCallable GetClusterCredentialsWithIAMCallable(const GetClusterCredentialsWithIAMRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::GetClusterCredentialsWithIAM, request);
        }
 
        template<typename GetClusterCredentialsWithIAMRequestT = Model::GetClusterCredentialsWithIAMRequest>
        void GetClusterCredentialsWithIAMAsync(const GetClusterCredentialsWithIAMResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetClusterCredentialsWithIAMRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::GetClusterCredentialsWithIAM, request, handler, context);
        }
 
        virtual Model::GetReservedNodeExchangeConfigurationOptionsOutcome GetReservedNodeExchangeConfigurationOptions(const Model::GetReservedNodeExchangeConfigurationOptionsRequest& request) const;
 
        template<typename GetReservedNodeExchangeConfigurationOptionsRequestT = Model::GetReservedNodeExchangeConfigurationOptionsRequest>
        Model::GetReservedNodeExchangeConfigurationOptionsOutcomeCallable GetReservedNodeExchangeConfigurationOptionsCallable(const GetReservedNodeExchangeConfigurationOptionsRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::GetReservedNodeExchangeConfigurationOptions, request);
        }
 
        template<typename GetReservedNodeExchangeConfigurationOptionsRequestT = Model::GetReservedNodeExchangeConfigurationOptionsRequest>
        void GetReservedNodeExchangeConfigurationOptionsAsync(const GetReservedNodeExchangeConfigurationOptionsRequestT& request, const GetReservedNodeExchangeConfigurationOptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::GetReservedNodeExchangeConfigurationOptions, request, handler, context);
        }
 
        virtual Model::GetReservedNodeExchangeOfferingsOutcome GetReservedNodeExchangeOfferings(const Model::GetReservedNodeExchangeOfferingsRequest& request) const;
 
        template<typename GetReservedNodeExchangeOfferingsRequestT = Model::GetReservedNodeExchangeOfferingsRequest>
        Model::GetReservedNodeExchangeOfferingsOutcomeCallable GetReservedNodeExchangeOfferingsCallable(const GetReservedNodeExchangeOfferingsRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::GetReservedNodeExchangeOfferings, request);
        }
 
        template<typename GetReservedNodeExchangeOfferingsRequestT = Model::GetReservedNodeExchangeOfferingsRequest>
        void GetReservedNodeExchangeOfferingsAsync(const GetReservedNodeExchangeOfferingsRequestT& request, const GetReservedNodeExchangeOfferingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::GetReservedNodeExchangeOfferings, 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(&RedshiftClient::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(&RedshiftClient::GetResourcePolicy, request, handler, context);
        }
 
        virtual Model::ListRecommendationsOutcome ListRecommendations(const Model::ListRecommendationsRequest& request = {}) const;
 
        template<typename ListRecommendationsRequestT = Model::ListRecommendationsRequest>
        Model::ListRecommendationsOutcomeCallable ListRecommendationsCallable(const ListRecommendationsRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::ListRecommendations, request);
        }
 
        template<typename ListRecommendationsRequestT = Model::ListRecommendationsRequest>
        void ListRecommendationsAsync(const ListRecommendationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRecommendationsRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::ListRecommendations, request, handler, context);
        }
 
        virtual Model::ModifyAquaConfigurationOutcome ModifyAquaConfiguration(const Model::ModifyAquaConfigurationRequest& request) const;
 
        template<typename ModifyAquaConfigurationRequestT = Model::ModifyAquaConfigurationRequest>
        Model::ModifyAquaConfigurationOutcomeCallable ModifyAquaConfigurationCallable(const ModifyAquaConfigurationRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::ModifyAquaConfiguration, request);
        }
 
        template<typename ModifyAquaConfigurationRequestT = Model::ModifyAquaConfigurationRequest>
        void ModifyAquaConfigurationAsync(const ModifyAquaConfigurationRequestT& request, const ModifyAquaConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::ModifyAquaConfiguration, request, handler, context);
        }
 
        virtual Model::ModifyAuthenticationProfileOutcome ModifyAuthenticationProfile(const Model::ModifyAuthenticationProfileRequest& request) const;
 
        template<typename ModifyAuthenticationProfileRequestT = Model::ModifyAuthenticationProfileRequest>
        Model::ModifyAuthenticationProfileOutcomeCallable ModifyAuthenticationProfileCallable(const ModifyAuthenticationProfileRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::ModifyAuthenticationProfile, request);
        }
 
        template<typename ModifyAuthenticationProfileRequestT = Model::ModifyAuthenticationProfileRequest>
        void ModifyAuthenticationProfileAsync(const ModifyAuthenticationProfileRequestT& request, const ModifyAuthenticationProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::ModifyAuthenticationProfile, request, handler, context);
        }
 
        virtual Model::ModifyClusterOutcome ModifyCluster(const Model::ModifyClusterRequest& request) const;
 
        template<typename ModifyClusterRequestT = Model::ModifyClusterRequest>
        Model::ModifyClusterOutcomeCallable ModifyClusterCallable(const ModifyClusterRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::ModifyCluster, request);
        }
 
        template<typename ModifyClusterRequestT = Model::ModifyClusterRequest>
        void ModifyClusterAsync(const ModifyClusterRequestT& request, const ModifyClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::ModifyCluster, request, handler, context);
        }
 
        virtual Model::ModifyClusterDbRevisionOutcome ModifyClusterDbRevision(const Model::ModifyClusterDbRevisionRequest& request) const;
 
        template<typename ModifyClusterDbRevisionRequestT = Model::ModifyClusterDbRevisionRequest>
        Model::ModifyClusterDbRevisionOutcomeCallable ModifyClusterDbRevisionCallable(const ModifyClusterDbRevisionRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::ModifyClusterDbRevision, request);
        }
 
        template<typename ModifyClusterDbRevisionRequestT = Model::ModifyClusterDbRevisionRequest>
        void ModifyClusterDbRevisionAsync(const ModifyClusterDbRevisionRequestT& request, const ModifyClusterDbRevisionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::ModifyClusterDbRevision, request, handler, context);
        }
 
        virtual Model::ModifyClusterIamRolesOutcome ModifyClusterIamRoles(const Model::ModifyClusterIamRolesRequest& request) const;
 
        template<typename ModifyClusterIamRolesRequestT = Model::ModifyClusterIamRolesRequest>
        Model::ModifyClusterIamRolesOutcomeCallable ModifyClusterIamRolesCallable(const ModifyClusterIamRolesRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::ModifyClusterIamRoles, request);
        }
 
        template<typename ModifyClusterIamRolesRequestT = Model::ModifyClusterIamRolesRequest>
        void ModifyClusterIamRolesAsync(const ModifyClusterIamRolesRequestT& request, const ModifyClusterIamRolesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::ModifyClusterIamRoles, request, handler, context);
        }
 
        virtual Model::ModifyClusterMaintenanceOutcome ModifyClusterMaintenance(const Model::ModifyClusterMaintenanceRequest& request) const;
 
        template<typename ModifyClusterMaintenanceRequestT = Model::ModifyClusterMaintenanceRequest>
        Model::ModifyClusterMaintenanceOutcomeCallable ModifyClusterMaintenanceCallable(const ModifyClusterMaintenanceRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::ModifyClusterMaintenance, request);
        }
 
        template<typename ModifyClusterMaintenanceRequestT = Model::ModifyClusterMaintenanceRequest>
        void ModifyClusterMaintenanceAsync(const ModifyClusterMaintenanceRequestT& request, const ModifyClusterMaintenanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::ModifyClusterMaintenance, request, handler, context);
        }
 
        virtual Model::ModifyClusterParameterGroupOutcome ModifyClusterParameterGroup(const Model::ModifyClusterParameterGroupRequest& request) const;
 
        template<typename ModifyClusterParameterGroupRequestT = Model::ModifyClusterParameterGroupRequest>
        Model::ModifyClusterParameterGroupOutcomeCallable ModifyClusterParameterGroupCallable(const ModifyClusterParameterGroupRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::ModifyClusterParameterGroup, request);
        }
 
        template<typename ModifyClusterParameterGroupRequestT = Model::ModifyClusterParameterGroupRequest>
        void ModifyClusterParameterGroupAsync(const ModifyClusterParameterGroupRequestT& request, const ModifyClusterParameterGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::ModifyClusterParameterGroup, request, handler, context);
        }
 
        virtual Model::ModifyClusterSnapshotOutcome ModifyClusterSnapshot(const Model::ModifyClusterSnapshotRequest& request) const;
 
        template<typename ModifyClusterSnapshotRequestT = Model::ModifyClusterSnapshotRequest>
        Model::ModifyClusterSnapshotOutcomeCallable ModifyClusterSnapshotCallable(const ModifyClusterSnapshotRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::ModifyClusterSnapshot, request);
        }
 
        template<typename ModifyClusterSnapshotRequestT = Model::ModifyClusterSnapshotRequest>
        void ModifyClusterSnapshotAsync(const ModifyClusterSnapshotRequestT& request, const ModifyClusterSnapshotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::ModifyClusterSnapshot, request, handler, context);
        }
 
        virtual Model::ModifyClusterSnapshotScheduleOutcome ModifyClusterSnapshotSchedule(const Model::ModifyClusterSnapshotScheduleRequest& request) const;
 
        template<typename ModifyClusterSnapshotScheduleRequestT = Model::ModifyClusterSnapshotScheduleRequest>
        Model::ModifyClusterSnapshotScheduleOutcomeCallable ModifyClusterSnapshotScheduleCallable(const ModifyClusterSnapshotScheduleRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::ModifyClusterSnapshotSchedule, request);
        }
 
        template<typename ModifyClusterSnapshotScheduleRequestT = Model::ModifyClusterSnapshotScheduleRequest>
        void ModifyClusterSnapshotScheduleAsync(const ModifyClusterSnapshotScheduleRequestT& request, const ModifyClusterSnapshotScheduleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::ModifyClusterSnapshotSchedule, request, handler, context);
        }
 
        virtual Model::ModifyClusterSubnetGroupOutcome ModifyClusterSubnetGroup(const Model::ModifyClusterSubnetGroupRequest& request) const;
 
        template<typename ModifyClusterSubnetGroupRequestT = Model::ModifyClusterSubnetGroupRequest>
        Model::ModifyClusterSubnetGroupOutcomeCallable ModifyClusterSubnetGroupCallable(const ModifyClusterSubnetGroupRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::ModifyClusterSubnetGroup, request);
        }
 
        template<typename ModifyClusterSubnetGroupRequestT = Model::ModifyClusterSubnetGroupRequest>
        void ModifyClusterSubnetGroupAsync(const ModifyClusterSubnetGroupRequestT& request, const ModifyClusterSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::ModifyClusterSubnetGroup, request, handler, context);
        }
 
        virtual Model::ModifyCustomDomainAssociationOutcome ModifyCustomDomainAssociation(const Model::ModifyCustomDomainAssociationRequest& request) const;
 
        template<typename ModifyCustomDomainAssociationRequestT = Model::ModifyCustomDomainAssociationRequest>
        Model::ModifyCustomDomainAssociationOutcomeCallable ModifyCustomDomainAssociationCallable(const ModifyCustomDomainAssociationRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::ModifyCustomDomainAssociation, request);
        }
 
        template<typename ModifyCustomDomainAssociationRequestT = Model::ModifyCustomDomainAssociationRequest>
        void ModifyCustomDomainAssociationAsync(const ModifyCustomDomainAssociationRequestT& request, const ModifyCustomDomainAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::ModifyCustomDomainAssociation, request, handler, context);
        }
 
        virtual Model::ModifyEndpointAccessOutcome ModifyEndpointAccess(const Model::ModifyEndpointAccessRequest& request) const;
 
        template<typename ModifyEndpointAccessRequestT = Model::ModifyEndpointAccessRequest>
        Model::ModifyEndpointAccessOutcomeCallable ModifyEndpointAccessCallable(const ModifyEndpointAccessRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::ModifyEndpointAccess, request);
        }
 
        template<typename ModifyEndpointAccessRequestT = Model::ModifyEndpointAccessRequest>
        void ModifyEndpointAccessAsync(const ModifyEndpointAccessRequestT& request, const ModifyEndpointAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::ModifyEndpointAccess, request, handler, context);
        }
 
        virtual Model::ModifyEventSubscriptionOutcome ModifyEventSubscription(const Model::ModifyEventSubscriptionRequest& request) const;
 
        template<typename ModifyEventSubscriptionRequestT = Model::ModifyEventSubscriptionRequest>
        Model::ModifyEventSubscriptionOutcomeCallable ModifyEventSubscriptionCallable(const ModifyEventSubscriptionRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::ModifyEventSubscription, request);
        }
 
        template<typename ModifyEventSubscriptionRequestT = Model::ModifyEventSubscriptionRequest>
        void ModifyEventSubscriptionAsync(const ModifyEventSubscriptionRequestT& request, const ModifyEventSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::ModifyEventSubscription, request, handler, context);
        }
 
        virtual Model::ModifyIntegrationOutcome ModifyIntegration(const Model::ModifyIntegrationRequest& request) const;
 
        template<typename ModifyIntegrationRequestT = Model::ModifyIntegrationRequest>
        Model::ModifyIntegrationOutcomeCallable ModifyIntegrationCallable(const ModifyIntegrationRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::ModifyIntegration, request);
        }
 
        template<typename ModifyIntegrationRequestT = Model::ModifyIntegrationRequest>
        void ModifyIntegrationAsync(const ModifyIntegrationRequestT& request, const ModifyIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::ModifyIntegration, request, handler, context);
        }
 
        virtual Model::ModifyRedshiftIdcApplicationOutcome ModifyRedshiftIdcApplication(const Model::ModifyRedshiftIdcApplicationRequest& request) const;
 
        template<typename ModifyRedshiftIdcApplicationRequestT = Model::ModifyRedshiftIdcApplicationRequest>
        Model::ModifyRedshiftIdcApplicationOutcomeCallable ModifyRedshiftIdcApplicationCallable(const ModifyRedshiftIdcApplicationRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::ModifyRedshiftIdcApplication, request);
        }
 
        template<typename ModifyRedshiftIdcApplicationRequestT = Model::ModifyRedshiftIdcApplicationRequest>
        void ModifyRedshiftIdcApplicationAsync(const ModifyRedshiftIdcApplicationRequestT& request, const ModifyRedshiftIdcApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::ModifyRedshiftIdcApplication, request, handler, context);
        }
 
        virtual Model::ModifyScheduledActionOutcome ModifyScheduledAction(const Model::ModifyScheduledActionRequest& request) const;
 
        template<typename ModifyScheduledActionRequestT = Model::ModifyScheduledActionRequest>
        Model::ModifyScheduledActionOutcomeCallable ModifyScheduledActionCallable(const ModifyScheduledActionRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::ModifyScheduledAction, request);
        }
 
        template<typename ModifyScheduledActionRequestT = Model::ModifyScheduledActionRequest>
        void ModifyScheduledActionAsync(const ModifyScheduledActionRequestT& request, const ModifyScheduledActionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::ModifyScheduledAction, request, handler, context);
        }
 
        virtual Model::ModifySnapshotCopyRetentionPeriodOutcome ModifySnapshotCopyRetentionPeriod(const Model::ModifySnapshotCopyRetentionPeriodRequest& request) const;
 
        template<typename ModifySnapshotCopyRetentionPeriodRequestT = Model::ModifySnapshotCopyRetentionPeriodRequest>
        Model::ModifySnapshotCopyRetentionPeriodOutcomeCallable ModifySnapshotCopyRetentionPeriodCallable(const ModifySnapshotCopyRetentionPeriodRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::ModifySnapshotCopyRetentionPeriod, request);
        }
 
        template<typename ModifySnapshotCopyRetentionPeriodRequestT = Model::ModifySnapshotCopyRetentionPeriodRequest>
        void ModifySnapshotCopyRetentionPeriodAsync(const ModifySnapshotCopyRetentionPeriodRequestT& request, const ModifySnapshotCopyRetentionPeriodResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::ModifySnapshotCopyRetentionPeriod, request, handler, context);
        }
 
        virtual Model::ModifySnapshotScheduleOutcome ModifySnapshotSchedule(const Model::ModifySnapshotScheduleRequest& request) const;
 
        template<typename ModifySnapshotScheduleRequestT = Model::ModifySnapshotScheduleRequest>
        Model::ModifySnapshotScheduleOutcomeCallable ModifySnapshotScheduleCallable(const ModifySnapshotScheduleRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::ModifySnapshotSchedule, request);
        }
 
        template<typename ModifySnapshotScheduleRequestT = Model::ModifySnapshotScheduleRequest>
        void ModifySnapshotScheduleAsync(const ModifySnapshotScheduleRequestT& request, const ModifySnapshotScheduleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::ModifySnapshotSchedule, request, handler, context);
        }
 
        virtual Model::ModifyUsageLimitOutcome ModifyUsageLimit(const Model::ModifyUsageLimitRequest& request) const;
 
        template<typename ModifyUsageLimitRequestT = Model::ModifyUsageLimitRequest>
        Model::ModifyUsageLimitOutcomeCallable ModifyUsageLimitCallable(const ModifyUsageLimitRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::ModifyUsageLimit, request);
        }
 
        template<typename ModifyUsageLimitRequestT = Model::ModifyUsageLimitRequest>
        void ModifyUsageLimitAsync(const ModifyUsageLimitRequestT& request, const ModifyUsageLimitResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::ModifyUsageLimit, request, handler, context);
        }
 
        virtual Model::PauseClusterOutcome PauseCluster(const Model::PauseClusterRequest& request) const;
 
        template<typename PauseClusterRequestT = Model::PauseClusterRequest>
        Model::PauseClusterOutcomeCallable PauseClusterCallable(const PauseClusterRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::PauseCluster, request);
        }
 
        template<typename PauseClusterRequestT = Model::PauseClusterRequest>
        void PauseClusterAsync(const PauseClusterRequestT& request, const PauseClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::PauseCluster, request, handler, context);
        }
 
        virtual Model::PurchaseReservedNodeOfferingOutcome PurchaseReservedNodeOffering(const Model::PurchaseReservedNodeOfferingRequest& request) const;
 
        template<typename PurchaseReservedNodeOfferingRequestT = Model::PurchaseReservedNodeOfferingRequest>
        Model::PurchaseReservedNodeOfferingOutcomeCallable PurchaseReservedNodeOfferingCallable(const PurchaseReservedNodeOfferingRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::PurchaseReservedNodeOffering, request);
        }
 
        template<typename PurchaseReservedNodeOfferingRequestT = Model::PurchaseReservedNodeOfferingRequest>
        void PurchaseReservedNodeOfferingAsync(const PurchaseReservedNodeOfferingRequestT& request, const PurchaseReservedNodeOfferingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::PurchaseReservedNodeOffering, 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(&RedshiftClient::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(&RedshiftClient::PutResourcePolicy, request, handler, context);
        }
 
        virtual Model::RebootClusterOutcome RebootCluster(const Model::RebootClusterRequest& request) const;
 
        template<typename RebootClusterRequestT = Model::RebootClusterRequest>
        Model::RebootClusterOutcomeCallable RebootClusterCallable(const RebootClusterRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::RebootCluster, request);
        }
 
        template<typename RebootClusterRequestT = Model::RebootClusterRequest>
        void RebootClusterAsync(const RebootClusterRequestT& request, const RebootClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::RebootCluster, request, handler, context);
        }
 
        virtual Model::RejectDataShareOutcome RejectDataShare(const Model::RejectDataShareRequest& request) const;
 
        template<typename RejectDataShareRequestT = Model::RejectDataShareRequest>
        Model::RejectDataShareOutcomeCallable RejectDataShareCallable(const RejectDataShareRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::RejectDataShare, request);
        }
 
        template<typename RejectDataShareRequestT = Model::RejectDataShareRequest>
        void RejectDataShareAsync(const RejectDataShareRequestT& request, const RejectDataShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::RejectDataShare, request, handler, context);
        }
 
        virtual Model::ResetClusterParameterGroupOutcome ResetClusterParameterGroup(const Model::ResetClusterParameterGroupRequest& request) const;
 
        template<typename ResetClusterParameterGroupRequestT = Model::ResetClusterParameterGroupRequest>
        Model::ResetClusterParameterGroupOutcomeCallable ResetClusterParameterGroupCallable(const ResetClusterParameterGroupRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::ResetClusterParameterGroup, request);
        }
 
        template<typename ResetClusterParameterGroupRequestT = Model::ResetClusterParameterGroupRequest>
        void ResetClusterParameterGroupAsync(const ResetClusterParameterGroupRequestT& request, const ResetClusterParameterGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::ResetClusterParameterGroup, request, handler, context);
        }
 
        virtual Model::ResizeClusterOutcome ResizeCluster(const Model::ResizeClusterRequest& request) const;
 
        template<typename ResizeClusterRequestT = Model::ResizeClusterRequest>
        Model::ResizeClusterOutcomeCallable ResizeClusterCallable(const ResizeClusterRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::ResizeCluster, request);
        }
 
        template<typename ResizeClusterRequestT = Model::ResizeClusterRequest>
        void ResizeClusterAsync(const ResizeClusterRequestT& request, const ResizeClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::ResizeCluster, request, handler, context);
        }
 
        virtual Model::RestoreFromClusterSnapshotOutcome RestoreFromClusterSnapshot(const Model::RestoreFromClusterSnapshotRequest& request) const;
 
        template<typename RestoreFromClusterSnapshotRequestT = Model::RestoreFromClusterSnapshotRequest>
        Model::RestoreFromClusterSnapshotOutcomeCallable RestoreFromClusterSnapshotCallable(const RestoreFromClusterSnapshotRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::RestoreFromClusterSnapshot, request);
        }
 
        template<typename RestoreFromClusterSnapshotRequestT = Model::RestoreFromClusterSnapshotRequest>
        void RestoreFromClusterSnapshotAsync(const RestoreFromClusterSnapshotRequestT& request, const RestoreFromClusterSnapshotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::RestoreFromClusterSnapshot, request, handler, context);
        }
 
        virtual Model::RestoreTableFromClusterSnapshotOutcome RestoreTableFromClusterSnapshot(const Model::RestoreTableFromClusterSnapshotRequest& request) const;
 
        template<typename RestoreTableFromClusterSnapshotRequestT = Model::RestoreTableFromClusterSnapshotRequest>
        Model::RestoreTableFromClusterSnapshotOutcomeCallable RestoreTableFromClusterSnapshotCallable(const RestoreTableFromClusterSnapshotRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::RestoreTableFromClusterSnapshot, request);
        }
 
        template<typename RestoreTableFromClusterSnapshotRequestT = Model::RestoreTableFromClusterSnapshotRequest>
        void RestoreTableFromClusterSnapshotAsync(const RestoreTableFromClusterSnapshotRequestT& request, const RestoreTableFromClusterSnapshotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::RestoreTableFromClusterSnapshot, request, handler, context);
        }
 
        virtual Model::ResumeClusterOutcome ResumeCluster(const Model::ResumeClusterRequest& request) const;
 
        template<typename ResumeClusterRequestT = Model::ResumeClusterRequest>
        Model::ResumeClusterOutcomeCallable ResumeClusterCallable(const ResumeClusterRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::ResumeCluster, request);
        }
 
        template<typename ResumeClusterRequestT = Model::ResumeClusterRequest>
        void ResumeClusterAsync(const ResumeClusterRequestT& request, const ResumeClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::ResumeCluster, request, handler, context);
        }
 
        virtual Model::RevokeClusterSecurityGroupIngressOutcome RevokeClusterSecurityGroupIngress(const Model::RevokeClusterSecurityGroupIngressRequest& request) const;
 
        template<typename RevokeClusterSecurityGroupIngressRequestT = Model::RevokeClusterSecurityGroupIngressRequest>
        Model::RevokeClusterSecurityGroupIngressOutcomeCallable RevokeClusterSecurityGroupIngressCallable(const RevokeClusterSecurityGroupIngressRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::RevokeClusterSecurityGroupIngress, request);
        }
 
        template<typename RevokeClusterSecurityGroupIngressRequestT = Model::RevokeClusterSecurityGroupIngressRequest>
        void RevokeClusterSecurityGroupIngressAsync(const RevokeClusterSecurityGroupIngressRequestT& request, const RevokeClusterSecurityGroupIngressResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::RevokeClusterSecurityGroupIngress, request, handler, context);
        }
 
        virtual Model::RevokeEndpointAccessOutcome RevokeEndpointAccess(const Model::RevokeEndpointAccessRequest& request = {}) const;
 
        template<typename RevokeEndpointAccessRequestT = Model::RevokeEndpointAccessRequest>
        Model::RevokeEndpointAccessOutcomeCallable RevokeEndpointAccessCallable(const RevokeEndpointAccessRequestT& request = {}) const
        {
            return SubmitCallable(&RedshiftClient::RevokeEndpointAccess, request);
        }
 
        template<typename RevokeEndpointAccessRequestT = Model::RevokeEndpointAccessRequest>
        void RevokeEndpointAccessAsync(const RevokeEndpointAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const RevokeEndpointAccessRequestT& request = {}) const
        {
            return SubmitAsync(&RedshiftClient::RevokeEndpointAccess, request, handler, context);
        }
 
        virtual Model::RevokeSnapshotAccessOutcome RevokeSnapshotAccess(const Model::RevokeSnapshotAccessRequest& request) const;
 
        template<typename RevokeSnapshotAccessRequestT = Model::RevokeSnapshotAccessRequest>
        Model::RevokeSnapshotAccessOutcomeCallable RevokeSnapshotAccessCallable(const RevokeSnapshotAccessRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::RevokeSnapshotAccess, request);
        }
 
        template<typename RevokeSnapshotAccessRequestT = Model::RevokeSnapshotAccessRequest>
        void RevokeSnapshotAccessAsync(const RevokeSnapshotAccessRequestT& request, const RevokeSnapshotAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::RevokeSnapshotAccess, request, handler, context);
        }
 
        virtual Model::RotateEncryptionKeyOutcome RotateEncryptionKey(const Model::RotateEncryptionKeyRequest& request) const;
 
        template<typename RotateEncryptionKeyRequestT = Model::RotateEncryptionKeyRequest>
        Model::RotateEncryptionKeyOutcomeCallable RotateEncryptionKeyCallable(const RotateEncryptionKeyRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::RotateEncryptionKey, request);
        }
 
        template<typename RotateEncryptionKeyRequestT = Model::RotateEncryptionKeyRequest>
        void RotateEncryptionKeyAsync(const RotateEncryptionKeyRequestT& request, const RotateEncryptionKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::RotateEncryptionKey, request, handler, context);
        }
 
        virtual Model::UpdatePartnerStatusOutcome UpdatePartnerStatus(const Model::UpdatePartnerStatusRequest& request) const;
 
        template<typename UpdatePartnerStatusRequestT = Model::UpdatePartnerStatusRequest>
        Model::UpdatePartnerStatusOutcomeCallable UpdatePartnerStatusCallable(const UpdatePartnerStatusRequestT& request) const
        {
            return SubmitCallable(&RedshiftClient::UpdatePartnerStatus, request);
        }
 
        template<typename UpdatePartnerStatusRequestT = Model::UpdatePartnerStatusRequest>
        void UpdatePartnerStatusAsync(const UpdatePartnerStatusRequestT& request, const UpdatePartnerStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RedshiftClient::UpdatePartnerStatus, request, handler, context);
        }
 
 
        void OverrideEndpoint(const Aws::String& endpoint);
        std::shared_ptr<RedshiftEndpointProviderBase>& accessEndpointProvider();
  private:
        friend class Aws::Client::ClientWithAsyncTemplateMethods<RedshiftClient>;
        void init(const RedshiftClientConfiguration& clientConfiguration);
 
        RedshiftClientConfiguration m_clientConfiguration;
        std::shared_ptr<RedshiftEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Redshift
} // namespace Aws