AWS SDK for C++  1.9.108
AWS SDK for C++
Classes | Namespaces | Typedefs
RedshiftClient.h File Reference
#include <aws/redshift/Redshift_EXPORTS.h>
#include <aws/redshift/RedshiftErrors.h>
#include <aws/core/client/AWSError.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/redshift/model/AcceptReservedNodeExchangeResult.h>
#include <aws/redshift/model/AddPartnerResult.h>
#include <aws/redshift/model/AssociateDataShareConsumerResult.h>
#include <aws/redshift/model/AuthorizeClusterSecurityGroupIngressResult.h>
#include <aws/redshift/model/AuthorizeDataShareResult.h>
#include <aws/redshift/model/AuthorizeEndpointAccessResult.h>
#include <aws/redshift/model/AuthorizeSnapshotAccessResult.h>
#include <aws/redshift/model/BatchDeleteClusterSnapshotsResult.h>
#include <aws/redshift/model/BatchModifyClusterSnapshotsResult.h>
#include <aws/redshift/model/CancelResizeResult.h>
#include <aws/redshift/model/CopyClusterSnapshotResult.h>
#include <aws/redshift/model/CreateAuthenticationProfileResult.h>
#include <aws/redshift/model/CreateClusterResult.h>
#include <aws/redshift/model/CreateClusterParameterGroupResult.h>
#include <aws/redshift/model/CreateClusterSecurityGroupResult.h>
#include <aws/redshift/model/CreateClusterSnapshotResult.h>
#include <aws/redshift/model/CreateClusterSubnetGroupResult.h>
#include <aws/redshift/model/CreateEndpointAccessResult.h>
#include <aws/redshift/model/CreateEventSubscriptionResult.h>
#include <aws/redshift/model/CreateHsmClientCertificateResult.h>
#include <aws/redshift/model/CreateHsmConfigurationResult.h>
#include <aws/redshift/model/CreateScheduledActionResult.h>
#include <aws/redshift/model/CreateSnapshotCopyGrantResult.h>
#include <aws/redshift/model/CreateSnapshotScheduleResult.h>
#include <aws/redshift/model/CreateUsageLimitResult.h>
#include <aws/redshift/model/DeauthorizeDataShareResult.h>
#include <aws/redshift/model/DeleteAuthenticationProfileResult.h>
#include <aws/redshift/model/DeleteClusterResult.h>
#include <aws/redshift/model/DeleteClusterSnapshotResult.h>
#include <aws/redshift/model/DeleteEndpointAccessResult.h>
#include <aws/redshift/model/DeletePartnerResult.h>
#include <aws/redshift/model/DescribeAccountAttributesResult.h>
#include <aws/redshift/model/DescribeAuthenticationProfilesResult.h>
#include <aws/redshift/model/DescribeClusterDbRevisionsResult.h>
#include <aws/redshift/model/DescribeClusterParameterGroupsResult.h>
#include <aws/redshift/model/DescribeClusterParametersResult.h>
#include <aws/redshift/model/DescribeClusterSecurityGroupsResult.h>
#include <aws/redshift/model/DescribeClusterSnapshotsResult.h>
#include <aws/redshift/model/DescribeClusterSubnetGroupsResult.h>
#include <aws/redshift/model/DescribeClusterTracksResult.h>
#include <aws/redshift/model/DescribeClusterVersionsResult.h>
#include <aws/redshift/model/DescribeClustersResult.h>
#include <aws/redshift/model/DescribeDataSharesResult.h>
#include <aws/redshift/model/DescribeDataSharesForConsumerResult.h>
#include <aws/redshift/model/DescribeDataSharesForProducerResult.h>
#include <aws/redshift/model/DescribeDefaultClusterParametersResult.h>
#include <aws/redshift/model/DescribeEndpointAccessResult.h>
#include <aws/redshift/model/DescribeEndpointAuthorizationResult.h>
#include <aws/redshift/model/DescribeEventCategoriesResult.h>
#include <aws/redshift/model/DescribeEventSubscriptionsResult.h>
#include <aws/redshift/model/DescribeEventsResult.h>
#include <aws/redshift/model/DescribeHsmClientCertificatesResult.h>
#include <aws/redshift/model/DescribeHsmConfigurationsResult.h>
#include <aws/redshift/model/DescribeLoggingStatusResult.h>
#include <aws/redshift/model/DescribeNodeConfigurationOptionsResult.h>
#include <aws/redshift/model/DescribeOrderableClusterOptionsResult.h>
#include <aws/redshift/model/DescribePartnersResult.h>
#include <aws/redshift/model/DescribeReservedNodeOfferingsResult.h>
#include <aws/redshift/model/DescribeReservedNodesResult.h>
#include <aws/redshift/model/DescribeResizeResult.h>
#include <aws/redshift/model/DescribeScheduledActionsResult.h>
#include <aws/redshift/model/DescribeSnapshotCopyGrantsResult.h>
#include <aws/redshift/model/DescribeSnapshotSchedulesResult.h>
#include <aws/redshift/model/DescribeStorageResult.h>
#include <aws/redshift/model/DescribeTableRestoreStatusResult.h>
#include <aws/redshift/model/DescribeTagsResult.h>
#include <aws/redshift/model/DescribeUsageLimitsResult.h>
#include <aws/redshift/model/DisableLoggingResult.h>
#include <aws/redshift/model/DisableSnapshotCopyResult.h>
#include <aws/redshift/model/DisassociateDataShareConsumerResult.h>
#include <aws/redshift/model/EnableLoggingResult.h>
#include <aws/redshift/model/EnableSnapshotCopyResult.h>
#include <aws/redshift/model/GetClusterCredentialsResult.h>
#include <aws/redshift/model/GetReservedNodeExchangeOfferingsResult.h>
#include <aws/redshift/model/ModifyAquaConfigurationResult.h>
#include <aws/redshift/model/ModifyAuthenticationProfileResult.h>
#include <aws/redshift/model/ModifyClusterResult.h>
#include <aws/redshift/model/ModifyClusterDbRevisionResult.h>
#include <aws/redshift/model/ModifyClusterIamRolesResult.h>
#include <aws/redshift/model/ModifyClusterMaintenanceResult.h>
#include <aws/redshift/model/ModifyClusterParameterGroupResult.h>
#include <aws/redshift/model/ModifyClusterSnapshotResult.h>
#include <aws/redshift/model/ModifyClusterSubnetGroupResult.h>
#include <aws/redshift/model/ModifyEndpointAccessResult.h>
#include <aws/redshift/model/ModifyEventSubscriptionResult.h>
#include <aws/redshift/model/ModifyScheduledActionResult.h>
#include <aws/redshift/model/ModifySnapshotCopyRetentionPeriodResult.h>
#include <aws/redshift/model/ModifySnapshotScheduleResult.h>
#include <aws/redshift/model/ModifyUsageLimitResult.h>
#include <aws/redshift/model/PauseClusterResult.h>
#include <aws/redshift/model/PurchaseReservedNodeOfferingResult.h>
#include <aws/redshift/model/RebootClusterResult.h>
#include <aws/redshift/model/RejectDataShareResult.h>
#include <aws/redshift/model/ResetClusterParameterGroupResult.h>
#include <aws/redshift/model/ResizeClusterResult.h>
#include <aws/redshift/model/RestoreFromClusterSnapshotResult.h>
#include <aws/redshift/model/RestoreTableFromClusterSnapshotResult.h>
#include <aws/redshift/model/ResumeClusterResult.h>
#include <aws/redshift/model/RevokeClusterSecurityGroupIngressResult.h>
#include <aws/redshift/model/RevokeEndpointAccessResult.h>
#include <aws/redshift/model/RevokeSnapshotAccessResult.h>
#include <aws/redshift/model/RotateEncryptionKeyResult.h>
#include <aws/redshift/model/UpdatePartnerStatusResult.h>
#include <aws/core/NoResult.h>
#include <aws/core/client/AsyncCallerContext.h>
#include <aws/core/http/HttpTypes.h>
#include <future>
#include <functional>

