@aws-sdk/client-redshift 3.34.0 → 3.37.0

package/dist-types/commands/ModifySnapshotScheduleCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { SnapshotSchedule } from "../models/models_0";
+import { ModifySnapshotScheduleMessage } from "../models/models_1";
+import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
+export interface ModifySnapshotScheduleCommandInput extends ModifySnapshotScheduleMessage {
+}
+export interface ModifySnapshotScheduleCommandOutput extends SnapshotSchedule, __MetadataBearer {
+}
+/**
+ * <p>Modifies a snapshot schedule. Any schedule associated with a cluster is modified
+ *             asynchronously.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftClient, ModifySnapshotScheduleCommand } from "@aws-sdk/client-redshift"; // ES Modules import
+ * // const { RedshiftClient, ModifySnapshotScheduleCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
+ * const client = new RedshiftClient(config);
+ * const command = new ModifySnapshotScheduleCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ModifySnapshotScheduleCommandInput} for command's `input` shape.
+ * @see {@link ModifySnapshotScheduleCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ModifySnapshotScheduleCommand extends $Command<ModifySnapshotScheduleCommandInput, ModifySnapshotScheduleCommandOutput, RedshiftClientResolvedConfig> {
+    readonly input: ModifySnapshotScheduleCommandInput;
+    constructor(input: ModifySnapshotScheduleCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifySnapshotScheduleCommandInput, ModifySnapshotScheduleCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ModifyUsageLimitCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { UsageLimit } from "../models/models_0";
+import { ModifyUsageLimitMessage } from "../models/models_1";
+import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
+export interface ModifyUsageLimitCommandInput extends ModifyUsageLimitMessage {
+}
+export interface ModifyUsageLimitCommandOutput extends UsageLimit, __MetadataBearer {
+}
+/**
+ * <p>Modifies a usage limit in a cluster.
+ *             You can't modify the feature type or period of a usage limit.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftClient, ModifyUsageLimitCommand } from "@aws-sdk/client-redshift"; // ES Modules import
+ * // const { RedshiftClient, ModifyUsageLimitCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
+ * const client = new RedshiftClient(config);
+ * const command = new ModifyUsageLimitCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ModifyUsageLimitCommandInput} for command's `input` shape.
+ * @see {@link ModifyUsageLimitCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ModifyUsageLimitCommand extends $Command<ModifyUsageLimitCommandInput, ModifyUsageLimitCommandOutput, RedshiftClientResolvedConfig> {
+    readonly input: ModifyUsageLimitCommandInput;
+    constructor(input: ModifyUsageLimitCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyUsageLimitCommandInput, ModifyUsageLimitCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/PauseClusterCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { PauseClusterMessage } from "../models/models_0";
+import { PauseClusterResult } from "../models/models_1";
+import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
+export interface PauseClusterCommandInput extends PauseClusterMessage {
+}
+export interface PauseClusterCommandOutput extends PauseClusterResult, __MetadataBearer {
+}
+/**
+ * <p>Pauses a cluster.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftClient, PauseClusterCommand } from "@aws-sdk/client-redshift"; // ES Modules import
+ * // const { RedshiftClient, PauseClusterCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
+ * const client = new RedshiftClient(config);
+ * const command = new PauseClusterCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PauseClusterCommandInput} for command's `input` shape.
+ * @see {@link PauseClusterCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PauseClusterCommand extends $Command<PauseClusterCommandInput, PauseClusterCommandOutput, RedshiftClientResolvedConfig> {
+    readonly input: PauseClusterCommandInput;
+    constructor(input: PauseClusterCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PauseClusterCommandInput, PauseClusterCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/PurchaseReservedNodeOfferingCommand.d.ts

@@ -0,0 +1,43 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { PurchaseReservedNodeOfferingMessage, PurchaseReservedNodeOfferingResult } from "../models/models_1";
+import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
+export interface PurchaseReservedNodeOfferingCommandInput extends PurchaseReservedNodeOfferingMessage {
+}
+export interface PurchaseReservedNodeOfferingCommandOutput extends PurchaseReservedNodeOfferingResult, __MetadataBearer {
+}
+/**
+ * <p>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
+ *                 <a>DescribeReservedNodeOfferings</a> 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. </p>
+ *         <p>
+ * For more information about reserved node offerings, go to
+ * <a href="https://docs.aws.amazon.com/redshift/latest/mgmt/purchase-reserved-node-instance.html">Purchasing Reserved Nodes</a>
+ * in the <i>Amazon Redshift Cluster Management Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftClient, PurchaseReservedNodeOfferingCommand } from "@aws-sdk/client-redshift"; // ES Modules import
+ * // const { RedshiftClient, PurchaseReservedNodeOfferingCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
+ * const client = new RedshiftClient(config);
+ * const command = new PurchaseReservedNodeOfferingCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PurchaseReservedNodeOfferingCommandInput} for command's `input` shape.
+ * @see {@link PurchaseReservedNodeOfferingCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PurchaseReservedNodeOfferingCommand extends $Command<PurchaseReservedNodeOfferingCommandInput, PurchaseReservedNodeOfferingCommandOutput, RedshiftClientResolvedConfig> {
+    readonly input: PurchaseReservedNodeOfferingCommandInput;
+    constructor(input: PurchaseReservedNodeOfferingCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PurchaseReservedNodeOfferingCommandInput, PurchaseReservedNodeOfferingCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RebootClusterCommand.d.ts

@@ -0,0 +1,42 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { RebootClusterMessage, RebootClusterResult } from "../models/models_1";
+import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
+export interface RebootClusterCommandInput extends RebootClusterMessage {
+}
+export interface RebootClusterCommandOutput extends RebootClusterResult, __MetadataBearer {
+}
+/**
+ * <p>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
+ *                 <code>rebooting</code>. A cluster event is created when the reboot is completed. Any
+ *             pending cluster modifications (see <a>ModifyCluster</a>) are applied at this
+ *             reboot.
+ * For more information about managing clusters, go to
+ * <a href="https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-clusters.html">Amazon Redshift Clusters</a>
+ * in the <i>Amazon Redshift Cluster Management Guide</i>. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftClient, RebootClusterCommand } from "@aws-sdk/client-redshift"; // ES Modules import
+ * // const { RedshiftClient, RebootClusterCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
+ * const client = new RedshiftClient(config);
+ * const command = new RebootClusterCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RebootClusterCommandInput} for command's `input` shape.
+ * @see {@link RebootClusterCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RebootClusterCommand extends $Command<RebootClusterCommandInput, RebootClusterCommandOutput, RedshiftClientResolvedConfig> {
+    readonly input: RebootClusterCommandInput;
+    constructor(input: RebootClusterCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RebootClusterCommandInput, RebootClusterCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RejectDataShareCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DataShare } from "../models/models_0";
+import { RejectDataShareMessage } from "../models/models_1";
+import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
+export interface RejectDataShareCommandInput extends RejectDataShareMessage {
+}
+export interface RejectDataShareCommandOutput extends DataShare, __MetadataBearer {
+}
+/**
+ * <p>From the consumer account, rejects the specified datashare.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftClient, RejectDataShareCommand } from "@aws-sdk/client-redshift"; // ES Modules import
+ * // const { RedshiftClient, RejectDataShareCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
+ * const client = new RedshiftClient(config);
+ * const command = new RejectDataShareCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RejectDataShareCommandInput} for command's `input` shape.
+ * @see {@link RejectDataShareCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RejectDataShareCommand extends $Command<RejectDataShareCommandInput, RejectDataShareCommandOutput, RedshiftClientResolvedConfig> {
+    readonly input: RejectDataShareCommandInput;
+    constructor(input: RejectDataShareCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RejectDataShareCommandInput, RejectDataShareCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ResetClusterParameterGroupCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ClusterParameterGroupNameMessage } from "../models/models_0";
+import { ResetClusterParameterGroupMessage } from "../models/models_1";
+import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
+export interface ResetClusterParameterGroupCommandInput extends ResetClusterParameterGroupMessage {
+}
+export interface ResetClusterParameterGroupCommandOutput extends ClusterParameterGroupNameMessage, __MetadataBearer {
+}
+/**
+ * <p>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 <i>ResetAllParameters</i> parameter.
+ *             For parameter changes to take effect you must reboot any associated clusters. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftClient, ResetClusterParameterGroupCommand } from "@aws-sdk/client-redshift"; // ES Modules import
+ * // const { RedshiftClient, ResetClusterParameterGroupCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
+ * const client = new RedshiftClient(config);
+ * const command = new ResetClusterParameterGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ResetClusterParameterGroupCommandInput} for command's `input` shape.
+ * @see {@link ResetClusterParameterGroupCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ResetClusterParameterGroupCommand extends $Command<ResetClusterParameterGroupCommandInput, ResetClusterParameterGroupCommandOutput, RedshiftClientResolvedConfig> {
+    readonly input: ResetClusterParameterGroupCommandInput;
+    constructor(input: ResetClusterParameterGroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ResetClusterParameterGroupCommandInput, ResetClusterParameterGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ResizeClusterCommand.d.ts

@@ -0,0 +1,78 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ResizeClusterMessage } from "../models/models_0";
+import { ResizeClusterResult } from "../models/models_1";
+import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
+export interface ResizeClusterCommandInput extends ResizeClusterMessage {
+}
+export interface ResizeClusterCommandOutput extends ResizeClusterResult, __MetadataBearer {
+}
+/**
+ * <p>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. </p>
+ *         <p>Elastic resize operations have the following restrictions:</p>
+ *         <ul>
+ *             <li>
+ *                 <p>You can only resize clusters of the following types:</p>
+ *                 <ul>
+ *                   <li>
+ *                         <p>dc1.large (if your cluster is in a VPC)</p>
+ *                     </li>
+ *                   <li>
+ *                         <p>dc1.8xlarge (if your cluster is in a VPC)</p>
+ *                     </li>
+ *                   <li>
+ *                         <p>dc2.large</p>
+ *                     </li>
+ *                   <li>
+ *                         <p>dc2.8xlarge</p>
+ *                     </li>
+ *                   <li>
+ *                         <p>ds2.xlarge</p>
+ *                     </li>
+ *                   <li>
+ *                         <p>ds2.8xlarge</p>
+ *                     </li>
+ *                   <li>
+ *                         <p>ra3.xlplus</p>
+ *                     </li>
+ *                   <li>
+ *                         <p>ra3.4xlarge</p>
+ *                     </li>
+ *                   <li>
+ *                         <p>ra3.16xlarge</p>
+ *                     </li>
+ *                </ul>
+ *             </li>
+ *             <li>
+ *                 <p>The type of nodes that you add must match the node type for the
+ *                     cluster.</p>
+ *             </li>
+ *          </ul>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftClient, ResizeClusterCommand } from "@aws-sdk/client-redshift"; // ES Modules import
+ * // const { RedshiftClient, ResizeClusterCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
+ * const client = new RedshiftClient(config);
+ * const command = new ResizeClusterCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ResizeClusterCommandInput} for command's `input` shape.
+ * @see {@link ResizeClusterCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ResizeClusterCommand extends $Command<ResizeClusterCommandInput, ResizeClusterCommandOutput, RedshiftClientResolvedConfig> {
+    readonly input: ResizeClusterCommandInput;
+    constructor(input: ResizeClusterCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ResizeClusterCommandInput, ResizeClusterCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RestoreFromClusterSnapshotCommand.d.ts

@@ -0,0 +1,46 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { RestoreFromClusterSnapshotMessage, RestoreFromClusterSnapshotResult } from "../models/models_1";
+import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
+export interface RestoreFromClusterSnapshotCommandInput extends RestoreFromClusterSnapshotMessage {
+}
+export interface RestoreFromClusterSnapshotCommandOutput extends RestoreFromClusterSnapshotResult, __MetadataBearer {
+}
+/**
+ * <p>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 <a>ModifyCluster</a> 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.</p>
+ *         <p>If you restore a cluster into a VPC, you must provide a cluster subnet group where
+ *             you want the cluster restored.</p>
+ *         <p>
+ * For more information about working with snapshots, go to
+ * <a href="https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-snapshots.html">Amazon Redshift Snapshots</a>
+ * in the <i>Amazon Redshift Cluster Management Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftClient, RestoreFromClusterSnapshotCommand } from "@aws-sdk/client-redshift"; // ES Modules import
+ * // const { RedshiftClient, RestoreFromClusterSnapshotCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
+ * const client = new RedshiftClient(config);
+ * const command = new RestoreFromClusterSnapshotCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RestoreFromClusterSnapshotCommandInput} for command's `input` shape.
+ * @see {@link RestoreFromClusterSnapshotCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RestoreFromClusterSnapshotCommand extends $Command<RestoreFromClusterSnapshotCommandInput, RestoreFromClusterSnapshotCommandOutput, RedshiftClientResolvedConfig> {
+    readonly input: RestoreFromClusterSnapshotCommandInput;
+    constructor(input: RestoreFromClusterSnapshotCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RestoreFromClusterSnapshotCommandInput, RestoreFromClusterSnapshotCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RestoreTableFromClusterSnapshotCommand.d.ts

@@ -0,0 +1,46 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { RestoreTableFromClusterSnapshotMessage, RestoreTableFromClusterSnapshotResult } from "../models/models_1";
+import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
+export interface RestoreTableFromClusterSnapshotCommandInput extends RestoreTableFromClusterSnapshotMessage {
+}
+export interface RestoreTableFromClusterSnapshotCommandOutput extends RestoreTableFromClusterSnapshotResult, __MetadataBearer {
+}
+/**
+ * <p>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.</p>
+ *         <p>You cannot use <code>RestoreTableFromClusterSnapshot</code> 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 <code>RestoreTableFromClusterSnapshot</code>. When you have renamed your
+ *             original table, then you can pass the original name of the table as the
+ *                 <code>NewTableName</code> parameter value in the call to
+ *                 <code>RestoreTableFromClusterSnapshot</code>. This way, you can replace the original
+ *             table with the table created from the snapshot.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftClient, RestoreTableFromClusterSnapshotCommand } from "@aws-sdk/client-redshift"; // ES Modules import
+ * // const { RedshiftClient, RestoreTableFromClusterSnapshotCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
+ * const client = new RedshiftClient(config);
+ * const command = new RestoreTableFromClusterSnapshotCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RestoreTableFromClusterSnapshotCommandInput} for command's `input` shape.
+ * @see {@link RestoreTableFromClusterSnapshotCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RestoreTableFromClusterSnapshotCommand extends $Command<RestoreTableFromClusterSnapshotCommandInput, RestoreTableFromClusterSnapshotCommandOutput, RedshiftClientResolvedConfig> {
+    readonly input: RestoreTableFromClusterSnapshotCommandInput;
+    constructor(input: RestoreTableFromClusterSnapshotCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RestoreTableFromClusterSnapshotCommandInput, RestoreTableFromClusterSnapshotCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ResumeClusterCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ResumeClusterMessage } from "../models/models_0";
+import { ResumeClusterResult } from "../models/models_1";
+import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
+export interface ResumeClusterCommandInput extends ResumeClusterMessage {
+}
+export interface ResumeClusterCommandOutput extends ResumeClusterResult, __MetadataBearer {
+}
+/**
+ * <p>Resumes a paused cluster.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftClient, ResumeClusterCommand } from "@aws-sdk/client-redshift"; // ES Modules import
+ * // const { RedshiftClient, ResumeClusterCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
+ * const client = new RedshiftClient(config);
+ * const command = new ResumeClusterCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ResumeClusterCommandInput} for command's `input` shape.
+ * @see {@link ResumeClusterCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ResumeClusterCommand extends $Command<ResumeClusterCommandInput, ResumeClusterCommandOutput, RedshiftClientResolvedConfig> {
+    readonly input: ResumeClusterCommandInput;
+    constructor(input: ResumeClusterCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ResumeClusterCommandInput, ResumeClusterCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RevokeClusterSecurityGroupIngressCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { RevokeClusterSecurityGroupIngressMessage, RevokeClusterSecurityGroupIngressResult } from "../models/models_1";
+import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
+export interface RevokeClusterSecurityGroupIngressCommandInput extends RevokeClusterSecurityGroupIngressMessage {
+}
+export interface RevokeClusterSecurityGroupIngressCommandOutput extends RevokeClusterSecurityGroupIngressResult, __MetadataBearer {
+}
+/**
+ * <p>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 <a>AuthorizeClusterSecurityGroupIngress</a>.
+ * For information about managing security groups, go to
+ * <a href="https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-security-groups.html">Amazon Redshift Cluster Security Groups</a> in the
+ * <i>Amazon Redshift Cluster Management Guide</i>. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftClient, RevokeClusterSecurityGroupIngressCommand } from "@aws-sdk/client-redshift"; // ES Modules import
+ * // const { RedshiftClient, RevokeClusterSecurityGroupIngressCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
+ * const client = new RedshiftClient(config);
+ * const command = new RevokeClusterSecurityGroupIngressCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RevokeClusterSecurityGroupIngressCommandInput} for command's `input` shape.
+ * @see {@link RevokeClusterSecurityGroupIngressCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RevokeClusterSecurityGroupIngressCommand extends $Command<RevokeClusterSecurityGroupIngressCommandInput, RevokeClusterSecurityGroupIngressCommandOutput, RedshiftClientResolvedConfig> {
+    readonly input: RevokeClusterSecurityGroupIngressCommandInput;
+    constructor(input: RevokeClusterSecurityGroupIngressCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RevokeClusterSecurityGroupIngressCommandInput, RevokeClusterSecurityGroupIngressCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RevokeEndpointAccessCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EndpointAuthorization } from "../models/models_0";
+import { RevokeEndpointAccessMessage } from "../models/models_1";
+import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
+export interface RevokeEndpointAccessCommandInput extends RevokeEndpointAccessMessage {
+}
+export interface RevokeEndpointAccessCommandOutput extends EndpointAuthorization, __MetadataBearer {
+}
+/**
+ * <p>Revokes access to a cluster.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftClient, RevokeEndpointAccessCommand } from "@aws-sdk/client-redshift"; // ES Modules import
+ * // const { RedshiftClient, RevokeEndpointAccessCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
+ * const client = new RedshiftClient(config);
+ * const command = new RevokeEndpointAccessCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RevokeEndpointAccessCommandInput} for command's `input` shape.
+ * @see {@link RevokeEndpointAccessCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RevokeEndpointAccessCommand extends $Command<RevokeEndpointAccessCommandInput, RevokeEndpointAccessCommandOutput, RedshiftClientResolvedConfig> {
+    readonly input: RevokeEndpointAccessCommandInput;
+    constructor(input: RevokeEndpointAccessCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RevokeEndpointAccessCommandInput, RevokeEndpointAccessCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RevokeSnapshotAccessCommand.d.ts

@@ -0,0 +1,41 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { RevokeSnapshotAccessMessage, RevokeSnapshotAccessResult } from "../models/models_1";
+import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
+export interface RevokeSnapshotAccessCommandInput extends RevokeSnapshotAccessMessage {
+}
+export interface RevokeSnapshotAccessCommandOutput extends RevokeSnapshotAccessResult, __MetadataBearer {
+}
+/**
+ * <p>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.</p>
+ *         <p>
+ * For more information about working with snapshots, go to
+ * <a href="https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-snapshots.html">Amazon Redshift Snapshots</a>
+ * in the <i>Amazon Redshift Cluster Management Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftClient, RevokeSnapshotAccessCommand } from "@aws-sdk/client-redshift"; // ES Modules import
+ * // const { RedshiftClient, RevokeSnapshotAccessCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
+ * const client = new RedshiftClient(config);
+ * const command = new RevokeSnapshotAccessCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RevokeSnapshotAccessCommandInput} for command's `input` shape.
+ * @see {@link RevokeSnapshotAccessCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RevokeSnapshotAccessCommand extends $Command<RevokeSnapshotAccessCommandInput, RevokeSnapshotAccessCommandOutput, RedshiftClientResolvedConfig> {
+    readonly input: RevokeSnapshotAccessCommandInput;
+    constructor(input: RevokeSnapshotAccessCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RevokeSnapshotAccessCommandInput, RevokeSnapshotAccessCommandOutput>;
+    private serialize;
+    private deserialize;
+}