RedshiftClient.h

 
#pragma once
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/redshift/RedshiftPaginationBase.h>
#include <aws/redshift/RedshiftServiceClientModel.h>
#include <aws/redshift/RedshiftWaiter.h>
#include <aws/redshift/Redshift_EXPORTS.h>
 
namespace Aws {
namespace Redshift {
class AWS_REDSHIFT_API RedshiftClient : public Aws::Client::AWSXMLClient,
                                        public Aws::Client::ClientWithAsyncTemplateMethods<RedshiftClient>,
                                        public RedshiftPaginationBase<RedshiftClient>,
                                        public RedshiftWaiter<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::DeregisterNamespaceOutcome DeregisterNamespace(const Model::DeregisterNamespaceRequest& request) const;
 
  template <typename DeregisterNamespaceRequestT = Model::DeregisterNamespaceRequest>
  Model::DeregisterNamespaceOutcomeCallable DeregisterNamespaceCallable(const DeregisterNamespaceRequestT& request) const {
    return SubmitCallable(&RedshiftClient::DeregisterNamespace, request);
  }
 
  template <typename DeregisterNamespaceRequestT = Model::DeregisterNamespaceRequest>
  void DeregisterNamespaceAsync(const DeregisterNamespaceRequestT& request, const DeregisterNamespaceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftClient::DeregisterNamespace, 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::GetIdentityCenterAuthTokenOutcome GetIdentityCenterAuthToken(
      const Model::GetIdentityCenterAuthTokenRequest& request) const;
 
  template <typename GetIdentityCenterAuthTokenRequestT = Model::GetIdentityCenterAuthTokenRequest>
  Model::GetIdentityCenterAuthTokenOutcomeCallable GetIdentityCenterAuthTokenCallable(
      const GetIdentityCenterAuthTokenRequestT& request) const {
    return SubmitCallable(&RedshiftClient::GetIdentityCenterAuthToken, request);
  }
 
  template <typename GetIdentityCenterAuthTokenRequestT = Model::GetIdentityCenterAuthTokenRequest>
  void GetIdentityCenterAuthTokenAsync(const GetIdentityCenterAuthTokenRequestT& request,
                                       const GetIdentityCenterAuthTokenResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftClient::GetIdentityCenterAuthToken, 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::ModifyLakehouseConfigurationOutcome ModifyLakehouseConfiguration(
      const Model::ModifyLakehouseConfigurationRequest& request) const;
 
  template <typename ModifyLakehouseConfigurationRequestT = Model::ModifyLakehouseConfigurationRequest>
  Model::ModifyLakehouseConfigurationOutcomeCallable ModifyLakehouseConfigurationCallable(
      const ModifyLakehouseConfigurationRequestT& request) const {
    return SubmitCallable(&RedshiftClient::ModifyLakehouseConfiguration, request);
  }
 
  template <typename ModifyLakehouseConfigurationRequestT = Model::ModifyLakehouseConfigurationRequest>
  void ModifyLakehouseConfigurationAsync(const ModifyLakehouseConfigurationRequestT& request,
                                         const ModifyLakehouseConfigurationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftClient::ModifyLakehouseConfiguration, 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::RegisterNamespaceOutcome RegisterNamespace(const Model::RegisterNamespaceRequest& request) const;
 
  template <typename RegisterNamespaceRequestT = Model::RegisterNamespaceRequest>
  Model::RegisterNamespaceOutcomeCallable RegisterNamespaceCallable(const RegisterNamespaceRequestT& request) const {
    return SubmitCallable(&RedshiftClient::RegisterNamespace, request);
  }
 
  template <typename RegisterNamespaceRequestT = Model::RegisterNamespaceRequest>
  void RegisterNamespaceAsync(const RegisterNamespaceRequestT& request, const RegisterNamespaceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RedshiftClient::RegisterNamespace, 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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<RedshiftEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<RedshiftClient>;
  void init(const RedshiftClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, RedshiftError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  RedshiftClientConfiguration m_clientConfiguration;
  std::shared_ptr<RedshiftEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Redshift
}  // namespace Aws