Go to the source code of this file.

Classes

class  Aws::Redshift::RedshiftClient
 

Namespaces

 Aws
 
 Aws::Http
 
 Aws::Utils
 
 Aws::Utils::Threading
 
 Aws::Utils::Xml
 
 Aws::Auth
 
 Aws::Client
 
 Aws::Redshift
 
 Aws::Redshift::Model
 

Typedefs

typedef Aws::Utils::Outcome< AcceptReservedNodeExchangeResult, RedshiftError > Aws::Redshift::Model::AcceptReservedNodeExchangeOutcome
 
typedef Aws::Utils::Outcome< AddPartnerResult, RedshiftError > Aws::Redshift::Model::AddPartnerOutcome
 
typedef Aws::Utils::Outcome< AssociateDataShareConsumerResult, RedshiftError > Aws::Redshift::Model::AssociateDataShareConsumerOutcome
 
typedef Aws::Utils::Outcome< AuthorizeClusterSecurityGroupIngressResult, RedshiftError > Aws::Redshift::Model::AuthorizeClusterSecurityGroupIngressOutcome
 
typedef Aws::Utils::Outcome< AuthorizeDataShareResult, RedshiftError > Aws::Redshift::Model::AuthorizeDataShareOutcome
 
typedef Aws::Utils::Outcome< AuthorizeEndpointAccessResult, RedshiftError > Aws::Redshift::Model::AuthorizeEndpointAccessOutcome
 
typedef Aws::Utils::Outcome< AuthorizeSnapshotAccessResult, RedshiftError > Aws::Redshift::Model::AuthorizeSnapshotAccessOutcome
 
typedef Aws::Utils::Outcome< BatchDeleteClusterSnapshotsResult, RedshiftError > Aws::Redshift::Model::BatchDeleteClusterSnapshotsOutcome
 
typedef Aws::Utils::Outcome< BatchModifyClusterSnapshotsResult, RedshiftError > Aws::Redshift::Model::BatchModifyClusterSnapshotsOutcome
 
typedef Aws::Utils::Outcome< CancelResizeResult, RedshiftError > Aws::Redshift::Model::CancelResizeOutcome
 
typedef Aws::Utils::Outcome< CopyClusterSnapshotResult, RedshiftError > Aws::Redshift::Model::CopyClusterSnapshotOutcome
 
typedef Aws::Utils::Outcome< CreateAuthenticationProfileResult, RedshiftError > Aws::Redshift::Model::CreateAuthenticationProfileOutcome
 
typedef Aws::Utils::Outcome< CreateClusterResult, RedshiftError > Aws::Redshift::Model::CreateClusterOutcome
 
typedef Aws::Utils::Outcome< CreateClusterParameterGroupResult, RedshiftError > Aws::Redshift::Model::CreateClusterParameterGroupOutcome
 
typedef Aws::Utils::Outcome< CreateClusterSecurityGroupResult, RedshiftError > Aws::Redshift::Model::CreateClusterSecurityGroupOutcome
 
typedef Aws::Utils::Outcome< CreateClusterSnapshotResult, RedshiftError > Aws::Redshift::Model::CreateClusterSnapshotOutcome
 
typedef Aws::Utils::Outcome< CreateClusterSubnetGroupResult, RedshiftError > Aws::Redshift::Model::CreateClusterSubnetGroupOutcome
 
typedef Aws::Utils::Outcome< CreateEndpointAccessResult, RedshiftError > Aws::Redshift::Model::CreateEndpointAccessOutcome
 
typedef Aws::Utils::Outcome< CreateEventSubscriptionResult, RedshiftError > Aws::Redshift::Model::CreateEventSubscriptionOutcome
 
typedef Aws::Utils::Outcome< CreateHsmClientCertificateResult, RedshiftError > Aws::Redshift::Model::CreateHsmClientCertificateOutcome
 
typedef Aws::Utils::Outcome< CreateHsmConfigurationResult, RedshiftError > Aws::Redshift::Model::CreateHsmConfigurationOutcome
 
typedef Aws::Utils::Outcome< CreateScheduledActionResult, RedshiftError > Aws::Redshift::Model::CreateScheduledActionOutcome
 
typedef Aws::Utils::Outcome< CreateSnapshotCopyGrantResult, RedshiftError > Aws::Redshift::Model::CreateSnapshotCopyGrantOutcome
 
typedef Aws::Utils::Outcome< CreateSnapshotScheduleResult, RedshiftError > Aws::Redshift::Model::CreateSnapshotScheduleOutcome
 
typedef Aws::Utils::Outcome< Aws::NoResult, RedshiftError > Aws::Redshift::Model::CreateTagsOutcome
 
typedef Aws::Utils::Outcome< CreateUsageLimitResult, RedshiftError > Aws::Redshift::Model::CreateUsageLimitOutcome
 
typedef Aws::Utils::Outcome< DeauthorizeDataShareResult, RedshiftError > Aws::Redshift::Model::DeauthorizeDataShareOutcome
 
typedef Aws::Utils::Outcome< DeleteAuthenticationProfileResult, RedshiftError > Aws::Redshift::Model::DeleteAuthenticationProfileOutcome
 
typedef Aws::Utils::Outcome< DeleteClusterResult, RedshiftError > Aws::Redshift::Model::DeleteClusterOutcome
 
typedef Aws::Utils::Outcome< Aws::NoResult, RedshiftError > Aws::Redshift::Model::DeleteClusterParameterGroupOutcome
 
typedef Aws::Utils::Outcome< Aws::NoResult, RedshiftError > Aws::Redshift::Model::DeleteClusterSecurityGroupOutcome
 
typedef Aws::Utils::Outcome< DeleteClusterSnapshotResult, RedshiftError > Aws::Redshift::Model::DeleteClusterSnapshotOutcome
 
typedef Aws::Utils::Outcome< Aws::NoResult, RedshiftError > Aws::Redshift::Model::DeleteClusterSubnetGroupOutcome
 
typedef Aws::Utils::Outcome< DeleteEndpointAccessResult, RedshiftError > Aws::Redshift::Model::DeleteEndpointAccessOutcome
 
typedef Aws::Utils::Outcome< Aws::NoResult, RedshiftError > Aws::Redshift::Model::DeleteEventSubscriptionOutcome
 
typedef Aws::Utils::Outcome< Aws::NoResult, RedshiftError > Aws::Redshift::Model::DeleteHsmClientCertificateOutcome
 
typedef Aws::Utils::Outcome< Aws::NoResult, RedshiftError > Aws::Redshift::Model::DeleteHsmConfigurationOutcome
 
typedef Aws::Utils::Outcome< DeletePartnerResult, RedshiftError > Aws::Redshift::Model::DeletePartnerOutcome
 
typedef Aws::Utils::Outcome< Aws::NoResult, RedshiftError > Aws::Redshift::Model::DeleteScheduledActionOutcome
 
typedef Aws::Utils::Outcome< Aws::NoResult, RedshiftError > Aws::Redshift::Model::DeleteSnapshotCopyGrantOutcome
 
typedef Aws::Utils::Outcome< Aws::NoResult, RedshiftError > Aws::Redshift::Model::DeleteSnapshotScheduleOutcome
 
typedef Aws::Utils::Outcome< Aws::NoResult, RedshiftError > Aws::Redshift::Model::DeleteTagsOutcome
 
typedef Aws::Utils::Outcome< Aws::NoResult, RedshiftError > Aws::Redshift::Model::DeleteUsageLimitOutcome
 
typedef Aws::Utils::Outcome< DescribeAccountAttributesResult, RedshiftError > Aws::Redshift::Model::DescribeAccountAttributesOutcome
 
typedef Aws::Utils::Outcome< DescribeAuthenticationProfilesResult, RedshiftError > Aws::Redshift::Model::DescribeAuthenticationProfilesOutcome
 
typedef Aws::Utils::Outcome< DescribeClusterDbRevisionsResult, RedshiftError > Aws::Redshift::Model::DescribeClusterDbRevisionsOutcome
 
typedef Aws::Utils::Outcome< DescribeClusterParameterGroupsResult, RedshiftError > Aws::Redshift::Model::DescribeClusterParameterGroupsOutcome
 
typedef Aws::Utils::Outcome< DescribeClusterParametersResult, RedshiftError > Aws::Redshift::Model::DescribeClusterParametersOutcome
 
typedef Aws::Utils::Outcome< DescribeClusterSecurityGroupsResult, RedshiftError > Aws::Redshift::Model::DescribeClusterSecurityGroupsOutcome
 
typedef Aws::Utils::Outcome< DescribeClusterSnapshotsResult, RedshiftError > Aws::Redshift::Model::DescribeClusterSnapshotsOutcome
 
typedef Aws::Utils::Outcome< DescribeClusterSubnetGroupsResult, RedshiftError > Aws::Redshift::Model::DescribeClusterSubnetGroupsOutcome
 
typedef Aws::Utils::Outcome< DescribeClusterTracksResult, RedshiftError > Aws::Redshift::Model::DescribeClusterTracksOutcome
 
typedef Aws::Utils::Outcome< DescribeClusterVersionsResult, RedshiftError > Aws::Redshift::Model::DescribeClusterVersionsOutcome
 
typedef Aws::Utils::Outcome< DescribeClustersResult, RedshiftError > Aws::Redshift::Model::DescribeClustersOutcome
 
typedef Aws::Utils::Outcome< DescribeDataSharesResult, RedshiftError > Aws::Redshift::Model::DescribeDataSharesOutcome
 
typedef Aws::Utils::Outcome< DescribeDataSharesForConsumerResult, RedshiftError > Aws::Redshift::Model::DescribeDataSharesForConsumerOutcome
 
typedef Aws::Utils::Outcome< DescribeDataSharesForProducerResult, RedshiftError > Aws::Redshift::Model::DescribeDataSharesForProducerOutcome
 
typedef Aws::Utils::Outcome< DescribeDefaultClusterParametersResult, RedshiftError > Aws::Redshift::Model::DescribeDefaultClusterParametersOutcome
 
typedef Aws::Utils::Outcome< DescribeEndpointAccessResult, RedshiftError > Aws::Redshift::Model::DescribeEndpointAccessOutcome
 
typedef Aws::Utils::Outcome< DescribeEndpointAuthorizationResult, RedshiftError > Aws::Redshift::Model::DescribeEndpointAuthorizationOutcome
 
typedef Aws::Utils::Outcome< DescribeEventCategoriesResult, RedshiftError > Aws::Redshift::Model::DescribeEventCategoriesOutcome
 
typedef Aws::Utils::Outcome< DescribeEventSubscriptionsResult, RedshiftError > Aws::Redshift::Model::DescribeEventSubscriptionsOutcome
 
typedef Aws::Utils::Outcome< DescribeEventsResult, RedshiftError > Aws::Redshift::Model::DescribeEventsOutcome
 
typedef Aws::Utils::Outcome< DescribeHsmClientCertificatesResult, RedshiftError > Aws::Redshift::Model::DescribeHsmClientCertificatesOutcome
 
typedef Aws::Utils::Outcome< DescribeHsmConfigurationsResult, RedshiftError > Aws::Redshift::Model::DescribeHsmConfigurationsOutcome
 
typedef Aws::Utils::Outcome< DescribeLoggingStatusResult, RedshiftError > Aws::Redshift::Model::DescribeLoggingStatusOutcome
 
typedef Aws::Utils::Outcome< DescribeNodeConfigurationOptionsResult, RedshiftError > Aws::Redshift::Model::DescribeNodeConfigurationOptionsOutcome
 
typedef Aws::Utils::Outcome< DescribeOrderableClusterOptionsResult, RedshiftError > Aws::Redshift::Model::DescribeOrderableClusterOptionsOutcome
 
typedef Aws::Utils::Outcome< DescribePartnersResult, RedshiftError > Aws::Redshift::Model::DescribePartnersOutcome
 
typedef Aws::Utils::Outcome< DescribeReservedNodeOfferingsResult, RedshiftError > Aws::Redshift::Model::DescribeReservedNodeOfferingsOutcome
 
typedef Aws::Utils::Outcome< DescribeReservedNodesResult, RedshiftError > Aws::Redshift::Model::DescribeReservedNodesOutcome
 
typedef Aws::Utils::Outcome< DescribeResizeResult, RedshiftError > Aws::Redshift::Model::DescribeResizeOutcome
 
typedef Aws::Utils::Outcome< DescribeScheduledActionsResult, RedshiftError > Aws::Redshift::Model::DescribeScheduledActionsOutcome
 
typedef Aws::Utils::Outcome< DescribeSnapshotCopyGrantsResult, RedshiftError > Aws::Redshift::Model::DescribeSnapshotCopyGrantsOutcome
 
typedef Aws::Utils::Outcome< DescribeSnapshotSchedulesResult, RedshiftError > Aws::Redshift::Model::DescribeSnapshotSchedulesOutcome
 
typedef Aws::Utils::Outcome< DescribeStorageResult, RedshiftError > Aws::Redshift::Model::DescribeStorageOutcome
 
typedef Aws::Utils::Outcome< DescribeTableRestoreStatusResult, RedshiftError > Aws::Redshift::Model::DescribeTableRestoreStatusOutcome
 
typedef Aws::Utils::Outcome< DescribeTagsResult, RedshiftError > Aws::Redshift::Model::DescribeTagsOutcome
 
typedef Aws::Utils::Outcome< DescribeUsageLimitsResult, RedshiftError > Aws::Redshift::Model::DescribeUsageLimitsOutcome
 
typedef Aws::Utils::Outcome< DisableLoggingResult, RedshiftError > Aws::Redshift::Model::DisableLoggingOutcome
 
typedef Aws::Utils::Outcome< DisableSnapshotCopyResult, RedshiftError > Aws::Redshift::Model::DisableSnapshotCopyOutcome
 
