/* * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * http://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. */ /* * Do not modify this file. This file is generated from the redshift-2012-12-01.normal.json service model. */ using System; using System.Runtime.ExceptionServices; using System.Threading; using System.Threading.Tasks; using System.Collections.Generic; using System.Net; using Amazon.Redshift.Model; using Amazon.Redshift.Model.Internal.MarshallTransformations; using Amazon.Redshift.Internal; using Amazon.Runtime; using Amazon.Runtime.Internal; using Amazon.Runtime.Internal.Auth; using Amazon.Runtime.Internal.Transform; namespace Amazon.Redshift { ///

/// Implementation for accessing 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. /// ///

public partial class AmazonRedshiftClient : AmazonServiceClient, IAmazonRedshift { private static IServiceMetadata serviceMetadata = new AmazonRedshiftMetadata(); private IRedshiftPaginatorFactory _paginators; ///

/// Paginators for the service ///

public IRedshiftPaginatorFactory Paginators { get { if (this._paginators == null) { this._paginators = new RedshiftPaginatorFactory(this); } return this._paginators; } } #region Constructors ///

/// Constructs AmazonRedshiftClient with the credentials loaded from the application's /// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance. /// /// Example App.config with credentials set. ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

public AmazonRedshiftClient() : base(FallbackCredentialsFactory.GetCredentials(), new AmazonRedshiftConfig()) { } ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

/// The region to connect. public AmazonRedshiftClient(RegionEndpoint region) : base(FallbackCredentialsFactory.GetCredentials(), new AmazonRedshiftConfig{RegionEndpoint = region}) { } ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

/// The AmazonRedshiftClient Configuration Object public AmazonRedshiftClient(AmazonRedshiftConfig config) : base(FallbackCredentialsFactory.GetCredentials(config), config){} ///

/// Constructs AmazonRedshiftClient with AWS Credentials ///

/// AWS Credentials public AmazonRedshiftClient(AWSCredentials credentials) : this(credentials, new AmazonRedshiftConfig()) { } ///

/// Constructs AmazonRedshiftClient with AWS Credentials ///

/// AWS Credentials /// The region to connect. public AmazonRedshiftClient(AWSCredentials credentials, RegionEndpoint region) : this(credentials, new AmazonRedshiftConfig{RegionEndpoint = region}) { } ///

/// Constructs AmazonRedshiftClient with AWS Credentials and an /// AmazonRedshiftClient Configuration object. ///

/// AWS Credentials /// The AmazonRedshiftClient Configuration Object public AmazonRedshiftClient(AWSCredentials credentials, AmazonRedshiftConfig clientConfig) : base(credentials, clientConfig) { } ///

/// Constructs AmazonRedshiftClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key public AmazonRedshiftClient(string awsAccessKeyId, string awsSecretAccessKey) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonRedshiftConfig()) { } ///

/// Constructs AmazonRedshiftClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// The region to connect. public AmazonRedshiftClient(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonRedshiftConfig() {RegionEndpoint=region}) { } ///

/// Constructs AmazonRedshiftClient with AWS Access Key ID, AWS Secret Key and an /// AmazonRedshiftClient Configuration object. ///

/// AWS Access Key ID /// AWS Secret Access Key /// The AmazonRedshiftClient Configuration Object public AmazonRedshiftClient(string awsAccessKeyId, string awsSecretAccessKey, AmazonRedshiftConfig clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, clientConfig) { } ///

/// Constructs AmazonRedshiftClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token public AmazonRedshiftClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonRedshiftConfig()) { } ///

/// Constructs AmazonRedshiftClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The region to connect. public AmazonRedshiftClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonRedshiftConfig{RegionEndpoint = region}) { } ///

/// Constructs AmazonRedshiftClient with AWS Access Key ID, AWS Secret Key and an /// AmazonRedshiftClient Configuration object. ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The AmazonRedshiftClient Configuration Object public AmazonRedshiftClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonRedshiftConfig clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, clientConfig) { } #endregion #region Overrides ///

/// Creates the signer for the service. ///

protected override AbstractAWSSigner CreateSigner() { return new AWS4Signer(); } ///

/// Customize the pipeline ///

/// protected override void CustomizeRuntimePipeline(RuntimePipeline pipeline) { pipeline.RemoveHandler(); pipeline.AddHandlerAfter(new AmazonRedshiftEndpointResolver()); } ///

/// Capture metadata for the service. ///

protected override IServiceMetadata ServiceMetadata { get { return serviceMetadata; } } #endregion #region Dispose ///

/// Disposes the service client. ///

protected override void Dispose(bool disposing) { base.Dispose(disposing); } #endregion #region AcceptReservedNodeExchange ///

/// 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. ///

/// Container for the necessary parameters to execute the AcceptReservedNodeExchange service method. /// /// The response from the AcceptReservedNodeExchange service method, as returned by Redshift. /// /// Your request cannot be completed because a dependent internal service is temporarily /// unavailable. Wait 30 to 60 seconds and try again. /// /// /// Indicates that the Reserved Node being exchanged is not in an active state. /// /// /// User already has a reservation with the given identifier. /// /// /// Indicates that the reserved node has already been exchanged. /// /// /// The specified reserved compute node not found. /// /// /// Specified offering does not exist. /// /// /// The requested operation isn't supported. /// /// REST API Reference for AcceptReservedNodeExchange Operation public virtual AcceptReservedNodeExchangeResponse AcceptReservedNodeExchange(AcceptReservedNodeExchangeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptReservedNodeExchangeRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptReservedNodeExchangeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// Container for the necessary parameters to execute the AcceptReservedNodeExchange service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AcceptReservedNodeExchange service method, as returned by Redshift. /// /// Your request cannot be completed because a dependent internal service is temporarily /// unavailable. Wait 30 to 60 seconds and try again. /// /// /// Indicates that the Reserved Node being exchanged is not in an active state. /// /// /// User already has a reservation with the given identifier. /// /// /// Indicates that the reserved node has already been exchanged. /// /// /// The specified reserved compute node not found. /// /// /// Specified offering does not exist. /// /// /// The requested operation isn't supported. /// /// REST API Reference for AcceptReservedNodeExchange Operation public virtual Task AcceptReservedNodeExchangeAsync(AcceptReservedNodeExchangeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptReservedNodeExchangeRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptReservedNodeExchangeResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region AddPartner ///

/// 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. ///

/// Container for the necessary parameters to execute the AddPartner service method. /// /// The response from the AddPartner service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The name of the partner was not found. /// /// /// The partner integration is not authorized. /// /// REST API Reference for AddPartner Operation public virtual AddPartnerResponse AddPartner(AddPartnerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AddPartnerRequestMarshaller.Instance; options.ResponseUnmarshaller = AddPartnerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the AddPartner service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AddPartner service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The name of the partner was not found. /// /// /// The partner integration is not authorized. /// /// REST API Reference for AddPartner Operation public virtual Task AddPartnerAsync(AddPartnerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AddPartnerRequestMarshaller.Instance; options.ResponseUnmarshaller = AddPartnerResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region AssociateDataShareConsumer ///

/// 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. ///

/// Container for the necessary parameters to execute the AssociateDataShareConsumer service method. /// /// The response from the AssociateDataShareConsumer service method, as returned by Redshift. /// /// There is an error with the datashare. /// /// /// The namespace isn't valid because the namespace doesn't exist. Provide a valid namespace. /// /// REST API Reference for AssociateDataShareConsumer Operation public virtual AssociateDataShareConsumerResponse AssociateDataShareConsumer(AssociateDataShareConsumerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateDataShareConsumerRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateDataShareConsumerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the AssociateDataShareConsumer service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AssociateDataShareConsumer service method, as returned by Redshift. /// /// There is an error with the datashare. /// /// /// The namespace isn't valid because the namespace doesn't exist. Provide a valid namespace. /// /// REST API Reference for AssociateDataShareConsumer Operation public virtual Task AssociateDataShareConsumerAsync(AssociateDataShareConsumerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateDataShareConsumerRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateDataShareConsumerResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region AuthorizeClusterSecurityGroupIngress ///

/// 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. /// ///

/// Container for the necessary parameters to execute the AuthorizeClusterSecurityGroupIngress service method. /// /// The response from the AuthorizeClusterSecurityGroupIngress service method, as returned by Redshift. /// /// The specified CIDR block or EC2 security group is already authorized for the specified /// cluster security group. /// /// /// The authorization quota for the cluster security group has been reached. /// /// /// The cluster security group name does not refer to an existing cluster security group. /// /// /// The state of the cluster security group is not available. /// /// REST API Reference for AuthorizeClusterSecurityGroupIngress Operation public virtual AuthorizeClusterSecurityGroupIngressResponse AuthorizeClusterSecurityGroupIngress(AuthorizeClusterSecurityGroupIngressRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AuthorizeClusterSecurityGroupIngressRequestMarshaller.Instance; options.ResponseUnmarshaller = AuthorizeClusterSecurityGroupIngressResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the AuthorizeClusterSecurityGroupIngress service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AuthorizeClusterSecurityGroupIngress service method, as returned by Redshift. /// /// The specified CIDR block or EC2 security group is already authorized for the specified /// cluster security group. /// /// /// The authorization quota for the cluster security group has been reached. /// /// /// The cluster security group name does not refer to an existing cluster security group. /// /// /// The state of the cluster security group is not available. /// /// REST API Reference for AuthorizeClusterSecurityGroupIngress Operation public virtual Task AuthorizeClusterSecurityGroupIngressAsync(AuthorizeClusterSecurityGroupIngressRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AuthorizeClusterSecurityGroupIngressRequestMarshaller.Instance; options.ResponseUnmarshaller = AuthorizeClusterSecurityGroupIngressResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region AuthorizeDataShare ///

/// 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. ///

/// Container for the necessary parameters to execute the AuthorizeDataShare service method. /// /// The response from the AuthorizeDataShare service method, as returned by Redshift. /// /// There is an error with the datashare. /// /// REST API Reference for AuthorizeDataShare Operation public virtual AuthorizeDataShareResponse AuthorizeDataShare(AuthorizeDataShareRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AuthorizeDataShareRequestMarshaller.Instance; options.ResponseUnmarshaller = AuthorizeDataShareResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the AuthorizeDataShare service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AuthorizeDataShare service method, as returned by Redshift. /// /// There is an error with the datashare. /// /// REST API Reference for AuthorizeDataShare Operation public virtual Task AuthorizeDataShareAsync(AuthorizeDataShareRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AuthorizeDataShareRequestMarshaller.Instance; options.ResponseUnmarshaller = AuthorizeDataShareResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region AuthorizeEndpointAccess ///

/// Grants access to a cluster. ///

/// Container for the necessary parameters to execute the AuthorizeEndpointAccess service method. /// /// The response from the AuthorizeEndpointAccess service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The authorization already exists for this endpoint. /// /// /// The number of endpoint authorizations per cluster has exceeded its limit. /// /// /// The status of the authorization is not valid. /// /// /// The specified cluster is not in the available state. /// /// /// The requested operation isn't supported. /// /// REST API Reference for AuthorizeEndpointAccess Operation public virtual AuthorizeEndpointAccessResponse AuthorizeEndpointAccess(AuthorizeEndpointAccessRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AuthorizeEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = AuthorizeEndpointAccessResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Grants access to a cluster. ///

/// Container for the necessary parameters to execute the AuthorizeEndpointAccess service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AuthorizeEndpointAccess service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The authorization already exists for this endpoint. /// /// /// The number of endpoint authorizations per cluster has exceeded its limit. /// /// /// The status of the authorization is not valid. /// /// /// The specified cluster is not in the available state. /// /// /// The requested operation isn't supported. /// /// REST API Reference for AuthorizeEndpointAccess Operation public virtual Task AuthorizeEndpointAccessAsync(AuthorizeEndpointAccessRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AuthorizeEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = AuthorizeEndpointAccessResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region AuthorizeSnapshotAccess ///

/// 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. /// ///

/// Container for the necessary parameters to execute the AuthorizeSnapshotAccess service method. /// /// The response from the AuthorizeSnapshotAccess service method, as returned by Redshift. /// /// The specified CIDR block or EC2 security group is already authorized for the specified /// cluster security group. /// /// /// The authorization quota for the cluster security group has been reached. /// /// /// The snapshot identifier does not refer to an existing cluster snapshot. /// /// /// The request cannot be completed because a dependent service is throttling requests /// made by Amazon Redshift on your behalf. Wait and retry the request. /// /// /// The specified cluster snapshot is not in the available state, or other /// accounts are authorized to access the snapshot. /// /// /// The encryption key has exceeded its grant limit in Amazon Web Services KMS. /// /// /// The requested operation isn't supported. /// /// REST API Reference for AuthorizeSnapshotAccess Operation public virtual AuthorizeSnapshotAccessResponse AuthorizeSnapshotAccess(AuthorizeSnapshotAccessRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AuthorizeSnapshotAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = AuthorizeSnapshotAccessResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the AuthorizeSnapshotAccess service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AuthorizeSnapshotAccess service method, as returned by Redshift. /// /// The specified CIDR block or EC2 security group is already authorized for the specified /// cluster security group. /// /// /// The authorization quota for the cluster security group has been reached. /// /// /// The snapshot identifier does not refer to an existing cluster snapshot. /// /// /// The request cannot be completed because a dependent service is throttling requests /// made by Amazon Redshift on your behalf. Wait and retry the request. /// /// /// The specified cluster snapshot is not in the available state, or other /// accounts are authorized to access the snapshot. /// /// /// The encryption key has exceeded its grant limit in Amazon Web Services KMS. /// /// /// The requested operation isn't supported. /// /// REST API Reference for AuthorizeSnapshotAccess Operation public virtual Task AuthorizeSnapshotAccessAsync(AuthorizeSnapshotAccessRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AuthorizeSnapshotAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = AuthorizeSnapshotAccessResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region BatchDeleteClusterSnapshots ///

/// Deletes a set of cluster snapshots. ///

/// Container for the necessary parameters to execute the BatchDeleteClusterSnapshots service method. /// /// The response from the BatchDeleteClusterSnapshots service method, as returned by Redshift. /// /// The maximum number for a batch delete of snapshots has been reached. The limit is /// 100. /// /// REST API Reference for BatchDeleteClusterSnapshots Operation public virtual BatchDeleteClusterSnapshotsResponse BatchDeleteClusterSnapshots(BatchDeleteClusterSnapshotsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = BatchDeleteClusterSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = BatchDeleteClusterSnapshotsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a set of cluster snapshots. ///

/// Container for the necessary parameters to execute the BatchDeleteClusterSnapshots service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the BatchDeleteClusterSnapshots service method, as returned by Redshift. /// /// The maximum number for a batch delete of snapshots has been reached. The limit is /// 100. /// /// REST API Reference for BatchDeleteClusterSnapshots Operation public virtual Task BatchDeleteClusterSnapshotsAsync(BatchDeleteClusterSnapshotsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = BatchDeleteClusterSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = BatchDeleteClusterSnapshotsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region BatchModifyClusterSnapshots ///

/// Modifies the settings for a set of cluster snapshots. ///

/// Container for the necessary parameters to execute the BatchModifyClusterSnapshots service method. /// /// The response from the BatchModifyClusterSnapshots service method, as returned by Redshift. /// /// The maximum number for snapshot identifiers has been reached. The limit is 100. /// /// /// The retention period specified is either in the past or is not a valid value. /// /// /// /// The value must be either -1 or an integer between 1 and 3,653. /// /// /// REST API Reference for BatchModifyClusterSnapshots Operation public virtual BatchModifyClusterSnapshotsResponse BatchModifyClusterSnapshots(BatchModifyClusterSnapshotsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = BatchModifyClusterSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = BatchModifyClusterSnapshotsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Modifies the settings for a set of cluster snapshots. ///

/// Container for the necessary parameters to execute the BatchModifyClusterSnapshots service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the BatchModifyClusterSnapshots service method, as returned by Redshift. /// /// The maximum number for snapshot identifiers has been reached. The limit is 100. /// /// /// The retention period specified is either in the past or is not a valid value. /// /// /// /// The value must be either -1 or an integer between 1 and 3,653. /// /// /// REST API Reference for BatchModifyClusterSnapshots Operation public virtual Task BatchModifyClusterSnapshotsAsync(BatchModifyClusterSnapshotsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = BatchModifyClusterSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = BatchModifyClusterSnapshotsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CancelResize ///

/// Cancels a resize operation for a cluster. ///

/// Container for the necessary parameters to execute the CancelResize service method. /// /// The response from the CancelResize service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The specified cluster is not in the available state. /// /// /// A resize operation for the specified cluster is not found. /// /// /// The requested operation isn't supported. /// /// REST API Reference for CancelResize Operation public virtual CancelResizeResponse CancelResize(CancelResizeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelResizeRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelResizeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Cancels a resize operation for a cluster. ///

/// Container for the necessary parameters to execute the CancelResize service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CancelResize service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The specified cluster is not in the available state. /// /// /// A resize operation for the specified cluster is not found. /// /// /// The requested operation isn't supported. /// /// REST API Reference for CancelResize Operation public virtual Task CancelResizeAsync(CancelResizeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CancelResizeRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelResizeResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CopyClusterSnapshot ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CopyClusterSnapshot service method. /// /// The response from the CopyClusterSnapshot service method, as returned by Redshift. /// /// The value specified as a snapshot identifier is already used by an existing snapshot. /// /// /// The snapshot identifier does not refer to an existing cluster snapshot. /// /// /// The request would result in the user exceeding the allowed number of cluster snapshots. /// /// /// The specified cluster snapshot is not in the available state, or other /// accounts are authorized to access the snapshot. /// /// /// The retention period specified is either in the past or is not a valid value. /// /// /// /// The value must be either -1 or an integer between 1 and 3,653. /// /// /// REST API Reference for CopyClusterSnapshot Operation public virtual CopyClusterSnapshotResponse CopyClusterSnapshot(CopyClusterSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CopyClusterSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CopyClusterSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the CopyClusterSnapshot service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CopyClusterSnapshot service method, as returned by Redshift. /// /// The value specified as a snapshot identifier is already used by an existing snapshot. /// /// /// The snapshot identifier does not refer to an existing cluster snapshot. /// /// /// The request would result in the user exceeding the allowed number of cluster snapshots. /// /// /// The specified cluster snapshot is not in the available state, or other /// accounts are authorized to access the snapshot. /// /// /// The retention period specified is either in the past or is not a valid value. /// /// /// /// The value must be either -1 or an integer between 1 and 3,653. /// /// /// REST API Reference for CopyClusterSnapshot Operation public virtual Task CopyClusterSnapshotAsync(CopyClusterSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CopyClusterSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CopyClusterSnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateAuthenticationProfile ///

/// Creates an authentication profile with the specified parameters. ///

/// Container for the necessary parameters to execute the CreateAuthenticationProfile service method. /// /// The response from the CreateAuthenticationProfile service method, as returned by Redshift. /// /// The authentication profile already exists. /// /// /// The size or number of authentication profiles has exceeded the quota. The maximum /// length of the JSON string and maximum number of authentication profiles is determined /// by a quota for your account. /// /// /// The authentication profile request is not valid. The profile name can't be null or /// empty. The authentication profile API operation must be available in the Amazon Web /// Services Region. /// /// REST API Reference for CreateAuthenticationProfile Operation public virtual CreateAuthenticationProfileResponse CreateAuthenticationProfile(CreateAuthenticationProfileRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateAuthenticationProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateAuthenticationProfileResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates an authentication profile with the specified parameters. ///

/// Container for the necessary parameters to execute the CreateAuthenticationProfile service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateAuthenticationProfile service method, as returned by Redshift. /// /// The authentication profile already exists. /// /// /// The size or number of authentication profiles has exceeded the quota. The maximum /// length of the JSON string and maximum number of authentication profiles is determined /// by a quota for your account. /// /// /// The authentication profile request is not valid. The profile name can't be null or /// empty. The authentication profile API operation must be available in the Amazon Web /// Services Region. /// /// REST API Reference for CreateAuthenticationProfile Operation public virtual Task CreateAuthenticationProfileAsync(CreateAuthenticationProfileRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateAuthenticationProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateAuthenticationProfileResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateCluster ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateCluster service method. /// /// The response from the CreateCluster service method, as returned by Redshift. /// /// The account already has a cluster with the given identifier. /// /// /// The parameter group name does not refer to an existing parameter group. /// /// /// The request would exceed the allowed number of cluster instances for this account. /// For information about increasing your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// The cluster security group name does not refer to an existing cluster security group. /// /// /// The cluster subnet group name does not refer to an existing cluster subnet group. /// /// /// The request cannot be completed because a dependent service is throttling requests /// made by Amazon Redshift on your behalf. Wait and retry the request. /// /// /// There is no Amazon Redshift HSM client certificate with the specified identifier. /// /// /// There is no Amazon Redshift HSM configuration with the specified identifier. /// /// /// The number of nodes specified exceeds the allotted capacity of the cluster. /// /// /// The cluster subnet group cannot be deleted because it is in use. /// /// /// The provided cluster track name is not valid. /// /// /// The Elastic IP (EIP) is invalid or cannot be found. /// /// /// The retention period specified is either in the past or is not a valid value. /// /// /// /// The value must be either -1 or an integer between 1 and 3,653. /// /// /// /// The requested subnet is not valid, or not all of the subnets are in the same VPC. /// /// /// The tag is invalid. /// /// /// The cluster subnet group does not cover all Availability Zones. /// /// /// The encryption key has exceeded its grant limit in Amazon Web Services KMS. /// /// /// The operation would exceed the number of nodes allowed for a cluster. /// /// /// The operation would exceed the number of nodes allotted to the account. For information /// about increasing your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// We could not find the specified snapshot schedule. /// /// /// You have exceeded the number of tags allowed. /// /// /// Your account is not authorized to perform the requested operation. /// /// REST API Reference for CreateCluster Operation public virtual CreateClusterResponse CreateCluster(CreateClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the CreateCluster service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateCluster service method, as returned by Redshift. /// /// The account already has a cluster with the given identifier. /// /// /// The parameter group name does not refer to an existing parameter group. /// /// /// The request would exceed the allowed number of cluster instances for this account. /// For information about increasing your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// The cluster security group name does not refer to an existing cluster security group. /// /// /// The cluster subnet group name does not refer to an existing cluster subnet group. /// /// /// The request cannot be completed because a dependent service is throttling requests /// made by Amazon Redshift on your behalf. Wait and retry the request. /// /// /// There is no Amazon Redshift HSM client certificate with the specified identifier. /// /// /// There is no Amazon Redshift HSM configuration with the specified identifier. /// /// /// The number of nodes specified exceeds the allotted capacity of the cluster. /// /// /// The cluster subnet group cannot be deleted because it is in use. /// /// /// The provided cluster track name is not valid. /// /// /// The Elastic IP (EIP) is invalid or cannot be found. /// /// /// The retention period specified is either in the past or is not a valid value. /// /// /// /// The value must be either -1 or an integer between 1 and 3,653. /// /// /// /// The requested subnet is not valid, or not all of the subnets are in the same VPC. /// /// /// The tag is invalid. /// /// /// The cluster subnet group does not cover all Availability Zones. /// /// /// The encryption key has exceeded its grant limit in Amazon Web Services KMS. /// /// /// The operation would exceed the number of nodes allowed for a cluster. /// /// /// The operation would exceed the number of nodes allotted to the account. For information /// about increasing your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// We could not find the specified snapshot schedule. /// /// /// You have exceeded the number of tags allowed. /// /// /// Your account is not authorized to perform the requested operation. /// /// REST API Reference for CreateCluster Operation public virtual Task CreateClusterAsync(CreateClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateClusterResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateClusterParameterGroup ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateClusterParameterGroup service method. /// /// The response from the CreateClusterParameterGroup service method, as returned by Redshift. /// /// A cluster parameter group with the same name already exists. /// /// /// The request would result in the user exceeding the allowed number of cluster parameter /// groups. For information about increasing your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// The tag is invalid. /// /// /// You have exceeded the number of tags allowed. /// /// REST API Reference for CreateClusterParameterGroup Operation public virtual CreateClusterParameterGroupResponse CreateClusterParameterGroup(CreateClusterParameterGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateClusterParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateClusterParameterGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the CreateClusterParameterGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateClusterParameterGroup service method, as returned by Redshift. /// /// A cluster parameter group with the same name already exists. /// /// /// The request would result in the user exceeding the allowed number of cluster parameter /// groups. For information about increasing your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// The tag is invalid. /// /// /// You have exceeded the number of tags allowed. /// /// REST API Reference for CreateClusterParameterGroup Operation public virtual Task CreateClusterParameterGroupAsync(CreateClusterParameterGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateClusterParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateClusterParameterGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateClusterSecurityGroup ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateClusterSecurityGroup service method. /// /// The response from the CreateClusterSecurityGroup service method, as returned by Redshift. /// /// A cluster security group with the same name already exists. /// /// /// The request would result in the user exceeding the allowed number of cluster security /// groups. For information about increasing your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// The tag is invalid. /// /// /// You have exceeded the number of tags allowed. /// /// REST API Reference for CreateClusterSecurityGroup Operation public virtual CreateClusterSecurityGroupResponse CreateClusterSecurityGroup(CreateClusterSecurityGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateClusterSecurityGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateClusterSecurityGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the CreateClusterSecurityGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateClusterSecurityGroup service method, as returned by Redshift. /// /// A cluster security group with the same name already exists. /// /// /// The request would result in the user exceeding the allowed number of cluster security /// groups. For information about increasing your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// The tag is invalid. /// /// /// You have exceeded the number of tags allowed. /// /// REST API Reference for CreateClusterSecurityGroup Operation public virtual Task CreateClusterSecurityGroupAsync(CreateClusterSecurityGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateClusterSecurityGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateClusterSecurityGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateClusterSnapshot ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateClusterSnapshot service method. /// /// The response from the CreateClusterSnapshot service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The value specified as a snapshot identifier is already used by an existing snapshot. /// /// /// The request would result in the user exceeding the allowed number of cluster snapshots. /// /// /// The specified cluster is not in the available state. /// /// /// The retention period specified is either in the past or is not a valid value. /// /// /// /// The value must be either -1 or an integer between 1 and 3,653. /// /// /// /// The tag is invalid. /// /// /// You have exceeded the number of tags allowed. /// /// REST API Reference for CreateClusterSnapshot Operation public virtual CreateClusterSnapshotResponse CreateClusterSnapshot(CreateClusterSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateClusterSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateClusterSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the CreateClusterSnapshot service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateClusterSnapshot service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The value specified as a snapshot identifier is already used by an existing snapshot. /// /// /// The request would result in the user exceeding the allowed number of cluster snapshots. /// /// /// The specified cluster is not in the available state. /// /// /// The retention period specified is either in the past or is not a valid value. /// /// /// /// The value must be either -1 or an integer between 1 and 3,653. /// /// /// /// The tag is invalid. /// /// /// You have exceeded the number of tags allowed. /// /// REST API Reference for CreateClusterSnapshot Operation public virtual Task CreateClusterSnapshotAsync(CreateClusterSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateClusterSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateClusterSnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateClusterSubnetGroup ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateClusterSubnetGroup service method. /// /// The response from the CreateClusterSubnetGroup service method, as returned by Redshift. /// /// A ClusterSubnetGroupName is already used by an existing cluster subnet group. /// /// /// The request would result in user exceeding the allowed number of cluster subnet groups. /// For information about increasing your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// The request would result in user exceeding the allowed number of subnets in a cluster /// subnet groups. For information about increasing your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// The request cannot be completed because a dependent service is throttling requests /// made by Amazon Redshift on your behalf. Wait and retry the request. /// /// /// The requested subnet is not valid, or not all of the subnets are in the same VPC. /// /// /// The tag is invalid. /// /// /// You have exceeded the number of tags allowed. /// /// /// Your account is not authorized to perform the requested operation. /// /// REST API Reference for CreateClusterSubnetGroup Operation public virtual CreateClusterSubnetGroupResponse CreateClusterSubnetGroup(CreateClusterSubnetGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateClusterSubnetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateClusterSubnetGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the CreateClusterSubnetGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateClusterSubnetGroup service method, as returned by Redshift. /// /// A ClusterSubnetGroupName is already used by an existing cluster subnet group. /// /// /// The request would result in user exceeding the allowed number of cluster subnet groups. /// For information about increasing your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// The request would result in user exceeding the allowed number of subnets in a cluster /// subnet groups. For information about increasing your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// The request cannot be completed because a dependent service is throttling requests /// made by Amazon Redshift on your behalf. Wait and retry the request. /// /// /// The requested subnet is not valid, or not all of the subnets are in the same VPC. /// /// /// The tag is invalid. /// /// /// You have exceeded the number of tags allowed. /// /// /// Your account is not authorized to perform the requested operation. /// /// REST API Reference for CreateClusterSubnetGroup Operation public virtual Task CreateClusterSubnetGroupAsync(CreateClusterSubnetGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateClusterSubnetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateClusterSubnetGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateCustomDomainAssociation ///

/// 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). ///

/// Container for the necessary parameters to execute the CreateCustomDomainAssociation service method. /// /// The response from the CreateCustomDomainAssociation service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// An error occurred when an attempt was made to change the custom domain association. /// /// /// The requested operation isn't supported. /// /// REST API Reference for CreateCustomDomainAssociation Operation public virtual CreateCustomDomainAssociationResponse CreateCustomDomainAssociation(CreateCustomDomainAssociationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCustomDomainAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCustomDomainAssociationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the CreateCustomDomainAssociation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateCustomDomainAssociation service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// An error occurred when an attempt was made to change the custom domain association. /// /// /// The requested operation isn't supported. /// /// REST API Reference for CreateCustomDomainAssociation Operation public virtual Task CreateCustomDomainAssociationAsync(CreateCustomDomainAssociationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCustomDomainAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCustomDomainAssociationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateEndpointAccess ///

/// Creates a Redshift-managed VPC endpoint. ///

/// Container for the necessary parameters to execute the CreateEndpointAccess service method. /// /// The response from the CreateEndpointAccess service method, as returned by Redshift. /// /// You are not authorized to access the cluster. /// /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The cluster subnet group name does not refer to an existing cluster subnet group. /// /// /// The account already has a Redshift-managed VPC endpoint with the given identifier. /// /// /// The number of Redshift-managed VPC endpoints per authorization has exceeded its limit. /// /// /// The number of Redshift-managed VPC endpoints per cluster has exceeded its limit. /// /// /// The state of the cluster security group is not available. /// /// /// The specified cluster is not in the available state. /// /// /// Your account is not authorized to perform the requested operation. /// /// /// The requested operation isn't supported. /// /// REST API Reference for CreateEndpointAccess Operation public virtual CreateEndpointAccessResponse CreateEndpointAccess(CreateEndpointAccessRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateEndpointAccessResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a Redshift-managed VPC endpoint. ///

/// Container for the necessary parameters to execute the CreateEndpointAccess service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateEndpointAccess service method, as returned by Redshift. /// /// You are not authorized to access the cluster. /// /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The cluster subnet group name does not refer to an existing cluster subnet group. /// /// /// The account already has a Redshift-managed VPC endpoint with the given identifier. /// /// /// The number of Redshift-managed VPC endpoints per authorization has exceeded its limit. /// /// /// The number of Redshift-managed VPC endpoints per cluster has exceeded its limit. /// /// /// The state of the cluster security group is not available. /// /// /// The specified cluster is not in the available state. /// /// /// Your account is not authorized to perform the requested operation. /// /// /// The requested operation isn't supported. /// /// REST API Reference for CreateEndpointAccess Operation public virtual Task CreateEndpointAccessAsync(CreateEndpointAccessRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateEndpointAccessResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateEventSubscription ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateEventSubscription service method. /// /// The response from the CreateEventSubscription service method, as returned by Redshift. /// /// The request would exceed the allowed number of event subscriptions for this account. /// For information about increasing your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// The tag is invalid. /// /// /// Amazon SNS has responded that there is a problem with the specified Amazon SNS topic. /// /// /// You do not have permission to publish to the specified Amazon SNS topic. /// /// /// An Amazon SNS topic with the specified Amazon Resource Name (ARN) does not exist. /// /// /// The specified Amazon Redshift event source could not be found. /// /// /// There is already an existing event notification subscription with the specified name. /// /// /// The value specified for the event category was not one of the allowed values, or it /// specified a category that does not apply to the specified source type. The allowed /// values are Configuration, Management, Monitoring, and Security. /// /// /// An Amazon Redshift event with the specified event ID does not exist. /// /// /// The value specified for the event severity was not one of the allowed values, or it /// specified a severity that does not apply to the specified source type. The allowed /// values are ERROR and INFO. /// /// /// You have exceeded the number of tags allowed. /// /// REST API Reference for CreateEventSubscription Operation public virtual CreateEventSubscriptionResponse CreateEventSubscription(CreateEventSubscriptionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateEventSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateEventSubscriptionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the CreateEventSubscription service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateEventSubscription service method, as returned by Redshift. /// /// The request would exceed the allowed number of event subscriptions for this account. /// For information about increasing your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// The tag is invalid. /// /// /// Amazon SNS has responded that there is a problem with the specified Amazon SNS topic. /// /// /// You do not have permission to publish to the specified Amazon SNS topic. /// /// /// An Amazon SNS topic with the specified Amazon Resource Name (ARN) does not exist. /// /// /// The specified Amazon Redshift event source could not be found. /// /// /// There is already an existing event notification subscription with the specified name. /// /// /// The value specified for the event category was not one of the allowed values, or it /// specified a category that does not apply to the specified source type. The allowed /// values are Configuration, Management, Monitoring, and Security. /// /// /// An Amazon Redshift event with the specified event ID does not exist. /// /// /// The value specified for the event severity was not one of the allowed values, or it /// specified a severity that does not apply to the specified source type. The allowed /// values are ERROR and INFO. /// /// /// You have exceeded the number of tags allowed. /// /// REST API Reference for CreateEventSubscription Operation public virtual Task CreateEventSubscriptionAsync(CreateEventSubscriptionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateEventSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateEventSubscriptionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateHsmClientCertificate ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateHsmClientCertificate service method. /// /// The response from the CreateHsmClientCertificate service method, as returned by Redshift. /// /// There is already an existing Amazon Redshift HSM client certificate with the specified /// identifier. /// /// /// The quota for HSM client certificates has been reached. For information about increasing /// your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// The tag is invalid. /// /// /// You have exceeded the number of tags allowed. /// /// REST API Reference for CreateHsmClientCertificate Operation public virtual CreateHsmClientCertificateResponse CreateHsmClientCertificate(CreateHsmClientCertificateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateHsmClientCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateHsmClientCertificateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the CreateHsmClientCertificate service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateHsmClientCertificate service method, as returned by Redshift. /// /// There is already an existing Amazon Redshift HSM client certificate with the specified /// identifier. /// /// /// The quota for HSM client certificates has been reached. For information about increasing /// your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// The tag is invalid. /// /// /// You have exceeded the number of tags allowed. /// /// REST API Reference for CreateHsmClientCertificate Operation public virtual Task CreateHsmClientCertificateAsync(CreateHsmClientCertificateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateHsmClientCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateHsmClientCertificateResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateHsmConfiguration ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateHsmConfiguration service method. /// /// The response from the CreateHsmConfiguration service method, as returned by Redshift. /// /// There is already an existing Amazon Redshift HSM configuration with the specified /// identifier. /// /// /// The quota for HSM configurations has been reached. For information about increasing /// your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// The tag is invalid. /// /// /// You have exceeded the number of tags allowed. /// /// REST API Reference for CreateHsmConfiguration Operation public virtual CreateHsmConfigurationResponse CreateHsmConfiguration(CreateHsmConfigurationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateHsmConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateHsmConfigurationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the CreateHsmConfiguration service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateHsmConfiguration service method, as returned by Redshift. /// /// There is already an existing Amazon Redshift HSM configuration with the specified /// identifier. /// /// /// The quota for HSM configurations has been reached. For information about increasing /// your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// The tag is invalid. /// /// /// You have exceeded the number of tags allowed. /// /// REST API Reference for CreateHsmConfiguration Operation public virtual Task CreateHsmConfigurationAsync(CreateHsmConfigurationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateHsmConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateHsmConfigurationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateScheduledAction ///

/// 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. ///

/// Container for the necessary parameters to execute the CreateScheduledAction service method. /// /// The response from the CreateScheduledAction service method, as returned by Redshift. /// /// The scheduled action is not valid. /// /// /// The schedule you submitted isn't valid. /// /// /// The scheduled action already exists. /// /// /// The quota for scheduled actions exceeded. /// /// /// The action type specified for a scheduled action is not supported. /// /// /// Your account is not authorized to perform the requested operation. /// /// REST API Reference for CreateScheduledAction Operation public virtual CreateScheduledActionResponse CreateScheduledAction(CreateScheduledActionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateScheduledActionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateScheduledActionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the CreateScheduledAction service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateScheduledAction service method, as returned by Redshift. /// /// The scheduled action is not valid. /// /// /// The schedule you submitted isn't valid. /// /// /// The scheduled action already exists. /// /// /// The quota for scheduled actions exceeded. /// /// /// The action type specified for a scheduled action is not supported. /// /// /// Your account is not authorized to perform the requested operation. /// /// REST API Reference for CreateScheduledAction Operation public virtual Task CreateScheduledActionAsync(CreateScheduledActionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateScheduledActionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateScheduledActionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateSnapshotCopyGrant ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the CreateSnapshotCopyGrant service method. /// /// The response from the CreateSnapshotCopyGrant service method, as returned by Redshift. /// /// The request cannot be completed because a dependent service is throttling requests /// made by Amazon Redshift on your behalf. Wait and retry the request. /// /// /// The tag is invalid. /// /// /// The encryption key has exceeded its grant limit in Amazon Web Services KMS. /// /// /// The snapshot copy grant can't be created because a grant with the same name already /// exists. /// /// /// The Amazon Web Services account has exceeded the maximum number of snapshot copy grants /// in this region. /// /// /// You have exceeded the number of tags allowed. /// /// REST API Reference for CreateSnapshotCopyGrant Operation public virtual CreateSnapshotCopyGrantResponse CreateSnapshotCopyGrant(CreateSnapshotCopyGrantRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSnapshotCopyGrantRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSnapshotCopyGrantResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the CreateSnapshotCopyGrant service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateSnapshotCopyGrant service method, as returned by Redshift. /// /// The request cannot be completed because a dependent service is throttling requests /// made by Amazon Redshift on your behalf. Wait and retry the request. /// /// /// The tag is invalid. /// /// /// The encryption key has exceeded its grant limit in Amazon Web Services KMS. /// /// /// The snapshot copy grant can't be created because a grant with the same name already /// exists. /// /// /// The Amazon Web Services account has exceeded the maximum number of snapshot copy grants /// in this region. /// /// /// You have exceeded the number of tags allowed. /// /// REST API Reference for CreateSnapshotCopyGrant Operation public virtual Task CreateSnapshotCopyGrantAsync(CreateSnapshotCopyGrantRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSnapshotCopyGrantRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSnapshotCopyGrantResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateSnapshotSchedule ///

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

/// Container for the necessary parameters to execute the CreateSnapshotSchedule service method. /// /// The response from the CreateSnapshotSchedule service method, as returned by Redshift. /// /// The schedule you submitted isn't valid. /// /// /// The tag is invalid. /// /// /// The definition you submitted is not supported. /// /// /// The specified snapshot schedule already exists. /// /// /// You have exceeded the quota of snapshot schedules. /// /// /// You have exceeded the number of tags allowed. /// /// REST API Reference for CreateSnapshotSchedule Operation public virtual CreateSnapshotScheduleResponse CreateSnapshotSchedule(CreateSnapshotScheduleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSnapshotScheduleRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSnapshotScheduleResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the CreateSnapshotSchedule service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateSnapshotSchedule service method, as returned by Redshift. /// /// The schedule you submitted isn't valid. /// /// /// The tag is invalid. /// /// /// The definition you submitted is not supported. /// /// /// The specified snapshot schedule already exists. /// /// /// You have exceeded the quota of snapshot schedules. /// /// /// You have exceeded the number of tags allowed. /// /// REST API Reference for CreateSnapshotSchedule Operation public virtual Task CreateSnapshotScheduleAsync(CreateSnapshotScheduleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSnapshotScheduleRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSnapshotScheduleResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateTags ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateTags service method. /// /// The response from the CreateTags service method, as returned by Redshift. /// /// The specified cluster is not in the available state. /// /// /// The tag is invalid. /// /// /// The resource could not be found. /// /// /// You have exceeded the number of tags allowed. /// /// REST API Reference for CreateTags Operation public virtual CreateTagsResponse CreateTags(CreateTagsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTagsRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTagsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the CreateTags service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateTags service method, as returned by Redshift. /// /// The specified cluster is not in the available state. /// /// /// The tag is invalid. /// /// /// The resource could not be found. /// /// /// You have exceeded the number of tags allowed. /// /// REST API Reference for CreateTags Operation public virtual Task CreateTagsAsync(CreateTagsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTagsRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTagsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateUsageLimit ///

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

/// Container for the necessary parameters to execute the CreateUsageLimit service method. /// /// The response from the CreateUsageLimit service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The specified cluster is not in the available state. /// /// /// The usage limit is not valid. /// /// /// The encryption key has exceeded its grant limit in Amazon Web Services KMS. /// /// /// You have exceeded the number of tags allowed. /// /// /// The requested operation isn't supported. /// /// /// The usage limit already exists. /// /// REST API Reference for CreateUsageLimit Operation public virtual CreateUsageLimitResponse CreateUsageLimit(CreateUsageLimitRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateUsageLimitRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateUsageLimitResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the CreateUsageLimit service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateUsageLimit service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The specified cluster is not in the available state. /// /// /// The usage limit is not valid. /// /// /// The encryption key has exceeded its grant limit in Amazon Web Services KMS. /// /// /// You have exceeded the number of tags allowed. /// /// /// The requested operation isn't supported. /// /// /// The usage limit already exists. /// /// REST API Reference for CreateUsageLimit Operation public virtual Task CreateUsageLimitAsync(CreateUsageLimitRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateUsageLimitRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateUsageLimitResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeauthorizeDataShare ///

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

/// Container for the necessary parameters to execute the DeauthorizeDataShare service method. /// /// The response from the DeauthorizeDataShare service method, as returned by Redshift. /// /// There is an error with the datashare. /// /// REST API Reference for DeauthorizeDataShare Operation public virtual DeauthorizeDataShareResponse DeauthorizeDataShare(DeauthorizeDataShareRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeauthorizeDataShareRequestMarshaller.Instance; options.ResponseUnmarshaller = DeauthorizeDataShareResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DeauthorizeDataShare service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeauthorizeDataShare service method, as returned by Redshift. /// /// There is an error with the datashare. /// /// REST API Reference for DeauthorizeDataShare Operation public virtual Task DeauthorizeDataShareAsync(DeauthorizeDataShareRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeauthorizeDataShareRequestMarshaller.Instance; options.ResponseUnmarshaller = DeauthorizeDataShareResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteAuthenticationProfile ///

/// Deletes an authentication profile. ///

/// Container for the necessary parameters to execute the DeleteAuthenticationProfile service method. /// /// The response from the DeleteAuthenticationProfile service method, as returned by Redshift. /// /// The authentication profile can't be found. /// /// /// The authentication profile request is not valid. The profile name can't be null or /// empty. The authentication profile API operation must be available in the Amazon Web /// Services Region. /// /// REST API Reference for DeleteAuthenticationProfile Operation public virtual DeleteAuthenticationProfileResponse DeleteAuthenticationProfile(DeleteAuthenticationProfileRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteAuthenticationProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteAuthenticationProfileResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes an authentication profile. ///

/// Container for the necessary parameters to execute the DeleteAuthenticationProfile service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteAuthenticationProfile service method, as returned by Redshift. /// /// The authentication profile can't be found. /// /// /// The authentication profile request is not valid. The profile name can't be null or /// empty. The authentication profile API operation must be available in the Amazon Web /// Services Region. /// /// REST API Reference for DeleteAuthenticationProfile Operation public virtual Task DeleteAuthenticationProfileAsync(DeleteAuthenticationProfileRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteAuthenticationProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteAuthenticationProfileResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteCluster ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DeleteCluster service method. /// /// The response from the DeleteCluster service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The value specified as a snapshot identifier is already used by an existing snapshot. /// /// /// The request would result in the user exceeding the allowed number of cluster snapshots. /// /// /// The specified cluster is not in the available state. /// /// /// The retention period specified is either in the past or is not a valid value. /// /// /// /// The value must be either -1 or an integer between 1 and 3,653. /// /// /// REST API Reference for DeleteCluster Operation public virtual DeleteClusterResponse DeleteCluster(DeleteClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the DeleteCluster service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteCluster service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The value specified as a snapshot identifier is already used by an existing snapshot. /// /// /// The request would result in the user exceeding the allowed number of cluster snapshots. /// /// /// The specified cluster is not in the available state. /// /// /// The retention period specified is either in the past or is not a valid value. /// /// /// /// The value must be either -1 or an integer between 1 and 3,653. /// /// /// REST API Reference for DeleteCluster Operation public virtual Task DeleteClusterAsync(DeleteClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteClusterResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteClusterParameterGroup ///

/// Deletes a specified Amazon Redshift parameter group. /// /// /// /// You cannot delete a parameter group if it is associated with a cluster. /// /// ///

/// Container for the necessary parameters to execute the DeleteClusterParameterGroup service method. /// /// The response from the DeleteClusterParameterGroup service method, as returned by Redshift. /// /// The parameter group name does not refer to an existing parameter group. /// /// /// The cluster parameter group action can not be completed because another task is in /// progress that involves the parameter group. Wait a few moments and try the operation /// again. /// /// REST API Reference for DeleteClusterParameterGroup Operation public virtual DeleteClusterParameterGroupResponse DeleteClusterParameterGroup(DeleteClusterParameterGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteClusterParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteClusterParameterGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a specified Amazon Redshift parameter group. /// /// /// /// You cannot delete a parameter group if it is associated with a cluster. /// /// ///

/// Container for the necessary parameters to execute the DeleteClusterParameterGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteClusterParameterGroup service method, as returned by Redshift. /// /// The parameter group name does not refer to an existing parameter group. /// /// /// The cluster parameter group action can not be completed because another task is in /// progress that involves the parameter group. Wait a few moments and try the operation /// again. /// /// REST API Reference for DeleteClusterParameterGroup Operation public virtual Task DeleteClusterParameterGroupAsync(DeleteClusterParameterGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteClusterParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteClusterParameterGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteClusterSecurityGroup ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DeleteClusterSecurityGroup service method. /// /// The response from the DeleteClusterSecurityGroup service method, as returned by Redshift. /// /// The cluster security group name does not refer to an existing cluster security group. /// /// /// The state of the cluster security group is not available. /// /// REST API Reference for DeleteClusterSecurityGroup Operation public virtual DeleteClusterSecurityGroupResponse DeleteClusterSecurityGroup(DeleteClusterSecurityGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteClusterSecurityGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteClusterSecurityGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the DeleteClusterSecurityGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteClusterSecurityGroup service method, as returned by Redshift. /// /// The cluster security group name does not refer to an existing cluster security group. /// /// /// The state of the cluster security group is not available. /// /// REST API Reference for DeleteClusterSecurityGroup Operation public virtual Task DeleteClusterSecurityGroupAsync(DeleteClusterSecurityGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteClusterSecurityGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteClusterSecurityGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteClusterSnapshot ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DeleteClusterSnapshot service method. /// /// The response from the DeleteClusterSnapshot service method, as returned by Redshift. /// /// The snapshot identifier does not refer to an existing cluster snapshot. /// /// /// The specified cluster snapshot is not in the available state, or other /// accounts are authorized to access the snapshot. /// /// REST API Reference for DeleteClusterSnapshot Operation public virtual DeleteClusterSnapshotResponse DeleteClusterSnapshot(DeleteClusterSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteClusterSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteClusterSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the DeleteClusterSnapshot service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteClusterSnapshot service method, as returned by Redshift. /// /// The snapshot identifier does not refer to an existing cluster snapshot. /// /// /// The specified cluster snapshot is not in the available state, or other /// accounts are authorized to access the snapshot. /// /// REST API Reference for DeleteClusterSnapshot Operation public virtual Task DeleteClusterSnapshotAsync(DeleteClusterSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteClusterSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteClusterSnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteClusterSubnetGroup ///

/// Deletes the specified cluster subnet group. ///

/// Container for the necessary parameters to execute the DeleteClusterSubnetGroup service method. /// /// The response from the DeleteClusterSubnetGroup service method, as returned by Redshift. /// /// The cluster subnet group name does not refer to an existing cluster subnet group. /// /// /// The cluster subnet group cannot be deleted because it is in use. /// /// /// The state of the subnet is invalid. /// /// REST API Reference for DeleteClusterSubnetGroup Operation public virtual DeleteClusterSubnetGroupResponse DeleteClusterSubnetGroup(DeleteClusterSubnetGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteClusterSubnetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteClusterSubnetGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes the specified cluster subnet group. ///

/// Container for the necessary parameters to execute the DeleteClusterSubnetGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteClusterSubnetGroup service method, as returned by Redshift. /// /// The cluster subnet group name does not refer to an existing cluster subnet group. /// /// /// The cluster subnet group cannot be deleted because it is in use. /// /// /// The state of the subnet is invalid. /// /// REST API Reference for DeleteClusterSubnetGroup Operation public virtual Task DeleteClusterSubnetGroupAsync(DeleteClusterSubnetGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteClusterSubnetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteClusterSubnetGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteCustomDomainAssociation ///

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

/// Container for the necessary parameters to execute the DeleteCustomDomainAssociation service method. /// /// The response from the DeleteCustomDomainAssociation service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// An error occurred when an attempt was made to change the custom domain association. /// /// /// The requested operation isn't supported. /// /// REST API Reference for DeleteCustomDomainAssociation Operation public virtual DeleteCustomDomainAssociationResponse DeleteCustomDomainAssociation(DeleteCustomDomainAssociationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteCustomDomainAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteCustomDomainAssociationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DeleteCustomDomainAssociation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteCustomDomainAssociation service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// An error occurred when an attempt was made to change the custom domain association. /// /// /// The requested operation isn't supported. /// /// REST API Reference for DeleteCustomDomainAssociation Operation public virtual Task DeleteCustomDomainAssociationAsync(DeleteCustomDomainAssociationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteCustomDomainAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteCustomDomainAssociationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteEndpointAccess ///

/// Deletes a Redshift-managed VPC endpoint. ///

/// Container for the necessary parameters to execute the DeleteEndpointAccess service method. /// /// The response from the DeleteEndpointAccess service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The endpoint name doesn't refer to an existing endpoint. /// /// /// The state of the cluster security group is not available. /// /// /// The specified cluster is not in the available state. /// /// /// The status of the endpoint is not valid. /// /// REST API Reference for DeleteEndpointAccess Operation public virtual DeleteEndpointAccessResponse DeleteEndpointAccess(DeleteEndpointAccessRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteEndpointAccessResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a Redshift-managed VPC endpoint. ///

/// Container for the necessary parameters to execute the DeleteEndpointAccess service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteEndpointAccess service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The endpoint name doesn't refer to an existing endpoint. /// /// /// The state of the cluster security group is not available. /// /// /// The specified cluster is not in the available state. /// /// /// The status of the endpoint is not valid. /// /// REST API Reference for DeleteEndpointAccess Operation public virtual Task DeleteEndpointAccessAsync(DeleteEndpointAccessRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteEndpointAccessResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteEventSubscription ///

/// Deletes an Amazon Redshift event notification subscription. ///

/// Container for the necessary parameters to execute the DeleteEventSubscription service method. /// /// The response from the DeleteEventSubscription service method, as returned by Redshift. /// /// The subscription request is invalid because it is a duplicate request. This subscription /// request is already in progress. /// /// /// An Amazon Redshift event notification subscription with the specified name does not /// exist. /// /// REST API Reference for DeleteEventSubscription Operation public virtual DeleteEventSubscriptionResponse DeleteEventSubscription(DeleteEventSubscriptionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteEventSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteEventSubscriptionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes an Amazon Redshift event notification subscription. ///

/// Container for the necessary parameters to execute the DeleteEventSubscription service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteEventSubscription service method, as returned by Redshift. /// /// The subscription request is invalid because it is a duplicate request. This subscription /// request is already in progress. /// /// /// An Amazon Redshift event notification subscription with the specified name does not /// exist. /// /// REST API Reference for DeleteEventSubscription Operation public virtual Task DeleteEventSubscriptionAsync(DeleteEventSubscriptionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteEventSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteEventSubscriptionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteHsmClientCertificate ///

/// Deletes the specified HSM client certificate. ///

/// Container for the necessary parameters to execute the DeleteHsmClientCertificate service method. /// /// The response from the DeleteHsmClientCertificate service method, as returned by Redshift. /// /// There is no Amazon Redshift HSM client certificate with the specified identifier. /// /// /// The specified HSM client certificate is not in the available state, or /// it is still in use by one or more Amazon Redshift clusters. /// /// REST API Reference for DeleteHsmClientCertificate Operation public virtual DeleteHsmClientCertificateResponse DeleteHsmClientCertificate(DeleteHsmClientCertificateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteHsmClientCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteHsmClientCertificateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes the specified HSM client certificate. ///

/// Container for the necessary parameters to execute the DeleteHsmClientCertificate service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteHsmClientCertificate service method, as returned by Redshift. /// /// There is no Amazon Redshift HSM client certificate with the specified identifier. /// /// /// The specified HSM client certificate is not in the available state, or /// it is still in use by one or more Amazon Redshift clusters. /// /// REST API Reference for DeleteHsmClientCertificate Operation public virtual Task DeleteHsmClientCertificateAsync(DeleteHsmClientCertificateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteHsmClientCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteHsmClientCertificateResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteHsmConfiguration ///

/// Deletes the specified Amazon Redshift HSM configuration. ///

/// Container for the necessary parameters to execute the DeleteHsmConfiguration service method. /// /// The response from the DeleteHsmConfiguration service method, as returned by Redshift. /// /// There is no Amazon Redshift HSM configuration with the specified identifier. /// /// /// The specified HSM configuration is not in the available state, or it /// is still in use by one or more Amazon Redshift clusters. /// /// REST API Reference for DeleteHsmConfiguration Operation public virtual DeleteHsmConfigurationResponse DeleteHsmConfiguration(DeleteHsmConfigurationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteHsmConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteHsmConfigurationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes the specified Amazon Redshift HSM configuration. ///

/// Container for the necessary parameters to execute the DeleteHsmConfiguration service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteHsmConfiguration service method, as returned by Redshift. /// /// There is no Amazon Redshift HSM configuration with the specified identifier. /// /// /// The specified HSM configuration is not in the available state, or it /// is still in use by one or more Amazon Redshift clusters. /// /// REST API Reference for DeleteHsmConfiguration Operation public virtual Task DeleteHsmConfigurationAsync(DeleteHsmConfigurationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteHsmConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteHsmConfigurationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeletePartner ///

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

/// Container for the necessary parameters to execute the DeletePartner service method. /// /// The response from the DeletePartner service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The name of the partner was not found. /// /// /// The partner integration is not authorized. /// /// REST API Reference for DeletePartner Operation public virtual DeletePartnerResponse DeletePartner(DeletePartnerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeletePartnerRequestMarshaller.Instance; options.ResponseUnmarshaller = DeletePartnerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DeletePartner service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeletePartner service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The name of the partner was not found. /// /// /// The partner integration is not authorized. /// /// REST API Reference for DeletePartner Operation public virtual Task DeletePartnerAsync(DeletePartnerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeletePartnerRequestMarshaller.Instance; options.ResponseUnmarshaller = DeletePartnerResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteScheduledAction ///

/// Deletes a scheduled action. ///

/// Container for the necessary parameters to execute the DeleteScheduledAction service method. /// /// The response from the DeleteScheduledAction service method, as returned by Redshift. /// /// The scheduled action cannot be found. /// /// /// Your account is not authorized to perform the requested operation. /// /// REST API Reference for DeleteScheduledAction Operation public virtual DeleteScheduledActionResponse DeleteScheduledAction(DeleteScheduledActionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteScheduledActionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteScheduledActionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a scheduled action. ///

/// Container for the necessary parameters to execute the DeleteScheduledAction service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteScheduledAction service method, as returned by Redshift. /// /// The scheduled action cannot be found. /// /// /// Your account is not authorized to perform the requested operation. /// /// REST API Reference for DeleteScheduledAction Operation public virtual Task DeleteScheduledActionAsync(DeleteScheduledActionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteScheduledActionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteScheduledActionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteSnapshotCopyGrant ///

/// Deletes the specified snapshot copy grant. ///

/// Container for the necessary parameters to execute the DeleteSnapshotCopyGrant service method. /// /// The response from the DeleteSnapshotCopyGrant service method, as returned by Redshift. /// /// The snapshot copy grant can't be deleted because it is used by one or more clusters. /// /// /// The specified snapshot copy grant can't be found. Make sure that the name is typed /// correctly and that the grant exists in the destination region. /// /// REST API Reference for DeleteSnapshotCopyGrant Operation public virtual DeleteSnapshotCopyGrantResponse DeleteSnapshotCopyGrant(DeleteSnapshotCopyGrantRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSnapshotCopyGrantRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSnapshotCopyGrantResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes the specified snapshot copy grant. ///

/// Container for the necessary parameters to execute the DeleteSnapshotCopyGrant service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteSnapshotCopyGrant service method, as returned by Redshift. /// /// The snapshot copy grant can't be deleted because it is used by one or more clusters. /// /// /// The specified snapshot copy grant can't be found. Make sure that the name is typed /// correctly and that the grant exists in the destination region. /// /// REST API Reference for DeleteSnapshotCopyGrant Operation public virtual Task DeleteSnapshotCopyGrantAsync(DeleteSnapshotCopyGrantRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSnapshotCopyGrantRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSnapshotCopyGrantResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteSnapshotSchedule ///

/// Deletes a snapshot schedule. ///

/// Container for the necessary parameters to execute the DeleteSnapshotSchedule service method. /// /// The response from the DeleteSnapshotSchedule service method, as returned by Redshift. /// /// The cluster snapshot schedule state is not valid. /// /// /// We could not find the specified snapshot schedule. /// /// REST API Reference for DeleteSnapshotSchedule Operation public virtual DeleteSnapshotScheduleResponse DeleteSnapshotSchedule(DeleteSnapshotScheduleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSnapshotScheduleRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSnapshotScheduleResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a snapshot schedule. ///

/// Container for the necessary parameters to execute the DeleteSnapshotSchedule service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteSnapshotSchedule service method, as returned by Redshift. /// /// The cluster snapshot schedule state is not valid. /// /// /// We could not find the specified snapshot schedule. /// /// REST API Reference for DeleteSnapshotSchedule Operation public virtual Task DeleteSnapshotScheduleAsync(DeleteSnapshotScheduleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSnapshotScheduleRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSnapshotScheduleResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteTags ///

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

/// Container for the necessary parameters to execute the DeleteTags service method. /// /// The response from the DeleteTags service method, as returned by Redshift. /// /// The tag is invalid. /// /// /// The resource could not be found. /// /// REST API Reference for DeleteTags Operation public virtual DeleteTagsResponse DeleteTags(DeleteTagsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteTagsRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteTagsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DeleteTags service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteTags service method, as returned by Redshift. /// /// The tag is invalid. /// /// /// The resource could not be found. /// /// REST API Reference for DeleteTags Operation public virtual Task DeleteTagsAsync(DeleteTagsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteTagsRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteTagsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteUsageLimit ///

/// Deletes a usage limit from a cluster. ///

/// Container for the necessary parameters to execute the DeleteUsageLimit service method. /// /// The response from the DeleteUsageLimit service method, as returned by Redshift. /// /// The requested operation isn't supported. /// /// /// The usage limit identifier can't be found. /// /// REST API Reference for DeleteUsageLimit Operation public virtual DeleteUsageLimitResponse DeleteUsageLimit(DeleteUsageLimitRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteUsageLimitRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteUsageLimitResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a usage limit from a cluster. ///

/// Container for the necessary parameters to execute the DeleteUsageLimit service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteUsageLimit service method, as returned by Redshift. /// /// The requested operation isn't supported. /// /// /// The usage limit identifier can't be found. /// /// REST API Reference for DeleteUsageLimit Operation public virtual Task DeleteUsageLimitAsync(DeleteUsageLimitRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteUsageLimitRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteUsageLimitResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeAccountAttributes ///

/// Returns a list of attributes attached to an account ///

/// Container for the necessary parameters to execute the DescribeAccountAttributes service method. /// /// The response from the DescribeAccountAttributes service method, as returned by Redshift. /// REST API Reference for DescribeAccountAttributes Operation public virtual DescribeAccountAttributesResponse DescribeAccountAttributes(DescribeAccountAttributesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAccountAttributesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAccountAttributesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns a list of attributes attached to an account ///

/// Container for the necessary parameters to execute the DescribeAccountAttributes service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAccountAttributes service method, as returned by Redshift. /// REST API Reference for DescribeAccountAttributes Operation public virtual Task DescribeAccountAttributesAsync(DescribeAccountAttributesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAccountAttributesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAccountAttributesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeAuthenticationProfiles ///

/// Describes an authentication profile. ///

/// Container for the necessary parameters to execute the DescribeAuthenticationProfiles service method. /// /// The response from the DescribeAuthenticationProfiles service method, as returned by Redshift. /// /// The authentication profile can't be found. /// /// /// The authentication profile request is not valid. The profile name can't be null or /// empty. The authentication profile API operation must be available in the Amazon Web /// Services Region. /// /// REST API Reference for DescribeAuthenticationProfiles Operation public virtual DescribeAuthenticationProfilesResponse DescribeAuthenticationProfiles(DescribeAuthenticationProfilesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAuthenticationProfilesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAuthenticationProfilesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Describes an authentication profile. ///

/// Container for the necessary parameters to execute the DescribeAuthenticationProfiles service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAuthenticationProfiles service method, as returned by Redshift. /// /// The authentication profile can't be found. /// /// /// The authentication profile request is not valid. The profile name can't be null or /// empty. The authentication profile API operation must be available in the Amazon Web /// Services Region. /// /// REST API Reference for DescribeAuthenticationProfiles Operation public virtual Task DescribeAuthenticationProfilesAsync(DescribeAuthenticationProfilesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAuthenticationProfilesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAuthenticationProfilesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeClusterDbRevisions ///

/// Returns an array of ClusterDbRevision objects. ///

/// Container for the necessary parameters to execute the DescribeClusterDbRevisions service method. /// /// The response from the DescribeClusterDbRevisions service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The specified cluster is not in the available state. /// /// REST API Reference for DescribeClusterDbRevisions Operation public virtual DescribeClusterDbRevisionsResponse DescribeClusterDbRevisions(DescribeClusterDbRevisionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClusterDbRevisionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClusterDbRevisionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns an array of ClusterDbRevision objects. ///

/// Container for the necessary parameters to execute the DescribeClusterDbRevisions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeClusterDbRevisions service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The specified cluster is not in the available state. /// /// REST API Reference for DescribeClusterDbRevisions Operation public virtual Task DescribeClusterDbRevisionsAsync(DescribeClusterDbRevisionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClusterDbRevisionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClusterDbRevisionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeClusterParameterGroups ///

/// 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. /// ///

/// /// The response from the DescribeClusterParameterGroups service method, as returned by Redshift. /// /// The parameter group name does not refer to an existing parameter group. /// /// /// The tag is invalid. /// /// REST API Reference for DescribeClusterParameterGroups Operation public virtual DescribeClusterParameterGroupsResponse DescribeClusterParameterGroups() { return DescribeClusterParameterGroups(new DescribeClusterParameterGroupsRequest()); } ///

/// Container for the necessary parameters to execute the DescribeClusterParameterGroups service method. /// /// The response from the DescribeClusterParameterGroups service method, as returned by Redshift. /// /// The parameter group name does not refer to an existing parameter group. /// /// /// The tag is invalid. /// /// REST API Reference for DescribeClusterParameterGroups Operation public virtual DescribeClusterParameterGroupsResponse DescribeClusterParameterGroups(DescribeClusterParameterGroupsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClusterParameterGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClusterParameterGroupsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeClusterParameterGroups service method, as returned by Redshift. /// /// The parameter group name does not refer to an existing parameter group. /// /// /// The tag is invalid. /// /// REST API Reference for DescribeClusterParameterGroups Operation public virtual Task DescribeClusterParameterGroupsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeClusterParameterGroupsAsync(new DescribeClusterParameterGroupsRequest(), cancellationToken); } ///

/// Container for the necessary parameters to execute the DescribeClusterParameterGroups service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeClusterParameterGroups service method, as returned by Redshift. /// /// The parameter group name does not refer to an existing parameter group. /// /// /// The tag is invalid. /// /// REST API Reference for DescribeClusterParameterGroups Operation public virtual Task DescribeClusterParameterGroupsAsync(DescribeClusterParameterGroupsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClusterParameterGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClusterParameterGroupsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeClusterParameters ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DescribeClusterParameters service method. /// /// The response from the DescribeClusterParameters service method, as returned by Redshift. /// /// The parameter group name does not refer to an existing parameter group. /// /// REST API Reference for DescribeClusterParameters Operation public virtual DescribeClusterParametersResponse DescribeClusterParameters(DescribeClusterParametersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClusterParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClusterParametersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the DescribeClusterParameters service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeClusterParameters service method, as returned by Redshift. /// /// The parameter group name does not refer to an existing parameter group. /// /// REST API Reference for DescribeClusterParameters Operation public virtual Task DescribeClusterParametersAsync(DescribeClusterParametersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClusterParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClusterParametersResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeClusters ///

/// 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. /// ///

/// /// The response from the DescribeClusters service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The tag is invalid. /// /// REST API Reference for DescribeClusters Operation public virtual DescribeClustersResponse DescribeClusters() { return DescribeClusters(new DescribeClustersRequest()); } ///

/// Container for the necessary parameters to execute the DescribeClusters service method. /// /// The response from the DescribeClusters service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The tag is invalid. /// /// REST API Reference for DescribeClusters Operation public virtual DescribeClustersResponse DescribeClusters(DescribeClustersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClustersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClustersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeClusters service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The tag is invalid. /// /// REST API Reference for DescribeClusters Operation public virtual Task DescribeClustersAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeClustersAsync(new DescribeClustersRequest(), cancellationToken); } ///

/// Container for the necessary parameters to execute the DescribeClusters service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeClusters service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The tag is invalid. /// /// REST API Reference for DescribeClusters Operation public virtual Task DescribeClustersAsync(DescribeClustersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClustersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClustersResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeClusterSecurityGroups ///

/// 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. /// ///

/// /// The response from the DescribeClusterSecurityGroups service method, as returned by Redshift. /// /// The cluster security group name does not refer to an existing cluster security group. /// /// /// The tag is invalid. /// /// REST API Reference for DescribeClusterSecurityGroups Operation public virtual DescribeClusterSecurityGroupsResponse DescribeClusterSecurityGroups() { return DescribeClusterSecurityGroups(new DescribeClusterSecurityGroupsRequest()); } ///

/// Container for the necessary parameters to execute the DescribeClusterSecurityGroups service method. /// /// The response from the DescribeClusterSecurityGroups service method, as returned by Redshift. /// /// The cluster security group name does not refer to an existing cluster security group. /// /// /// The tag is invalid. /// /// REST API Reference for DescribeClusterSecurityGroups Operation public virtual DescribeClusterSecurityGroupsResponse DescribeClusterSecurityGroups(DescribeClusterSecurityGroupsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClusterSecurityGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClusterSecurityGroupsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeClusterSecurityGroups service method, as returned by Redshift. /// /// The cluster security group name does not refer to an existing cluster security group. /// /// /// The tag is invalid. /// /// REST API Reference for DescribeClusterSecurityGroups Operation public virtual Task DescribeClusterSecurityGroupsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeClusterSecurityGroupsAsync(new DescribeClusterSecurityGroupsRequest(), cancellationToken); } ///

/// Container for the necessary parameters to execute the DescribeClusterSecurityGroups service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeClusterSecurityGroups service method, as returned by Redshift. /// /// The cluster security group name does not refer to an existing cluster security group. /// /// /// The tag is invalid. /// /// REST API Reference for DescribeClusterSecurityGroups Operation public virtual Task DescribeClusterSecurityGroupsAsync(DescribeClusterSecurityGroupsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClusterSecurityGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClusterSecurityGroupsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeClusterSnapshots ///

/// 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. /// ///

/// /// The response from the DescribeClusterSnapshots service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The snapshot identifier does not refer to an existing cluster snapshot. /// /// /// The tag is invalid. /// /// /// The requested operation isn't supported. /// /// REST API Reference for DescribeClusterSnapshots Operation public virtual DescribeClusterSnapshotsResponse DescribeClusterSnapshots() { return DescribeClusterSnapshots(new DescribeClusterSnapshotsRequest()); } ///

/// Container for the necessary parameters to execute the DescribeClusterSnapshots service method. /// /// The response from the DescribeClusterSnapshots service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The snapshot identifier does not refer to an existing cluster snapshot. /// /// /// The tag is invalid. /// /// /// The requested operation isn't supported. /// /// REST API Reference for DescribeClusterSnapshots Operation public virtual DescribeClusterSnapshotsResponse DescribeClusterSnapshots(DescribeClusterSnapshotsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClusterSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClusterSnapshotsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeClusterSnapshots service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The snapshot identifier does not refer to an existing cluster snapshot. /// /// /// The tag is invalid. /// /// /// The requested operation isn't supported. /// /// REST API Reference for DescribeClusterSnapshots Operation public virtual Task DescribeClusterSnapshotsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeClusterSnapshotsAsync(new DescribeClusterSnapshotsRequest(), cancellationToken); } ///

/// Container for the necessary parameters to execute the DescribeClusterSnapshots service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeClusterSnapshots service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The snapshot identifier does not refer to an existing cluster snapshot. /// /// /// The tag is invalid. /// /// /// The requested operation isn't supported. /// /// REST API Reference for DescribeClusterSnapshots Operation public virtual Task DescribeClusterSnapshotsAsync(DescribeClusterSnapshotsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClusterSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClusterSnapshotsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeClusterSubnetGroups ///

/// 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. /// ///

/// /// The response from the DescribeClusterSubnetGroups service method, as returned by Redshift. /// /// The cluster subnet group name does not refer to an existing cluster subnet group. /// /// /// The tag is invalid. /// /// REST API Reference for DescribeClusterSubnetGroups Operation public virtual DescribeClusterSubnetGroupsResponse DescribeClusterSubnetGroups() { return DescribeClusterSubnetGroups(new DescribeClusterSubnetGroupsRequest()); } ///

/// Container for the necessary parameters to execute the DescribeClusterSubnetGroups service method. /// /// The response from the DescribeClusterSubnetGroups service method, as returned by Redshift. /// /// The cluster subnet group name does not refer to an existing cluster subnet group. /// /// /// The tag is invalid. /// /// REST API Reference for DescribeClusterSubnetGroups Operation public virtual DescribeClusterSubnetGroupsResponse DescribeClusterSubnetGroups(DescribeClusterSubnetGroupsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClusterSubnetGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClusterSubnetGroupsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeClusterSubnetGroups service method, as returned by Redshift. /// /// The cluster subnet group name does not refer to an existing cluster subnet group. /// /// /// The tag is invalid. /// /// REST API Reference for DescribeClusterSubnetGroups Operation public virtual Task DescribeClusterSubnetGroupsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeClusterSubnetGroupsAsync(new DescribeClusterSubnetGroupsRequest(), cancellationToken); } ///

/// Container for the necessary parameters to execute the DescribeClusterSubnetGroups service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeClusterSubnetGroups service method, as returned by Redshift. /// /// The cluster subnet group name does not refer to an existing cluster subnet group. /// /// /// The tag is invalid. /// /// REST API Reference for DescribeClusterSubnetGroups Operation public virtual Task DescribeClusterSubnetGroupsAsync(DescribeClusterSubnetGroupsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClusterSubnetGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClusterSubnetGroupsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeClusterTracks ///

/// Returns a list of all the available maintenance tracks. ///

/// Container for the necessary parameters to execute the DescribeClusterTracks service method. /// /// The response from the DescribeClusterTracks service method, as returned by Redshift. /// /// The provided cluster track name is not valid. /// /// /// Your account is not authorized to perform the requested operation. /// /// REST API Reference for DescribeClusterTracks Operation public virtual DescribeClusterTracksResponse DescribeClusterTracks(DescribeClusterTracksRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClusterTracksRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClusterTracksResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns a list of all the available maintenance tracks. ///

/// Container for the necessary parameters to execute the DescribeClusterTracks service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeClusterTracks service method, as returned by Redshift. /// /// The provided cluster track name is not valid. /// /// /// Your account is not authorized to perform the requested operation. /// /// REST API Reference for DescribeClusterTracks Operation public virtual Task DescribeClusterTracksAsync(DescribeClusterTracksRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClusterTracksRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClusterTracksResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeClusterVersions ///

/// 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. ///

/// /// The response from the DescribeClusterVersions service method, as returned by Redshift. /// REST API Reference for DescribeClusterVersions Operation public virtual DescribeClusterVersionsResponse DescribeClusterVersions() { return DescribeClusterVersions(new DescribeClusterVersionsRequest()); } ///

/// Container for the necessary parameters to execute the DescribeClusterVersions service method. /// /// The response from the DescribeClusterVersions service method, as returned by Redshift. /// REST API Reference for DescribeClusterVersions Operation public virtual DescribeClusterVersionsResponse DescribeClusterVersions(DescribeClusterVersionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClusterVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClusterVersionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeClusterVersions service method, as returned by Redshift. /// REST API Reference for DescribeClusterVersions Operation public virtual Task DescribeClusterVersionsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeClusterVersionsAsync(new DescribeClusterVersionsRequest(), cancellationToken); } ///

/// Container for the necessary parameters to execute the DescribeClusterVersions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeClusterVersions service method, as returned by Redshift. /// REST API Reference for DescribeClusterVersions Operation public virtual Task DescribeClusterVersionsAsync(DescribeClusterVersionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClusterVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClusterVersionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeCustomDomainAssociations ///

/// Contains information for custom domain associations for a cluster. ///

/// Container for the necessary parameters to execute the DescribeCustomDomainAssociations service method. /// /// The response from the DescribeCustomDomainAssociations service method, as returned by Redshift. /// /// An error occurred. The custom domain name couldn't be found. /// /// /// The requested operation isn't supported. /// /// REST API Reference for DescribeCustomDomainAssociations Operation public virtual DescribeCustomDomainAssociationsResponse DescribeCustomDomainAssociations(DescribeCustomDomainAssociationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeCustomDomainAssociationsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeCustomDomainAssociationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Contains information for custom domain associations for a cluster. ///

/// Container for the necessary parameters to execute the DescribeCustomDomainAssociations service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeCustomDomainAssociations service method, as returned by Redshift. /// /// An error occurred. The custom domain name couldn't be found. /// /// /// The requested operation isn't supported. /// /// REST API Reference for DescribeCustomDomainAssociations Operation public virtual Task DescribeCustomDomainAssociationsAsync(DescribeCustomDomainAssociationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeCustomDomainAssociationsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeCustomDomainAssociationsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDataShares ///

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

/// Container for the necessary parameters to execute the DescribeDataShares service method. /// /// The response from the DescribeDataShares service method, as returned by Redshift. /// /// There is an error with the datashare. /// /// REST API Reference for DescribeDataShares Operation public virtual DescribeDataSharesResponse DescribeDataShares(DescribeDataSharesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDataSharesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDataSharesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeDataShares service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDataShares service method, as returned by Redshift. /// /// There is an error with the datashare. /// /// REST API Reference for DescribeDataShares Operation public virtual Task DescribeDataSharesAsync(DescribeDataSharesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDataSharesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDataSharesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDataSharesForConsumer ///

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

/// Container for the necessary parameters to execute the DescribeDataSharesForConsumer service method. /// /// The response from the DescribeDataSharesForConsumer service method, as returned by Redshift. /// /// The namespace isn't valid because the namespace doesn't exist. Provide a valid namespace. /// /// REST API Reference for DescribeDataSharesForConsumer Operation public virtual DescribeDataSharesForConsumerResponse DescribeDataSharesForConsumer(DescribeDataSharesForConsumerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDataSharesForConsumerRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDataSharesForConsumerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeDataSharesForConsumer service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDataSharesForConsumer service method, as returned by Redshift. /// /// The namespace isn't valid because the namespace doesn't exist. Provide a valid namespace. /// /// REST API Reference for DescribeDataSharesForConsumer Operation public virtual Task DescribeDataSharesForConsumerAsync(DescribeDataSharesForConsumerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDataSharesForConsumerRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDataSharesForConsumerResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDataSharesForProducer ///

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

/// Container for the necessary parameters to execute the DescribeDataSharesForProducer service method. /// /// The response from the DescribeDataSharesForProducer service method, as returned by Redshift. /// /// The namespace isn't valid because the namespace doesn't exist. Provide a valid namespace. /// /// REST API Reference for DescribeDataSharesForProducer Operation public virtual DescribeDataSharesForProducerResponse DescribeDataSharesForProducer(DescribeDataSharesForProducerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDataSharesForProducerRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDataSharesForProducerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeDataSharesForProducer service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDataSharesForProducer service method, as returned by Redshift. /// /// The namespace isn't valid because the namespace doesn't exist. Provide a valid namespace. /// /// REST API Reference for DescribeDataSharesForProducer Operation public virtual Task DescribeDataSharesForProducerAsync(DescribeDataSharesForProducerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDataSharesForProducerRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDataSharesForProducerResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDefaultClusterParameters ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DescribeDefaultClusterParameters service method. /// /// The response from the DescribeDefaultClusterParameters service method, as returned by Redshift. /// REST API Reference for DescribeDefaultClusterParameters Operation public virtual DescribeDefaultClusterParametersResponse DescribeDefaultClusterParameters(DescribeDefaultClusterParametersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDefaultClusterParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDefaultClusterParametersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the DescribeDefaultClusterParameters service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDefaultClusterParameters service method, as returned by Redshift. /// REST API Reference for DescribeDefaultClusterParameters Operation public virtual Task DescribeDefaultClusterParametersAsync(DescribeDefaultClusterParametersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDefaultClusterParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDefaultClusterParametersResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeEndpointAccess ///

/// Describes a Redshift-managed VPC endpoint. ///

/// Container for the necessary parameters to execute the DescribeEndpointAccess service method. /// /// The response from the DescribeEndpointAccess service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The endpoint name doesn't refer to an existing endpoint. /// /// /// The specified cluster is not in the available state. /// /// REST API Reference for DescribeEndpointAccess Operation public virtual DescribeEndpointAccessResponse DescribeEndpointAccess(DescribeEndpointAccessRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEndpointAccessResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Describes a Redshift-managed VPC endpoint. ///

/// Container for the necessary parameters to execute the DescribeEndpointAccess service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeEndpointAccess service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The endpoint name doesn't refer to an existing endpoint. /// /// /// The specified cluster is not in the available state. /// /// REST API Reference for DescribeEndpointAccess Operation public virtual Task DescribeEndpointAccessAsync(DescribeEndpointAccessRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEndpointAccessResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeEndpointAuthorization ///

/// Describes an endpoint authorization. ///

/// Container for the necessary parameters to execute the DescribeEndpointAuthorization service method. /// /// The response from the DescribeEndpointAuthorization service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The requested operation isn't supported. /// /// REST API Reference for DescribeEndpointAuthorization Operation public virtual DescribeEndpointAuthorizationResponse DescribeEndpointAuthorization(DescribeEndpointAuthorizationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEndpointAuthorizationRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEndpointAuthorizationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Describes an endpoint authorization. ///

/// Container for the necessary parameters to execute the DescribeEndpointAuthorization service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeEndpointAuthorization service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The requested operation isn't supported. /// /// REST API Reference for DescribeEndpointAuthorization Operation public virtual Task DescribeEndpointAuthorizationAsync(DescribeEndpointAuthorizationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEndpointAuthorizationRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEndpointAuthorizationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeEventCategories ///

/// 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. ///

/// /// The response from the DescribeEventCategories service method, as returned by Redshift. /// REST API Reference for DescribeEventCategories Operation public virtual DescribeEventCategoriesResponse DescribeEventCategories() { return DescribeEventCategories(new DescribeEventCategoriesRequest()); } ///

/// Container for the necessary parameters to execute the DescribeEventCategories service method. /// /// The response from the DescribeEventCategories service method, as returned by Redshift. /// REST API Reference for DescribeEventCategories Operation public virtual DescribeEventCategoriesResponse DescribeEventCategories(DescribeEventCategoriesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEventCategoriesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEventCategoriesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeEventCategories service method, as returned by Redshift. /// REST API Reference for DescribeEventCategories Operation public virtual Task DescribeEventCategoriesAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeEventCategoriesAsync(new DescribeEventCategoriesRequest(), cancellationToken); } ///

/// Container for the necessary parameters to execute the DescribeEventCategories service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeEventCategories service method, as returned by Redshift. /// REST API Reference for DescribeEventCategories Operation public virtual Task DescribeEventCategoriesAsync(DescribeEventCategoriesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEventCategoriesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEventCategoriesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeEvents ///

/// 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. ///

/// /// The response from the DescribeEvents service method, as returned by Redshift. /// REST API Reference for DescribeEvents Operation public virtual DescribeEventsResponse DescribeEvents() { return DescribeEvents(new DescribeEventsRequest()); } ///

/// Container for the necessary parameters to execute the DescribeEvents service method. /// /// The response from the DescribeEvents service method, as returned by Redshift. /// REST API Reference for DescribeEvents Operation public virtual DescribeEventsResponse DescribeEvents(DescribeEventsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEventsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEventsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeEvents service method, as returned by Redshift. /// REST API Reference for DescribeEvents Operation public virtual Task DescribeEventsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeEventsAsync(new DescribeEventsRequest(), cancellationToken); } ///

/// Container for the necessary parameters to execute the DescribeEvents service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeEvents service method, as returned by Redshift. /// REST API Reference for DescribeEvents Operation public virtual Task DescribeEventsAsync(DescribeEventsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEventsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEventsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeEventSubscriptions ///

/// 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. /// ///

/// /// The response from the DescribeEventSubscriptions service method, as returned by Redshift. /// /// The tag is invalid. /// /// /// An Amazon Redshift event notification subscription with the specified name does not /// exist. /// /// REST API Reference for DescribeEventSubscriptions Operation public virtual DescribeEventSubscriptionsResponse DescribeEventSubscriptions() { return DescribeEventSubscriptions(new DescribeEventSubscriptionsRequest()); } ///

/// Container for the necessary parameters to execute the DescribeEventSubscriptions service method. /// /// The response from the DescribeEventSubscriptions service method, as returned by Redshift. /// /// The tag is invalid. /// /// /// An Amazon Redshift event notification subscription with the specified name does not /// exist. /// /// REST API Reference for DescribeEventSubscriptions Operation public virtual DescribeEventSubscriptionsResponse DescribeEventSubscriptions(DescribeEventSubscriptionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEventSubscriptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEventSubscriptionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeEventSubscriptions service method, as returned by Redshift. /// /// The tag is invalid. /// /// /// An Amazon Redshift event notification subscription with the specified name does not /// exist. /// /// REST API Reference for DescribeEventSubscriptions Operation public virtual Task DescribeEventSubscriptionsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeEventSubscriptionsAsync(new DescribeEventSubscriptionsRequest(), cancellationToken); } ///

/// Container for the necessary parameters to execute the DescribeEventSubscriptions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeEventSubscriptions service method, as returned by Redshift. /// /// The tag is invalid. /// /// /// An Amazon Redshift event notification subscription with the specified name does not /// exist. /// /// REST API Reference for DescribeEventSubscriptions Operation public virtual Task DescribeEventSubscriptionsAsync(DescribeEventSubscriptionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEventSubscriptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEventSubscriptionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeHsmClientCertificates ///

/// 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. /// ///

/// /// The response from the DescribeHsmClientCertificates service method, as returned by Redshift. /// /// There is no Amazon Redshift HSM client certificate with the specified identifier. /// /// /// The tag is invalid. /// /// REST API Reference for DescribeHsmClientCertificates Operation public virtual DescribeHsmClientCertificatesResponse DescribeHsmClientCertificates() { return DescribeHsmClientCertificates(new DescribeHsmClientCertificatesRequest()); } ///

/// Container for the necessary parameters to execute the DescribeHsmClientCertificates service method. /// /// The response from the DescribeHsmClientCertificates service method, as returned by Redshift. /// /// There is no Amazon Redshift HSM client certificate with the specified identifier. /// /// /// The tag is invalid. /// /// REST API Reference for DescribeHsmClientCertificates Operation public virtual DescribeHsmClientCertificatesResponse DescribeHsmClientCertificates(DescribeHsmClientCertificatesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeHsmClientCertificatesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeHsmClientCertificatesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeHsmClientCertificates service method, as returned by Redshift. /// /// There is no Amazon Redshift HSM client certificate with the specified identifier. /// /// /// The tag is invalid. /// /// REST API Reference for DescribeHsmClientCertificates Operation public virtual Task DescribeHsmClientCertificatesAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeHsmClientCertificatesAsync(new DescribeHsmClientCertificatesRequest(), cancellationToken); } ///

/// Container for the necessary parameters to execute the DescribeHsmClientCertificates service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeHsmClientCertificates service method, as returned by Redshift. /// /// There is no Amazon Redshift HSM client certificate with the specified identifier. /// /// /// The tag is invalid. /// /// REST API Reference for DescribeHsmClientCertificates Operation public virtual Task DescribeHsmClientCertificatesAsync(DescribeHsmClientCertificatesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeHsmClientCertificatesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeHsmClientCertificatesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeHsmConfigurations ///

/// 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. /// ///

/// /// The response from the DescribeHsmConfigurations service method, as returned by Redshift. /// /// There is no Amazon Redshift HSM configuration with the specified identifier. /// /// /// The tag is invalid. /// /// REST API Reference for DescribeHsmConfigurations Operation public virtual DescribeHsmConfigurationsResponse DescribeHsmConfigurations() { return DescribeHsmConfigurations(new DescribeHsmConfigurationsRequest()); } ///

/// Container for the necessary parameters to execute the DescribeHsmConfigurations service method. /// /// The response from the DescribeHsmConfigurations service method, as returned by Redshift. /// /// There is no Amazon Redshift HSM configuration with the specified identifier. /// /// /// The tag is invalid. /// /// REST API Reference for DescribeHsmConfigurations Operation public virtual DescribeHsmConfigurationsResponse DescribeHsmConfigurations(DescribeHsmConfigurationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeHsmConfigurationsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeHsmConfigurationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeHsmConfigurations service method, as returned by Redshift. /// /// There is no Amazon Redshift HSM configuration with the specified identifier. /// /// /// The tag is invalid. /// /// REST API Reference for DescribeHsmConfigurations Operation public virtual Task DescribeHsmConfigurationsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeHsmConfigurationsAsync(new DescribeHsmConfigurationsRequest(), cancellationToken); } ///

/// Container for the necessary parameters to execute the DescribeHsmConfigurations service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeHsmConfigurations service method, as returned by Redshift. /// /// There is no Amazon Redshift HSM configuration with the specified identifier. /// /// /// The tag is invalid. /// /// REST API Reference for DescribeHsmConfigurations Operation public virtual Task DescribeHsmConfigurationsAsync(DescribeHsmConfigurationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeHsmConfigurationsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeHsmConfigurationsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeLoggingStatus ///

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

/// Container for the necessary parameters to execute the DescribeLoggingStatus service method. /// /// The response from the DescribeLoggingStatus service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// REST API Reference for DescribeLoggingStatus Operation public virtual DescribeLoggingStatusResponse DescribeLoggingStatus(DescribeLoggingStatusRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeLoggingStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeLoggingStatusResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeLoggingStatus service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeLoggingStatus service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// REST API Reference for DescribeLoggingStatus Operation public virtual Task DescribeLoggingStatusAsync(DescribeLoggingStatusRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeLoggingStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeLoggingStatusResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeNodeConfigurationOptions ///

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

/// Container for the necessary parameters to execute the DescribeNodeConfigurationOptions service method. /// /// The response from the DescribeNodeConfigurationOptions service method, as returned by Redshift. /// /// The owner of the specified snapshot has not authorized your account to access the /// snapshot. /// /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The snapshot identifier does not refer to an existing cluster snapshot. /// /// /// The specified cluster snapshot is not in the available state, or other /// accounts are authorized to access the snapshot. /// /// /// The requested operation isn't supported. /// /// REST API Reference for DescribeNodeConfigurationOptions Operation public virtual DescribeNodeConfigurationOptionsResponse DescribeNodeConfigurationOptions(DescribeNodeConfigurationOptionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeNodeConfigurationOptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeNodeConfigurationOptionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeNodeConfigurationOptions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeNodeConfigurationOptions service method, as returned by Redshift. /// /// The owner of the specified snapshot has not authorized your account to access the /// snapshot. /// /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The snapshot identifier does not refer to an existing cluster snapshot. /// /// /// The specified cluster snapshot is not in the available state, or other /// accounts are authorized to access the snapshot. /// /// /// The requested operation isn't supported. /// /// REST API Reference for DescribeNodeConfigurationOptions Operation public virtual Task DescribeNodeConfigurationOptionsAsync(DescribeNodeConfigurationOptionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeNodeConfigurationOptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeNodeConfigurationOptionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeOrderableClusterOptions ///

/// 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. ///

/// /// The response from the DescribeOrderableClusterOptions service method, as returned by Redshift. /// REST API Reference for DescribeOrderableClusterOptions Operation public virtual DescribeOrderableClusterOptionsResponse DescribeOrderableClusterOptions() { return DescribeOrderableClusterOptions(new DescribeOrderableClusterOptionsRequest()); } ///

/// Container for the necessary parameters to execute the DescribeOrderableClusterOptions service method. /// /// The response from the DescribeOrderableClusterOptions service method, as returned by Redshift. /// REST API Reference for DescribeOrderableClusterOptions Operation public virtual DescribeOrderableClusterOptionsResponse DescribeOrderableClusterOptions(DescribeOrderableClusterOptionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeOrderableClusterOptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeOrderableClusterOptionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeOrderableClusterOptions service method, as returned by Redshift. /// REST API Reference for DescribeOrderableClusterOptions Operation public virtual Task DescribeOrderableClusterOptionsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeOrderableClusterOptionsAsync(new DescribeOrderableClusterOptionsRequest(), cancellationToken); } ///

/// Container for the necessary parameters to execute the DescribeOrderableClusterOptions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeOrderableClusterOptions service method, as returned by Redshift. /// REST API Reference for DescribeOrderableClusterOptions Operation public virtual Task DescribeOrderableClusterOptionsAsync(DescribeOrderableClusterOptionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeOrderableClusterOptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeOrderableClusterOptionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribePartners ///

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

/// Container for the necessary parameters to execute the DescribePartners service method. /// /// The response from the DescribePartners service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The partner integration is not authorized. /// /// REST API Reference for DescribePartners Operation public virtual DescribePartnersResponse DescribePartners(DescribePartnersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribePartnersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribePartnersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribePartners service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribePartners service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The partner integration is not authorized. /// /// REST API Reference for DescribePartners Operation public virtual Task DescribePartnersAsync(DescribePartnersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribePartnersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribePartnersResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeReservedNodeExchangeStatus ///

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

/// Container for the necessary parameters to execute the DescribeReservedNodeExchangeStatus service method. /// /// The response from the DescribeReservedNodeExchangeStatus service method, as returned by Redshift. /// /// The reserved-node exchange status wasn't found. /// /// /// The specified reserved compute node not found. /// /// /// The requested operation isn't supported. /// /// REST API Reference for DescribeReservedNodeExchangeStatus Operation public virtual DescribeReservedNodeExchangeStatusResponse DescribeReservedNodeExchangeStatus(DescribeReservedNodeExchangeStatusRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeReservedNodeExchangeStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeReservedNodeExchangeStatusResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeReservedNodeExchangeStatus service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeReservedNodeExchangeStatus service method, as returned by Redshift. /// /// The reserved-node exchange status wasn't found. /// /// /// The specified reserved compute node not found. /// /// /// The requested operation isn't supported. /// /// REST API Reference for DescribeReservedNodeExchangeStatus Operation public virtual Task DescribeReservedNodeExchangeStatusAsync(DescribeReservedNodeExchangeStatusRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeReservedNodeExchangeStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeReservedNodeExchangeStatusResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeReservedNodeOfferings ///

/// 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. /// ///

/// /// The response from the DescribeReservedNodeOfferings service method, as returned by Redshift. /// /// Your request cannot be completed because a dependent internal service is temporarily /// unavailable. Wait 30 to 60 seconds and try again. /// /// /// Specified offering does not exist. /// /// /// The requested operation isn't supported. /// /// REST API Reference for DescribeReservedNodeOfferings Operation public virtual DescribeReservedNodeOfferingsResponse DescribeReservedNodeOfferings() { return DescribeReservedNodeOfferings(new DescribeReservedNodeOfferingsRequest()); } ///

/// Container for the necessary parameters to execute the DescribeReservedNodeOfferings service method. /// /// The response from the DescribeReservedNodeOfferings service method, as returned by Redshift. /// /// Your request cannot be completed because a dependent internal service is temporarily /// unavailable. Wait 30 to 60 seconds and try again. /// /// /// Specified offering does not exist. /// /// /// The requested operation isn't supported. /// /// REST API Reference for DescribeReservedNodeOfferings Operation public virtual DescribeReservedNodeOfferingsResponse DescribeReservedNodeOfferings(DescribeReservedNodeOfferingsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeReservedNodeOfferingsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeReservedNodeOfferingsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeReservedNodeOfferings service method, as returned by Redshift. /// /// Your request cannot be completed because a dependent internal service is temporarily /// unavailable. Wait 30 to 60 seconds and try again. /// /// /// Specified offering does not exist. /// /// /// The requested operation isn't supported. /// /// REST API Reference for DescribeReservedNodeOfferings Operation public virtual Task DescribeReservedNodeOfferingsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeReservedNodeOfferingsAsync(new DescribeReservedNodeOfferingsRequest(), cancellationToken); } ///

/// Container for the necessary parameters to execute the DescribeReservedNodeOfferings service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeReservedNodeOfferings service method, as returned by Redshift. /// /// Your request cannot be completed because a dependent internal service is temporarily /// unavailable. Wait 30 to 60 seconds and try again. /// /// /// Specified offering does not exist. /// /// /// The requested operation isn't supported. /// /// REST API Reference for DescribeReservedNodeOfferings Operation public virtual Task DescribeReservedNodeOfferingsAsync(DescribeReservedNodeOfferingsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeReservedNodeOfferingsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeReservedNodeOfferingsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeReservedNodes ///

/// Returns the descriptions of the reserved nodes. ///

/// /// The response from the DescribeReservedNodes service method, as returned by Redshift. /// /// Your request cannot be completed because a dependent internal service is temporarily /// unavailable. Wait 30 to 60 seconds and try again. /// /// /// The specified reserved compute node not found. /// /// REST API Reference for DescribeReservedNodes Operation public virtual DescribeReservedNodesResponse DescribeReservedNodes() { return DescribeReservedNodes(new DescribeReservedNodesRequest()); } ///

/// Returns the descriptions of the reserved nodes. ///

/// Container for the necessary parameters to execute the DescribeReservedNodes service method. /// /// The response from the DescribeReservedNodes service method, as returned by Redshift. /// /// Your request cannot be completed because a dependent internal service is temporarily /// unavailable. Wait 30 to 60 seconds and try again. /// /// /// The specified reserved compute node not found. /// /// REST API Reference for DescribeReservedNodes Operation public virtual DescribeReservedNodesResponse DescribeReservedNodes(DescribeReservedNodesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeReservedNodesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeReservedNodesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns the descriptions of the reserved nodes. ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeReservedNodes service method, as returned by Redshift. /// /// Your request cannot be completed because a dependent internal service is temporarily /// unavailable. Wait 30 to 60 seconds and try again. /// /// /// The specified reserved compute node not found. /// /// REST API Reference for DescribeReservedNodes Operation public virtual Task DescribeReservedNodesAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeReservedNodesAsync(new DescribeReservedNodesRequest(), cancellationToken); } ///

/// Returns the descriptions of the reserved nodes. ///

/// Container for the necessary parameters to execute the DescribeReservedNodes service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeReservedNodes service method, as returned by Redshift. /// /// Your request cannot be completed because a dependent internal service is temporarily /// unavailable. Wait 30 to 60 seconds and try again. /// /// /// The specified reserved compute node not found. /// /// REST API Reference for DescribeReservedNodes Operation public virtual Task DescribeReservedNodesAsync(DescribeReservedNodesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeReservedNodesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeReservedNodesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeResize ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DescribeResize service method. /// /// The response from the DescribeResize service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// A resize operation for the specified cluster is not found. /// /// REST API Reference for DescribeResize Operation public virtual DescribeResizeResponse DescribeResize(DescribeResizeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeResizeRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeResizeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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

/// Container for the necessary parameters to execute the DescribeResize service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeResize service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// A resize operation for the specified cluster is not found. /// /// REST API Reference for DescribeResize Operation public virtual Task DescribeResizeAsync(DescribeResizeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeResizeRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeResizeResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeScheduledActions ///

/// Describes properties of scheduled actions. ///

/// Container for the necessary parameters to execute the DescribeScheduledActions service method. /// /// The response from the DescribeScheduledActions service method, as returned by Redshift. /// /// The scheduled action cannot be found. /// /// /// Your account is not authorized to perform the requested operation. /// /// REST API Reference for DescribeScheduledActions Operation public virtual DescribeScheduledActionsResponse DescribeScheduledActions(DescribeScheduledActionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeScheduledActionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeScheduledActionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Describes properties of scheduled actions. ///

/// Container for the necessary parameters to execute the DescribeScheduledActions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeScheduledActions service method, as returned by Redshift. /// /// The scheduled action cannot be found. /// /// /// Your account is not authorized to perform the requested operation. /// /// REST API Reference for DescribeScheduledActions Operation public virtual Task DescribeScheduledActionsAsync(DescribeScheduledActionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeScheduledActionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeScheduledActionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeSnapshotCopyGrants ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the DescribeSnapshotCopyGrants service method. /// /// The response from the DescribeSnapshotCopyGrants service method, as returned by Redshift. /// /// The tag is invalid. /// /// /// The specified snapshot copy grant can't be found. Make sure that the name is typed /// correctly and that the grant exists in the destination region. /// /// REST API Reference for DescribeSnapshotCopyGrants Operation public virtual DescribeSnapshotCopyGrantsResponse DescribeSnapshotCopyGrants(DescribeSnapshotCopyGrantsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSnapshotCopyGrantsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSnapshotCopyGrantsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the DescribeSnapshotCopyGrants service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeSnapshotCopyGrants service method, as returned by Redshift. /// /// The tag is invalid. /// /// /// The specified snapshot copy grant can't be found. Make sure that the name is typed /// correctly and that the grant exists in the destination region. /// /// REST API Reference for DescribeSnapshotCopyGrants Operation public virtual Task DescribeSnapshotCopyGrantsAsync(DescribeSnapshotCopyGrantsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSnapshotCopyGrantsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSnapshotCopyGrantsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeSnapshotSchedules ///

/// Returns a list of snapshot schedules. ///

/// Container for the necessary parameters to execute the DescribeSnapshotSchedules service method. /// /// The response from the DescribeSnapshotSchedules service method, as returned by Redshift. /// REST API Reference for DescribeSnapshotSchedules Operation public virtual DescribeSnapshotSchedulesResponse DescribeSnapshotSchedules(DescribeSnapshotSchedulesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSnapshotSchedulesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSnapshotSchedulesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns a list of snapshot schedules. ///

/// Container for the necessary parameters to execute the DescribeSnapshotSchedules service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeSnapshotSchedules service method, as returned by Redshift. /// REST API Reference for DescribeSnapshotSchedules Operation public virtual Task DescribeSnapshotSchedulesAsync(DescribeSnapshotSchedulesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSnapshotSchedulesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSnapshotSchedulesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeStorage ///

/// Returns account level backups storage size and provisional storage. ///

/// Container for the necessary parameters to execute the DescribeStorage service method. /// /// The response from the DescribeStorage service method, as returned by Redshift. /// REST API Reference for DescribeStorage Operation public virtual DescribeStorageResponse DescribeStorage(DescribeStorageRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeStorageRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeStorageResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns account level backups storage size and provisional storage. ///

/// Container for the necessary parameters to execute the DescribeStorage service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeStorage service method, as returned by Redshift. /// REST API Reference for DescribeStorage Operation public virtual Task DescribeStorageAsync(DescribeStorageRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeStorageRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeStorageResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeTableRestoreStatus ///

/// 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. ///

/// Container for the necessary parameters to execute the DescribeTableRestoreStatus service method. /// /// The response from the DescribeTableRestoreStatus service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The specified TableRestoreRequestId value was not found. /// /// REST API Reference for DescribeTableRestoreStatus Operation public virtual DescribeTableRestoreStatusResponse DescribeTableRestoreStatus(DescribeTableRestoreStatusRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeTableRestoreStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeTableRestoreStatusResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the DescribeTableRestoreStatus service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeTableRestoreStatus service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The specified TableRestoreRequestId value was not found. /// /// REST API Reference for DescribeTableRestoreStatus Operation public virtual Task DescribeTableRestoreStatusAsync(DescribeTableRestoreStatusRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeTableRestoreStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeTableRestoreStatusResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeTags ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DescribeTags service method. /// /// The response from the DescribeTags service method, as returned by Redshift. /// /// The tag is invalid. /// /// /// The resource could not be found. /// /// REST API Reference for DescribeTags Operation public virtual DescribeTagsResponse DescribeTags(DescribeTagsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeTagsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeTagsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// /// 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. /// ///

/// Container for the necessary parameters to execute the DescribeTags service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeTags service method, as returned by Redshift. /// /// The tag is invalid. /// /// /// The resource could not be found. /// /// REST API Reference for DescribeTags Operation public virtual Task DescribeTagsAsync(DescribeTagsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeTagsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeTagsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeUsageLimits ///

/// 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. /// ///

///

/// Container for the necessary parameters to execute the DescribeUsageLimits service method. /// /// The response from the DescribeUsageLimits service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The requested operation isn't supported. /// /// REST API Reference for DescribeUsageLimits Operation public virtual DescribeUsageLimitsResponse DescribeUsageLimits(DescribeUsageLimitsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeUsageLimitsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeUsageLimitsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

///

/// Container for the necessary parameters to execute the DescribeUsageLimits service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeUsageLimits service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The requested operation isn't supported. /// /// REST API Reference for DescribeUsageLimits Operation public virtual Task DescribeUsageLimitsAsync(DescribeUsageLimitsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeUsageLimitsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeUsageLimitsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DisableLogging ///

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

/// Container for the necessary parameters to execute the DisableLogging service method. /// /// The response from the DisableLogging service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The specified cluster is not in the available state. /// /// REST API Reference for DisableLogging Operation public virtual DisableLoggingResponse DisableLogging(DisableLoggingRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DisableLoggingRequestMarshaller.Instance; options.ResponseUnmarshaller = DisableLoggingResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DisableLogging service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DisableLogging service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The specified cluster is not in the available state. /// /// REST API Reference for DisableLogging Operation public virtual Task DisableLoggingAsync(DisableLoggingRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DisableLoggingRequestMarshaller.Instance; options.ResponseUnmarshaller = DisableLoggingResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DisableSnapshotCopy ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DisableSnapshotCopy service method. /// /// The response from the DisableSnapshotCopy service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The specified cluster is not in the available state. /// /// /// The cluster already has cross-region snapshot copy disabled. /// /// /// Your account is not authorized to perform the requested operation. /// /// REST API Reference for DisableSnapshotCopy Operation public virtual DisableSnapshotCopyResponse DisableSnapshotCopy(DisableSnapshotCopyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DisableSnapshotCopyRequestMarshaller.Instance; options.ResponseUnmarshaller = DisableSnapshotCopyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the DisableSnapshotCopy service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DisableSnapshotCopy service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The specified cluster is not in the available state. /// /// /// The cluster already has cross-region snapshot copy disabled. /// /// /// Your account is not authorized to perform the requested operation. /// /// REST API Reference for DisableSnapshotCopy Operation public virtual Task DisableSnapshotCopyAsync(DisableSnapshotCopyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DisableSnapshotCopyRequestMarshaller.Instance; options.ResponseUnmarshaller = DisableSnapshotCopyResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DisassociateDataShareConsumer ///

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

/// Container for the necessary parameters to execute the DisassociateDataShareConsumer service method. /// /// The response from the DisassociateDataShareConsumer service method, as returned by Redshift. /// /// There is an error with the datashare. /// /// /// The namespace isn't valid because the namespace doesn't exist. Provide a valid namespace. /// /// REST API Reference for DisassociateDataShareConsumer Operation public virtual DisassociateDataShareConsumerResponse DisassociateDataShareConsumer(DisassociateDataShareConsumerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DisassociateDataShareConsumerRequestMarshaller.Instance; options.ResponseUnmarshaller = DisassociateDataShareConsumerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DisassociateDataShareConsumer service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DisassociateDataShareConsumer service method, as returned by Redshift. /// /// There is an error with the datashare. /// /// /// The namespace isn't valid because the namespace doesn't exist. Provide a valid namespace. /// /// REST API Reference for DisassociateDataShareConsumer Operation public virtual Task DisassociateDataShareConsumerAsync(DisassociateDataShareConsumerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DisassociateDataShareConsumerRequestMarshaller.Instance; options.ResponseUnmarshaller = DisassociateDataShareConsumerResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region EnableLogging ///

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

/// Container for the necessary parameters to execute the EnableLogging service method. /// /// The response from the EnableLogging service method, as returned by Redshift. /// /// Could not find the specified S3 bucket. /// /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The cluster does not have read bucket or put object permissions on the S3 bucket specified /// when enabling logging. /// /// /// The specified cluster is not in the available state. /// /// /// The S3 bucket name is invalid. For more information about naming rules, go to Bucket /// Restrictions and Limitations in the Amazon Simple Storage Service (S3) Developer /// Guide. /// /// /// The string specified for the logging S3 key prefix does not comply with the documented /// constraints. /// /// REST API Reference for EnableLogging Operation public virtual EnableLoggingResponse EnableLogging(EnableLoggingRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = EnableLoggingRequestMarshaller.Instance; options.ResponseUnmarshaller = EnableLoggingResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the EnableLogging service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the EnableLogging service method, as returned by Redshift. /// /// Could not find the specified S3 bucket. /// /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The cluster does not have read bucket or put object permissions on the S3 bucket specified /// when enabling logging. /// /// /// The specified cluster is not in the available state. /// /// /// The S3 bucket name is invalid. For more information about naming rules, go to Bucket /// Restrictions and Limitations in the Amazon Simple Storage Service (S3) Developer /// Guide. /// /// /// The string specified for the logging S3 key prefix does not comply with the documented /// constraints. /// /// REST API Reference for EnableLogging Operation public virtual Task EnableLoggingAsync(EnableLoggingRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = EnableLoggingRequestMarshaller.Instance; options.ResponseUnmarshaller = EnableLoggingResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region EnableSnapshotCopy ///

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

/// Container for the necessary parameters to execute the EnableSnapshotCopy service method. /// /// The response from the EnableSnapshotCopy service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// Cross-region snapshot copy was temporarily disabled. Try your request again. /// /// /// The request cannot be completed because a dependent service is throttling requests /// made by Amazon Redshift on your behalf. Wait and retry the request. /// /// /// The specified options are incompatible. /// /// /// The specified cluster is not in the available state. /// /// /// The retention period specified is either in the past or is not a valid value. /// /// /// /// The value must be either -1 or an integer between 1 and 3,653. /// /// /// /// The encryption key has exceeded its grant limit in Amazon Web Services KMS. /// /// /// The cluster already has cross-region snapshot copy enabled. /// /// /// The specified snapshot copy grant can't be found. Make sure that the name is typed /// correctly and that the grant exists in the destination region. /// /// /// Your account is not authorized to perform the requested operation. /// /// /// The specified region is incorrect or does not exist. /// /// REST API Reference for EnableSnapshotCopy Operation public virtual EnableSnapshotCopyResponse EnableSnapshotCopy(EnableSnapshotCopyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = EnableSnapshotCopyRequestMarshaller.Instance; options.ResponseUnmarshaller = EnableSnapshotCopyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the EnableSnapshotCopy service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the EnableSnapshotCopy service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// Cross-region snapshot copy was temporarily disabled. Try your request again. /// /// /// The request cannot be completed because a dependent service is throttling requests /// made by Amazon Redshift on your behalf. Wait and retry the request. /// /// /// The specified options are incompatible. /// /// /// The specified cluster is not in the available state. /// /// /// The retention period specified is either in the past or is not a valid value. /// /// /// /// The value must be either -1 or an integer between 1 and 3,653. /// /// /// /// The encryption key has exceeded its grant limit in Amazon Web Services KMS. /// /// /// The cluster already has cross-region snapshot copy enabled. /// /// /// The specified snapshot copy grant can't be found. Make sure that the name is typed /// correctly and that the grant exists in the destination region. /// /// /// Your account is not authorized to perform the requested operation. /// /// /// The specified region is incorrect or does not exist. /// /// REST API Reference for EnableSnapshotCopy Operation public virtual Task EnableSnapshotCopyAsync(EnableSnapshotCopyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = EnableSnapshotCopyRequestMarshaller.Instance; options.ResponseUnmarshaller = EnableSnapshotCopyResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetClusterCredentials ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetClusterCredentials service method. /// /// The response from the GetClusterCredentials service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The requested operation isn't supported. /// /// REST API Reference for GetClusterCredentials Operation public virtual GetClusterCredentialsResponse GetClusterCredentials(GetClusterCredentialsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetClusterCredentialsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetClusterCredentialsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the GetClusterCredentials service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetClusterCredentials service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The requested operation isn't supported. /// /// REST API Reference for GetClusterCredentials Operation public virtual Task GetClusterCredentialsAsync(GetClusterCredentialsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetClusterCredentialsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetClusterCredentialsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetClusterCredentialsWithIAM ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetClusterCredentialsWithIAM service method. /// /// The response from the GetClusterCredentialsWithIAM service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The requested operation isn't supported. /// /// REST API Reference for GetClusterCredentialsWithIAM Operation public virtual GetClusterCredentialsWithIAMResponse GetClusterCredentialsWithIAM(GetClusterCredentialsWithIAMRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetClusterCredentialsWithIAMRequestMarshaller.Instance; options.ResponseUnmarshaller = GetClusterCredentialsWithIAMResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the GetClusterCredentialsWithIAM service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetClusterCredentialsWithIAM service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The requested operation isn't supported. /// /// REST API Reference for GetClusterCredentialsWithIAM Operation public virtual Task GetClusterCredentialsWithIAMAsync(GetClusterCredentialsWithIAMRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetClusterCredentialsWithIAMRequestMarshaller.Instance; options.ResponseUnmarshaller = GetClusterCredentialsWithIAMResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetReservedNodeExchangeConfigurationOptions ///

/// 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. ///

/// Container for the necessary parameters to execute the GetReservedNodeExchangeConfigurationOptions service method. /// /// The response from the GetReservedNodeExchangeConfigurationOptions service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The snapshot identifier does not refer to an existing cluster snapshot. /// /// /// Your request cannot be completed because a dependent internal service is temporarily /// unavailable. Wait 30 to 60 seconds and try again. /// /// /// Indicates that the Reserved Node being exchanged is not in an active state. /// /// /// Indicates that the reserved node has already been exchanged. /// /// /// The specified reserved compute node not found. /// /// /// Specified offering does not exist. /// /// /// The requested operation isn't supported. /// /// REST API Reference for GetReservedNodeExchangeConfigurationOptions Operation public virtual GetReservedNodeExchangeConfigurationOptionsResponse GetReservedNodeExchangeConfigurationOptions(GetReservedNodeExchangeConfigurationOptionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetReservedNodeExchangeConfigurationOptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetReservedNodeExchangeConfigurationOptionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the GetReservedNodeExchangeConfigurationOptions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetReservedNodeExchangeConfigurationOptions service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The snapshot identifier does not refer to an existing cluster snapshot. /// /// /// Your request cannot be completed because a dependent internal service is temporarily /// unavailable. Wait 30 to 60 seconds and try again. /// /// /// Indicates that the Reserved Node being exchanged is not in an active state. /// /// /// Indicates that the reserved node has already been exchanged. /// /// /// The specified reserved compute node not found. /// /// /// Specified offering does not exist. /// /// /// The requested operation isn't supported. /// /// REST API Reference for GetReservedNodeExchangeConfigurationOptions Operation public virtual Task GetReservedNodeExchangeConfigurationOptionsAsync(GetReservedNodeExchangeConfigurationOptionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetReservedNodeExchangeConfigurationOptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetReservedNodeExchangeConfigurationOptionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetReservedNodeExchangeOfferings ///

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

/// Container for the necessary parameters to execute the GetReservedNodeExchangeOfferings service method. /// /// The response from the GetReservedNodeExchangeOfferings service method, as returned by Redshift. /// /// Your request cannot be completed because a dependent internal service is temporarily /// unavailable. Wait 30 to 60 seconds and try again. /// /// /// Indicates that the Reserved Node being exchanged is not in an active state. /// /// /// Indicates that the reserved node has already been exchanged. /// /// /// The specified reserved compute node not found. /// /// /// Specified offering does not exist. /// /// /// The requested operation isn't supported. /// /// REST API Reference for GetReservedNodeExchangeOfferings Operation public virtual GetReservedNodeExchangeOfferingsResponse GetReservedNodeExchangeOfferings(GetReservedNodeExchangeOfferingsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetReservedNodeExchangeOfferingsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetReservedNodeExchangeOfferingsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the GetReservedNodeExchangeOfferings service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetReservedNodeExchangeOfferings service method, as returned by Redshift. /// /// Your request cannot be completed because a dependent internal service is temporarily /// unavailable. Wait 30 to 60 seconds and try again. /// /// /// Indicates that the Reserved Node being exchanged is not in an active state. /// /// /// Indicates that the reserved node has already been exchanged. /// /// /// The specified reserved compute node not found. /// /// /// Specified offering does not exist. /// /// /// The requested operation isn't supported. /// /// REST API Reference for GetReservedNodeExchangeOfferings Operation public virtual Task GetReservedNodeExchangeOfferingsAsync(GetReservedNodeExchangeOfferingsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetReservedNodeExchangeOfferingsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetReservedNodeExchangeOfferingsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyAquaConfiguration ///

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

/// Container for the necessary parameters to execute the ModifyAquaConfiguration service method. /// /// The response from the ModifyAquaConfiguration service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The specified cluster is not in the available state. /// /// /// The requested operation isn't supported. /// /// REST API Reference for ModifyAquaConfiguration Operation public virtual ModifyAquaConfigurationResponse ModifyAquaConfiguration(ModifyAquaConfigurationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyAquaConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyAquaConfigurationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the ModifyAquaConfiguration service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyAquaConfiguration service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The specified cluster is not in the available state. /// /// /// The requested operation isn't supported. /// /// REST API Reference for ModifyAquaConfiguration Operation public virtual Task ModifyAquaConfigurationAsync(ModifyAquaConfigurationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyAquaConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyAquaConfigurationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyAuthenticationProfile ///

/// Modifies an authentication profile. ///

/// Container for the necessary parameters to execute the ModifyAuthenticationProfile service method. /// /// The response from the ModifyAuthenticationProfile service method, as returned by Redshift. /// /// The authentication profile can't be found. /// /// /// The size or number of authentication profiles has exceeded the quota. The maximum /// length of the JSON string and maximum number of authentication profiles is determined /// by a quota for your account. /// /// /// The authentication profile request is not valid. The profile name can't be null or /// empty. The authentication profile API operation must be available in the Amazon Web /// Services Region. /// /// REST API Reference for ModifyAuthenticationProfile Operation public virtual ModifyAuthenticationProfileResponse ModifyAuthenticationProfile(ModifyAuthenticationProfileRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyAuthenticationProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyAuthenticationProfileResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Modifies an authentication profile. ///

/// Container for the necessary parameters to execute the ModifyAuthenticationProfile service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyAuthenticationProfile service method, as returned by Redshift. /// /// The authentication profile can't be found. /// /// /// The size or number of authentication profiles has exceeded the quota. The maximum /// length of the JSON string and maximum number of authentication profiles is determined /// by a quota for your account. /// /// /// The authentication profile request is not valid. The profile name can't be null or /// empty. The authentication profile API operation must be available in the Amazon Web /// Services Region. /// /// REST API Reference for ModifyAuthenticationProfile Operation public virtual Task ModifyAuthenticationProfileAsync(ModifyAuthenticationProfileRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyAuthenticationProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyAuthenticationProfileResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyCluster ///

/// 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. /// ///

/// Container for the necessary parameters to execute the ModifyCluster service method. /// /// The response from the ModifyCluster service method, as returned by Redshift. /// /// The account already has a cluster with the given identifier. /// /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The parameter group name does not refer to an existing parameter group. /// /// /// The cluster security group name does not refer to an existing cluster security group. /// /// /// An error occurred when an attempt was made to change the custom domain association. /// /// /// The request cannot be completed because a dependent service is throttling requests /// made by Amazon Redshift on your behalf. Wait and retry the request. /// /// /// There is no Amazon Redshift HSM client certificate with the specified identifier. /// /// /// There is no Amazon Redshift HSM configuration with the specified identifier. /// /// /// The number of nodes specified exceeds the allotted capacity of the cluster. /// /// /// The state of the cluster security group is not available. /// /// /// The specified cluster is not in the available state. /// /// /// The provided cluster track name is not valid. /// /// /// The Elastic IP (EIP) is invalid or cannot be found. /// /// /// The retention period specified is either in the past or is not a valid value. /// /// /// /// The value must be either -1 or an integer between 1 and 3,653. /// /// /// /// The encryption key has exceeded its grant limit in Amazon Web Services KMS. /// /// /// The operation would exceed the number of nodes allowed for a cluster. /// /// /// The operation would exceed the number of nodes allotted to the account. For information /// about increasing your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// The number of tables in the cluster exceeds the limit for the requested new cluster /// node type. /// /// /// Your account is not authorized to perform the requested operation. /// /// /// The requested operation isn't supported. /// /// /// A request option was specified that is not supported. /// /// REST API Reference for ModifyCluster Operation public virtual ModifyClusterResponse ModifyCluster(ModifyClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the ModifyCluster service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyCluster service method, as returned by Redshift. /// /// The account already has a cluster with the given identifier. /// /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The parameter group name does not refer to an existing parameter group. /// /// /// The cluster security group name does not refer to an existing cluster security group. /// /// /// An error occurred when an attempt was made to change the custom domain association. /// /// /// The request cannot be completed because a dependent service is throttling requests /// made by Amazon Redshift on your behalf. Wait and retry the request. /// /// /// There is no Amazon Redshift HSM client certificate with the specified identifier. /// /// /// There is no Amazon Redshift HSM configuration with the specified identifier. /// /// /// The number of nodes specified exceeds the allotted capacity of the cluster. /// /// /// The state of the cluster security group is not available. /// /// /// The specified cluster is not in the available state. /// /// /// The provided cluster track name is not valid. /// /// /// The Elastic IP (EIP) is invalid or cannot be found. /// /// /// The retention period specified is either in the past or is not a valid value. /// /// /// /// The value must be either -1 or an integer between 1 and 3,653. /// /// /// /// The encryption key has exceeded its grant limit in Amazon Web Services KMS. /// /// /// The operation would exceed the number of nodes allowed for a cluster. /// /// /// The operation would exceed the number of nodes allotted to the account. For information /// about increasing your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// The number of tables in the cluster exceeds the limit for the requested new cluster /// node type. /// /// /// Your account is not authorized to perform the requested operation. /// /// /// The requested operation isn't supported. /// /// /// A request option was specified that is not supported. /// /// REST API Reference for ModifyCluster Operation public virtual Task ModifyClusterAsync(ModifyClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyClusterResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyClusterDbRevision ///

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

/// Container for the necessary parameters to execute the ModifyClusterDbRevision service method. /// /// The response from the ModifyClusterDbRevision service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// Cluster is already on the latest database revision. /// /// /// The specified cluster is not in the available state. /// /// REST API Reference for ModifyClusterDbRevision Operation public virtual ModifyClusterDbRevisionResponse ModifyClusterDbRevision(ModifyClusterDbRevisionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyClusterDbRevisionRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyClusterDbRevisionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the ModifyClusterDbRevision service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyClusterDbRevision service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// Cluster is already on the latest database revision. /// /// /// The specified cluster is not in the available state. /// /// REST API Reference for ModifyClusterDbRevision Operation public virtual Task ModifyClusterDbRevisionAsync(ModifyClusterDbRevisionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyClusterDbRevisionRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyClusterDbRevisionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyClusterIamRoles ///

/// 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. /// ///

/// Container for the necessary parameters to execute the ModifyClusterIamRoles service method. /// /// The response from the ModifyClusterIamRoles service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The specified cluster is not in the available state. /// /// REST API Reference for ModifyClusterIamRoles Operation public virtual ModifyClusterIamRolesResponse ModifyClusterIamRoles(ModifyClusterIamRolesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyClusterIamRolesRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyClusterIamRolesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the ModifyClusterIamRoles service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyClusterIamRoles service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The specified cluster is not in the available state. /// /// REST API Reference for ModifyClusterIamRoles Operation public virtual Task ModifyClusterIamRolesAsync(ModifyClusterIamRolesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyClusterIamRolesRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyClusterIamRolesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyClusterMaintenance ///

/// Modifies the maintenance settings of a cluster. ///

/// Container for the necessary parameters to execute the ModifyClusterMaintenance service method. /// /// The response from the ModifyClusterMaintenance service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The specified cluster is not in the available state. /// /// REST API Reference for ModifyClusterMaintenance Operation public virtual ModifyClusterMaintenanceResponse ModifyClusterMaintenance(ModifyClusterMaintenanceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyClusterMaintenanceRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyClusterMaintenanceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Modifies the maintenance settings of a cluster. ///

/// Container for the necessary parameters to execute the ModifyClusterMaintenance service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyClusterMaintenance service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The specified cluster is not in the available state. /// /// REST API Reference for ModifyClusterMaintenance Operation public virtual Task ModifyClusterMaintenanceAsync(ModifyClusterMaintenanceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyClusterMaintenanceRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyClusterMaintenanceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyClusterParameterGroup ///

/// 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. /// ///

/// Container for the necessary parameters to execute the ModifyClusterParameterGroup service method. /// /// The response from the ModifyClusterParameterGroup service method, as returned by Redshift. /// /// The parameter group name does not refer to an existing parameter group. /// /// /// The cluster parameter group action can not be completed because another task is in /// progress that involves the parameter group. Wait a few moments and try the operation /// again. /// /// REST API Reference for ModifyClusterParameterGroup Operation public virtual ModifyClusterParameterGroupResponse ModifyClusterParameterGroup(ModifyClusterParameterGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyClusterParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyClusterParameterGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the ModifyClusterParameterGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyClusterParameterGroup service method, as returned by Redshift. /// /// The parameter group name does not refer to an existing parameter group. /// /// /// The cluster parameter group action can not be completed because another task is in /// progress that involves the parameter group. Wait a few moments and try the operation /// again. /// /// REST API Reference for ModifyClusterParameterGroup Operation public virtual Task ModifyClusterParameterGroupAsync(ModifyClusterParameterGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyClusterParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyClusterParameterGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyClusterSnapshot ///

/// Modifies the settings for a snapshot. /// /// /// /// This exanmple modifies the manual retention period setting for a cluster snapshot. /// ///

/// Container for the necessary parameters to execute the ModifyClusterSnapshot service method. /// /// The response from the ModifyClusterSnapshot service method, as returned by Redshift. /// /// The snapshot identifier does not refer to an existing cluster snapshot. /// /// /// The specified cluster snapshot is not in the available state, or other /// accounts are authorized to access the snapshot. /// /// /// The retention period specified is either in the past or is not a valid value. /// /// /// /// The value must be either -1 or an integer between 1 and 3,653. /// /// /// REST API Reference for ModifyClusterSnapshot Operation public virtual ModifyClusterSnapshotResponse ModifyClusterSnapshot(ModifyClusterSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyClusterSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyClusterSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Modifies the settings for a snapshot. /// /// /// /// This exanmple modifies the manual retention period setting for a cluster snapshot. /// ///

/// Container for the necessary parameters to execute the ModifyClusterSnapshot service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyClusterSnapshot service method, as returned by Redshift. /// /// The snapshot identifier does not refer to an existing cluster snapshot. /// /// /// The specified cluster snapshot is not in the available state, or other /// accounts are authorized to access the snapshot. /// /// /// The retention period specified is either in the past or is not a valid value. /// /// /// /// The value must be either -1 or an integer between 1 and 3,653. /// /// /// REST API Reference for ModifyClusterSnapshot Operation public virtual Task ModifyClusterSnapshotAsync(ModifyClusterSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyClusterSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyClusterSnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyClusterSnapshotSchedule ///

/// Modifies a snapshot schedule for a cluster. ///

/// Container for the necessary parameters to execute the ModifyClusterSnapshotSchedule service method. /// /// The response from the ModifyClusterSnapshotSchedule service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The cluster snapshot schedule state is not valid. /// /// /// We could not find the specified snapshot schedule. /// /// REST API Reference for ModifyClusterSnapshotSchedule Operation public virtual ModifyClusterSnapshotScheduleResponse ModifyClusterSnapshotSchedule(ModifyClusterSnapshotScheduleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyClusterSnapshotScheduleRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyClusterSnapshotScheduleResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Modifies a snapshot schedule for a cluster. ///

/// Container for the necessary parameters to execute the ModifyClusterSnapshotSchedule service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyClusterSnapshotSchedule service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The cluster snapshot schedule state is not valid. /// /// /// We could not find the specified snapshot schedule. /// /// REST API Reference for ModifyClusterSnapshotSchedule Operation public virtual Task ModifyClusterSnapshotScheduleAsync(ModifyClusterSnapshotScheduleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyClusterSnapshotScheduleRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyClusterSnapshotScheduleResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyClusterSubnetGroup ///

/// 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. ///

/// Container for the necessary parameters to execute the ModifyClusterSubnetGroup service method. /// /// The response from the ModifyClusterSubnetGroup service method, as returned by Redshift. /// /// The cluster subnet group name does not refer to an existing cluster subnet group. /// /// /// The request would result in user exceeding the allowed number of subnets in a cluster /// subnet groups. For information about increasing your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// The request cannot be completed because a dependent service is throttling requests /// made by Amazon Redshift on your behalf. Wait and retry the request. /// /// /// The requested subnet is not valid, or not all of the subnets are in the same VPC. /// /// /// A specified subnet is already in use by another cluster. /// /// /// Your account is not authorized to perform the requested operation. /// /// REST API Reference for ModifyClusterSubnetGroup Operation public virtual ModifyClusterSubnetGroupResponse ModifyClusterSubnetGroup(ModifyClusterSubnetGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyClusterSubnetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyClusterSubnetGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// Container for the necessary parameters to execute the ModifyClusterSubnetGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyClusterSubnetGroup service method, as returned by Redshift. /// /// The cluster subnet group name does not refer to an existing cluster subnet group. /// /// /// The request would result in user exceeding the allowed number of subnets in a cluster /// subnet groups. For information about increasing your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// The request cannot be completed because a dependent service is throttling requests /// made by Amazon Redshift on your behalf. Wait and retry the request. /// /// /// The requested subnet is not valid, or not all of the subnets are in the same VPC. /// /// /// A specified subnet is already in use by another cluster. /// /// /// Your account is not authorized to perform the requested operation. /// /// REST API Reference for ModifyClusterSubnetGroup Operation public virtual Task ModifyClusterSubnetGroupAsync(ModifyClusterSubnetGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyClusterSubnetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyClusterSubnetGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyCustomDomainAssociation ///

/// Contains information for changing a custom domain association. ///

/// Container for the necessary parameters to execute the ModifyCustomDomainAssociation service method. /// /// The response from the ModifyCustomDomainAssociation service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// An error occurred when an attempt was made to change the custom domain association. /// /// /// The requested operation isn't supported. /// /// REST API Reference for ModifyCustomDomainAssociation Operation public virtual ModifyCustomDomainAssociationResponse ModifyCustomDomainAssociation(ModifyCustomDomainAssociationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyCustomDomainAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyCustomDomainAssociationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Contains information for changing a custom domain association. ///

/// Container for the necessary parameters to execute the ModifyCustomDomainAssociation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyCustomDomainAssociation service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// An error occurred when an attempt was made to change the custom domain association. /// /// /// The requested operation isn't supported. /// /// REST API Reference for ModifyCustomDomainAssociation Operation public virtual Task ModifyCustomDomainAssociationAsync(ModifyCustomDomainAssociationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyCustomDomainAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyCustomDomainAssociationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyEndpointAccess ///

/// Modifies a Redshift-managed VPC endpoint. ///

/// Container for the necessary parameters to execute the ModifyEndpointAccess service method. /// /// The response from the ModifyEndpointAccess service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The endpoint name doesn't refer to an existing endpoint. /// /// /// The state of the cluster security group is not available. /// /// /// The specified cluster is not in the available state. /// /// /// The status of the endpoint is not valid. /// /// /// Your account is not authorized to perform the requested operation. /// /// REST API Reference for ModifyEndpointAccess Operation public virtual ModifyEndpointAccessResponse ModifyEndpointAccess(ModifyEndpointAccessRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyEndpointAccessResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Modifies a Redshift-managed VPC endpoint. ///

/// Container for the necessary parameters to execute the ModifyEndpointAccess service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyEndpointAccess service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The endpoint name doesn't refer to an existing endpoint. /// /// /// The state of the cluster security group is not available. /// /// /// The specified cluster is not in the available state. /// /// /// The status of the endpoint is not valid. /// /// /// Your account is not authorized to perform the requested operation. /// /// REST API Reference for ModifyEndpointAccess Operation public virtual Task ModifyEndpointAccessAsync(ModifyEndpointAccessRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyEndpointAccessResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyEventSubscription ///

/// Modifies an existing Amazon Redshift event notification subscription. ///

/// Container for the necessary parameters to execute the ModifyEventSubscription service method. /// /// The response from the ModifyEventSubscription service method, as returned by Redshift. /// /// The subscription request is invalid because it is a duplicate request. This subscription /// request is already in progress. /// /// /// Amazon SNS has responded that there is a problem with the specified Amazon SNS topic. /// /// /// You do not have permission to publish to the specified Amazon SNS topic. /// /// /// An Amazon SNS topic with the specified Amazon Resource Name (ARN) does not exist. /// /// /// The specified Amazon Redshift event source could not be found. /// /// /// The value specified for the event category was not one of the allowed values, or it /// specified a category that does not apply to the specified source type. The allowed /// values are Configuration, Management, Monitoring, and Security. /// /// /// An Amazon Redshift event with the specified event ID does not exist. /// /// /// An Amazon Redshift event notification subscription with the specified name does not /// exist. /// /// /// The value specified for the event severity was not one of the allowed values, or it /// specified a severity that does not apply to the specified source type. The allowed /// values are ERROR and INFO. /// /// REST API Reference for ModifyEventSubscription Operation public virtual ModifyEventSubscriptionResponse ModifyEventSubscription(ModifyEventSubscriptionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyEventSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyEventSubscriptionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Modifies an existing Amazon Redshift event notification subscription. ///

/// Container for the necessary parameters to execute the ModifyEventSubscription service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyEventSubscription service method, as returned by Redshift. /// /// The subscription request is invalid because it is a duplicate request. This subscription /// request is already in progress. /// /// /// Amazon SNS has responded that there is a problem with the specified Amazon SNS topic. /// /// /// You do not have permission to publish to the specified Amazon SNS topic. /// /// /// An Amazon SNS topic with the specified Amazon Resource Name (ARN) does not exist. /// /// /// The specified Amazon Redshift event source could not be found. /// /// /// The value specified for the event category was not one of the allowed values, or it /// specified a category that does not apply to the specified source type. The allowed /// values are Configuration, Management, Monitoring, and Security. /// /// /// An Amazon Redshift event with the specified event ID does not exist. /// /// /// An Amazon Redshift event notification subscription with the specified name does not /// exist. /// /// /// The value specified for the event severity was not one of the allowed values, or it /// specified a severity that does not apply to the specified source type. The allowed /// values are ERROR and INFO. /// /// REST API Reference for ModifyEventSubscription Operation public virtual Task ModifyEventSubscriptionAsync(ModifyEventSubscriptionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyEventSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyEventSubscriptionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyScheduledAction ///

/// Modifies a scheduled action. ///

/// Container for the necessary parameters to execute the ModifyScheduledAction service method. /// /// The response from the ModifyScheduledAction service method, as returned by Redshift. /// /// The scheduled action is not valid. /// /// /// The schedule you submitted isn't valid. /// /// /// The scheduled action cannot be found. /// /// /// The action type specified for a scheduled action is not supported. /// /// /// Your account is not authorized to perform the requested operation. /// /// REST API Reference for ModifyScheduledAction Operation public virtual ModifyScheduledActionResponse ModifyScheduledAction(ModifyScheduledActionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyScheduledActionRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyScheduledActionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Modifies a scheduled action. ///

/// Container for the necessary parameters to execute the ModifyScheduledAction service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyScheduledAction service method, as returned by Redshift. /// /// The scheduled action is not valid. /// /// /// The schedule you submitted isn't valid. /// /// /// The scheduled action cannot be found. /// /// /// The action type specified for a scheduled action is not supported. /// /// /// Your account is not authorized to perform the requested operation. /// /// REST API Reference for ModifyScheduledAction Operation public virtual Task ModifyScheduledActionAsync(ModifyScheduledActionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyScheduledActionRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyScheduledActionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifySnapshotCopyRetentionPeriod ///

/// 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. ///

/// Container for the necessary parameters to execute the ModifySnapshotCopyRetentionPeriod service method. /// /// The response from the ModifySnapshotCopyRetentionPeriod service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The specified cluster is not in the available state. /// /// /// The retention period specified is either in the past or is not a valid value. /// /// /// /// The value must be either -1 or an integer between 1 and 3,653. /// /// /// /// Cross-region snapshot copy was temporarily disabled. Try your request again. /// /// /// Your account is not authorized to perform the requested operation. /// /// REST API Reference for ModifySnapshotCopyRetentionPeriod Operation public virtual ModifySnapshotCopyRetentionPeriodResponse ModifySnapshotCopyRetentionPeriod(ModifySnapshotCopyRetentionPeriodRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifySnapshotCopyRetentionPeriodRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifySnapshotCopyRetentionPeriodResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the ModifySnapshotCopyRetentionPeriod service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifySnapshotCopyRetentionPeriod service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The specified cluster is not in the available state. /// /// /// The retention period specified is either in the past or is not a valid value. /// /// /// /// The value must be either -1 or an integer between 1 and 3,653. /// /// /// /// Cross-region snapshot copy was temporarily disabled. Try your request again. /// /// /// Your account is not authorized to perform the requested operation. /// /// REST API Reference for ModifySnapshotCopyRetentionPeriod Operation public virtual Task ModifySnapshotCopyRetentionPeriodAsync(ModifySnapshotCopyRetentionPeriodRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifySnapshotCopyRetentionPeriodRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifySnapshotCopyRetentionPeriodResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifySnapshotSchedule ///

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

/// Container for the necessary parameters to execute the ModifySnapshotSchedule service method. /// /// The response from the ModifySnapshotSchedule service method, as returned by Redshift. /// /// The schedule you submitted isn't valid. /// /// /// We could not find the specified snapshot schedule. /// /// /// The specified snapshot schedule is already being updated. /// /// REST API Reference for ModifySnapshotSchedule Operation public virtual ModifySnapshotScheduleResponse ModifySnapshotSchedule(ModifySnapshotScheduleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifySnapshotScheduleRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifySnapshotScheduleResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the ModifySnapshotSchedule service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifySnapshotSchedule service method, as returned by Redshift. /// /// The schedule you submitted isn't valid. /// /// /// We could not find the specified snapshot schedule. /// /// /// The specified snapshot schedule is already being updated. /// /// REST API Reference for ModifySnapshotSchedule Operation public virtual Task ModifySnapshotScheduleAsync(ModifySnapshotScheduleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifySnapshotScheduleRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifySnapshotScheduleResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyUsageLimit ///

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

/// Container for the necessary parameters to execute the ModifyUsageLimit service method. /// /// The response from the ModifyUsageLimit service method, as returned by Redshift. /// /// The usage limit is not valid. /// /// /// The requested operation isn't supported. /// /// /// The usage limit identifier can't be found. /// /// REST API Reference for ModifyUsageLimit Operation public virtual ModifyUsageLimitResponse ModifyUsageLimit(ModifyUsageLimitRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyUsageLimitRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyUsageLimitResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the ModifyUsageLimit service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyUsageLimit service method, as returned by Redshift. /// /// The usage limit is not valid. /// /// /// The requested operation isn't supported. /// /// /// The usage limit identifier can't be found. /// /// REST API Reference for ModifyUsageLimit Operation public virtual Task ModifyUsageLimitAsync(ModifyUsageLimitRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyUsageLimitRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyUsageLimitResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region PauseCluster ///

/// Pauses a cluster. ///

/// Container for the necessary parameters to execute the PauseCluster service method. /// /// The response from the PauseCluster service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The specified cluster is not in the available state. /// /// REST API Reference for PauseCluster Operation public virtual PauseClusterResponse PauseCluster(PauseClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = PauseClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = PauseClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Pauses a cluster. ///

/// Container for the necessary parameters to execute the PauseCluster service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the PauseCluster service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The specified cluster is not in the available state. /// /// REST API Reference for PauseCluster Operation public virtual Task PauseClusterAsync(PauseClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = PauseClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = PauseClusterResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region PurchaseReservedNodeOffering ///

/// 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. /// ///

/// Container for the necessary parameters to execute the PurchaseReservedNodeOffering service method. /// /// The response from the PurchaseReservedNodeOffering service method, as returned by Redshift. /// /// User already has a reservation with the given identifier. /// /// /// Specified offering does not exist. /// /// /// Request would exceed the user's compute node quota. For information about increasing /// your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// The requested operation isn't supported. /// /// REST API Reference for PurchaseReservedNodeOffering Operation public virtual PurchaseReservedNodeOfferingResponse PurchaseReservedNodeOffering(PurchaseReservedNodeOfferingRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = PurchaseReservedNodeOfferingRequestMarshaller.Instance; options.ResponseUnmarshaller = PurchaseReservedNodeOfferingResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the PurchaseReservedNodeOffering service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the PurchaseReservedNodeOffering service method, as returned by Redshift. /// /// User already has a reservation with the given identifier. /// /// /// Specified offering does not exist. /// /// /// Request would exceed the user's compute node quota. For information about increasing /// your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// The requested operation isn't supported. /// /// REST API Reference for PurchaseReservedNodeOffering Operation public virtual Task PurchaseReservedNodeOfferingAsync(PurchaseReservedNodeOfferingRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = PurchaseReservedNodeOfferingRequestMarshaller.Instance; options.ResponseUnmarshaller = PurchaseReservedNodeOfferingResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RebootCluster ///

/// 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. ///

/// Container for the necessary parameters to execute the RebootCluster service method. /// /// The response from the RebootCluster service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The specified cluster is not in the available state. /// /// REST API Reference for RebootCluster Operation public virtual RebootClusterResponse RebootCluster(RebootClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RebootClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = RebootClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the RebootCluster service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RebootCluster service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The specified cluster is not in the available state. /// /// REST API Reference for RebootCluster Operation public virtual Task RebootClusterAsync(RebootClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RebootClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = RebootClusterResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RejectDataShare ///

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

/// Container for the necessary parameters to execute the RejectDataShare service method. /// /// The response from the RejectDataShare service method, as returned by Redshift. /// /// There is an error with the datashare. /// /// REST API Reference for RejectDataShare Operation public virtual RejectDataShareResponse RejectDataShare(RejectDataShareRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RejectDataShareRequestMarshaller.Instance; options.ResponseUnmarshaller = RejectDataShareResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the RejectDataShare service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RejectDataShare service method, as returned by Redshift. /// /// There is an error with the datashare. /// /// REST API Reference for RejectDataShare Operation public virtual Task RejectDataShareAsync(RejectDataShareRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RejectDataShareRequestMarshaller.Instance; options.ResponseUnmarshaller = RejectDataShareResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ResetClusterParameterGroup ///

/// 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. ///

/// Container for the necessary parameters to execute the ResetClusterParameterGroup service method. /// /// The response from the ResetClusterParameterGroup service method, as returned by Redshift. /// /// The parameter group name does not refer to an existing parameter group. /// /// /// The cluster parameter group action can not be completed because another task is in /// progress that involves the parameter group. Wait a few moments and try the operation /// again. /// /// REST API Reference for ResetClusterParameterGroup Operation public virtual ResetClusterParameterGroupResponse ResetClusterParameterGroup(ResetClusterParameterGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ResetClusterParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = ResetClusterParameterGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the ResetClusterParameterGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ResetClusterParameterGroup service method, as returned by Redshift. /// /// The parameter group name does not refer to an existing parameter group. /// /// /// The cluster parameter group action can not be completed because another task is in /// progress that involves the parameter group. Wait a few moments and try the operation /// again. /// /// REST API Reference for ResetClusterParameterGroup Operation public virtual Task ResetClusterParameterGroupAsync(ResetClusterParameterGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ResetClusterParameterGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = ResetClusterParameterGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ResizeCluster ///

/// 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. /// ///

///

/// Container for the necessary parameters to execute the ResizeCluster service method. /// /// The response from the ResizeCluster service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// Your request cannot be completed because a dependent internal service is temporarily /// unavailable. Wait 30 to 60 seconds and try again. /// /// /// The number of nodes specified exceeds the allotted capacity of the cluster. /// /// /// The specified cluster is not in the available state. /// /// /// Indicates that the Reserved Node being exchanged is not in an active state. /// /// /// The encryption key has exceeded its grant limit in Amazon Web Services KMS. /// /// /// The operation would exceed the number of nodes allowed for a cluster. /// /// /// The operation would exceed the number of nodes allotted to the account. For information /// about increasing your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// User already has a reservation with the given identifier. /// /// /// Indicates that the reserved node has already been exchanged. /// /// /// The specified reserved compute node not found. /// /// /// Specified offering does not exist. /// /// /// Your account is not authorized to perform the requested operation. /// /// /// The requested operation isn't supported. /// /// /// A request option was specified that is not supported. /// /// REST API Reference for ResizeCluster Operation public virtual ResizeClusterResponse ResizeCluster(ResizeClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ResizeClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = ResizeClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// /// 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. /// ///

///

/// Container for the necessary parameters to execute the ResizeCluster service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ResizeCluster service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// Your request cannot be completed because a dependent internal service is temporarily /// unavailable. Wait 30 to 60 seconds and try again. /// /// /// The number of nodes specified exceeds the allotted capacity of the cluster. /// /// /// The specified cluster is not in the available state. /// /// /// Indicates that the Reserved Node being exchanged is not in an active state. /// /// /// The encryption key has exceeded its grant limit in Amazon Web Services KMS. /// /// /// The operation would exceed the number of nodes allowed for a cluster. /// /// /// The operation would exceed the number of nodes allotted to the account. For information /// about increasing your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// User already has a reservation with the given identifier. /// /// /// Indicates that the reserved node has already been exchanged. /// /// /// The specified reserved compute node not found. /// /// /// Specified offering does not exist. /// /// /// Your account is not authorized to perform the requested operation. /// /// /// The requested operation isn't supported. /// /// /// A request option was specified that is not supported. /// /// REST API Reference for ResizeCluster Operation public virtual Task ResizeClusterAsync(ResizeClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ResizeClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = ResizeClusterResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RestoreFromClusterSnapshot ///

/// 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. /// ///

/// Container for the necessary parameters to execute the RestoreFromClusterSnapshot service method. /// /// The response from the RestoreFromClusterSnapshot service method, as returned by Redshift. /// /// The owner of the specified snapshot has not authorized your account to access the /// snapshot. /// /// /// The account already has a cluster with the given identifier. /// /// /// The parameter group name does not refer to an existing parameter group. /// /// /// The request would exceed the allowed number of cluster instances for this account. /// For information about increasing your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// The cluster security group name does not refer to an existing cluster security group. /// /// /// The snapshot identifier does not refer to an existing cluster snapshot. /// /// /// The cluster subnet group name does not refer to an existing cluster subnet group. /// /// /// The request cannot be completed because a dependent service is throttling requests /// made by Amazon Redshift on your behalf. Wait and retry the request. /// /// /// Your request cannot be completed because a dependent internal service is temporarily /// unavailable. Wait 30 to 60 seconds and try again. /// /// /// There is no Amazon Redshift HSM client certificate with the specified identifier. /// /// /// There is no Amazon Redshift HSM configuration with the specified identifier. /// /// /// The number of nodes specified exceeds the allotted capacity of the cluster. /// /// /// The specified cluster snapshot is not in the available state, or other /// accounts are authorized to access the snapshot. /// /// /// The cluster subnet group cannot be deleted because it is in use. /// /// /// The provided cluster track name is not valid. /// /// /// The Elastic IP (EIP) is invalid or cannot be found. /// /// /// Indicates that the Reserved Node being exchanged is not in an active state. /// /// /// The restore is invalid. /// /// /// The requested subnet is not valid, or not all of the subnets are in the same VPC. /// /// /// The tag is invalid. /// /// /// The cluster subnet group does not cover all Availability Zones. /// /// /// The encryption key has exceeded its grant limit in Amazon Web Services KMS. /// /// /// The operation would exceed the number of nodes allowed for a cluster. /// /// /// The operation would exceed the number of nodes allotted to the account. For information /// about increasing your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// User already has a reservation with the given identifier. /// /// /// Indicates that the reserved node has already been exchanged. /// /// /// The specified reserved compute node not found. /// /// /// Specified offering does not exist. /// /// /// We could not find the specified snapshot schedule. /// /// /// You have exceeded the number of tags allowed. /// /// /// Your account is not authorized to perform the requested operation. /// /// /// The requested operation isn't supported. /// /// REST API Reference for RestoreFromClusterSnapshot Operation public virtual RestoreFromClusterSnapshotResponse RestoreFromClusterSnapshot(RestoreFromClusterSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreFromClusterSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreFromClusterSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the RestoreFromClusterSnapshot service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RestoreFromClusterSnapshot service method, as returned by Redshift. /// /// The owner of the specified snapshot has not authorized your account to access the /// snapshot. /// /// /// The account already has a cluster with the given identifier. /// /// /// The parameter group name does not refer to an existing parameter group. /// /// /// The request would exceed the allowed number of cluster instances for this account. /// For information about increasing your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// The cluster security group name does not refer to an existing cluster security group. /// /// /// The snapshot identifier does not refer to an existing cluster snapshot. /// /// /// The cluster subnet group name does not refer to an existing cluster subnet group. /// /// /// The request cannot be completed because a dependent service is throttling requests /// made by Amazon Redshift on your behalf. Wait and retry the request. /// /// /// Your request cannot be completed because a dependent internal service is temporarily /// unavailable. Wait 30 to 60 seconds and try again. /// /// /// There is no Amazon Redshift HSM client certificate with the specified identifier. /// /// /// There is no Amazon Redshift HSM configuration with the specified identifier. /// /// /// The number of nodes specified exceeds the allotted capacity of the cluster. /// /// /// The specified cluster snapshot is not in the available state, or other /// accounts are authorized to access the snapshot. /// /// /// The cluster subnet group cannot be deleted because it is in use. /// /// /// The provided cluster track name is not valid. /// /// /// The Elastic IP (EIP) is invalid or cannot be found. /// /// /// Indicates that the Reserved Node being exchanged is not in an active state. /// /// /// The restore is invalid. /// /// /// The requested subnet is not valid, or not all of the subnets are in the same VPC. /// /// /// The tag is invalid. /// /// /// The cluster subnet group does not cover all Availability Zones. /// /// /// The encryption key has exceeded its grant limit in Amazon Web Services KMS. /// /// /// The operation would exceed the number of nodes allowed for a cluster. /// /// /// The operation would exceed the number of nodes allotted to the account. For information /// about increasing your quota, go to Limits /// in Amazon Redshift in the Amazon Redshift Cluster Management Guide. /// /// /// User already has a reservation with the given identifier. /// /// /// Indicates that the reserved node has already been exchanged. /// /// /// The specified reserved compute node not found. /// /// /// Specified offering does not exist. /// /// /// We could not find the specified snapshot schedule. /// /// /// You have exceeded the number of tags allowed. /// /// /// Your account is not authorized to perform the requested operation. /// /// /// The requested operation isn't supported. /// /// REST API Reference for RestoreFromClusterSnapshot Operation public virtual Task RestoreFromClusterSnapshotAsync(RestoreFromClusterSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreFromClusterSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreFromClusterSnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RestoreTableFromClusterSnapshot ///

/// 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. /// ///

/// Container for the necessary parameters to execute the RestoreTableFromClusterSnapshot service method. /// /// The response from the RestoreTableFromClusterSnapshot service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The snapshot identifier does not refer to an existing cluster snapshot. /// /// /// You have exceeded the allowed number of table restore requests. Wait for your current /// table restore requests to complete before making a new request. /// /// /// The specified cluster snapshot is not in the available state, or other /// accounts are authorized to access the snapshot. /// /// /// The specified cluster is not in the available state. /// /// /// The value specified for the sourceDatabaseName, sourceSchemaName, /// or sourceTableName parameter, or a combination of these, doesn't exist /// in the snapshot. /// /// /// The requested operation isn't supported. /// /// REST API Reference for RestoreTableFromClusterSnapshot Operation public virtual RestoreTableFromClusterSnapshotResponse RestoreTableFromClusterSnapshot(RestoreTableFromClusterSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreTableFromClusterSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreTableFromClusterSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the RestoreTableFromClusterSnapshot service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RestoreTableFromClusterSnapshot service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The snapshot identifier does not refer to an existing cluster snapshot. /// /// /// You have exceeded the allowed number of table restore requests. Wait for your current /// table restore requests to complete before making a new request. /// /// /// The specified cluster snapshot is not in the available state, or other /// accounts are authorized to access the snapshot. /// /// /// The specified cluster is not in the available state. /// /// /// The value specified for the sourceDatabaseName, sourceSchemaName, /// or sourceTableName parameter, or a combination of these, doesn't exist /// in the snapshot. /// /// /// The requested operation isn't supported. /// /// REST API Reference for RestoreTableFromClusterSnapshot Operation public virtual Task RestoreTableFromClusterSnapshotAsync(RestoreTableFromClusterSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreTableFromClusterSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreTableFromClusterSnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ResumeCluster ///

/// Resumes a paused cluster. ///

/// Container for the necessary parameters to execute the ResumeCluster service method. /// /// The response from the ResumeCluster service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The number of nodes specified exceeds the allotted capacity of the cluster. /// /// /// The specified cluster is not in the available state. /// /// REST API Reference for ResumeCluster Operation public virtual ResumeClusterResponse ResumeCluster(ResumeClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ResumeClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = ResumeClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Resumes a paused cluster. ///

/// Container for the necessary parameters to execute the ResumeCluster service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ResumeCluster service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The number of nodes specified exceeds the allotted capacity of the cluster. /// /// /// The specified cluster is not in the available state. /// /// REST API Reference for ResumeCluster Operation public virtual Task ResumeClusterAsync(ResumeClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ResumeClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = ResumeClusterResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RevokeClusterSecurityGroupIngress ///

/// 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. ///

/// Container for the necessary parameters to execute the RevokeClusterSecurityGroupIngress service method. /// /// The response from the RevokeClusterSecurityGroupIngress service method, as returned by Redshift. /// /// The specified CIDR IP range or EC2 security group is not authorized for the specified /// cluster security group. /// /// /// The cluster security group name does not refer to an existing cluster security group. /// /// /// The state of the cluster security group is not available. /// /// REST API Reference for RevokeClusterSecurityGroupIngress Operation public virtual RevokeClusterSecurityGroupIngressResponse RevokeClusterSecurityGroupIngress(RevokeClusterSecurityGroupIngressRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RevokeClusterSecurityGroupIngressRequestMarshaller.Instance; options.ResponseUnmarshaller = RevokeClusterSecurityGroupIngressResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the RevokeClusterSecurityGroupIngress service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RevokeClusterSecurityGroupIngress service method, as returned by Redshift. /// /// The specified CIDR IP range or EC2 security group is not authorized for the specified /// cluster security group. /// /// /// The cluster security group name does not refer to an existing cluster security group. /// /// /// The state of the cluster security group is not available. /// /// REST API Reference for RevokeClusterSecurityGroupIngress Operation public virtual Task RevokeClusterSecurityGroupIngressAsync(RevokeClusterSecurityGroupIngressRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RevokeClusterSecurityGroupIngressRequestMarshaller.Instance; options.ResponseUnmarshaller = RevokeClusterSecurityGroupIngressResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RevokeEndpointAccess ///

/// Revokes access to a cluster. ///

/// Container for the necessary parameters to execute the RevokeEndpointAccess service method. /// /// The response from the RevokeEndpointAccess service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The authorization for this endpoint can't be found. /// /// /// The endpoint name doesn't refer to an existing endpoint. /// /// /// The status of the authorization is not valid. /// /// /// The state of the cluster security group is not available. /// /// /// The specified cluster is not in the available state. /// /// /// The status of the endpoint is not valid. /// /// REST API Reference for RevokeEndpointAccess Operation public virtual RevokeEndpointAccessResponse RevokeEndpointAccess(RevokeEndpointAccessRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RevokeEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = RevokeEndpointAccessResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Revokes access to a cluster. ///

/// Container for the necessary parameters to execute the RevokeEndpointAccess service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RevokeEndpointAccess service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The authorization for this endpoint can't be found. /// /// /// The endpoint name doesn't refer to an existing endpoint. /// /// /// The status of the authorization is not valid. /// /// /// The state of the cluster security group is not available. /// /// /// The specified cluster is not in the available state. /// /// /// The status of the endpoint is not valid. /// /// REST API Reference for RevokeEndpointAccess Operation public virtual Task RevokeEndpointAccessAsync(RevokeEndpointAccessRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RevokeEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = RevokeEndpointAccessResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RevokeSnapshotAccess ///

/// 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. /// ///

/// Container for the necessary parameters to execute the RevokeSnapshotAccess service method. /// /// The response from the RevokeSnapshotAccess service method, as returned by Redshift. /// /// The owner of the specified snapshot has not authorized your account to access the /// snapshot. /// /// /// The specified CIDR IP range or EC2 security group is not authorized for the specified /// cluster security group. /// /// /// The snapshot identifier does not refer to an existing cluster snapshot. /// /// /// The requested operation isn't supported. /// /// REST API Reference for RevokeSnapshotAccess Operation public virtual RevokeSnapshotAccessResponse RevokeSnapshotAccess(RevokeSnapshotAccessRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RevokeSnapshotAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = RevokeSnapshotAccessResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Container for the necessary parameters to execute the RevokeSnapshotAccess service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RevokeSnapshotAccess service method, as returned by Redshift. /// /// The owner of the specified snapshot has not authorized your account to access the /// snapshot. /// /// /// The specified CIDR IP range or EC2 security group is not authorized for the specified /// cluster security group. /// /// /// The snapshot identifier does not refer to an existing cluster snapshot. /// /// /// The requested operation isn't supported. /// /// REST API Reference for RevokeSnapshotAccess Operation public virtual Task RevokeSnapshotAccessAsync(RevokeSnapshotAccessRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RevokeSnapshotAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = RevokeSnapshotAccessResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RotateEncryptionKey ///

/// Rotates the encryption keys for a cluster. ///

/// Container for the necessary parameters to execute the RotateEncryptionKey service method. /// /// The response from the RotateEncryptionKey service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The request cannot be completed because a dependent service is throttling requests /// made by Amazon Redshift on your behalf. Wait and retry the request. /// /// /// The specified cluster is not in the available state. /// /// REST API Reference for RotateEncryptionKey Operation public virtual RotateEncryptionKeyResponse RotateEncryptionKey(RotateEncryptionKeyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RotateEncryptionKeyRequestMarshaller.Instance; options.ResponseUnmarshaller = RotateEncryptionKeyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Rotates the encryption keys for a cluster. ///

/// Container for the necessary parameters to execute the RotateEncryptionKey service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RotateEncryptionKey service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The request cannot be completed because a dependent service is throttling requests /// made by Amazon Redshift on your behalf. Wait and retry the request. /// /// /// The specified cluster is not in the available state. /// /// REST API Reference for RotateEncryptionKey Operation public virtual Task RotateEncryptionKeyAsync(RotateEncryptionKeyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RotateEncryptionKeyRequestMarshaller.Instance; options.ResponseUnmarshaller = RotateEncryptionKeyResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region UpdatePartnerStatus ///

/// Updates the status of a partner integration. ///

/// Container for the necessary parameters to execute the UpdatePartnerStatus service method. /// /// The response from the UpdatePartnerStatus service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The name of the partner was not found. /// /// /// The partner integration is not authorized. /// /// REST API Reference for UpdatePartnerStatus Operation public virtual UpdatePartnerStatusResponse UpdatePartnerStatus(UpdatePartnerStatusRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdatePartnerStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdatePartnerStatusResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Updates the status of a partner integration. ///

/// Container for the necessary parameters to execute the UpdatePartnerStatus service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the UpdatePartnerStatus service method, as returned by Redshift. /// /// The ClusterIdentifier parameter does not refer to an existing cluster. /// /// /// The name of the partner was not found. /// /// /// The partner integration is not authorized. /// /// REST API Reference for UpdatePartnerStatus Operation public virtual Task UpdatePartnerStatusAsync(UpdatePartnerStatusRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdatePartnerStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdatePartnerStatusResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion } }