/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include #include namespace Aws { namespace Redshift { /** * Amazon Redshift

Overview

This is an * interface reference for Amazon Redshift. It contains documentation for one of * the programming or command line interfaces you can use to manage Amazon Redshift * clusters. Note that Amazon Redshift is asynchronous, which means that some * interfaces may require techniques, such as polling or asynchronous callback * handlers, to determine when a command has been applied. In this reference, the * parameter descriptions indicate whether a change is applied immediately, on the * next instance reboot, or during the next maintenance window. For a summary of * the Amazon Redshift cluster management interfaces, go to Using * the Amazon Redshift Management Interfaces.

Amazon Redshift manages * all the work of setting up, operating, and scaling a data warehouse: * provisioning capacity, monitoring and backing up the cluster, and applying * patches and upgrades to the Amazon Redshift engine. You can focus on using your * data to acquire new insights for your business and customers.

If you are * a first-time user of Amazon Redshift, we recommend that you begin by reading the * Amazon * Redshift Getting Started Guide.

If you are a database developer, the * Amazon * Redshift Database Developer Guide explains how to design, build, query, and * maintain the databases that make up your data warehouse.

*/ class AWS_REDSHIFT_API RedshiftClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef RedshiftClientConfiguration ClientConfigurationType; typedef RedshiftEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ RedshiftClient(const Aws::Redshift::RedshiftClientConfiguration& clientConfiguration = Aws::Redshift::RedshiftClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ RedshiftClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::Redshift::RedshiftClientConfiguration& clientConfiguration = Aws::Redshift::RedshiftClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ RedshiftClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::Redshift::RedshiftClientConfiguration& clientConfiguration = Aws::Redshift::RedshiftClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ RedshiftClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ RedshiftClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ RedshiftClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~RedshiftClient(); /** * Converts any request object to a presigned URL with the GET method, using region for the signer and a timeout of 15 minutes. */ Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const; /** *

Exchanges a DC1 Reserved Node for a DC2 Reserved Node with no changes to the * configuration (term, payment type, or number of nodes) and no additional costs. *

See Also:

AWS * API Reference

*/ virtual Model::AcceptReservedNodeExchangeOutcome AcceptReservedNodeExchange(const Model::AcceptReservedNodeExchangeRequest& request) const; /** * A Callable wrapper for AcceptReservedNodeExchange that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AcceptReservedNodeExchangeOutcomeCallable AcceptReservedNodeExchangeCallable(const AcceptReservedNodeExchangeRequestT& request) const { return SubmitCallable(&RedshiftClient::AcceptReservedNodeExchange, request); } /** * An Async wrapper for AcceptReservedNodeExchange that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AcceptReservedNodeExchangeAsync(const AcceptReservedNodeExchangeRequestT& request, const AcceptReservedNodeExchangeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::AcceptReservedNodeExchange, request, handler, context); } /** *

Adds a partner integration to a cluster. This operation authorizes a partner * to push status updates for the specified database. To complete the integration, * you also set up the integration on the partner website.

See Also:

* AWS * API Reference

*/ virtual Model::AddPartnerOutcome AddPartner(const Model::AddPartnerRequest& request) const; /** * A Callable wrapper for AddPartner that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AddPartnerOutcomeCallable AddPartnerCallable(const AddPartnerRequestT& request) const { return SubmitCallable(&RedshiftClient::AddPartner, request); } /** * An Async wrapper for AddPartner that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AddPartnerAsync(const AddPartnerRequestT& request, const AddPartnerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::AddPartner, request, handler, context); } /** *

From a datashare consumer account, associates a datashare with the account * (AssociateEntireAccount) or the specified namespace (ConsumerArn). If you make * this association, the consumer can consume the datashare.

See * Also:

AWS * API Reference

*/ virtual Model::AssociateDataShareConsumerOutcome AssociateDataShareConsumer(const Model::AssociateDataShareConsumerRequest& request) const; /** * A Callable wrapper for AssociateDataShareConsumer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateDataShareConsumerOutcomeCallable AssociateDataShareConsumerCallable(const AssociateDataShareConsumerRequestT& request) const { return SubmitCallable(&RedshiftClient::AssociateDataShareConsumer, request); } /** * An Async wrapper for AssociateDataShareConsumer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateDataShareConsumerAsync(const AssociateDataShareConsumerRequestT& request, const AssociateDataShareConsumerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::AssociateDataShareConsumer, request, handler, context); } /** *

Adds an inbound (ingress) rule to an Amazon Redshift security group. * Depending on whether the application accessing your cluster is running on the * Internet or an Amazon EC2 instance, you can authorize inbound access to either a * Classless Interdomain Routing (CIDR)/Internet Protocol (IP) range or to an * Amazon EC2 security group. You can add as many as 20 ingress rules to an Amazon * Redshift security group.

If you authorize access to an Amazon EC2 * security group, specify EC2SecurityGroupName and * EC2SecurityGroupOwnerId. The Amazon EC2 security group and Amazon * Redshift cluster must be in the same Amazon Web Services Region.

If you * authorize access to a CIDR/IP address range, specify CIDRIP. For an * overview of CIDR blocks, see the Wikipedia article on Classless * Inter-Domain Routing.

You must also associate the security group * with a cluster so that clients running on these IP addresses or the EC2 instance * are authorized to connect to the cluster. For information about managing * security groups, go to Working * with Security Groups in the Amazon Redshift Cluster Management * Guide.

See Also:

AWS * API Reference

*/ virtual Model::AuthorizeClusterSecurityGroupIngressOutcome AuthorizeClusterSecurityGroupIngress(const Model::AuthorizeClusterSecurityGroupIngressRequest& request) const; /** * A Callable wrapper for AuthorizeClusterSecurityGroupIngress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AuthorizeClusterSecurityGroupIngressOutcomeCallable AuthorizeClusterSecurityGroupIngressCallable(const AuthorizeClusterSecurityGroupIngressRequestT& request) const { return SubmitCallable(&RedshiftClient::AuthorizeClusterSecurityGroupIngress, request); } /** * An Async wrapper for AuthorizeClusterSecurityGroupIngress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AuthorizeClusterSecurityGroupIngressAsync(const AuthorizeClusterSecurityGroupIngressRequestT& request, const AuthorizeClusterSecurityGroupIngressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::AuthorizeClusterSecurityGroupIngress, request, handler, context); } /** *

From a data producer account, authorizes the sharing of a datashare with one * or more consumer accounts or managing entities. To authorize a datashare for a * data consumer, the producer account must have the correct access * permissions.

See Also:

AWS * API Reference

*/ virtual Model::AuthorizeDataShareOutcome AuthorizeDataShare(const Model::AuthorizeDataShareRequest& request) const; /** * A Callable wrapper for AuthorizeDataShare that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AuthorizeDataShareOutcomeCallable AuthorizeDataShareCallable(const AuthorizeDataShareRequestT& request) const { return SubmitCallable(&RedshiftClient::AuthorizeDataShare, request); } /** * An Async wrapper for AuthorizeDataShare that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AuthorizeDataShareAsync(const AuthorizeDataShareRequestT& request, const AuthorizeDataShareResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::AuthorizeDataShare, request, handler, context); } /** *

Grants access to a cluster.

See Also:

AWS * API Reference

*/ virtual Model::AuthorizeEndpointAccessOutcome AuthorizeEndpointAccess(const Model::AuthorizeEndpointAccessRequest& request) const; /** * A Callable wrapper for AuthorizeEndpointAccess that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AuthorizeEndpointAccessOutcomeCallable AuthorizeEndpointAccessCallable(const AuthorizeEndpointAccessRequestT& request) const { return SubmitCallable(&RedshiftClient::AuthorizeEndpointAccess, request); } /** * An Async wrapper for AuthorizeEndpointAccess that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AuthorizeEndpointAccessAsync(const AuthorizeEndpointAccessRequestT& request, const AuthorizeEndpointAccessResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::AuthorizeEndpointAccess, request, handler, context); } /** *

Authorizes the specified Amazon Web Services account to restore the specified * snapshot.

For more information about working with snapshots, go to Amazon * Redshift Snapshots in the Amazon Redshift Cluster Management * Guide.

See Also:

AWS * API Reference

*/ virtual Model::AuthorizeSnapshotAccessOutcome AuthorizeSnapshotAccess(const Model::AuthorizeSnapshotAccessRequest& request) const; /** * A Callable wrapper for AuthorizeSnapshotAccess that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AuthorizeSnapshotAccessOutcomeCallable AuthorizeSnapshotAccessCallable(const AuthorizeSnapshotAccessRequestT& request) const { return SubmitCallable(&RedshiftClient::AuthorizeSnapshotAccess, request); } /** * An Async wrapper for AuthorizeSnapshotAccess that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AuthorizeSnapshotAccessAsync(const AuthorizeSnapshotAccessRequestT& request, const AuthorizeSnapshotAccessResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::AuthorizeSnapshotAccess, request, handler, context); } /** *

Deletes a set of cluster snapshots.

See Also:

AWS * API Reference

*/ virtual Model::BatchDeleteClusterSnapshotsOutcome BatchDeleteClusterSnapshots(const Model::BatchDeleteClusterSnapshotsRequest& request) const; /** * A Callable wrapper for BatchDeleteClusterSnapshots that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchDeleteClusterSnapshotsOutcomeCallable BatchDeleteClusterSnapshotsCallable(const BatchDeleteClusterSnapshotsRequestT& request) const { return SubmitCallable(&RedshiftClient::BatchDeleteClusterSnapshots, request); } /** * An Async wrapper for BatchDeleteClusterSnapshots that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchDeleteClusterSnapshotsAsync(const BatchDeleteClusterSnapshotsRequestT& request, const BatchDeleteClusterSnapshotsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::BatchDeleteClusterSnapshots, request, handler, context); } /** *

Modifies the settings for a set of cluster snapshots.

See * Also:

AWS * API Reference

*/ virtual Model::BatchModifyClusterSnapshotsOutcome BatchModifyClusterSnapshots(const Model::BatchModifyClusterSnapshotsRequest& request) const; /** * A Callable wrapper for BatchModifyClusterSnapshots that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchModifyClusterSnapshotsOutcomeCallable BatchModifyClusterSnapshotsCallable(const BatchModifyClusterSnapshotsRequestT& request) const { return SubmitCallable(&RedshiftClient::BatchModifyClusterSnapshots, request); } /** * An Async wrapper for BatchModifyClusterSnapshots that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchModifyClusterSnapshotsAsync(const BatchModifyClusterSnapshotsRequestT& request, const BatchModifyClusterSnapshotsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::BatchModifyClusterSnapshots, request, handler, context); } /** *

Cancels a resize operation for a cluster.

See Also:

AWS * API Reference

*/ virtual Model::CancelResizeOutcome CancelResize(const Model::CancelResizeRequest& request) const; /** * A Callable wrapper for CancelResize that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelResizeOutcomeCallable CancelResizeCallable(const CancelResizeRequestT& request) const { return SubmitCallable(&RedshiftClient::CancelResize, request); } /** * An Async wrapper for CancelResize that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelResizeAsync(const CancelResizeRequestT& request, const CancelResizeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::CancelResize, request, handler, context); } /** *

Copies the specified automated cluster snapshot to a new manual cluster * snapshot. The source must be an automated snapshot and it must be in the * available state.

When you delete a cluster, Amazon Redshift deletes any * automated snapshots of the cluster. Also, when the retention period of the * snapshot expires, Amazon Redshift automatically deletes it. If you want to keep * an automated snapshot for a longer period, you can make a manual copy of the * snapshot. Manual snapshots are retained until you delete them.

For more * information about working with snapshots, go to Amazon * Redshift Snapshots in the Amazon Redshift Cluster Management * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CopyClusterSnapshotOutcome CopyClusterSnapshot(const Model::CopyClusterSnapshotRequest& request) const; /** * A Callable wrapper for CopyClusterSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CopyClusterSnapshotOutcomeCallable CopyClusterSnapshotCallable(const CopyClusterSnapshotRequestT& request) const { return SubmitCallable(&RedshiftClient::CopyClusterSnapshot, request); } /** * An Async wrapper for CopyClusterSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CopyClusterSnapshotAsync(const CopyClusterSnapshotRequestT& request, const CopyClusterSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::CopyClusterSnapshot, request, handler, context); } /** *

Creates an authentication profile with the specified * parameters.

See Also:

AWS * API Reference

*/ virtual Model::CreateAuthenticationProfileOutcome CreateAuthenticationProfile(const Model::CreateAuthenticationProfileRequest& request) const; /** * A Callable wrapper for CreateAuthenticationProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAuthenticationProfileOutcomeCallable CreateAuthenticationProfileCallable(const CreateAuthenticationProfileRequestT& request) const { return SubmitCallable(&RedshiftClient::CreateAuthenticationProfile, request); } /** * An Async wrapper for CreateAuthenticationProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAuthenticationProfileAsync(const CreateAuthenticationProfileRequestT& request, const CreateAuthenticationProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::CreateAuthenticationProfile, request, handler, context); } /** *

Creates a new cluster with the specified parameters.

To create a * cluster in Virtual Private Cloud (VPC), you must provide a cluster subnet group * name. The cluster subnet group identifies the subnets of your VPC that Amazon * Redshift uses when creating the cluster. For more information about managing * clusters, go to Amazon * Redshift Clusters in the Amazon Redshift Cluster Management * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateClusterOutcome CreateCluster(const Model::CreateClusterRequest& request) const; /** * A Callable wrapper for CreateCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateClusterOutcomeCallable CreateClusterCallable(const CreateClusterRequestT& request) const { return SubmitCallable(&RedshiftClient::CreateCluster, request); } /** * An Async wrapper for CreateCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateClusterAsync(const CreateClusterRequestT& request, const CreateClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::CreateCluster, request, handler, context); } /** *

Creates an Amazon Redshift parameter group.

Creating parameter groups * is independent of creating clusters. You can associate a cluster with a * parameter group when you create the cluster. You can also associate an existing * cluster with a parameter group after the cluster is created by using * ModifyCluster.

Parameters in the parameter group define specific * behavior that applies to the databases you create on the cluster. For more * information about parameters and parameter groups, go to Amazon * Redshift Parameter Groups in the Amazon Redshift Cluster Management * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateClusterParameterGroupOutcome CreateClusterParameterGroup(const Model::CreateClusterParameterGroupRequest& request) const; /** * A Callable wrapper for CreateClusterParameterGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateClusterParameterGroupOutcomeCallable CreateClusterParameterGroupCallable(const CreateClusterParameterGroupRequestT& request) const { return SubmitCallable(&RedshiftClient::CreateClusterParameterGroup, request); } /** * An Async wrapper for CreateClusterParameterGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateClusterParameterGroupAsync(const CreateClusterParameterGroupRequestT& request, const CreateClusterParameterGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::CreateClusterParameterGroup, request, handler, context); } /** *

Creates a new Amazon Redshift security group. You use security groups to * control access to non-VPC clusters.

For information about managing * security groups, go to Amazon * Redshift Cluster Security Groups in the Amazon Redshift Cluster * Management Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateClusterSecurityGroupOutcome CreateClusterSecurityGroup(const Model::CreateClusterSecurityGroupRequest& request) const; /** * A Callable wrapper for CreateClusterSecurityGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateClusterSecurityGroupOutcomeCallable CreateClusterSecurityGroupCallable(const CreateClusterSecurityGroupRequestT& request) const { return SubmitCallable(&RedshiftClient::CreateClusterSecurityGroup, request); } /** * An Async wrapper for CreateClusterSecurityGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateClusterSecurityGroupAsync(const CreateClusterSecurityGroupRequestT& request, const CreateClusterSecurityGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::CreateClusterSecurityGroup, request, handler, context); } /** *

Creates a manual snapshot of the specified cluster. The cluster must be in * the available state.

For more information about working * with snapshots, go to Amazon * Redshift Snapshots in the Amazon Redshift Cluster Management * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateClusterSnapshotOutcome CreateClusterSnapshot(const Model::CreateClusterSnapshotRequest& request) const; /** * A Callable wrapper for CreateClusterSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateClusterSnapshotOutcomeCallable CreateClusterSnapshotCallable(const CreateClusterSnapshotRequestT& request) const { return SubmitCallable(&RedshiftClient::CreateClusterSnapshot, request); } /** * An Async wrapper for CreateClusterSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateClusterSnapshotAsync(const CreateClusterSnapshotRequestT& request, const CreateClusterSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::CreateClusterSnapshot, request, handler, context); } /** *

Creates a new Amazon Redshift subnet group. You must provide a list of one or * more subnets in your existing Amazon Virtual Private Cloud (Amazon VPC) when * creating Amazon Redshift subnet group.

For information about subnet * groups, go to Amazon * Redshift Cluster Subnet Groups in the Amazon Redshift Cluster Management * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateClusterSubnetGroupOutcome CreateClusterSubnetGroup(const Model::CreateClusterSubnetGroupRequest& request) const; /** * A Callable wrapper for CreateClusterSubnetGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateClusterSubnetGroupOutcomeCallable CreateClusterSubnetGroupCallable(const CreateClusterSubnetGroupRequestT& request) const { return SubmitCallable(&RedshiftClient::CreateClusterSubnetGroup, request); } /** * An Async wrapper for CreateClusterSubnetGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateClusterSubnetGroupAsync(const CreateClusterSubnetGroupRequestT& request, const CreateClusterSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::CreateClusterSubnetGroup, request, handler, context); } /** *

Used to create a custom domain name for a cluster. Properties include the * custom domain name, the cluster the custom domain is associated with, and the * certificate Amazon Resource Name (ARN).

See Also:

AWS * API Reference

*/ virtual Model::CreateCustomDomainAssociationOutcome CreateCustomDomainAssociation(const Model::CreateCustomDomainAssociationRequest& request) const; /** * A Callable wrapper for CreateCustomDomainAssociation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCustomDomainAssociationOutcomeCallable CreateCustomDomainAssociationCallable(const CreateCustomDomainAssociationRequestT& request) const { return SubmitCallable(&RedshiftClient::CreateCustomDomainAssociation, request); } /** * An Async wrapper for CreateCustomDomainAssociation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCustomDomainAssociationAsync(const CreateCustomDomainAssociationRequestT& request, const CreateCustomDomainAssociationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::CreateCustomDomainAssociation, request, handler, context); } /** *

Creates a Redshift-managed VPC endpoint.

See Also:

AWS * API Reference

*/ virtual Model::CreateEndpointAccessOutcome CreateEndpointAccess(const Model::CreateEndpointAccessRequest& request) const; /** * A Callable wrapper for CreateEndpointAccess that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateEndpointAccessOutcomeCallable CreateEndpointAccessCallable(const CreateEndpointAccessRequestT& request) const { return SubmitCallable(&RedshiftClient::CreateEndpointAccess, request); } /** * An Async wrapper for CreateEndpointAccess that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateEndpointAccessAsync(const CreateEndpointAccessRequestT& request, const CreateEndpointAccessResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::CreateEndpointAccess, request, handler, context); } /** *

Creates an Amazon Redshift event notification subscription. This action * requires an ARN (Amazon Resource Name) of an Amazon SNS topic created by either * the Amazon Redshift console, the Amazon SNS console, or the Amazon SNS API. To * obtain an ARN with Amazon SNS, you must create a topic in Amazon SNS and * subscribe to the topic. The ARN is displayed in the SNS console.

You can * specify the source type, and lists of Amazon Redshift source IDs, event * categories, and event severities. Notifications will be sent for all events you * want that match those criteria. For example, you can specify source type = * cluster, source ID = my-cluster-1 and mycluster2, event categories = * Availability, Backup, and severity = ERROR. The subscription will only send * notifications for those ERROR events in the Availability and Backup categories * for the specified clusters.

If you specify both the source type and * source IDs, such as source type = cluster and source identifier = my-cluster-1, * notifications will be sent for all the cluster events for my-cluster-1. If you * specify a source type but do not specify a source identifier, you will receive * notice of the events for the objects of that type in your Amazon Web Services * account. If you do not specify either the SourceType nor the SourceIdentifier, * you will be notified of events generated from all Amazon Redshift sources * belonging to your Amazon Web Services account. You must specify a source type if * you specify a source ID.

See Also:

AWS * API Reference

*/ virtual Model::CreateEventSubscriptionOutcome CreateEventSubscription(const Model::CreateEventSubscriptionRequest& request) const; /** * A Callable wrapper for CreateEventSubscription that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateEventSubscriptionOutcomeCallable CreateEventSubscriptionCallable(const CreateEventSubscriptionRequestT& request) const { return SubmitCallable(&RedshiftClient::CreateEventSubscription, request); } /** * An Async wrapper for CreateEventSubscription that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateEventSubscriptionAsync(const CreateEventSubscriptionRequestT& request, const CreateEventSubscriptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::CreateEventSubscription, request, handler, context); } /** *

Creates an HSM client certificate that an Amazon Redshift cluster will use to * connect to the client's HSM in order to store and retrieve the keys used to * encrypt the cluster databases.

The command returns a public key, which * you must store in the HSM. In addition to creating the HSM certificate, you must * create an Amazon Redshift HSM configuration that provides a cluster the * information needed to store and use encryption keys in the HSM. For more * information, go to Hardware * Security Modules in the Amazon Redshift Cluster Management * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateHsmClientCertificateOutcome CreateHsmClientCertificate(const Model::CreateHsmClientCertificateRequest& request) const; /** * A Callable wrapper for CreateHsmClientCertificate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateHsmClientCertificateOutcomeCallable CreateHsmClientCertificateCallable(const CreateHsmClientCertificateRequestT& request) const { return SubmitCallable(&RedshiftClient::CreateHsmClientCertificate, request); } /** * An Async wrapper for CreateHsmClientCertificate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateHsmClientCertificateAsync(const CreateHsmClientCertificateRequestT& request, const CreateHsmClientCertificateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::CreateHsmClientCertificate, request, handler, context); } /** *

Creates an HSM configuration that contains the information required by an * Amazon Redshift cluster to store and use database encryption keys in a Hardware * Security Module (HSM). After creating the HSM configuration, you can specify it * as a parameter when creating a cluster. The cluster will then store its * encryption keys in the HSM.

In addition to creating an HSM configuration, * you must also create an HSM client certificate. For more information, go to Hardware * Security Modules in the Amazon Redshift Cluster Management * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateHsmConfigurationOutcome CreateHsmConfiguration(const Model::CreateHsmConfigurationRequest& request) const; /** * A Callable wrapper for CreateHsmConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateHsmConfigurationOutcomeCallable CreateHsmConfigurationCallable(const CreateHsmConfigurationRequestT& request) const { return SubmitCallable(&RedshiftClient::CreateHsmConfiguration, request); } /** * An Async wrapper for CreateHsmConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateHsmConfigurationAsync(const CreateHsmConfigurationRequestT& request, const CreateHsmConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::CreateHsmConfiguration, request, handler, context); } /** *

Creates a scheduled action. A scheduled action contains a schedule and an * Amazon Redshift API action. For example, you can create a schedule of when to * run the ResizeCluster API operation.

See Also:

AWS * API Reference

*/ virtual Model::CreateScheduledActionOutcome CreateScheduledAction(const Model::CreateScheduledActionRequest& request) const; /** * A Callable wrapper for CreateScheduledAction that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateScheduledActionOutcomeCallable CreateScheduledActionCallable(const CreateScheduledActionRequestT& request) const { return SubmitCallable(&RedshiftClient::CreateScheduledAction, request); } /** * An Async wrapper for CreateScheduledAction that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateScheduledActionAsync(const CreateScheduledActionRequestT& request, const CreateScheduledActionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::CreateScheduledAction, request, handler, context); } /** *

Creates a snapshot copy grant that permits Amazon Redshift to use an * encrypted symmetric key from Key Management Service (KMS) to encrypt copied * snapshots in a destination region.

For more information about managing * snapshot copy grants, go to Amazon * Redshift Database Encryption in the Amazon Redshift Cluster Management * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateSnapshotCopyGrantOutcome CreateSnapshotCopyGrant(const Model::CreateSnapshotCopyGrantRequest& request) const; /** * A Callable wrapper for CreateSnapshotCopyGrant that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateSnapshotCopyGrantOutcomeCallable CreateSnapshotCopyGrantCallable(const CreateSnapshotCopyGrantRequestT& request) const { return SubmitCallable(&RedshiftClient::CreateSnapshotCopyGrant, request); } /** * An Async wrapper for CreateSnapshotCopyGrant that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateSnapshotCopyGrantAsync(const CreateSnapshotCopyGrantRequestT& request, const CreateSnapshotCopyGrantResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::CreateSnapshotCopyGrant, request, handler, context); } /** *

Create a snapshot schedule that can be associated to a cluster and which * overrides the default system backup schedule.

See Also:

AWS * API Reference

*/ virtual Model::CreateSnapshotScheduleOutcome CreateSnapshotSchedule(const Model::CreateSnapshotScheduleRequest& request) const; /** * A Callable wrapper for CreateSnapshotSchedule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateSnapshotScheduleOutcomeCallable CreateSnapshotScheduleCallable(const CreateSnapshotScheduleRequestT& request) const { return SubmitCallable(&RedshiftClient::CreateSnapshotSchedule, request); } /** * An Async wrapper for CreateSnapshotSchedule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateSnapshotScheduleAsync(const CreateSnapshotScheduleRequestT& request, const CreateSnapshotScheduleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::CreateSnapshotSchedule, request, handler, context); } /** *

Adds tags to a cluster.

A resource can have up to 50 tags. If you try * to create more than 50 tags for a resource, you will receive an error and the * attempt will fail.

If you specify a key that already exists for the * resource, the value for that key will be updated with the new * value.

See Also:

AWS * API Reference

*/ virtual Model::CreateTagsOutcome CreateTags(const Model::CreateTagsRequest& request) const; /** * A Callable wrapper for CreateTags that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTagsOutcomeCallable CreateTagsCallable(const CreateTagsRequestT& request) const { return SubmitCallable(&RedshiftClient::CreateTags, request); } /** * An Async wrapper for CreateTags that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTagsAsync(const CreateTagsRequestT& request, const CreateTagsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::CreateTags, request, handler, context); } /** *

Creates a usage limit for a specified Amazon Redshift feature on a cluster. * The usage limit is identified by the returned usage limit * identifier.

See Also:

AWS * API Reference

*/ virtual Model::CreateUsageLimitOutcome CreateUsageLimit(const Model::CreateUsageLimitRequest& request) const; /** * A Callable wrapper for CreateUsageLimit that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateUsageLimitOutcomeCallable CreateUsageLimitCallable(const CreateUsageLimitRequestT& request) const { return SubmitCallable(&RedshiftClient::CreateUsageLimit, request); } /** * An Async wrapper for CreateUsageLimit that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateUsageLimitAsync(const CreateUsageLimitRequestT& request, const CreateUsageLimitResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::CreateUsageLimit, request, handler, context); } /** *

From a datashare producer account, removes authorization from the specified * datashare.

See Also:

AWS * API Reference

*/ virtual Model::DeauthorizeDataShareOutcome DeauthorizeDataShare(const Model::DeauthorizeDataShareRequest& request) const; /** * A Callable wrapper for DeauthorizeDataShare that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeauthorizeDataShareOutcomeCallable DeauthorizeDataShareCallable(const DeauthorizeDataShareRequestT& request) const { return SubmitCallable(&RedshiftClient::DeauthorizeDataShare, request); } /** * An Async wrapper for DeauthorizeDataShare that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeauthorizeDataShareAsync(const DeauthorizeDataShareRequestT& request, const DeauthorizeDataShareResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DeauthorizeDataShare, request, handler, context); } /** *

Deletes an authentication profile.

See Also:

AWS * API Reference

*/ virtual Model::DeleteAuthenticationProfileOutcome DeleteAuthenticationProfile(const Model::DeleteAuthenticationProfileRequest& request) const; /** * A Callable wrapper for DeleteAuthenticationProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAuthenticationProfileOutcomeCallable DeleteAuthenticationProfileCallable(const DeleteAuthenticationProfileRequestT& request) const { return SubmitCallable(&RedshiftClient::DeleteAuthenticationProfile, request); } /** * An Async wrapper for DeleteAuthenticationProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAuthenticationProfileAsync(const DeleteAuthenticationProfileRequestT& request, const DeleteAuthenticationProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DeleteAuthenticationProfile, request, handler, context); } /** *

Deletes a previously provisioned cluster without its final snapshot being * created. A successful response from the web service indicates that the request * was received correctly. Use DescribeClusters to monitor the status of the * deletion. The delete operation cannot be canceled or reverted once submitted. * For more information about managing clusters, go to Amazon * Redshift Clusters in the Amazon Redshift Cluster Management * Guide.

If you want to shut down the cluster and retain it for future * use, set SkipFinalClusterSnapshot to false and specify a * name for FinalClusterSnapshotIdentifier. You can later restore this * snapshot to resume using the cluster. If a final cluster snapshot is requested, * the status of the cluster will be "final-snapshot" while the snapshot is being * taken, then it's "deleting" once Amazon Redshift begins deleting the cluster. *

For more information about managing clusters, go to Amazon * Redshift Clusters in the Amazon Redshift Cluster Management * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteClusterOutcome DeleteCluster(const Model::DeleteClusterRequest& request) const; /** * A Callable wrapper for DeleteCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteClusterOutcomeCallable DeleteClusterCallable(const DeleteClusterRequestT& request) const { return SubmitCallable(&RedshiftClient::DeleteCluster, request); } /** * An Async wrapper for DeleteCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteClusterAsync(const DeleteClusterRequestT& request, const DeleteClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DeleteCluster, request, handler, context); } /** *

Deletes a specified Amazon Redshift parameter group.

You cannot * delete a parameter group if it is associated with a cluster.

*

See Also:

AWS * API Reference

*/ virtual Model::DeleteClusterParameterGroupOutcome DeleteClusterParameterGroup(const Model::DeleteClusterParameterGroupRequest& request) const; /** * A Callable wrapper for DeleteClusterParameterGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteClusterParameterGroupOutcomeCallable DeleteClusterParameterGroupCallable(const DeleteClusterParameterGroupRequestT& request) const { return SubmitCallable(&RedshiftClient::DeleteClusterParameterGroup, request); } /** * An Async wrapper for DeleteClusterParameterGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteClusterParameterGroupAsync(const DeleteClusterParameterGroupRequestT& request, const DeleteClusterParameterGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DeleteClusterParameterGroup, request, handler, context); } /** *

Deletes an Amazon Redshift security group.

You cannot delete a * security group that is associated with any clusters. You cannot delete the * default security group.

For information about managing security * groups, go to Amazon * Redshift Cluster Security Groups in the Amazon Redshift Cluster * Management Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteClusterSecurityGroupOutcome DeleteClusterSecurityGroup(const Model::DeleteClusterSecurityGroupRequest& request) const; /** * A Callable wrapper for DeleteClusterSecurityGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteClusterSecurityGroupOutcomeCallable DeleteClusterSecurityGroupCallable(const DeleteClusterSecurityGroupRequestT& request) const { return SubmitCallable(&RedshiftClient::DeleteClusterSecurityGroup, request); } /** * An Async wrapper for DeleteClusterSecurityGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteClusterSecurityGroupAsync(const DeleteClusterSecurityGroupRequestT& request, const DeleteClusterSecurityGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DeleteClusterSecurityGroup, request, handler, context); } /** *

Deletes the specified manual snapshot. The snapshot must be in the * available state, with no other users authorized to access the * snapshot.

Unlike automated snapshots, manual snapshots are retained even * after you delete your cluster. Amazon Redshift does not delete your manual * snapshots. You must delete manual snapshot explicitly to avoid getting charged. * If other accounts are authorized to access the snapshot, you must revoke all of * the authorizations before you can delete the snapshot.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteClusterSnapshotOutcome DeleteClusterSnapshot(const Model::DeleteClusterSnapshotRequest& request) const; /** * A Callable wrapper for DeleteClusterSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteClusterSnapshotOutcomeCallable DeleteClusterSnapshotCallable(const DeleteClusterSnapshotRequestT& request) const { return SubmitCallable(&RedshiftClient::DeleteClusterSnapshot, request); } /** * An Async wrapper for DeleteClusterSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteClusterSnapshotAsync(const DeleteClusterSnapshotRequestT& request, const DeleteClusterSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DeleteClusterSnapshot, request, handler, context); } /** *

Deletes the specified cluster subnet group.

See Also:

AWS * API Reference

*/ virtual Model::DeleteClusterSubnetGroupOutcome DeleteClusterSubnetGroup(const Model::DeleteClusterSubnetGroupRequest& request) const; /** * A Callable wrapper for DeleteClusterSubnetGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteClusterSubnetGroupOutcomeCallable DeleteClusterSubnetGroupCallable(const DeleteClusterSubnetGroupRequestT& request) const { return SubmitCallable(&RedshiftClient::DeleteClusterSubnetGroup, request); } /** * An Async wrapper for DeleteClusterSubnetGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteClusterSubnetGroupAsync(const DeleteClusterSubnetGroupRequestT& request, const DeleteClusterSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DeleteClusterSubnetGroup, request, handler, context); } /** *

Contains information about deleting a custom domain association for a * cluster.

See Also:

AWS * API Reference

*/ virtual Model::DeleteCustomDomainAssociationOutcome DeleteCustomDomainAssociation(const Model::DeleteCustomDomainAssociationRequest& request) const; /** * A Callable wrapper for DeleteCustomDomainAssociation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCustomDomainAssociationOutcomeCallable DeleteCustomDomainAssociationCallable(const DeleteCustomDomainAssociationRequestT& request) const { return SubmitCallable(&RedshiftClient::DeleteCustomDomainAssociation, request); } /** * An Async wrapper for DeleteCustomDomainAssociation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCustomDomainAssociationAsync(const DeleteCustomDomainAssociationRequestT& request, const DeleteCustomDomainAssociationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DeleteCustomDomainAssociation, request, handler, context); } /** *

Deletes a Redshift-managed VPC endpoint.

See Also:

AWS * API Reference

*/ virtual Model::DeleteEndpointAccessOutcome DeleteEndpointAccess(const Model::DeleteEndpointAccessRequest& request) const; /** * A Callable wrapper for DeleteEndpointAccess that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteEndpointAccessOutcomeCallable DeleteEndpointAccessCallable(const DeleteEndpointAccessRequestT& request) const { return SubmitCallable(&RedshiftClient::DeleteEndpointAccess, request); } /** * An Async wrapper for DeleteEndpointAccess that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteEndpointAccessAsync(const DeleteEndpointAccessRequestT& request, const DeleteEndpointAccessResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DeleteEndpointAccess, request, handler, context); } /** *

Deletes an Amazon Redshift event notification subscription.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteEventSubscriptionOutcome DeleteEventSubscription(const Model::DeleteEventSubscriptionRequest& request) const; /** * A Callable wrapper for DeleteEventSubscription that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteEventSubscriptionOutcomeCallable DeleteEventSubscriptionCallable(const DeleteEventSubscriptionRequestT& request) const { return SubmitCallable(&RedshiftClient::DeleteEventSubscription, request); } /** * An Async wrapper for DeleteEventSubscription that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteEventSubscriptionAsync(const DeleteEventSubscriptionRequestT& request, const DeleteEventSubscriptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DeleteEventSubscription, request, handler, context); } /** *

Deletes the specified HSM client certificate.

See Also:

AWS * API Reference

*/ virtual Model::DeleteHsmClientCertificateOutcome DeleteHsmClientCertificate(const Model::DeleteHsmClientCertificateRequest& request) const; /** * A Callable wrapper for DeleteHsmClientCertificate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteHsmClientCertificateOutcomeCallable DeleteHsmClientCertificateCallable(const DeleteHsmClientCertificateRequestT& request) const { return SubmitCallable(&RedshiftClient::DeleteHsmClientCertificate, request); } /** * An Async wrapper for DeleteHsmClientCertificate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteHsmClientCertificateAsync(const DeleteHsmClientCertificateRequestT& request, const DeleteHsmClientCertificateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DeleteHsmClientCertificate, request, handler, context); } /** *

Deletes the specified Amazon Redshift HSM configuration.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteHsmConfigurationOutcome DeleteHsmConfiguration(const Model::DeleteHsmConfigurationRequest& request) const; /** * A Callable wrapper for DeleteHsmConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteHsmConfigurationOutcomeCallable DeleteHsmConfigurationCallable(const DeleteHsmConfigurationRequestT& request) const { return SubmitCallable(&RedshiftClient::DeleteHsmConfiguration, request); } /** * An Async wrapper for DeleteHsmConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteHsmConfigurationAsync(const DeleteHsmConfigurationRequestT& request, const DeleteHsmConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DeleteHsmConfiguration, request, handler, context); } /** *

Deletes a partner integration from a cluster. Data can still flow to the * cluster until the integration is deleted at the partner's website.

See * Also:

AWS * API Reference

*/ virtual Model::DeletePartnerOutcome DeletePartner(const Model::DeletePartnerRequest& request) const; /** * A Callable wrapper for DeletePartner that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeletePartnerOutcomeCallable DeletePartnerCallable(const DeletePartnerRequestT& request) const { return SubmitCallable(&RedshiftClient::DeletePartner, request); } /** * An Async wrapper for DeletePartner that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeletePartnerAsync(const DeletePartnerRequestT& request, const DeletePartnerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DeletePartner, request, handler, context); } /** *

Deletes a scheduled action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteScheduledActionOutcome DeleteScheduledAction(const Model::DeleteScheduledActionRequest& request) const; /** * A Callable wrapper for DeleteScheduledAction that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteScheduledActionOutcomeCallable DeleteScheduledActionCallable(const DeleteScheduledActionRequestT& request) const { return SubmitCallable(&RedshiftClient::DeleteScheduledAction, request); } /** * An Async wrapper for DeleteScheduledAction that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteScheduledActionAsync(const DeleteScheduledActionRequestT& request, const DeleteScheduledActionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DeleteScheduledAction, request, handler, context); } /** *

Deletes the specified snapshot copy grant.

See Also:

AWS * API Reference

*/ virtual Model::DeleteSnapshotCopyGrantOutcome DeleteSnapshotCopyGrant(const Model::DeleteSnapshotCopyGrantRequest& request) const; /** * A Callable wrapper for DeleteSnapshotCopyGrant that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteSnapshotCopyGrantOutcomeCallable DeleteSnapshotCopyGrantCallable(const DeleteSnapshotCopyGrantRequestT& request) const { return SubmitCallable(&RedshiftClient::DeleteSnapshotCopyGrant, request); } /** * An Async wrapper for DeleteSnapshotCopyGrant that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteSnapshotCopyGrantAsync(const DeleteSnapshotCopyGrantRequestT& request, const DeleteSnapshotCopyGrantResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DeleteSnapshotCopyGrant, request, handler, context); } /** *

Deletes a snapshot schedule.

See Also:

AWS * API Reference

*/ virtual Model::DeleteSnapshotScheduleOutcome DeleteSnapshotSchedule(const Model::DeleteSnapshotScheduleRequest& request) const; /** * A Callable wrapper for DeleteSnapshotSchedule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteSnapshotScheduleOutcomeCallable DeleteSnapshotScheduleCallable(const DeleteSnapshotScheduleRequestT& request) const { return SubmitCallable(&RedshiftClient::DeleteSnapshotSchedule, request); } /** * An Async wrapper for DeleteSnapshotSchedule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteSnapshotScheduleAsync(const DeleteSnapshotScheduleRequestT& request, const DeleteSnapshotScheduleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DeleteSnapshotSchedule, request, handler, context); } /** *

Deletes tags from a resource. You must provide the ARN of the resource from * which you want to delete the tag or tags.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTagsOutcome DeleteTags(const Model::DeleteTagsRequest& request) const; /** * A Callable wrapper for DeleteTags that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTagsOutcomeCallable DeleteTagsCallable(const DeleteTagsRequestT& request) const { return SubmitCallable(&RedshiftClient::DeleteTags, request); } /** * An Async wrapper for DeleteTags that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTagsAsync(const DeleteTagsRequestT& request, const DeleteTagsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DeleteTags, request, handler, context); } /** *

Deletes a usage limit from a cluster.

See Also:

AWS * API Reference

*/ virtual Model::DeleteUsageLimitOutcome DeleteUsageLimit(const Model::DeleteUsageLimitRequest& request) const; /** * A Callable wrapper for DeleteUsageLimit that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteUsageLimitOutcomeCallable DeleteUsageLimitCallable(const DeleteUsageLimitRequestT& request) const { return SubmitCallable(&RedshiftClient::DeleteUsageLimit, request); } /** * An Async wrapper for DeleteUsageLimit that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteUsageLimitAsync(const DeleteUsageLimitRequestT& request, const DeleteUsageLimitResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DeleteUsageLimit, request, handler, context); } /** *

Returns a list of attributes attached to an account

See Also:

* AWS * API Reference

*/ virtual Model::DescribeAccountAttributesOutcome DescribeAccountAttributes(const Model::DescribeAccountAttributesRequest& request) const; /** * A Callable wrapper for DescribeAccountAttributes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAccountAttributesOutcomeCallable DescribeAccountAttributesCallable(const DescribeAccountAttributesRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeAccountAttributes, request); } /** * An Async wrapper for DescribeAccountAttributes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAccountAttributesAsync(const DescribeAccountAttributesRequestT& request, const DescribeAccountAttributesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeAccountAttributes, request, handler, context); } /** *

Describes an authentication profile.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAuthenticationProfilesOutcome DescribeAuthenticationProfiles(const Model::DescribeAuthenticationProfilesRequest& request) const; /** * A Callable wrapper for DescribeAuthenticationProfiles that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAuthenticationProfilesOutcomeCallable DescribeAuthenticationProfilesCallable(const DescribeAuthenticationProfilesRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeAuthenticationProfiles, request); } /** * An Async wrapper for DescribeAuthenticationProfiles that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAuthenticationProfilesAsync(const DescribeAuthenticationProfilesRequestT& request, const DescribeAuthenticationProfilesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeAuthenticationProfiles, request, handler, context); } /** *

Returns an array of ClusterDbRevision objects.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeClusterDbRevisionsOutcome DescribeClusterDbRevisions(const Model::DescribeClusterDbRevisionsRequest& request) const; /** * A Callable wrapper for DescribeClusterDbRevisions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeClusterDbRevisionsOutcomeCallable DescribeClusterDbRevisionsCallable(const DescribeClusterDbRevisionsRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeClusterDbRevisions, request); } /** * An Async wrapper for DescribeClusterDbRevisions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeClusterDbRevisionsAsync(const DescribeClusterDbRevisionsRequestT& request, const DescribeClusterDbRevisionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeClusterDbRevisions, request, handler, context); } /** *

Returns a list of Amazon Redshift parameter groups, including parameter * groups you created and the default parameter group. For each parameter group, * the response includes the parameter group name, description, and parameter group * family name. You can optionally specify a name to retrieve the description of a * specific parameter group.

For more information about parameters and * parameter groups, go to Amazon * Redshift Parameter Groups in the Amazon Redshift Cluster Management * Guide.

If you specify both tag keys and tag values in the same * request, Amazon Redshift returns all parameter groups that match any combination * of the specified keys and values. For example, if you have owner * and environment for tag keys, and admin and * test for tag values, all parameter groups that have any combination * of those values are returned.

If both tag keys and values are omitted * from the request, parameter groups are returned regardless of whether they have * tag keys or values associated with them.

See Also:

AWS * API Reference

*/ virtual Model::DescribeClusterParameterGroupsOutcome DescribeClusterParameterGroups(const Model::DescribeClusterParameterGroupsRequest& request) const; /** * A Callable wrapper for DescribeClusterParameterGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeClusterParameterGroupsOutcomeCallable DescribeClusterParameterGroupsCallable(const DescribeClusterParameterGroupsRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeClusterParameterGroups, request); } /** * An Async wrapper for DescribeClusterParameterGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeClusterParameterGroupsAsync(const DescribeClusterParameterGroupsRequestT& request, const DescribeClusterParameterGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeClusterParameterGroups, request, handler, context); } /** *

Returns a detailed list of parameters contained within the specified Amazon * Redshift parameter group. For each parameter the response includes information * such as parameter name, description, data type, value, whether the parameter * value is modifiable, and so on.

You can specify source filter to * retrieve parameters of only specific type. For example, to retrieve parameters * that were modified by a user action such as from * ModifyClusterParameterGroup, you can specify source equal to * user.

For more information about parameters and parameter groups, * go to Amazon * Redshift Parameter Groups in the Amazon Redshift Cluster Management * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeClusterParametersOutcome DescribeClusterParameters(const Model::DescribeClusterParametersRequest& request) const; /** * A Callable wrapper for DescribeClusterParameters that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeClusterParametersOutcomeCallable DescribeClusterParametersCallable(const DescribeClusterParametersRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeClusterParameters, request); } /** * An Async wrapper for DescribeClusterParameters that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeClusterParametersAsync(const DescribeClusterParametersRequestT& request, const DescribeClusterParametersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeClusterParameters, request, handler, context); } /** *

Returns information about Amazon Redshift security groups. If the name of a * security group is specified, the response will contain only information about * only that security group.

For information about managing security * groups, go to Amazon * Redshift Cluster Security Groups in the Amazon Redshift Cluster * Management Guide.

If you specify both tag keys and tag values in the * same request, Amazon Redshift returns all security groups that match any * combination of the specified keys and values. For example, if you have * owner and environment for tag keys, and * admin and test for tag values, all security groups * that have any combination of those values are returned.

If both tag keys * and values are omitted from the request, security groups are returned regardless * of whether they have tag keys or values associated with them.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeClusterSecurityGroupsOutcome DescribeClusterSecurityGroups(const Model::DescribeClusterSecurityGroupsRequest& request) const; /** * A Callable wrapper for DescribeClusterSecurityGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeClusterSecurityGroupsOutcomeCallable DescribeClusterSecurityGroupsCallable(const DescribeClusterSecurityGroupsRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeClusterSecurityGroups, request); } /** * An Async wrapper for DescribeClusterSecurityGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeClusterSecurityGroupsAsync(const DescribeClusterSecurityGroupsRequestT& request, const DescribeClusterSecurityGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeClusterSecurityGroups, request, handler, context); } /** *

Returns one or more snapshot objects, which contain metadata about your * cluster snapshots. By default, this operation returns information about all * snapshots of all clusters that are owned by your Amazon Web Services account. No * information is returned for snapshots owned by inactive Amazon Web Services * accounts.

If you specify both tag keys and tag values in the same * request, Amazon Redshift returns all snapshots that match any combination of the * specified keys and values. For example, if you have owner and * environment for tag keys, and admin and * test for tag values, all snapshots that have any combination of * those values are returned. Only snapshots that you own are returned in the * response; shared snapshots are not returned with the tag key and tag value * request parameters.

If both tag keys and values are omitted from the * request, snapshots are returned regardless of whether they have tag keys or * values associated with them.

See Also:

AWS * API Reference

*/ virtual Model::DescribeClusterSnapshotsOutcome DescribeClusterSnapshots(const Model::DescribeClusterSnapshotsRequest& request) const; /** * A Callable wrapper for DescribeClusterSnapshots that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeClusterSnapshotsOutcomeCallable DescribeClusterSnapshotsCallable(const DescribeClusterSnapshotsRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeClusterSnapshots, request); } /** * An Async wrapper for DescribeClusterSnapshots that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeClusterSnapshotsAsync(const DescribeClusterSnapshotsRequestT& request, const DescribeClusterSnapshotsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeClusterSnapshots, request, handler, context); } /** *

Returns one or more cluster subnet group objects, which contain metadata * about your cluster subnet groups. By default, this operation returns information * about all cluster subnet groups that are defined in your Amazon Web Services * account.

If you specify both tag keys and tag values in the same request, * Amazon Redshift returns all subnet groups that match any combination of the * specified keys and values. For example, if you have owner and * environment for tag keys, and admin and * test for tag values, all subnet groups that have any combination of * those values are returned.

If both tag keys and values are omitted from * the request, subnet groups are returned regardless of whether they have tag keys * or values associated with them.

See Also:

AWS * API Reference

*/ virtual Model::DescribeClusterSubnetGroupsOutcome DescribeClusterSubnetGroups(const Model::DescribeClusterSubnetGroupsRequest& request) const; /** * A Callable wrapper for DescribeClusterSubnetGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeClusterSubnetGroupsOutcomeCallable DescribeClusterSubnetGroupsCallable(const DescribeClusterSubnetGroupsRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeClusterSubnetGroups, request); } /** * An Async wrapper for DescribeClusterSubnetGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeClusterSubnetGroupsAsync(const DescribeClusterSubnetGroupsRequestT& request, const DescribeClusterSubnetGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeClusterSubnetGroups, request, handler, context); } /** *

Returns a list of all the available maintenance tracks.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeClusterTracksOutcome DescribeClusterTracks(const Model::DescribeClusterTracksRequest& request) const; /** * A Callable wrapper for DescribeClusterTracks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeClusterTracksOutcomeCallable DescribeClusterTracksCallable(const DescribeClusterTracksRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeClusterTracks, request); } /** * An Async wrapper for DescribeClusterTracks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeClusterTracksAsync(const DescribeClusterTracksRequestT& request, const DescribeClusterTracksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeClusterTracks, request, handler, context); } /** *

Returns descriptions of the available Amazon Redshift cluster versions. You * can call this operation even before creating any clusters to learn more about * the Amazon Redshift versions. For more information about managing clusters, go * to Amazon * Redshift Clusters in the Amazon Redshift Cluster Management * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeClusterVersionsOutcome DescribeClusterVersions(const Model::DescribeClusterVersionsRequest& request) const; /** * A Callable wrapper for DescribeClusterVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeClusterVersionsOutcomeCallable DescribeClusterVersionsCallable(const DescribeClusterVersionsRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeClusterVersions, request); } /** * An Async wrapper for DescribeClusterVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeClusterVersionsAsync(const DescribeClusterVersionsRequestT& request, const DescribeClusterVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeClusterVersions, request, handler, context); } /** *

Returns properties of provisioned clusters including general cluster * properties, cluster database properties, maintenance and backup properties, and * security and access properties. This operation supports pagination. For more * information about managing clusters, go to Amazon * Redshift Clusters in the Amazon Redshift Cluster Management * Guide.

If you specify both tag keys and tag values in the same * request, Amazon Redshift returns all clusters that match any combination of the * specified keys and values. For example, if you have owner and * environment for tag keys, and admin and * test for tag values, all clusters that have any combination of * those values are returned.

If both tag keys and values are omitted from * the request, clusters are returned regardless of whether they have tag keys or * values associated with them.

See Also:

AWS * API Reference

*/ virtual Model::DescribeClustersOutcome DescribeClusters(const Model::DescribeClustersRequest& request) const; /** * A Callable wrapper for DescribeClusters that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeClustersOutcomeCallable DescribeClustersCallable(const DescribeClustersRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeClusters, request); } /** * An Async wrapper for DescribeClusters that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeClustersAsync(const DescribeClustersRequestT& request, const DescribeClustersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeClusters, request, handler, context); } /** *

Contains information for custom domain associations for a * cluster.

See Also:

AWS * API Reference

*/ virtual Model::DescribeCustomDomainAssociationsOutcome DescribeCustomDomainAssociations(const Model::DescribeCustomDomainAssociationsRequest& request) const; /** * A Callable wrapper for DescribeCustomDomainAssociations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeCustomDomainAssociationsOutcomeCallable DescribeCustomDomainAssociationsCallable(const DescribeCustomDomainAssociationsRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeCustomDomainAssociations, request); } /** * An Async wrapper for DescribeCustomDomainAssociations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeCustomDomainAssociationsAsync(const DescribeCustomDomainAssociationsRequestT& request, const DescribeCustomDomainAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeCustomDomainAssociations, request, handler, context); } /** *

Shows the status of any inbound or outbound datashares available in the * specified account.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDataSharesOutcome DescribeDataShares(const Model::DescribeDataSharesRequest& request) const; /** * A Callable wrapper for DescribeDataShares that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDataSharesOutcomeCallable DescribeDataSharesCallable(const DescribeDataSharesRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeDataShares, request); } /** * An Async wrapper for DescribeDataShares that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDataSharesAsync(const DescribeDataSharesRequestT& request, const DescribeDataSharesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeDataShares, request, handler, context); } /** *

Returns a list of datashares where the account identifier being called is a * consumer account identifier.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDataSharesForConsumerOutcome DescribeDataSharesForConsumer(const Model::DescribeDataSharesForConsumerRequest& request) const; /** * A Callable wrapper for DescribeDataSharesForConsumer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDataSharesForConsumerOutcomeCallable DescribeDataSharesForConsumerCallable(const DescribeDataSharesForConsumerRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeDataSharesForConsumer, request); } /** * An Async wrapper for DescribeDataSharesForConsumer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDataSharesForConsumerAsync(const DescribeDataSharesForConsumerRequestT& request, const DescribeDataSharesForConsumerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeDataSharesForConsumer, request, handler, context); } /** *

Returns a list of datashares when the account identifier being called is a * producer account identifier.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDataSharesForProducerOutcome DescribeDataSharesForProducer(const Model::DescribeDataSharesForProducerRequest& request) const; /** * A Callable wrapper for DescribeDataSharesForProducer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDataSharesForProducerOutcomeCallable DescribeDataSharesForProducerCallable(const DescribeDataSharesForProducerRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeDataSharesForProducer, request); } /** * An Async wrapper for DescribeDataSharesForProducer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDataSharesForProducerAsync(const DescribeDataSharesForProducerRequestT& request, const DescribeDataSharesForProducerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeDataSharesForProducer, request, handler, context); } /** *

Returns a list of parameter settings for the specified parameter group * family.

For more information about parameters and parameter groups, go * to Amazon * Redshift Parameter Groups in the Amazon Redshift Cluster Management * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDefaultClusterParametersOutcome DescribeDefaultClusterParameters(const Model::DescribeDefaultClusterParametersRequest& request) const; /** * A Callable wrapper for DescribeDefaultClusterParameters that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDefaultClusterParametersOutcomeCallable DescribeDefaultClusterParametersCallable(const DescribeDefaultClusterParametersRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeDefaultClusterParameters, request); } /** * An Async wrapper for DescribeDefaultClusterParameters that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDefaultClusterParametersAsync(const DescribeDefaultClusterParametersRequestT& request, const DescribeDefaultClusterParametersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeDefaultClusterParameters, request, handler, context); } /** *

Describes a Redshift-managed VPC endpoint.

See Also:

AWS * API Reference

*/ virtual Model::DescribeEndpointAccessOutcome DescribeEndpointAccess(const Model::DescribeEndpointAccessRequest& request) const; /** * A Callable wrapper for DescribeEndpointAccess that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEndpointAccessOutcomeCallable DescribeEndpointAccessCallable(const DescribeEndpointAccessRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeEndpointAccess, request); } /** * An Async wrapper for DescribeEndpointAccess that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEndpointAccessAsync(const DescribeEndpointAccessRequestT& request, const DescribeEndpointAccessResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeEndpointAccess, request, handler, context); } /** *

Describes an endpoint authorization.

See Also:

AWS * API Reference

*/ virtual Model::DescribeEndpointAuthorizationOutcome DescribeEndpointAuthorization(const Model::DescribeEndpointAuthorizationRequest& request) const; /** * A Callable wrapper for DescribeEndpointAuthorization that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEndpointAuthorizationOutcomeCallable DescribeEndpointAuthorizationCallable(const DescribeEndpointAuthorizationRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeEndpointAuthorization, request); } /** * An Async wrapper for DescribeEndpointAuthorization that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEndpointAuthorizationAsync(const DescribeEndpointAuthorizationRequestT& request, const DescribeEndpointAuthorizationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeEndpointAuthorization, request, handler, context); } /** *

Displays a list of event categories for all event source types, or for a * specified source type. For a list of the event categories and source types, go * to Amazon * Redshift Event Notifications.

See Also:

AWS * API Reference

*/ virtual Model::DescribeEventCategoriesOutcome DescribeEventCategories(const Model::DescribeEventCategoriesRequest& request) const; /** * A Callable wrapper for DescribeEventCategories that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEventCategoriesOutcomeCallable DescribeEventCategoriesCallable(const DescribeEventCategoriesRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeEventCategories, request); } /** * An Async wrapper for DescribeEventCategories that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEventCategoriesAsync(const DescribeEventCategoriesRequestT& request, const DescribeEventCategoriesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeEventCategories, request, handler, context); } /** *

Lists descriptions of all the Amazon Redshift event notification * subscriptions for a customer account. If you specify a subscription name, lists * the description for that subscription.

If you specify both tag keys and * tag values in the same request, Amazon Redshift returns all event notification * subscriptions that match any combination of the specified keys and values. For * example, if you have owner and environment for tag * keys, and admin and test for tag values, all * subscriptions that have any combination of those values are returned.

If * both tag keys and values are omitted from the request, subscriptions are * returned regardless of whether they have tag keys or values associated with * them.

See Also:

AWS * API Reference

*/ virtual Model::DescribeEventSubscriptionsOutcome DescribeEventSubscriptions(const Model::DescribeEventSubscriptionsRequest& request) const; /** * A Callable wrapper for DescribeEventSubscriptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEventSubscriptionsOutcomeCallable DescribeEventSubscriptionsCallable(const DescribeEventSubscriptionsRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeEventSubscriptions, request); } /** * An Async wrapper for DescribeEventSubscriptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEventSubscriptionsAsync(const DescribeEventSubscriptionsRequestT& request, const DescribeEventSubscriptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeEventSubscriptions, request, handler, context); } /** *

Returns events related to clusters, security groups, snapshots, and parameter * groups for the past 14 days. Events specific to a particular cluster, security * group, snapshot or parameter group can be obtained by providing the name as a * parameter. By default, the past hour of events are returned.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeEventsOutcome DescribeEvents(const Model::DescribeEventsRequest& request) const; /** * A Callable wrapper for DescribeEvents that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEventsOutcomeCallable DescribeEventsCallable(const DescribeEventsRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeEvents, request); } /** * An Async wrapper for DescribeEvents that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEventsAsync(const DescribeEventsRequestT& request, const DescribeEventsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeEvents, request, handler, context); } /** *

Returns information about the specified HSM client certificate. If no * certificate ID is specified, returns information about all the HSM certificates * owned by your Amazon Web Services account.

If you specify both tag keys * and tag values in the same request, Amazon Redshift returns all HSM client * certificates that match any combination of the specified keys and values. For * example, if you have owner and environment for tag * keys, and admin and test for tag values, all HSM * client certificates that have any combination of those values are returned.

*

If both tag keys and values are omitted from the request, HSM client * certificates are returned regardless of whether they have tag keys or values * associated with them.

See Also:

AWS * API Reference

*/ virtual Model::DescribeHsmClientCertificatesOutcome DescribeHsmClientCertificates(const Model::DescribeHsmClientCertificatesRequest& request) const; /** * A Callable wrapper for DescribeHsmClientCertificates that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeHsmClientCertificatesOutcomeCallable DescribeHsmClientCertificatesCallable(const DescribeHsmClientCertificatesRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeHsmClientCertificates, request); } /** * An Async wrapper for DescribeHsmClientCertificates that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeHsmClientCertificatesAsync(const DescribeHsmClientCertificatesRequestT& request, const DescribeHsmClientCertificatesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeHsmClientCertificates, request, handler, context); } /** *

Returns information about the specified Amazon Redshift HSM configuration. If * no configuration ID is specified, returns information about all the HSM * configurations owned by your Amazon Web Services account.

If you specify * both tag keys and tag values in the same request, Amazon Redshift returns all * HSM connections that match any combination of the specified keys and values. For * example, if you have owner and environment for tag * keys, and admin and test for tag values, all HSM * connections that have any combination of those values are returned.

If * both tag keys and values are omitted from the request, HSM connections are * returned regardless of whether they have tag keys or values associated with * them.

See Also:

AWS * API Reference

*/ virtual Model::DescribeHsmConfigurationsOutcome DescribeHsmConfigurations(const Model::DescribeHsmConfigurationsRequest& request) const; /** * A Callable wrapper for DescribeHsmConfigurations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeHsmConfigurationsOutcomeCallable DescribeHsmConfigurationsCallable(const DescribeHsmConfigurationsRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeHsmConfigurations, request); } /** * An Async wrapper for DescribeHsmConfigurations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeHsmConfigurationsAsync(const DescribeHsmConfigurationsRequestT& request, const DescribeHsmConfigurationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeHsmConfigurations, request, handler, context); } /** *

Describes whether information, such as queries and connection attempts, is * being logged for the specified Amazon Redshift cluster.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeLoggingStatusOutcome DescribeLoggingStatus(const Model::DescribeLoggingStatusRequest& request) const; /** * A Callable wrapper for DescribeLoggingStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLoggingStatusOutcomeCallable DescribeLoggingStatusCallable(const DescribeLoggingStatusRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeLoggingStatus, request); } /** * An Async wrapper for DescribeLoggingStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLoggingStatusAsync(const DescribeLoggingStatusRequestT& request, const DescribeLoggingStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeLoggingStatus, request, handler, context); } /** *

Returns properties of possible node configurations such as node type, number * of nodes, and disk usage for the specified action type.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeNodeConfigurationOptionsOutcome DescribeNodeConfigurationOptions(const Model::DescribeNodeConfigurationOptionsRequest& request) const; /** * A Callable wrapper for DescribeNodeConfigurationOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeNodeConfigurationOptionsOutcomeCallable DescribeNodeConfigurationOptionsCallable(const DescribeNodeConfigurationOptionsRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeNodeConfigurationOptions, request); } /** * An Async wrapper for DescribeNodeConfigurationOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeNodeConfigurationOptionsAsync(const DescribeNodeConfigurationOptionsRequestT& request, const DescribeNodeConfigurationOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeNodeConfigurationOptions, request, handler, context); } /** *

Returns a list of orderable cluster options. Before you create a new cluster * you can use this operation to find what options are available, such as the EC2 * Availability Zones (AZ) in the specific Amazon Web Services Region that you can * specify, and the node types you can request. The node types differ by available * storage, memory, CPU and price. With the cost involved you might want to obtain * a list of cluster options in the specific region and specify values when * creating a cluster. For more information about managing clusters, go to Amazon * Redshift Clusters in the Amazon Redshift Cluster Management * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeOrderableClusterOptionsOutcome DescribeOrderableClusterOptions(const Model::DescribeOrderableClusterOptionsRequest& request) const; /** * A Callable wrapper for DescribeOrderableClusterOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeOrderableClusterOptionsOutcomeCallable DescribeOrderableClusterOptionsCallable(const DescribeOrderableClusterOptionsRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeOrderableClusterOptions, request); } /** * An Async wrapper for DescribeOrderableClusterOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeOrderableClusterOptionsAsync(const DescribeOrderableClusterOptionsRequestT& request, const DescribeOrderableClusterOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeOrderableClusterOptions, request, handler, context); } /** *

Returns information about the partner integrations defined for a * cluster.

See Also:

AWS * API Reference

*/ virtual Model::DescribePartnersOutcome DescribePartners(const Model::DescribePartnersRequest& request) const; /** * A Callable wrapper for DescribePartners that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribePartnersOutcomeCallable DescribePartnersCallable(const DescribePartnersRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribePartners, request); } /** * An Async wrapper for DescribePartners that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribePartnersAsync(const DescribePartnersRequestT& request, const DescribePartnersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribePartners, request, handler, context); } /** *

Returns exchange status details and associated metadata for a reserved-node * exchange. Statuses include such values as in progress and * requested.

See Also:

AWS * API Reference

*/ virtual Model::DescribeReservedNodeExchangeStatusOutcome DescribeReservedNodeExchangeStatus(const Model::DescribeReservedNodeExchangeStatusRequest& request) const; /** * A Callable wrapper for DescribeReservedNodeExchangeStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeReservedNodeExchangeStatusOutcomeCallable DescribeReservedNodeExchangeStatusCallable(const DescribeReservedNodeExchangeStatusRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeReservedNodeExchangeStatus, request); } /** * An Async wrapper for DescribeReservedNodeExchangeStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeReservedNodeExchangeStatusAsync(const DescribeReservedNodeExchangeStatusRequestT& request, const DescribeReservedNodeExchangeStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeReservedNodeExchangeStatus, request, handler, context); } /** *

Returns a list of the available reserved node offerings by Amazon Redshift * with their descriptions including the node type, the fixed and recurring costs * of reserving the node and duration the node will be reserved for you. These * descriptions help you determine which reserve node offering you want to * purchase. You then use the unique offering ID in you call to * PurchaseReservedNodeOffering to reserve one or more nodes for your Amazon * Redshift cluster.

For more information about reserved node offerings, * go to Purchasing * Reserved Nodes in the Amazon Redshift Cluster Management * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeReservedNodeOfferingsOutcome DescribeReservedNodeOfferings(const Model::DescribeReservedNodeOfferingsRequest& request) const; /** * A Callable wrapper for DescribeReservedNodeOfferings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeReservedNodeOfferingsOutcomeCallable DescribeReservedNodeOfferingsCallable(const DescribeReservedNodeOfferingsRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeReservedNodeOfferings, request); } /** * An Async wrapper for DescribeReservedNodeOfferings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeReservedNodeOfferingsAsync(const DescribeReservedNodeOfferingsRequestT& request, const DescribeReservedNodeOfferingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeReservedNodeOfferings, request, handler, context); } /** *

Returns the descriptions of the reserved nodes.

See Also:

AWS * API Reference

*/ virtual Model::DescribeReservedNodesOutcome DescribeReservedNodes(const Model::DescribeReservedNodesRequest& request) const; /** * A Callable wrapper for DescribeReservedNodes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeReservedNodesOutcomeCallable DescribeReservedNodesCallable(const DescribeReservedNodesRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeReservedNodes, request); } /** * An Async wrapper for DescribeReservedNodes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeReservedNodesAsync(const DescribeReservedNodesRequestT& request, const DescribeReservedNodesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeReservedNodes, request, handler, context); } /** *

Returns information about the last resize operation for the specified * cluster. If no resize operation has ever been initiated for the specified * cluster, a HTTP 404 error is returned. If a resize operation was * initiated and completed, the status of the resize remains as * SUCCEEDED until the next resize.

A resize operation can be * requested using ModifyCluster and specifying a different number or type * of nodes for the cluster.

See Also:

AWS * API Reference

*/ virtual Model::DescribeResizeOutcome DescribeResize(const Model::DescribeResizeRequest& request) const; /** * A Callable wrapper for DescribeResize that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeResizeOutcomeCallable DescribeResizeCallable(const DescribeResizeRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeResize, request); } /** * An Async wrapper for DescribeResize that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeResizeAsync(const DescribeResizeRequestT& request, const DescribeResizeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeResize, request, handler, context); } /** *

Describes properties of scheduled actions.

See Also:

AWS * API Reference

*/ virtual Model::DescribeScheduledActionsOutcome DescribeScheduledActions(const Model::DescribeScheduledActionsRequest& request) const; /** * A Callable wrapper for DescribeScheduledActions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeScheduledActionsOutcomeCallable DescribeScheduledActionsCallable(const DescribeScheduledActionsRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeScheduledActions, request); } /** * An Async wrapper for DescribeScheduledActions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeScheduledActionsAsync(const DescribeScheduledActionsRequestT& request, const DescribeScheduledActionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeScheduledActions, request, handler, context); } /** *

Returns a list of snapshot copy grants owned by the Amazon Web Services * account in the destination region.

For more information about managing * snapshot copy grants, go to Amazon * Redshift Database Encryption in the Amazon Redshift Cluster Management * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeSnapshotCopyGrantsOutcome DescribeSnapshotCopyGrants(const Model::DescribeSnapshotCopyGrantsRequest& request) const; /** * A Callable wrapper for DescribeSnapshotCopyGrants that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSnapshotCopyGrantsOutcomeCallable DescribeSnapshotCopyGrantsCallable(const DescribeSnapshotCopyGrantsRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeSnapshotCopyGrants, request); } /** * An Async wrapper for DescribeSnapshotCopyGrants that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSnapshotCopyGrantsAsync(const DescribeSnapshotCopyGrantsRequestT& request, const DescribeSnapshotCopyGrantsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeSnapshotCopyGrants, request, handler, context); } /** *

Returns a list of snapshot schedules.

See Also:

AWS * API Reference

*/ virtual Model::DescribeSnapshotSchedulesOutcome DescribeSnapshotSchedules(const Model::DescribeSnapshotSchedulesRequest& request) const; /** * A Callable wrapper for DescribeSnapshotSchedules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSnapshotSchedulesOutcomeCallable DescribeSnapshotSchedulesCallable(const DescribeSnapshotSchedulesRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeSnapshotSchedules, request); } /** * An Async wrapper for DescribeSnapshotSchedules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSnapshotSchedulesAsync(const DescribeSnapshotSchedulesRequestT& request, const DescribeSnapshotSchedulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeSnapshotSchedules, request, handler, context); } /** *

Returns account level backups storage size and provisional * storage.

See Also:

AWS * API Reference

*/ virtual Model::DescribeStorageOutcome DescribeStorage(const Model::DescribeStorageRequest& request) const; /** * A Callable wrapper for DescribeStorage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeStorageOutcomeCallable DescribeStorageCallable(const DescribeStorageRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeStorage, request); } /** * An Async wrapper for DescribeStorage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeStorageAsync(const DescribeStorageRequestT& request, const DescribeStorageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeStorage, request, handler, context); } /** *

Lists the status of one or more table restore requests made using the * RestoreTableFromClusterSnapshot API action. If you don't specify a value * for the TableRestoreRequestId parameter, then * DescribeTableRestoreStatus returns the status of all table restore * requests ordered by the date and time of the request in ascending order. * Otherwise DescribeTableRestoreStatus returns the status of the * table specified by TableRestoreRequestId.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeTableRestoreStatusOutcome DescribeTableRestoreStatus(const Model::DescribeTableRestoreStatusRequest& request) const; /** * A Callable wrapper for DescribeTableRestoreStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTableRestoreStatusOutcomeCallable DescribeTableRestoreStatusCallable(const DescribeTableRestoreStatusRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeTableRestoreStatus, request); } /** * An Async wrapper for DescribeTableRestoreStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTableRestoreStatusAsync(const DescribeTableRestoreStatusRequestT& request, const DescribeTableRestoreStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeTableRestoreStatus, request, handler, context); } /** *

Returns a list of tags. You can return tags from a specific resource by * specifying an ARN, or you can return all tags for a given type of resource, such * as clusters, snapshots, and so on.

The following are limitations for * DescribeTags:

  • You cannot specify an ARN and a * resource-type value together in the same request.

  • You cannot * use the MaxRecords and Marker parameters together with * the ARN parameter.

  • The MaxRecords parameter can * be a range from 10 to 50 results to return in a request.

If * you specify both tag keys and tag values in the same request, Amazon Redshift * returns all resources that match any combination of the specified keys and * values. For example, if you have owner and environment * for tag keys, and admin and test for tag values, all * resources that have any combination of those values are returned.

If both * tag keys and values are omitted from the request, resources are returned * regardless of whether they have tag keys or values associated with * them.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTagsOutcome DescribeTags(const Model::DescribeTagsRequest& request) const; /** * A Callable wrapper for DescribeTags that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTagsOutcomeCallable DescribeTagsCallable(const DescribeTagsRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeTags, request); } /** * An Async wrapper for DescribeTags that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTagsAsync(const DescribeTagsRequestT& request, const DescribeTagsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeTags, request, handler, context); } /** *

Shows usage limits on a cluster. Results are filtered based on the * combination of input usage limit identifier, cluster identifier, and feature * type parameters:

  • If usage limit identifier, cluster identifier, * and feature type are not provided, then all usage limit objects for the current * account in the current region are returned.

  • If usage limit * identifier is provided, then the corresponding usage limit object is * returned.

  • If cluster identifier is provided, then all usage * limit objects for the specified cluster are returned.

  • If * cluster identifier and feature type are provided, then all usage limit objects * for the combination of cluster and feature are returned.

    • *

See Also:

AWS * API Reference

*/ virtual Model::DescribeUsageLimitsOutcome DescribeUsageLimits(const Model::DescribeUsageLimitsRequest& request) const; /** * A Callable wrapper for DescribeUsageLimits that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeUsageLimitsOutcomeCallable DescribeUsageLimitsCallable(const DescribeUsageLimitsRequestT& request) const { return SubmitCallable(&RedshiftClient::DescribeUsageLimits, request); } /** * An Async wrapper for DescribeUsageLimits that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeUsageLimitsAsync(const DescribeUsageLimitsRequestT& request, const DescribeUsageLimitsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DescribeUsageLimits, request, handler, context); } /** *

Stops logging information, such as queries and connection attempts, for the * specified Amazon Redshift cluster.

See Also:

AWS * API Reference

*/ virtual Model::DisableLoggingOutcome DisableLogging(const Model::DisableLoggingRequest& request) const; /** * A Callable wrapper for DisableLogging that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableLoggingOutcomeCallable DisableLoggingCallable(const DisableLoggingRequestT& request) const { return SubmitCallable(&RedshiftClient::DisableLogging, request); } /** * An Async wrapper for DisableLogging that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableLoggingAsync(const DisableLoggingRequestT& request, const DisableLoggingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DisableLogging, request, handler, context); } /** *

Disables the automatic copying of snapshots from one region to another region * for a specified cluster.

If your cluster and its snapshots are encrypted * using an encrypted symmetric key from Key Management Service, use * DeleteSnapshotCopyGrant to delete the grant that grants Amazon Redshift * permission to the key in the destination region.

See Also:

AWS * API Reference

*/ virtual Model::DisableSnapshotCopyOutcome DisableSnapshotCopy(const Model::DisableSnapshotCopyRequest& request) const; /** * A Callable wrapper for DisableSnapshotCopy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableSnapshotCopyOutcomeCallable DisableSnapshotCopyCallable(const DisableSnapshotCopyRequestT& request) const { return SubmitCallable(&RedshiftClient::DisableSnapshotCopy, request); } /** * An Async wrapper for DisableSnapshotCopy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableSnapshotCopyAsync(const DisableSnapshotCopyRequestT& request, const DisableSnapshotCopyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DisableSnapshotCopy, request, handler, context); } /** *

From a datashare consumer account, remove association for the specified * datashare.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateDataShareConsumerOutcome DisassociateDataShareConsumer(const Model::DisassociateDataShareConsumerRequest& request) const; /** * A Callable wrapper for DisassociateDataShareConsumer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateDataShareConsumerOutcomeCallable DisassociateDataShareConsumerCallable(const DisassociateDataShareConsumerRequestT& request) const { return SubmitCallable(&RedshiftClient::DisassociateDataShareConsumer, request); } /** * An Async wrapper for DisassociateDataShareConsumer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateDataShareConsumerAsync(const DisassociateDataShareConsumerRequestT& request, const DisassociateDataShareConsumerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::DisassociateDataShareConsumer, request, handler, context); } /** *

Starts logging information, such as queries and connection attempts, for the * specified Amazon Redshift cluster.

See Also:

AWS * API Reference

*/ virtual Model::EnableLoggingOutcome EnableLogging(const Model::EnableLoggingRequest& request) const; /** * A Callable wrapper for EnableLogging that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableLoggingOutcomeCallable EnableLoggingCallable(const EnableLoggingRequestT& request) const { return SubmitCallable(&RedshiftClient::EnableLogging, request); } /** * An Async wrapper for EnableLogging that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableLoggingAsync(const EnableLoggingRequestT& request, const EnableLoggingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::EnableLogging, request, handler, context); } /** *

Enables the automatic copy of snapshots from one region to another region for * a specified cluster.

See Also:

AWS * API Reference

*/ virtual Model::EnableSnapshotCopyOutcome EnableSnapshotCopy(const Model::EnableSnapshotCopyRequest& request) const; /** * A Callable wrapper for EnableSnapshotCopy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableSnapshotCopyOutcomeCallable EnableSnapshotCopyCallable(const EnableSnapshotCopyRequestT& request) const { return SubmitCallable(&RedshiftClient::EnableSnapshotCopy, request); } /** * An Async wrapper for EnableSnapshotCopy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableSnapshotCopyAsync(const EnableSnapshotCopyRequestT& request, const EnableSnapshotCopyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::EnableSnapshotCopy, request, handler, context); } /** *

Returns a database user name and temporary password with temporary * authorization to log on to an Amazon Redshift database. The action returns the * database user name prefixed with IAM: if AutoCreate is * False or IAMA: if AutoCreate is * True. You can optionally specify one or more database user groups * that the user will join at log on. By default, the temporary credentials expire * in 900 seconds. You can optionally specify a duration between 900 seconds (15 * minutes) and 3600 seconds (60 minutes). For more information, see Using * IAM Authentication to Generate Database User Credentials in the Amazon * Redshift Cluster Management Guide.

The Identity and Access Management * (IAM) user or role that runs GetClusterCredentials must have an IAM policy * attached that allows access to all necessary actions and resources. For more * information about permissions, see Resource * Policies for GetClusterCredentials in the Amazon Redshift Cluster Management * Guide.

If the DbGroups parameter is specified, the IAM * policy must allow the redshift:JoinGroup action with access to the * listed dbgroups.

In addition, if the * AutoCreate parameter is set to True, then the policy * must include the redshift:CreateClusterUser permission.

If * the DbName parameter is specified, the IAM policy must allow access * to the resource dbname for the specified database name. *

See Also:

AWS * API Reference

*/ virtual Model::GetClusterCredentialsOutcome GetClusterCredentials(const Model::GetClusterCredentialsRequest& request) const; /** * A Callable wrapper for GetClusterCredentials that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetClusterCredentialsOutcomeCallable GetClusterCredentialsCallable(const GetClusterCredentialsRequestT& request) const { return SubmitCallable(&RedshiftClient::GetClusterCredentials, request); } /** * An Async wrapper for GetClusterCredentials that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetClusterCredentialsAsync(const GetClusterCredentialsRequestT& request, const GetClusterCredentialsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::GetClusterCredentials, request, handler, context); } /** *

Returns a database user name and temporary password with temporary * authorization to log in to an Amazon Redshift database. The database user is * mapped 1:1 to the source Identity and Access Management (IAM) identity. For more * information about IAM identities, see IAM Identities * (users, user groups, and roles) in the Amazon Web Services Identity and * Access Management User Guide.

The Identity and Access Management (IAM) * identity that runs this operation must have an IAM policy attached that allows * access to all necessary actions and resources. For more information about * permissions, see Using * identity-based policies (IAM policies) in the Amazon Redshift Cluster * Management Guide.

See Also:

AWS * API Reference

*/ virtual Model::GetClusterCredentialsWithIAMOutcome GetClusterCredentialsWithIAM(const Model::GetClusterCredentialsWithIAMRequest& request) const; /** * A Callable wrapper for GetClusterCredentialsWithIAM that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetClusterCredentialsWithIAMOutcomeCallable GetClusterCredentialsWithIAMCallable(const GetClusterCredentialsWithIAMRequestT& request) const { return SubmitCallable(&RedshiftClient::GetClusterCredentialsWithIAM, request); } /** * An Async wrapper for GetClusterCredentialsWithIAM that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetClusterCredentialsWithIAMAsync(const GetClusterCredentialsWithIAMRequestT& request, const GetClusterCredentialsWithIAMResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::GetClusterCredentialsWithIAM, request, handler, context); } /** *

Gets the configuration options for the reserved-node exchange. These options * include information about the source reserved node and target reserved node * offering. Details include the node type, the price, the node count, and the * offering type.

See Also:

AWS * API Reference

*/ virtual Model::GetReservedNodeExchangeConfigurationOptionsOutcome GetReservedNodeExchangeConfigurationOptions(const Model::GetReservedNodeExchangeConfigurationOptionsRequest& request) const; /** * A Callable wrapper for GetReservedNodeExchangeConfigurationOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetReservedNodeExchangeConfigurationOptionsOutcomeCallable GetReservedNodeExchangeConfigurationOptionsCallable(const GetReservedNodeExchangeConfigurationOptionsRequestT& request) const { return SubmitCallable(&RedshiftClient::GetReservedNodeExchangeConfigurationOptions, request); } /** * An Async wrapper for GetReservedNodeExchangeConfigurationOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetReservedNodeExchangeConfigurationOptionsAsync(const GetReservedNodeExchangeConfigurationOptionsRequestT& request, const GetReservedNodeExchangeConfigurationOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::GetReservedNodeExchangeConfigurationOptions, request, handler, context); } /** *

Returns an array of DC2 ReservedNodeOfferings that matches the payment type, * term, and usage price of the given DC1 reserved node.

See Also:

* AWS * API Reference

*/ virtual Model::GetReservedNodeExchangeOfferingsOutcome GetReservedNodeExchangeOfferings(const Model::GetReservedNodeExchangeOfferingsRequest& request) const; /** * A Callable wrapper for GetReservedNodeExchangeOfferings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetReservedNodeExchangeOfferingsOutcomeCallable GetReservedNodeExchangeOfferingsCallable(const GetReservedNodeExchangeOfferingsRequestT& request) const { return SubmitCallable(&RedshiftClient::GetReservedNodeExchangeOfferings, request); } /** * An Async wrapper for GetReservedNodeExchangeOfferings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetReservedNodeExchangeOfferingsAsync(const GetReservedNodeExchangeOfferingsRequestT& request, const GetReservedNodeExchangeOfferingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::GetReservedNodeExchangeOfferings, request, handler, context); } /** *

This operation is retired. Calling this operation does not change AQUA * configuration. Amazon Redshift automatically determines whether to use AQUA * (Advanced Query Accelerator).

See Also:

AWS * API Reference

*/ virtual Model::ModifyAquaConfigurationOutcome ModifyAquaConfiguration(const Model::ModifyAquaConfigurationRequest& request) const; /** * A Callable wrapper for ModifyAquaConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyAquaConfigurationOutcomeCallable ModifyAquaConfigurationCallable(const ModifyAquaConfigurationRequestT& request) const { return SubmitCallable(&RedshiftClient::ModifyAquaConfiguration, request); } /** * An Async wrapper for ModifyAquaConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyAquaConfigurationAsync(const ModifyAquaConfigurationRequestT& request, const ModifyAquaConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::ModifyAquaConfiguration, request, handler, context); } /** *

Modifies an authentication profile.

See Also:

AWS * API Reference

*/ virtual Model::ModifyAuthenticationProfileOutcome ModifyAuthenticationProfile(const Model::ModifyAuthenticationProfileRequest& request) const; /** * A Callable wrapper for ModifyAuthenticationProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyAuthenticationProfileOutcomeCallable ModifyAuthenticationProfileCallable(const ModifyAuthenticationProfileRequestT& request) const { return SubmitCallable(&RedshiftClient::ModifyAuthenticationProfile, request); } /** * An Async wrapper for ModifyAuthenticationProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyAuthenticationProfileAsync(const ModifyAuthenticationProfileRequestT& request, const ModifyAuthenticationProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::ModifyAuthenticationProfile, request, handler, context); } /** *

Modifies the settings for a cluster.

You can also change node type and * the number of nodes to scale up or down the cluster. When resizing a cluster, * you must specify both the number of nodes and the node type even if one of the * parameters does not change.

You can add another security or parameter * group, or change the admin user password. Resetting a cluster password or * modifying the security groups associated with a cluster do not need a reboot. * However, modifying a parameter group requires a reboot for parameters to take * effect. For more information about managing clusters, go to Amazon * Redshift Clusters in the Amazon Redshift Cluster Management * Guide.

See Also:

AWS * API Reference

*/ virtual Model::ModifyClusterOutcome ModifyCluster(const Model::ModifyClusterRequest& request) const; /** * A Callable wrapper for ModifyCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyClusterOutcomeCallable ModifyClusterCallable(const ModifyClusterRequestT& request) const { return SubmitCallable(&RedshiftClient::ModifyCluster, request); } /** * An Async wrapper for ModifyCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyClusterAsync(const ModifyClusterRequestT& request, const ModifyClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::ModifyCluster, request, handler, context); } /** *

Modifies the database revision of a cluster. The database revision is a * unique revision of the database running in a cluster.

See Also:

* AWS * API Reference

*/ virtual Model::ModifyClusterDbRevisionOutcome ModifyClusterDbRevision(const Model::ModifyClusterDbRevisionRequest& request) const; /** * A Callable wrapper for ModifyClusterDbRevision that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyClusterDbRevisionOutcomeCallable ModifyClusterDbRevisionCallable(const ModifyClusterDbRevisionRequestT& request) const { return SubmitCallable(&RedshiftClient::ModifyClusterDbRevision, request); } /** * An Async wrapper for ModifyClusterDbRevision that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyClusterDbRevisionAsync(const ModifyClusterDbRevisionRequestT& request, const ModifyClusterDbRevisionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::ModifyClusterDbRevision, request, handler, context); } /** *

Modifies the list of Identity and Access Management (IAM) roles that can be * used by the cluster to access other Amazon Web Services services.

The * maximum number of IAM roles that you can associate is subject to a quota. For * more information, go to Quotas * and limits in the Amazon Redshift Cluster Management * Guide.

See Also:

AWS * API Reference

*/ virtual Model::ModifyClusterIamRolesOutcome ModifyClusterIamRoles(const Model::ModifyClusterIamRolesRequest& request) const; /** * A Callable wrapper for ModifyClusterIamRoles that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyClusterIamRolesOutcomeCallable ModifyClusterIamRolesCallable(const ModifyClusterIamRolesRequestT& request) const { return SubmitCallable(&RedshiftClient::ModifyClusterIamRoles, request); } /** * An Async wrapper for ModifyClusterIamRoles that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyClusterIamRolesAsync(const ModifyClusterIamRolesRequestT& request, const ModifyClusterIamRolesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::ModifyClusterIamRoles, request, handler, context); } /** *

Modifies the maintenance settings of a cluster.

See Also:

AWS * API Reference

*/ virtual Model::ModifyClusterMaintenanceOutcome ModifyClusterMaintenance(const Model::ModifyClusterMaintenanceRequest& request) const; /** * A Callable wrapper for ModifyClusterMaintenance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyClusterMaintenanceOutcomeCallable ModifyClusterMaintenanceCallable(const ModifyClusterMaintenanceRequestT& request) const { return SubmitCallable(&RedshiftClient::ModifyClusterMaintenance, request); } /** * An Async wrapper for ModifyClusterMaintenance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyClusterMaintenanceAsync(const ModifyClusterMaintenanceRequestT& request, const ModifyClusterMaintenanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::ModifyClusterMaintenance, request, handler, context); } /** *

Modifies the parameters of a parameter group. For the parameters parameter, * it can't contain ASCII characters.

For more information about parameters * and parameter groups, go to Amazon * Redshift Parameter Groups in the Amazon Redshift Cluster Management * Guide.

See Also:

AWS * API Reference

*/ virtual Model::ModifyClusterParameterGroupOutcome ModifyClusterParameterGroup(const Model::ModifyClusterParameterGroupRequest& request) const; /** * A Callable wrapper for ModifyClusterParameterGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyClusterParameterGroupOutcomeCallable ModifyClusterParameterGroupCallable(const ModifyClusterParameterGroupRequestT& request) const { return SubmitCallable(&RedshiftClient::ModifyClusterParameterGroup, request); } /** * An Async wrapper for ModifyClusterParameterGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyClusterParameterGroupAsync(const ModifyClusterParameterGroupRequestT& request, const ModifyClusterParameterGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::ModifyClusterParameterGroup, request, handler, context); } /** *

Modifies the settings for a snapshot.

This exanmple modifies the * manual retention period setting for a cluster snapshot.

See Also:

* AWS * API Reference

*/ virtual Model::ModifyClusterSnapshotOutcome ModifyClusterSnapshot(const Model::ModifyClusterSnapshotRequest& request) const; /** * A Callable wrapper for ModifyClusterSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyClusterSnapshotOutcomeCallable ModifyClusterSnapshotCallable(const ModifyClusterSnapshotRequestT& request) const { return SubmitCallable(&RedshiftClient::ModifyClusterSnapshot, request); } /** * An Async wrapper for ModifyClusterSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyClusterSnapshotAsync(const ModifyClusterSnapshotRequestT& request, const ModifyClusterSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::ModifyClusterSnapshot, request, handler, context); } /** *

Modifies a snapshot schedule for a cluster.

See Also:

AWS * API Reference

*/ virtual Model::ModifyClusterSnapshotScheduleOutcome ModifyClusterSnapshotSchedule(const Model::ModifyClusterSnapshotScheduleRequest& request) const; /** * A Callable wrapper for ModifyClusterSnapshotSchedule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyClusterSnapshotScheduleOutcomeCallable ModifyClusterSnapshotScheduleCallable(const ModifyClusterSnapshotScheduleRequestT& request) const { return SubmitCallable(&RedshiftClient::ModifyClusterSnapshotSchedule, request); } /** * An Async wrapper for ModifyClusterSnapshotSchedule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyClusterSnapshotScheduleAsync(const ModifyClusterSnapshotScheduleRequestT& request, const ModifyClusterSnapshotScheduleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::ModifyClusterSnapshotSchedule, request, handler, context); } /** *

Modifies a cluster subnet group to include the specified list of VPC subnets. * The operation replaces the existing list of subnets with the new list of * subnets.

See Also:

AWS * API Reference

*/ virtual Model::ModifyClusterSubnetGroupOutcome ModifyClusterSubnetGroup(const Model::ModifyClusterSubnetGroupRequest& request) const; /** * A Callable wrapper for ModifyClusterSubnetGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyClusterSubnetGroupOutcomeCallable ModifyClusterSubnetGroupCallable(const ModifyClusterSubnetGroupRequestT& request) const { return SubmitCallable(&RedshiftClient::ModifyClusterSubnetGroup, request); } /** * An Async wrapper for ModifyClusterSubnetGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyClusterSubnetGroupAsync(const ModifyClusterSubnetGroupRequestT& request, const ModifyClusterSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::ModifyClusterSubnetGroup, request, handler, context); } /** *

Contains information for changing a custom domain association.

See * Also:

AWS * API Reference

*/ virtual Model::ModifyCustomDomainAssociationOutcome ModifyCustomDomainAssociation(const Model::ModifyCustomDomainAssociationRequest& request) const; /** * A Callable wrapper for ModifyCustomDomainAssociation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyCustomDomainAssociationOutcomeCallable ModifyCustomDomainAssociationCallable(const ModifyCustomDomainAssociationRequestT& request) const { return SubmitCallable(&RedshiftClient::ModifyCustomDomainAssociation, request); } /** * An Async wrapper for ModifyCustomDomainAssociation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyCustomDomainAssociationAsync(const ModifyCustomDomainAssociationRequestT& request, const ModifyCustomDomainAssociationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::ModifyCustomDomainAssociation, request, handler, context); } /** *

Modifies a Redshift-managed VPC endpoint.

See Also:

AWS * API Reference

*/ virtual Model::ModifyEndpointAccessOutcome ModifyEndpointAccess(const Model::ModifyEndpointAccessRequest& request) const; /** * A Callable wrapper for ModifyEndpointAccess that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyEndpointAccessOutcomeCallable ModifyEndpointAccessCallable(const ModifyEndpointAccessRequestT& request) const { return SubmitCallable(&RedshiftClient::ModifyEndpointAccess, request); } /** * An Async wrapper for ModifyEndpointAccess that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyEndpointAccessAsync(const ModifyEndpointAccessRequestT& request, const ModifyEndpointAccessResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::ModifyEndpointAccess, request, handler, context); } /** *

Modifies an existing Amazon Redshift event notification * subscription.

See Also:

AWS * API Reference

*/ virtual Model::ModifyEventSubscriptionOutcome ModifyEventSubscription(const Model::ModifyEventSubscriptionRequest& request) const; /** * A Callable wrapper for ModifyEventSubscription that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyEventSubscriptionOutcomeCallable ModifyEventSubscriptionCallable(const ModifyEventSubscriptionRequestT& request) const { return SubmitCallable(&RedshiftClient::ModifyEventSubscription, request); } /** * An Async wrapper for ModifyEventSubscription that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyEventSubscriptionAsync(const ModifyEventSubscriptionRequestT& request, const ModifyEventSubscriptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::ModifyEventSubscription, request, handler, context); } /** *

Modifies a scheduled action.

See Also:

AWS * API Reference

*/ virtual Model::ModifyScheduledActionOutcome ModifyScheduledAction(const Model::ModifyScheduledActionRequest& request) const; /** * A Callable wrapper for ModifyScheduledAction that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyScheduledActionOutcomeCallable ModifyScheduledActionCallable(const ModifyScheduledActionRequestT& request) const { return SubmitCallable(&RedshiftClient::ModifyScheduledAction, request); } /** * An Async wrapper for ModifyScheduledAction that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyScheduledActionAsync(const ModifyScheduledActionRequestT& request, const ModifyScheduledActionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::ModifyScheduledAction, request, handler, context); } /** *

Modifies the number of days to retain snapshots in the destination Amazon Web * Services Region after they are copied from the source Amazon Web Services * Region. By default, this operation only changes the retention period of copied * automated snapshots. The retention periods for both new and existing copied * automated snapshots are updated with the new retention period. You can set the * manual option to change only the retention periods of copied manual snapshots. * If you set this option, only newly copied manual snapshots have the new * retention period.

See Also:

AWS * API Reference

*/ virtual Model::ModifySnapshotCopyRetentionPeriodOutcome ModifySnapshotCopyRetentionPeriod(const Model::ModifySnapshotCopyRetentionPeriodRequest& request) const; /** * A Callable wrapper for ModifySnapshotCopyRetentionPeriod that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifySnapshotCopyRetentionPeriodOutcomeCallable ModifySnapshotCopyRetentionPeriodCallable(const ModifySnapshotCopyRetentionPeriodRequestT& request) const { return SubmitCallable(&RedshiftClient::ModifySnapshotCopyRetentionPeriod, request); } /** * An Async wrapper for ModifySnapshotCopyRetentionPeriod that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifySnapshotCopyRetentionPeriodAsync(const ModifySnapshotCopyRetentionPeriodRequestT& request, const ModifySnapshotCopyRetentionPeriodResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::ModifySnapshotCopyRetentionPeriod, request, handler, context); } /** *

Modifies a snapshot schedule. Any schedule associated with a cluster is * modified asynchronously.

See Also:

AWS * API Reference

*/ virtual Model::ModifySnapshotScheduleOutcome ModifySnapshotSchedule(const Model::ModifySnapshotScheduleRequest& request) const; /** * A Callable wrapper for ModifySnapshotSchedule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifySnapshotScheduleOutcomeCallable ModifySnapshotScheduleCallable(const ModifySnapshotScheduleRequestT& request) const { return SubmitCallable(&RedshiftClient::ModifySnapshotSchedule, request); } /** * An Async wrapper for ModifySnapshotSchedule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifySnapshotScheduleAsync(const ModifySnapshotScheduleRequestT& request, const ModifySnapshotScheduleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::ModifySnapshotSchedule, request, handler, context); } /** *

Modifies a usage limit in a cluster. You can't modify the feature type or * period of a usage limit.

See Also:

AWS * API Reference

*/ virtual Model::ModifyUsageLimitOutcome ModifyUsageLimit(const Model::ModifyUsageLimitRequest& request) const; /** * A Callable wrapper for ModifyUsageLimit that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyUsageLimitOutcomeCallable ModifyUsageLimitCallable(const ModifyUsageLimitRequestT& request) const { return SubmitCallable(&RedshiftClient::ModifyUsageLimit, request); } /** * An Async wrapper for ModifyUsageLimit that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyUsageLimitAsync(const ModifyUsageLimitRequestT& request, const ModifyUsageLimitResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::ModifyUsageLimit, request, handler, context); } /** *

Pauses a cluster.

See Also:

AWS * API Reference

*/ virtual Model::PauseClusterOutcome PauseCluster(const Model::PauseClusterRequest& request) const; /** * A Callable wrapper for PauseCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PauseClusterOutcomeCallable PauseClusterCallable(const PauseClusterRequestT& request) const { return SubmitCallable(&RedshiftClient::PauseCluster, request); } /** * An Async wrapper for PauseCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PauseClusterAsync(const PauseClusterRequestT& request, const PauseClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::PauseCluster, request, handler, context); } /** *

Allows you to purchase reserved nodes. Amazon Redshift offers a predefined * set of reserved node offerings. You can purchase one or more of the offerings. * You can call the DescribeReservedNodeOfferings API to obtain the * available reserved node offerings. You can call this API by providing a specific * reserved node offering and the number of nodes you want to reserve.

For * more information about reserved node offerings, go to Purchasing * Reserved Nodes in the Amazon Redshift Cluster Management * Guide.

See Also:

AWS * API Reference

*/ virtual Model::PurchaseReservedNodeOfferingOutcome PurchaseReservedNodeOffering(const Model::PurchaseReservedNodeOfferingRequest& request) const; /** * A Callable wrapper for PurchaseReservedNodeOffering that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PurchaseReservedNodeOfferingOutcomeCallable PurchaseReservedNodeOfferingCallable(const PurchaseReservedNodeOfferingRequestT& request) const { return SubmitCallable(&RedshiftClient::PurchaseReservedNodeOffering, request); } /** * An Async wrapper for PurchaseReservedNodeOffering that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PurchaseReservedNodeOfferingAsync(const PurchaseReservedNodeOfferingRequestT& request, const PurchaseReservedNodeOfferingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::PurchaseReservedNodeOffering, request, handler, context); } /** *

Reboots a cluster. This action is taken as soon as possible. It results in a * momentary outage to the cluster, during which the cluster status is set to * rebooting. A cluster event is created when the reboot is completed. * Any pending cluster modifications (see ModifyCluster) are applied at this * reboot. For more information about managing clusters, go to Amazon * Redshift Clusters in the Amazon Redshift Cluster Management Guide. *

See Also:

AWS * API Reference

*/ virtual Model::RebootClusterOutcome RebootCluster(const Model::RebootClusterRequest& request) const; /** * A Callable wrapper for RebootCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RebootClusterOutcomeCallable RebootClusterCallable(const RebootClusterRequestT& request) const { return SubmitCallable(&RedshiftClient::RebootCluster, request); } /** * An Async wrapper for RebootCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RebootClusterAsync(const RebootClusterRequestT& request, const RebootClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::RebootCluster, request, handler, context); } /** *

From a datashare consumer account, rejects the specified * datashare.

See Also:

AWS * API Reference

*/ virtual Model::RejectDataShareOutcome RejectDataShare(const Model::RejectDataShareRequest& request) const; /** * A Callable wrapper for RejectDataShare that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RejectDataShareOutcomeCallable RejectDataShareCallable(const RejectDataShareRequestT& request) const { return SubmitCallable(&RedshiftClient::RejectDataShare, request); } /** * An Async wrapper for RejectDataShare that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RejectDataShareAsync(const RejectDataShareRequestT& request, const RejectDataShareResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::RejectDataShare, request, handler, context); } /** *

Sets one or more parameters of the specified parameter group to their default * values and sets the source values of the parameters to "engine-default". To * reset the entire parameter group specify the ResetAllParameters * parameter. For parameter changes to take effect you must reboot any associated * clusters.

See Also:

AWS * API Reference

*/ virtual Model::ResetClusterParameterGroupOutcome ResetClusterParameterGroup(const Model::ResetClusterParameterGroupRequest& request) const; /** * A Callable wrapper for ResetClusterParameterGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ResetClusterParameterGroupOutcomeCallable ResetClusterParameterGroupCallable(const ResetClusterParameterGroupRequestT& request) const { return SubmitCallable(&RedshiftClient::ResetClusterParameterGroup, request); } /** * An Async wrapper for ResetClusterParameterGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ResetClusterParameterGroupAsync(const ResetClusterParameterGroupRequestT& request, const ResetClusterParameterGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::ResetClusterParameterGroup, request, handler, context); } /** *

Changes the size of the cluster. You can change the cluster's type, or change * the number or type of nodes. The default behavior is to use the elastic resize * method. With an elastic resize, your cluster is available for read and write * operations more quickly than with the classic resize method.

Elastic * resize operations have the following restrictions:

  • You can only * resize clusters of the following types:

    • dc1.large (if your * cluster is in a VPC)

    • dc1.8xlarge (if your cluster is in a * VPC)

    • dc2.large

    • dc2.8xlarge

    • *

      ds2.xlarge

    • ds2.8xlarge

    • ra3.xlplus

      *

    • ra3.4xlarge

    • ra3.16xlarge

    • *

  • The type of nodes that you add must match the node type for the * cluster.

See Also:

AWS * API Reference

*/ virtual Model::ResizeClusterOutcome ResizeCluster(const Model::ResizeClusterRequest& request) const; /** * A Callable wrapper for ResizeCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ResizeClusterOutcomeCallable ResizeClusterCallable(const ResizeClusterRequestT& request) const { return SubmitCallable(&RedshiftClient::ResizeCluster, request); } /** * An Async wrapper for ResizeCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ResizeClusterAsync(const ResizeClusterRequestT& request, const ResizeClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::ResizeCluster, request, handler, context); } /** *

Creates a new cluster from a snapshot. By default, Amazon Redshift creates * the resulting cluster with the same configuration as the original cluster from * which the snapshot was created, except that the new cluster is created with the * default cluster security and parameter groups. After Amazon Redshift creates the * cluster, you can use the ModifyCluster API to associate a different * security group and different parameter group with the restored cluster. If you * are using a DS node type, you can also choose to change to another DS node type * of the same size during restore.

If you restore a cluster into a VPC, you * must provide a cluster subnet group where you want the cluster restored.

* For more information about working with snapshots, go to Amazon * Redshift Snapshots in the Amazon Redshift Cluster Management * Guide.

See Also:

AWS * API Reference

*/ virtual Model::RestoreFromClusterSnapshotOutcome RestoreFromClusterSnapshot(const Model::RestoreFromClusterSnapshotRequest& request) const; /** * A Callable wrapper for RestoreFromClusterSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RestoreFromClusterSnapshotOutcomeCallable RestoreFromClusterSnapshotCallable(const RestoreFromClusterSnapshotRequestT& request) const { return SubmitCallable(&RedshiftClient::RestoreFromClusterSnapshot, request); } /** * An Async wrapper for RestoreFromClusterSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RestoreFromClusterSnapshotAsync(const RestoreFromClusterSnapshotRequestT& request, const RestoreFromClusterSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::RestoreFromClusterSnapshot, request, handler, context); } /** *

Creates a new table from a table in an Amazon Redshift cluster snapshot. You * must create the new table within the Amazon Redshift cluster that the snapshot * was taken from.

You cannot use * RestoreTableFromClusterSnapshot to restore a table with the same * name as an existing table in an Amazon Redshift cluster. That is, you cannot * overwrite an existing table in a cluster with a restored table. If you want to * replace your original table with a new, restored table, then rename or drop your * original table before you call RestoreTableFromClusterSnapshot. * When you have renamed your original table, then you can pass the original name * of the table as the NewTableName parameter value in the call to * RestoreTableFromClusterSnapshot. This way, you can replace the * original table with the table created from the snapshot.

You can't use * this operation to restore tables with interleaved * sort keys.

See Also:

AWS * API Reference

*/ virtual Model::RestoreTableFromClusterSnapshotOutcome RestoreTableFromClusterSnapshot(const Model::RestoreTableFromClusterSnapshotRequest& request) const; /** * A Callable wrapper for RestoreTableFromClusterSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RestoreTableFromClusterSnapshotOutcomeCallable RestoreTableFromClusterSnapshotCallable(const RestoreTableFromClusterSnapshotRequestT& request) const { return SubmitCallable(&RedshiftClient::RestoreTableFromClusterSnapshot, request); } /** * An Async wrapper for RestoreTableFromClusterSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RestoreTableFromClusterSnapshotAsync(const RestoreTableFromClusterSnapshotRequestT& request, const RestoreTableFromClusterSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::RestoreTableFromClusterSnapshot, request, handler, context); } /** *

Resumes a paused cluster.

See Also:

AWS * API Reference

*/ virtual Model::ResumeClusterOutcome ResumeCluster(const Model::ResumeClusterRequest& request) const; /** * A Callable wrapper for ResumeCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ResumeClusterOutcomeCallable ResumeClusterCallable(const ResumeClusterRequestT& request) const { return SubmitCallable(&RedshiftClient::ResumeCluster, request); } /** * An Async wrapper for ResumeCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ResumeClusterAsync(const ResumeClusterRequestT& request, const ResumeClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::ResumeCluster, request, handler, context); } /** *

Revokes an ingress rule in an Amazon Redshift security group for a previously * authorized IP range or Amazon EC2 security group. To add an ingress rule, see * AuthorizeClusterSecurityGroupIngress. For information about managing * security groups, go to Amazon * Redshift Cluster Security Groups in the Amazon Redshift Cluster * Management Guide.

See Also:

AWS * API Reference

*/ virtual Model::RevokeClusterSecurityGroupIngressOutcome RevokeClusterSecurityGroupIngress(const Model::RevokeClusterSecurityGroupIngressRequest& request) const; /** * A Callable wrapper for RevokeClusterSecurityGroupIngress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RevokeClusterSecurityGroupIngressOutcomeCallable RevokeClusterSecurityGroupIngressCallable(const RevokeClusterSecurityGroupIngressRequestT& request) const { return SubmitCallable(&RedshiftClient::RevokeClusterSecurityGroupIngress, request); } /** * An Async wrapper for RevokeClusterSecurityGroupIngress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RevokeClusterSecurityGroupIngressAsync(const RevokeClusterSecurityGroupIngressRequestT& request, const RevokeClusterSecurityGroupIngressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::RevokeClusterSecurityGroupIngress, request, handler, context); } /** *

Revokes access to a cluster.

See Also:

AWS * API Reference

*/ virtual Model::RevokeEndpointAccessOutcome RevokeEndpointAccess(const Model::RevokeEndpointAccessRequest& request) const; /** * A Callable wrapper for RevokeEndpointAccess that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RevokeEndpointAccessOutcomeCallable RevokeEndpointAccessCallable(const RevokeEndpointAccessRequestT& request) const { return SubmitCallable(&RedshiftClient::RevokeEndpointAccess, request); } /** * An Async wrapper for RevokeEndpointAccess that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RevokeEndpointAccessAsync(const RevokeEndpointAccessRequestT& request, const RevokeEndpointAccessResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::RevokeEndpointAccess, request, handler, context); } /** *

Removes the ability of the specified Amazon Web Services account to restore * the specified snapshot. If the account is currently restoring the snapshot, the * restore will run to completion.

For more information about working with * snapshots, go to Amazon * Redshift Snapshots in the Amazon Redshift Cluster Management * Guide.

See Also:

AWS * API Reference

*/ virtual Model::RevokeSnapshotAccessOutcome RevokeSnapshotAccess(const Model::RevokeSnapshotAccessRequest& request) const; /** * A Callable wrapper for RevokeSnapshotAccess that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RevokeSnapshotAccessOutcomeCallable RevokeSnapshotAccessCallable(const RevokeSnapshotAccessRequestT& request) const { return SubmitCallable(&RedshiftClient::RevokeSnapshotAccess, request); } /** * An Async wrapper for RevokeSnapshotAccess that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RevokeSnapshotAccessAsync(const RevokeSnapshotAccessRequestT& request, const RevokeSnapshotAccessResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::RevokeSnapshotAccess, request, handler, context); } /** *

Rotates the encryption keys for a cluster.

See Also:

AWS * API Reference

*/ virtual Model::RotateEncryptionKeyOutcome RotateEncryptionKey(const Model::RotateEncryptionKeyRequest& request) const; /** * A Callable wrapper for RotateEncryptionKey that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RotateEncryptionKeyOutcomeCallable RotateEncryptionKeyCallable(const RotateEncryptionKeyRequestT& request) const { return SubmitCallable(&RedshiftClient::RotateEncryptionKey, request); } /** * An Async wrapper for RotateEncryptionKey that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RotateEncryptionKeyAsync(const RotateEncryptionKeyRequestT& request, const RotateEncryptionKeyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::RotateEncryptionKey, request, handler, context); } /** *

Updates the status of a partner integration.

See Also:

AWS * API Reference

*/ virtual Model::UpdatePartnerStatusOutcome UpdatePartnerStatus(const Model::UpdatePartnerStatusRequest& request) const; /** * A Callable wrapper for UpdatePartnerStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdatePartnerStatusOutcomeCallable UpdatePartnerStatusCallable(const UpdatePartnerStatusRequestT& request) const { return SubmitCallable(&RedshiftClient::UpdatePartnerStatus, request); } /** * An Async wrapper for UpdatePartnerStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdatePartnerStatusAsync(const UpdatePartnerStatusRequestT& request, const UpdatePartnerStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RedshiftClient::UpdatePartnerStatus, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const RedshiftClientConfiguration& clientConfiguration); RedshiftClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace Redshift } // namespace Aws