typedef Aws::Utils::Outcome< DisassociateDataShareConsumerResult, RedshiftError > Aws::Redshift::Model::DisassociateDataShareConsumerOutcome
 
typedef Aws::Utils::Outcome< EnableLoggingResult, RedshiftError > Aws::Redshift::Model::EnableLoggingOutcome
 
typedef Aws::Utils::Outcome< EnableSnapshotCopyResult, RedshiftError > Aws::Redshift::Model::EnableSnapshotCopyOutcome
 
typedef Aws::Utils::Outcome< GetClusterCredentialsResult, RedshiftError > Aws::Redshift::Model::GetClusterCredentialsOutcome
 
typedef Aws::Utils::Outcome< GetReservedNodeExchangeOfferingsResult, RedshiftError > Aws::Redshift::Model::GetReservedNodeExchangeOfferingsOutcome
 
typedef Aws::Utils::Outcome< ModifyAquaConfigurationResult, RedshiftError > Aws::Redshift::Model::ModifyAquaConfigurationOutcome
 
typedef Aws::Utils::Outcome< ModifyAuthenticationProfileResult, RedshiftError > Aws::Redshift::Model::ModifyAuthenticationProfileOutcome
 
typedef Aws::Utils::Outcome< ModifyClusterResult, RedshiftError > Aws::Redshift::Model::ModifyClusterOutcome
 
typedef Aws::Utils::Outcome< ModifyClusterDbRevisionResult, RedshiftError > Aws::Redshift::Model::ModifyClusterDbRevisionOutcome
 
typedef Aws::Utils::Outcome< ModifyClusterIamRolesResult, RedshiftError > Aws::Redshift::Model::ModifyClusterIamRolesOutcome
 
typedef Aws::Utils::Outcome< ModifyClusterMaintenanceResult, RedshiftError > Aws::Redshift::Model::ModifyClusterMaintenanceOutcome
 
typedef Aws::Utils::Outcome< ModifyClusterParameterGroupResult, RedshiftError > Aws::Redshift::Model::ModifyClusterParameterGroupOutcome
 
typedef Aws::Utils::Outcome< ModifyClusterSnapshotResult, RedshiftError > Aws::Redshift::Model::ModifyClusterSnapshotOutcome
 
typedef Aws::Utils::Outcome< Aws::NoResult, RedshiftError > Aws::Redshift::Model::ModifyClusterSnapshotScheduleOutcome
 
typedef Aws::Utils::Outcome< ModifyClusterSubnetGroupResult, RedshiftError > Aws::Redshift::Model::ModifyClusterSubnetGroupOutcome
 
typedef Aws::Utils::Outcome< ModifyEndpointAccessResult, RedshiftError > Aws::Redshift::Model::ModifyEndpointAccessOutcome
 
typedef Aws::Utils::Outcome< ModifyEventSubscriptionResult, RedshiftError > Aws::Redshift::Model::ModifyEventSubscriptionOutcome
 
typedef Aws::Utils::Outcome< ModifyScheduledActionResult, RedshiftError > Aws::Redshift::Model::ModifyScheduledActionOutcome
 
typedef Aws::Utils::Outcome< ModifySnapshotCopyRetentionPeriodResult, RedshiftError > Aws::Redshift::Model::ModifySnapshotCopyRetentionPeriodOutcome
 
typedef Aws::Utils::Outcome< ModifySnapshotScheduleResult, RedshiftError > Aws::Redshift::Model::ModifySnapshotScheduleOutcome
 
typedef Aws::Utils::Outcome< ModifyUsageLimitResult, RedshiftError > Aws::Redshift::Model::ModifyUsageLimitOutcome
 
typedef Aws::Utils::Outcome< PauseClusterResult, RedshiftError > Aws::Redshift::Model::PauseClusterOutcome
 
typedef Aws::Utils::Outcome< PurchaseReservedNodeOfferingResult, RedshiftError > Aws::Redshift::Model::PurchaseReservedNodeOfferingOutcome
 
typedef Aws::Utils::Outcome< RebootClusterResult, RedshiftError > Aws::Redshift::Model::RebootClusterOutcome
 
typedef Aws::Utils::Outcome< RejectDataShareResult, RedshiftError > Aws::Redshift::Model::RejectDataShareOutcome
 
typedef Aws::Utils::Outcome< ResetClusterParameterGroupResult, RedshiftError > Aws::Redshift::Model::ResetClusterParameterGroupOutcome
 
typedef Aws::Utils::Outcome< ResizeClusterResult, RedshiftError > Aws::Redshift::Model::ResizeClusterOutcome
 
typedef Aws::Utils::Outcome< RestoreFromClusterSnapshotResult, RedshiftError > Aws::Redshift::Model::RestoreFromClusterSnapshotOutcome
 
typedef Aws::Utils::Outcome< RestoreTableFromClusterSnapshotResult, RedshiftError > Aws::Redshift::Model::RestoreTableFromClusterSnapshotOutcome
 
typedef Aws::Utils::Outcome< ResumeClusterResult, RedshiftError > Aws::Redshift::Model::ResumeClusterOutcome
 
typedef Aws::Utils::Outcome< RevokeClusterSecurityGroupIngressResult, RedshiftError > Aws::Redshift::Model::RevokeClusterSecurityGroupIngressOutcome
 
typedef Aws::Utils::Outcome< RevokeEndpointAccessResult, RedshiftError > Aws::Redshift::Model::RevokeEndpointAccessOutcome
 
typedef Aws::Utils::Outcome< RevokeSnapshotAccessResult, RedshiftError > Aws::Redshift::Model::RevokeSnapshotAccessOutcome
 
typedef Aws::Utils::Outcome< RotateEncryptionKeyResult, RedshiftError > Aws::Redshift::Model::RotateEncryptionKeyOutcome
 
typedef Aws::Utils::Outcome< UpdatePartnerStatusResult, RedshiftError > Aws::Redshift::Model::UpdatePartnerStatusOutcome
 
typedef std::future< AcceptReservedNodeExchangeOutcome > Aws::Redshift::Model::AcceptReservedNodeExchangeOutcomeCallable
 
typedef std::future< AddPartnerOutcome > Aws::Redshift::Model::AddPartnerOutcomeCallable
 
typedef std::future< AssociateDataShareConsumerOutcome > Aws::Redshift::Model::AssociateDataShareConsumerOutcomeCallable
 
typedef std::future< AuthorizeClusterSecurityGroupIngressOutcome > Aws::Redshift::Model::AuthorizeClusterSecurityGroupIngressOutcomeCallable
 
typedef std::future< AuthorizeDataShareOutcome > Aws::Redshift::Model::AuthorizeDataShareOutcomeCallable
 
typedef std::future< AuthorizeEndpointAccessOutcome > Aws::Redshift::Model::AuthorizeEndpointAccessOutcomeCallable
 
typedef std::future< AuthorizeSnapshotAccessOutcome > Aws::Redshift::Model::AuthorizeSnapshotAccessOutcomeCallable
 
typedef std::future< BatchDeleteClusterSnapshotsOutcome > Aws::Redshift::Model::BatchDeleteClusterSnapshotsOutcomeCallable
 
typedef std::future< BatchModifyClusterSnapshotsOutcome > Aws::Redshift::Model::BatchModifyClusterSnapshotsOutcomeCallable
 
typedef std::future< CancelResizeOutcome > Aws::Redshift::Model::CancelResizeOutcomeCallable
 
typedef std::future< CopyClusterSnapshotOutcome > Aws::Redshift::Model::CopyClusterSnapshotOutcomeCallable
 
typedef std::future< CreateAuthenticationProfileOutcome > Aws::Redshift::Model::CreateAuthenticationProfileOutcomeCallable
 
typedef std::future< CreateClusterOutcome > Aws::Redshift::Model::CreateClusterOutcomeCallable
 
typedef std::future< CreateClusterParameterGroupOutcome > Aws::Redshift::Model::CreateClusterParameterGroupOutcomeCallable
 
typedef std::future< CreateClusterSecurityGroupOutcome > Aws::Redshift::Model::CreateClusterSecurityGroupOutcomeCallable
 
typedef std::future< CreateClusterSnapshotOutcome > Aws::Redshift::Model::CreateClusterSnapshotOutcomeCallable
 
typedef std::future< CreateClusterSubnetGroupOutcome > Aws::Redshift::Model::CreateClusterSubnetGroupOutcomeCallable
 
typedef std::future< CreateEndpointAccessOutcome > Aws::Redshift::Model::CreateEndpointAccessOutcomeCallable
 
typedef std::future< CreateEventSubscriptionOutcome > Aws::Redshift::Model::CreateEventSubscriptionOutcomeCallable
 
typedef std::future< CreateHsmClientCertificateOutcome > Aws::Redshift::Model::CreateHsmClientCertificateOutcomeCallable
 
typedef std::future< CreateHsmConfigurationOutcome > Aws::Redshift::Model::CreateHsmConfigurationOutcomeCallable
 
typedef std::future< CreateScheduledActionOutcome > Aws::Redshift::Model::CreateScheduledActionOutcomeCallable
 
typedef std::future< CreateSnapshotCopyGrantOutcome > Aws::Redshift::Model::CreateSnapshotCopyGrantOutcomeCallable
 
typedef std::future< CreateSnapshotScheduleOutcome > Aws::Redshift::Model::CreateSnapshotScheduleOutcomeCallable
 
typedef std::future< CreateTagsOutcome > Aws::Redshift::Model::CreateTagsOutcomeCallable
 
typedef std::future< CreateUsageLimitOutcome > Aws::Redshift::Model::CreateUsageLimitOutcomeCallable
 
typedef std::future< DeauthorizeDataShareOutcome > Aws::Redshift::Model::DeauthorizeDataShareOutcomeCallable
 
typedef std::future< DeleteAuthenticationProfileOutcome > Aws::Redshift::Model::DeleteAuthenticationProfileOutcomeCallable
 
typedef std::future< DeleteClusterOutcome > Aws::Redshift::Model::DeleteClusterOutcomeCallable
 
typedef std::future< DeleteClusterParameterGroupOutcome > Aws::Redshift::Model::DeleteClusterParameterGroupOutcomeCallable
 
typedef std::future< DeleteClusterSecurityGroupOutcome > Aws::Redshift::Model::DeleteClusterSecurityGroupOutcomeCallable
 
typedef std::future< DeleteClusterSnapshotOutcome > Aws::Redshift::Model::DeleteClusterSnapshotOutcomeCallable
 
typedef std::future< DeleteClusterSubnetGroupOutcome > Aws::Redshift::Model::DeleteClusterSubnetGroupOutcomeCallable
 
typedef std::future< DeleteEndpointAccessOutcome > Aws::Redshift::Model::DeleteEndpointAccessOutcomeCallable
 
typedef std::future< DeleteEventSubscriptionOutcome > Aws::Redshift::Model::DeleteEventSubscriptionOutcomeCallable
 
typedef std::future< DeleteHsmClientCertificateOutcome > Aws::Redshift::Model::DeleteHsmClientCertificateOutcomeCallable
 
typedef std::future< DeleteHsmConfigurationOutcome > Aws::Redshift::Model::DeleteHsmConfigurationOutcomeCallable
 
typedef std::future< DeletePartnerOutcome > Aws::Redshift::Model::DeletePartnerOutcomeCallable
 
typedef std::future< DeleteScheduledActionOutcome > Aws::Redshift::Model::DeleteScheduledActionOutcomeCallable
 
typedef std::future< DeleteSnapshotCopyGrantOutcome > Aws::Redshift::Model::DeleteSnapshotCopyGrantOutcomeCallable
 
typedef std::future< DeleteSnapshotScheduleOutcome > Aws::Redshift::Model::DeleteSnapshotScheduleOutcomeCallable
 
typedef std::future< DeleteTagsOutcome > Aws::Redshift::Model::DeleteTagsOutcomeCallable
 
typedef std::future< DeleteUsageLimitOutcome > Aws::Redshift::Model::DeleteUsageLimitOutcomeCallable
 
typedef std::future< DescribeAccountAttributesOutcome > Aws::Redshift::Model::DescribeAccountAttributesOutcomeCallable
 
typedef std::future< DescribeAuthenticationProfilesOutcome > Aws::Redshift::Model::DescribeAuthenticationProfilesOutcomeCallable
 
typedef std::future< DescribeClusterDbRevisionsOutcome > Aws::Redshift::Model::DescribeClusterDbRevisionsOutcomeCallable
 
typedef std::future< DescribeClusterParameterGroupsOutcome > Aws::Redshift::Model::DescribeClusterParameterGroupsOutcomeCallable
 
typedef std::future< DescribeClusterParametersOutcome > Aws::Redshift::Model::DescribeClusterParametersOutcomeCallable
 
typedef std::future< DescribeClusterSecurityGroupsOutcome > Aws::Redshift::Model::DescribeClusterSecurityGroupsOutcomeCallable
 
typedef std::future< DescribeClusterSnapshotsOutcome > Aws::Redshift::Model::DescribeClusterSnapshotsOutcomeCallable
 
typedef std::future< DescribeClusterSubnetGroupsOutcome > Aws::Redshift::Model::DescribeClusterSubnetGroupsOutcomeCallable
 
typedef std::future< DescribeClusterTracksOutcome > Aws::Redshift::Model::DescribeClusterTracksOutcomeCallable
 
typedef std::future< DescribeClusterVersionsOutcome > Aws::Redshift::Model::DescribeClusterVersionsOutcomeCallable
 
typedef std::future< DescribeClustersOutcome > Aws::Redshift::Model::DescribeClustersOutcomeCallable
 
typedef std::future< DescribeDataSharesOutcome > Aws::Redshift::Model::DescribeDataSharesOutcomeCallable
 
typedef std::future< DescribeDataSharesForConsumerOutcome > Aws::Redshift::Model::DescribeDataSharesForConsumerOutcomeCallable
 
typedef std::future< DescribeDataSharesForProducerOutcome > Aws::Redshift::Model::DescribeDataSharesForProducerOutcomeCallable
 
typedef std::future< DescribeDefaultClusterParametersOutcome > Aws::Redshift::Model::DescribeDefaultClusterParametersOutcomeCallable
 
typedef std::future< DescribeEndpointAccessOutcome > Aws::Redshift::Model::DescribeEndpointAccessOutcomeCallable
 
typedef std::future< DescribeEndpointAuthorizationOutcome > Aws::Redshift::Model::DescribeEndpointAuthorizationOutcomeCallable
 
typedef std::future< DescribeEventCategoriesOutcome > Aws::Redshift::Model::DescribeEventCategoriesOutcomeCallable
 
typedef std::future< DescribeEventSubscriptionsOutcome > Aws::Redshift::Model::DescribeEventSubscriptionsOutcomeCallable
 
typedef std::future< DescribeEventsOutcome > Aws::Redshift::Model::DescribeEventsOutcomeCallable
 
typedef std::future< DescribeHsmClientCertificatesOutcome > Aws::Redshift::Model::DescribeHsmClientCertificatesOutcomeCallable
 
typedef std::future< DescribeHsmConfigurationsOutcome > Aws::Redshift::Model::DescribeHsmConfigurationsOutcomeCallable
 
typedef std::future< DescribeLoggingStatusOutcome > Aws::Redshift::Model::DescribeLoggingStatusOutcomeCallable
 
typedef std::future< DescribeNodeConfigurationOptionsOutcome > Aws::Redshift::Model::DescribeNodeConfigurationOptionsOutcomeCallable
 
typedef std::future< DescribeOrderableClusterOptionsOutcome > Aws::Redshift::Model::DescribeOrderableClusterOptionsOutcomeCallable
 
typedef std::future< DescribePartnersOutcome > Aws::Redshift::Model::DescribePartnersOutcomeCallable
 
typedef std::future< DescribeReservedNodeOfferingsOutcome > Aws::Redshift::Model::DescribeReservedNodeOfferingsOutcomeCallable
 
typedef std::future< DescribeReservedNodesOutcome > Aws::Redshift::Model::DescribeReservedNodesOutcomeCallable
 
typedef std::future< DescribeResizeOutcome > Aws::Redshift::Model::DescribeResizeOutcomeCallable
 
typedef std::future< DescribeScheduledActionsOutcome > Aws::Redshift::Model::DescribeScheduledActionsOutcomeCallable
 
typedef std::future< DescribeSnapshotCopyGrantsOutcome > Aws::Redshift::Model::DescribeSnapshotCopyGrantsOutcomeCallable
 
typedef std::future< DescribeSnapshotSchedulesOutcome > Aws::Redshift::Model::DescribeSnapshotSchedulesOutcomeCallable
 
typedef std::future< DescribeStorageOutcome > Aws::Redshift::Model::DescribeStorageOutcomeCallable
 
typedef std::future< DescribeTableRestoreStatusOutcome > Aws::Redshift::Model::DescribeTableRestoreStatusOutcomeCallable
 
typedef std::future< DescribeTagsOutcome > Aws::Redshift::Model::DescribeTagsOutcomeCallable
 
typedef std::future< DescribeUsageLimitsOutcome > Aws::Redshift::Model::DescribeUsageLimitsOutcomeCallable
 
typedef std::future< DisableLoggingOutcome > Aws::Redshift::Model::DisableLoggingOutcomeCallable
 
typedef std::future< DisableSnapshotCopyOutcome > Aws::Redshift::Model::DisableSnapshotCopyOutcomeCallable
 
typedef std::future< DisassociateDataShareConsumerOutcome > Aws::Redshift::Model::DisassociateDataShareConsumerOutcomeCallable
 
typedef std::future< EnableLoggingOutcome > Aws::Redshift::Model::EnableLoggingOutcomeCallable
 
typedef std::future< EnableSnapshotCopyOutcome > Aws::Redshift::Model::EnableSnapshotCopyOutcomeCallable
 
typedef std::future< GetClusterCredentialsOutcome > Aws::Redshift::Model::GetClusterCredentialsOutcomeCallable
 
typedef std::future< GetReservedNodeExchangeOfferingsOutcome > Aws::Redshift::Model::GetReservedNodeExchangeOfferingsOutcomeCallable
 
typedef std::future< ModifyAquaConfigurationOutcome > Aws::Redshift::Model::ModifyAquaConfigurationOutcomeCallable
 
typedef std::future< ModifyAuthenticationProfileOutcome > Aws::Redshift::Model::ModifyAuthenticationProfileOutcomeCallable
 
typedef std::future< ModifyClusterOutcome > Aws::Redshift::Model::ModifyClusterOutcomeCallable
 
typedef std::future< ModifyClusterDbRevisionOutcome > Aws::Redshift::Model::ModifyClusterDbRevisionOutcomeCallable
 
typedef std::future< ModifyClusterIamRolesOutcome > Aws::Redshift::Model::ModifyClusterIamRolesOutcomeCallable
 
typedef std::future< ModifyClusterMaintenanceOutcome > Aws::Redshift::Model::ModifyClusterMaintenanceOutcomeCallable
 
typedef std::future< ModifyClusterParameterGroupOutcome > Aws::Redshift::Model::ModifyClusterParameterGroupOutcomeCallable
 
typedef std::future< ModifyClusterSnapshotOutcome > Aws::Redshift::Model::ModifyClusterSnapshotOutcomeCallable
 
typedef std::future< ModifyClusterSnapshotScheduleOutcome > Aws::Redshift::Model::ModifyClusterSnapshotScheduleOutcomeCallable
 
typedef std::future< ModifyClusterSubnetGroupOutcome > Aws::Redshift::Model::ModifyClusterSubnetGroupOutcomeCallable
 
typedef std::future< ModifyEndpointAccessOutcome > Aws::Redshift::Model::ModifyEndpointAccessOutcomeCallable
 
typedef std::future< ModifyEventSubscriptionOutcome > Aws::Redshift::Model::ModifyEventSubscriptionOutcomeCallable
 
typedef std::future< ModifyScheduledActionOutcome > Aws::Redshift::Model::ModifyScheduledActionOutcomeCallable
 
typedef std::future< ModifySnapshotCopyRetentionPeriodOutcome > Aws::Redshift::Model::ModifySnapshotCopyRetentionPeriodOutcomeCallable
 
typedef std::future< ModifySnapshotScheduleOutcome > Aws::Redshift::Model::ModifySnapshotScheduleOutcomeCallable
 
typedef std::future< ModifyUsageLimitOutcome > Aws::Redshift::Model::ModifyUsageLimitOutcomeCallable
 
typedef std::future< PauseClusterOutcome > Aws::Redshift::Model::PauseClusterOutcomeCallable
 
typedef std::future< PurchaseReservedNodeOfferingOutcome > Aws::Redshift::Model::PurchaseReservedNodeOfferingOutcomeCallable
 
typedef std::future< RebootClusterOutcome > Aws::Redshift::Model::RebootClusterOutcomeCallable
 
typedef std::future< RejectDataShareOutcome > Aws::Redshift::Model::RejectDataShareOutcomeCallable
 
typedef std::future< ResetClusterParameterGroupOutcome > Aws::Redshift::Model::ResetClusterParameterGroupOutcomeCallable
 
typedef std::future< ResizeClusterOutcome > Aws::Redshift::Model::ResizeClusterOutcomeCallable
 
typedef std::future< RestoreFromClusterSnapshotOutcome > Aws::Redshift::Model::RestoreFromClusterSnapshotOutcomeCallable
 
typedef std::future< RestoreTableFromClusterSnapshotOutcome > Aws::Redshift::Model::RestoreTableFromClusterSnapshotOutcomeCallable
 
typedef std::future< ResumeClusterOutcome > Aws::Redshift::Model::ResumeClusterOutcomeCallable
 
typedef std::future< RevokeClusterSecurityGroupIngressOutcome > Aws::Redshift::Model::RevokeClusterSecurityGroupIngressOutcomeCallable
 
typedef std::future< RevokeEndpointAccessOutcome > Aws::Redshift::Model::RevokeEndpointAccessOutcomeCallable
 
typedef std::future< RevokeSnapshotAccessOutcome > Aws::Redshift::Model::RevokeSnapshotAccessOutcomeCallable
 
typedef std::future< RotateEncryptionKeyOutcome > Aws::Redshift::Model::RotateEncryptionKeyOutcomeCallable
 
typedef std::future< UpdatePartnerStatusOutcome > Aws::Redshift::Model::UpdatePartnerStatusOutcomeCallable
 
typedef std::function< void(const RedshiftClient *, const Model::AcceptReservedNodeExchangeRequest &, const Model::AcceptReservedNodeExchangeOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::AcceptReservedNodeExchangeResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::AddPartnerRequest &, const Model::AddPartnerOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::AddPartnerResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::AssociateDataShareConsumerRequest &, const Model::AssociateDataShareConsumerOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::AssociateDataShareConsumerResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::AuthorizeClusterSecurityGroupIngressRequest &, const Model::AuthorizeClusterSecurityGroupIngressOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::AuthorizeClusterSecurityGroupIngressResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::AuthorizeDataShareRequest &, const Model::AuthorizeDataShareOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::AuthorizeDataShareResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::AuthorizeEndpointAccessRequest &, const Model::AuthorizeEndpointAccessOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::AuthorizeEndpointAccessResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::AuthorizeSnapshotAccessRequest &, const Model::AuthorizeSnapshotAccessOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::AuthorizeSnapshotAccessResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::BatchDeleteClusterSnapshotsRequest &, const Model::BatchDeleteClusterSnapshotsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::BatchDeleteClusterSnapshotsResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::BatchModifyClusterSnapshotsRequest &, const Model::BatchModifyClusterSnapshotsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::BatchModifyClusterSnapshotsResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::CancelResizeRequest &, const Model::CancelResizeOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::CancelResizeResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::CopyClusterSnapshotRequest &, const Model::CopyClusterSnapshotOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::CopyClusterSnapshotResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::CreateAuthenticationProfileRequest &, const Model::CreateAuthenticationProfileOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::CreateAuthenticationProfileResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::CreateClusterRequest &, const Model::CreateClusterOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::CreateClusterResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::CreateClusterParameterGroupRequest &, const Model::CreateClusterParameterGroupOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::CreateClusterParameterGroupResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::CreateClusterSecurityGroupRequest &, const Model::CreateClusterSecurityGroupOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::CreateClusterSecurityGroupResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::CreateClusterSnapshotRequest &, const Model::CreateClusterSnapshotOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::CreateClusterSnapshotResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::CreateClusterSubnetGroupRequest &, const Model::CreateClusterSubnetGroupOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::CreateClusterSubnetGroupResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::CreateEndpointAccessRequest &, const Model::CreateEndpointAccessOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::CreateEndpointAccessResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::CreateEventSubscriptionRequest &, const Model::CreateEventSubscriptionOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::CreateEventSubscriptionResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::CreateHsmClientCertificateRequest &, const Model::CreateHsmClientCertificateOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::CreateHsmClientCertificateResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::CreateHsmConfigurationRequest &, const Model::CreateHsmConfigurationOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::CreateHsmConfigurationResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::CreateScheduledActionRequest &, const Model::CreateScheduledActionOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::CreateScheduledActionResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::CreateSnapshotCopyGrantRequest &, const Model::CreateSnapshotCopyGrantOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::CreateSnapshotCopyGrantResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::CreateSnapshotScheduleRequest &, const Model::CreateSnapshotScheduleOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::CreateSnapshotScheduleResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::CreateTagsRequest &, const Model::CreateTagsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::CreateTagsResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::CreateUsageLimitRequest &, const Model::CreateUsageLimitOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::CreateUsageLimitResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DeauthorizeDataShareRequest &, const Model::DeauthorizeDataShareOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DeauthorizeDataShareResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DeleteAuthenticationProfileRequest &, const Model::DeleteAuthenticationProfileOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DeleteAuthenticationProfileResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DeleteClusterRequest &, const Model::DeleteClusterOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DeleteClusterResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DeleteClusterParameterGroupRequest &, const Model::DeleteClusterParameterGroupOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DeleteClusterParameterGroupResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DeleteClusterSecurityGroupRequest &, const Model::DeleteClusterSecurityGroupOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DeleteClusterSecurityGroupResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DeleteClusterSnapshotRequest &, const Model::DeleteClusterSnapshotOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DeleteClusterSnapshotResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DeleteClusterSubnetGroupRequest &, const Model::DeleteClusterSubnetGroupOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DeleteClusterSubnetGroupResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DeleteEndpointAccessRequest &, const Model::DeleteEndpointAccessOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DeleteEndpointAccessResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DeleteEventSubscriptionRequest &, const Model::DeleteEventSubscriptionOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DeleteEventSubscriptionResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DeleteHsmClientCertificateRequest &, const Model::DeleteHsmClientCertificateOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DeleteHsmClientCertificateResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DeleteHsmConfigurationRequest &, const Model::DeleteHsmConfigurationOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DeleteHsmConfigurationResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DeletePartnerRequest &, const Model::DeletePartnerOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DeletePartnerResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DeleteScheduledActionRequest &, const Model::DeleteScheduledActionOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DeleteScheduledActionResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DeleteSnapshotCopyGrantRequest &, const Model::DeleteSnapshotCopyGrantOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DeleteSnapshotCopyGrantResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DeleteSnapshotScheduleRequest &, const Model::DeleteSnapshotScheduleOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DeleteSnapshotScheduleResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DeleteTagsRequest &, const Model::DeleteTagsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DeleteTagsResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DeleteUsageLimitRequest &, const Model::DeleteUsageLimitOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DeleteUsageLimitResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeAccountAttributesRequest &, const Model::DescribeAccountAttributesOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeAccountAttributesResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeAuthenticationProfilesRequest &, const Model::DescribeAuthenticationProfilesOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeAuthenticationProfilesResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeClusterDbRevisionsRequest &, const Model::DescribeClusterDbRevisionsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeClusterDbRevisionsResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeClusterParameterGroupsRequest &, const Model::DescribeClusterParameterGroupsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeClusterParameterGroupsResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeClusterParametersRequest &, const Model::DescribeClusterParametersOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeClusterParametersResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeClusterSecurityGroupsRequest &, const Model::DescribeClusterSecurityGroupsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeClusterSecurityGroupsResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeClusterSnapshotsRequest &, const Model::DescribeClusterSnapshotsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeClusterSnapshotsResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeClusterSubnetGroupsRequest &, const Model::DescribeClusterSubnetGroupsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeClusterSubnetGroupsResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeClusterTracksRequest &, const Model::DescribeClusterTracksOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeClusterTracksResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeClusterVersionsRequest &, const Model::DescribeClusterVersionsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeClusterVersionsResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeClustersRequest &, const Model::DescribeClustersOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeClustersResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeDataSharesRequest &, const Model::DescribeDataSharesOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeDataSharesResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeDataSharesForConsumerRequest &, const Model::DescribeDataSharesForConsumerOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeDataSharesForConsumerResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeDataSharesForProducerRequest &, const Model::DescribeDataSharesForProducerOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeDataSharesForProducerResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeDefaultClusterParametersRequest &, const Model::DescribeDefaultClusterParametersOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeDefaultClusterParametersResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeEndpointAccessRequest &, const Model::DescribeEndpointAccessOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeEndpointAccessResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeEndpointAuthorizationRequest &, const Model::DescribeEndpointAuthorizationOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeEndpointAuthorizationResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeEventCategoriesRequest &, const Model::DescribeEventCategoriesOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeEventCategoriesResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeEventSubscriptionsRequest &, const Model::DescribeEventSubscriptionsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeEventSubscriptionsResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeEventsRequest &, const Model::DescribeEventsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeEventsResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeHsmClientCertificatesRequest &, const Model::DescribeHsmClientCertificatesOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeHsmClientCertificatesResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeHsmConfigurationsRequest &, const Model::DescribeHsmConfigurationsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeHsmConfigurationsResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeLoggingStatusRequest &, const Model::DescribeLoggingStatusOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeLoggingStatusResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeNodeConfigurationOptionsRequest &, const Model::DescribeNodeConfigurationOptionsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeNodeConfigurationOptionsResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeOrderableClusterOptionsRequest &, const Model::DescribeOrderableClusterOptionsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeOrderableClusterOptionsResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribePartnersRequest &, const Model::DescribePartnersOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribePartnersResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeReservedNodeOfferingsRequest &, const Model::DescribeReservedNodeOfferingsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeReservedNodeOfferingsResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeReservedNodesRequest &, const Model::DescribeReservedNodesOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeReservedNodesResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeResizeRequest &, const Model::DescribeResizeOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeResizeResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeScheduledActionsRequest &, const Model::DescribeScheduledActionsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeScheduledActionsResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeSnapshotCopyGrantsRequest &, const Model::DescribeSnapshotCopyGrantsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeSnapshotCopyGrantsResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeSnapshotSchedulesRequest &, const Model::DescribeSnapshotSchedulesOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeSnapshotSchedulesResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeStorageRequest &, const Model::DescribeStorageOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeStorageResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeTableRestoreStatusRequest &, const Model::DescribeTableRestoreStatusOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeTableRestoreStatusResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeTagsRequest &, const Model::DescribeTagsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeTagsResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DescribeUsageLimitsRequest &, const Model::DescribeUsageLimitsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DescribeUsageLimitsResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DisableLoggingRequest &, const Model::DisableLoggingOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DisableLoggingResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DisableSnapshotCopyRequest &, const Model::DisableSnapshotCopyOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DisableSnapshotCopyResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::DisassociateDataShareConsumerRequest &, const Model::DisassociateDataShareConsumerOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::DisassociateDataShareConsumerResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::EnableLoggingRequest &, const Model::EnableLoggingOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::EnableLoggingResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::EnableSnapshotCopyRequest &, const Model::EnableSnapshotCopyOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::EnableSnapshotCopyResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::GetClusterCredentialsRequest &, const Model::GetClusterCredentialsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::GetClusterCredentialsResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::GetReservedNodeExchangeOfferingsRequest &, const Model::GetReservedNodeExchangeOfferingsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::GetReservedNodeExchangeOfferingsResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::ModifyAquaConfigurationRequest &, const Model::ModifyAquaConfigurationOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::ModifyAquaConfigurationResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::ModifyAuthenticationProfileRequest &, const Model::ModifyAuthenticationProfileOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::ModifyAuthenticationProfileResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::ModifyClusterRequest &, const Model::ModifyClusterOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::ModifyClusterResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::ModifyClusterDbRevisionRequest &, const Model::ModifyClusterDbRevisionOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::ModifyClusterDbRevisionResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::ModifyClusterIamRolesRequest &, const Model::ModifyClusterIamRolesOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::ModifyClusterIamRolesResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::ModifyClusterMaintenanceRequest &, const Model::ModifyClusterMaintenanceOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::ModifyClusterMaintenanceResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::ModifyClusterParameterGroupRequest &, const Model::ModifyClusterParameterGroupOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::ModifyClusterParameterGroupResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::ModifyClusterSnapshotRequest &, const Model::ModifyClusterSnapshotOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::ModifyClusterSnapshotResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::ModifyClusterSnapshotScheduleRequest &, const Model::ModifyClusterSnapshotScheduleOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::ModifyClusterSnapshotScheduleResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::ModifyClusterSubnetGroupRequest &, const Model::ModifyClusterSubnetGroupOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::ModifyClusterSubnetGroupResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::ModifyEndpointAccessRequest &, const Model::ModifyEndpointAccessOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::ModifyEndpointAccessResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::ModifyEventSubscriptionRequest &, const Model::ModifyEventSubscriptionOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::ModifyEventSubscriptionResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::ModifyScheduledActionRequest &, const Model::ModifyScheduledActionOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::ModifyScheduledActionResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::ModifySnapshotCopyRetentionPeriodRequest &, const Model::ModifySnapshotCopyRetentionPeriodOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::ModifySnapshotCopyRetentionPeriodResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::ModifySnapshotScheduleRequest &, const Model::ModifySnapshotScheduleOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::ModifySnapshotScheduleResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::ModifyUsageLimitRequest &, const Model::ModifyUsageLimitOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::ModifyUsageLimitResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::PauseClusterRequest &, const Model::PauseClusterOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::PauseClusterResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::PurchaseReservedNodeOfferingRequest &, const Model::PurchaseReservedNodeOfferingOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::PurchaseReservedNodeOfferingResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::RebootClusterRequest &, const Model::RebootClusterOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::RebootClusterResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::RejectDataShareRequest &, const Model::RejectDataShareOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::RejectDataShareResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::ResetClusterParameterGroupRequest &, const Model::ResetClusterParameterGroupOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::ResetClusterParameterGroupResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::ResizeClusterRequest &, const Model::ResizeClusterOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::ResizeClusterResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::RestoreFromClusterSnapshotRequest &, const Model::RestoreFromClusterSnapshotOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::RestoreFromClusterSnapshotResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::RestoreTableFromClusterSnapshotRequest &, const Model::RestoreTableFromClusterSnapshotOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::RestoreTableFromClusterSnapshotResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::ResumeClusterRequest &, const Model::ResumeClusterOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::ResumeClusterResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::RevokeClusterSecurityGroupIngressRequest &, const Model::RevokeClusterSecurityGroupIngressOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::RevokeClusterSecurityGroupIngressResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::RevokeEndpointAccessRequest &, const Model::RevokeEndpointAccessOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::RevokeEndpointAccessResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::RevokeSnapshotAccessRequest &, const Model::RevokeSnapshotAccessOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::RevokeSnapshotAccessResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::RotateEncryptionKeyRequest &, const Model::RotateEncryptionKeyOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::RotateEncryptionKeyResponseReceivedHandler
 
typedef std::function< void(const RedshiftClient *, const Model::UpdatePartnerStatusRequest &, const Model::UpdatePartnerStatusOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &) > Aws::Redshift::UpdatePartnerStatusResponseReceivedHandler