@aws-sdk/client-redshift 3.34.0 → 3.37.0

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

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

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

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

package/dist-types/commands/CopyClusterSnapshotCommand.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 { CopyClusterSnapshotMessage, CopyClusterSnapshotResult } from "../models/models_0";
+import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
+export interface CopyClusterSnapshotCommandInput extends CopyClusterSnapshotMessage {
+}
+export interface CopyClusterSnapshotCommandOutput extends CopyClusterSnapshotResult, __MetadataBearer {
+}
+/**
+ * <p>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.</p>
+ *         <p>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.</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, CopyClusterSnapshotCommand } from "@aws-sdk/client-redshift"; // ES Modules import
+ * // const { RedshiftClient, CopyClusterSnapshotCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
+ * const client = new RedshiftClient(config);
+ * const command = new CopyClusterSnapshotCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CopyClusterSnapshotCommandInput} for command's `input` shape.
+ * @see {@link CopyClusterSnapshotCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CopyClusterSnapshotCommand extends $Command<CopyClusterSnapshotCommandInput, CopyClusterSnapshotCommandOutput, RedshiftClientResolvedConfig> {
+    readonly input: CopyClusterSnapshotCommandInput;
+    constructor(input: CopyClusterSnapshotCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CopyClusterSnapshotCommandInput, CopyClusterSnapshotCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

package/dist-types/commands/CreateClusterCommand.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 { CreateClusterMessage, CreateClusterResult } from "../models/models_0";
+import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
+export interface CreateClusterCommandInput extends CreateClusterMessage {
+}
+export interface CreateClusterCommandOutput extends CreateClusterResult, __MetadataBearer {
+}
+/**
+ * <p>Creates a new cluster with the specified parameters.</p>
+ *         <p>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
+ * <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, CreateClusterCommand } from "@aws-sdk/client-redshift"; // ES Modules import
+ * // const { RedshiftClient, CreateClusterCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
+ * const client = new RedshiftClient(config);
+ * const command = new CreateClusterCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateClusterCommandInput} for command's `input` shape.
+ * @see {@link CreateClusterCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateClusterCommand extends $Command<CreateClusterCommandInput, CreateClusterCommandOutput, RedshiftClientResolvedConfig> {
+    readonly input: CreateClusterCommandInput;
+    constructor(input: CreateClusterCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateClusterCommandInput, CreateClusterCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateClusterParameterGroupCommand.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 { CreateClusterParameterGroupMessage, CreateClusterParameterGroupResult } from "../models/models_0";
+import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
+export interface CreateClusterParameterGroupCommandInput extends CreateClusterParameterGroupMessage {
+}
+export interface CreateClusterParameterGroupCommandOutput extends CreateClusterParameterGroupResult, __MetadataBearer {
+}
+/**
+ * <p>Creates an Amazon Redshift parameter group.</p>
+ *         <p>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 <a>ModifyCluster</a>. </p>
+ *         <p>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
+ * <a href="https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-parameter-groups.html">Amazon Redshift Parameter 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, CreateClusterParameterGroupCommand } from "@aws-sdk/client-redshift"; // ES Modules import
+ * // const { RedshiftClient, CreateClusterParameterGroupCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
+ * const client = new RedshiftClient(config);
+ * const command = new CreateClusterParameterGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateClusterParameterGroupCommandInput} for command's `input` shape.
+ * @see {@link CreateClusterParameterGroupCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateClusterParameterGroupCommand extends $Command<CreateClusterParameterGroupCommandInput, CreateClusterParameterGroupCommandOutput, RedshiftClientResolvedConfig> {
+    readonly input: CreateClusterParameterGroupCommandInput;
+    constructor(input: CreateClusterParameterGroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateClusterParameterGroupCommandInput, CreateClusterParameterGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,40 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateClusterSecurityGroupMessage, CreateClusterSecurityGroupResult } from "../models/models_0";
+import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
+export interface CreateClusterSecurityGroupCommandInput extends CreateClusterSecurityGroupMessage {
+}
+export interface CreateClusterSecurityGroupCommandOutput extends CreateClusterSecurityGroupResult, __MetadataBearer {
+}
+/**
+ * <p>Creates a new Amazon Redshift security group. You use security groups to control access
+ *             to non-VPC clusters.</p>
+ *         <p>
+ * 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, CreateClusterSecurityGroupCommand } from "@aws-sdk/client-redshift"; // ES Modules import
+ * // const { RedshiftClient, CreateClusterSecurityGroupCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
+ * const client = new RedshiftClient(config);
+ * const command = new CreateClusterSecurityGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateClusterSecurityGroupCommandInput} for command's `input` shape.
+ * @see {@link CreateClusterSecurityGroupCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateClusterSecurityGroupCommand extends $Command<CreateClusterSecurityGroupCommandInput, CreateClusterSecurityGroupCommandOutput, RedshiftClientResolvedConfig> {
+    readonly input: CreateClusterSecurityGroupCommandInput;
+    constructor(input: CreateClusterSecurityGroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateClusterSecurityGroupCommandInput, CreateClusterSecurityGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,40 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateClusterSnapshotMessage, CreateClusterSnapshotResult } from "../models/models_0";
+import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
+export interface CreateClusterSnapshotCommandInput extends CreateClusterSnapshotMessage {
+}
+export interface CreateClusterSnapshotCommandOutput extends CreateClusterSnapshotResult, __MetadataBearer {
+}
+/**
+ * <p>Creates a manual snapshot of the specified cluster. The cluster must be in the
+ *                 <code>available</code> state. </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, CreateClusterSnapshotCommand } from "@aws-sdk/client-redshift"; // ES Modules import
+ * // const { RedshiftClient, CreateClusterSnapshotCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
+ * const client = new RedshiftClient(config);
+ * const command = new CreateClusterSnapshotCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateClusterSnapshotCommandInput} for command's `input` shape.
+ * @see {@link CreateClusterSnapshotCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateClusterSnapshotCommand extends $Command<CreateClusterSnapshotCommandInput, CreateClusterSnapshotCommandOutput, RedshiftClientResolvedConfig> {
+    readonly input: CreateClusterSnapshotCommandInput;
+    constructor(input: CreateClusterSnapshotCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateClusterSnapshotCommandInput, CreateClusterSnapshotCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateClusterSubnetGroupCommand.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 { CreateClusterSubnetGroupMessage, CreateClusterSubnetGroupResult } from "../models/models_0";
+import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
+export interface CreateClusterSubnetGroupCommandInput extends CreateClusterSubnetGroupMessage {
+}
+export interface CreateClusterSubnetGroupCommandOutput extends CreateClusterSubnetGroupResult, __MetadataBearer {
+}
+/**
+ * <p>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.</p>
+ *         <p>
+ * For information about subnet groups, go to
+ * <a href="https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-cluster-subnet-groups.html">Amazon Redshift Cluster Subnet 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, CreateClusterSubnetGroupCommand } from "@aws-sdk/client-redshift"; // ES Modules import
+ * // const { RedshiftClient, CreateClusterSubnetGroupCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
+ * const client = new RedshiftClient(config);
+ * const command = new CreateClusterSubnetGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateClusterSubnetGroupCommandInput} for command's `input` shape.
+ * @see {@link CreateClusterSubnetGroupCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateClusterSubnetGroupCommand extends $Command<CreateClusterSubnetGroupCommandInput, CreateClusterSubnetGroupCommandOutput, RedshiftClientResolvedConfig> {
+    readonly input: CreateClusterSubnetGroupCommandInput;
+    constructor(input: CreateClusterSubnetGroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateClusterSubnetGroupCommandInput, CreateClusterSubnetGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

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

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

package/dist-types/commands/CreateHsmClientCertificateCommand.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 { CreateHsmClientCertificateMessage, CreateHsmClientCertificateResult } from "../models/models_0";
+import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
+export interface CreateHsmClientCertificateCommandInput extends CreateHsmClientCertificateMessage {
+}
+export interface CreateHsmClientCertificateCommandOutput extends CreateHsmClientCertificateResult, __MetadataBearer {
+}
+/**
+ * <p>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.</p>
+ *         <p>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 <a href="https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-db-encryption.html#working-with-HSM">Hardware Security Modules</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, CreateHsmClientCertificateCommand } from "@aws-sdk/client-redshift"; // ES Modules import
+ * // const { RedshiftClient, CreateHsmClientCertificateCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
+ * const client = new RedshiftClient(config);
+ * const command = new CreateHsmClientCertificateCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateHsmClientCertificateCommandInput} for command's `input` shape.
+ * @see {@link CreateHsmClientCertificateCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateHsmClientCertificateCommand extends $Command<CreateHsmClientCertificateCommandInput, CreateHsmClientCertificateCommandOutput, RedshiftClientResolvedConfig> {
+    readonly input: CreateHsmClientCertificateCommandInput;
+    constructor(input: CreateHsmClientCertificateCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateHsmClientCertificateCommandInput, CreateHsmClientCertificateCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateHsmConfigurationCommand.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 { CreateHsmConfigurationMessage, CreateHsmConfigurationResult } from "../models/models_0";
+import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
+export interface CreateHsmConfigurationCommandInput extends CreateHsmConfigurationMessage {
+}
+export interface CreateHsmConfigurationCommandOutput extends CreateHsmConfigurationResult, __MetadataBearer {
+}
+/**
+ * <p>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.</p>
+ *         <p>In addition to creating an HSM configuration, you must also create an HSM client
+ *             certificate. For more information, go to <a href="https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-HSM.html">Hardware Security Modules</a>
+ *             in the Amazon Redshift Cluster Management Guide.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftClient, CreateHsmConfigurationCommand } from "@aws-sdk/client-redshift"; // ES Modules import
+ * // const { RedshiftClient, CreateHsmConfigurationCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
+ * const client = new RedshiftClient(config);
+ * const command = new CreateHsmConfigurationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateHsmConfigurationCommandInput} for command's `input` shape.
+ * @see {@link CreateHsmConfigurationCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateHsmConfigurationCommand extends $Command<CreateHsmConfigurationCommandInput, CreateHsmConfigurationCommandOutput, RedshiftClientResolvedConfig> {
+    readonly input: CreateHsmConfigurationCommandInput;
+    constructor(input: CreateHsmConfigurationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateHsmConfigurationCommandInput, CreateHsmConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateScheduledActionCommand.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 { CreateScheduledActionMessage, ScheduledAction } from "../models/models_0";
+import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
+export interface CreateScheduledActionCommandInput extends CreateScheduledActionMessage {
+}
+export interface CreateScheduledActionCommandOutput extends ScheduledAction, __MetadataBearer {
+}
+/**
+ * <p>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 <code>ResizeCluster</code> API operation.
+ *         </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RedshiftClient, CreateScheduledActionCommand } from "@aws-sdk/client-redshift"; // ES Modules import
+ * // const { RedshiftClient, CreateScheduledActionCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
+ * const client = new RedshiftClient(config);
+ * const command = new CreateScheduledActionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateScheduledActionCommandInput} for command's `input` shape.
+ * @see {@link CreateScheduledActionCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateScheduledActionCommand extends $Command<CreateScheduledActionCommandInput, CreateScheduledActionCommandOutput, RedshiftClientResolvedConfig> {
+    readonly input: CreateScheduledActionCommandInput;
+    constructor(input: CreateScheduledActionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateScheduledActionCommandInput, CreateScheduledActionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateSnapshotCopyGrantCommand.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 { CreateSnapshotCopyGrantMessage, CreateSnapshotCopyGrantResult } from "../models/models_0";
+import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
+export interface CreateSnapshotCopyGrantCommandInput extends CreateSnapshotCopyGrantMessage {
+}
+export interface CreateSnapshotCopyGrantCommandOutput extends CreateSnapshotCopyGrantResult, __MetadataBearer {
+}
+/**
+ * <p>Creates a snapshot copy grant that permits Amazon Redshift to use a customer master key
+ *             (CMK) from Key Management Service (KMS) to encrypt copied snapshots in a
+ *             destination region.</p>
+ *         <p>
+ * For more information about managing snapshot copy grants, go to
+ * <a href="https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-db-encryption.html">Amazon Redshift Database Encryption</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, CreateSnapshotCopyGrantCommand } from "@aws-sdk/client-redshift"; // ES Modules import
+ * // const { RedshiftClient, CreateSnapshotCopyGrantCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
+ * const client = new RedshiftClient(config);
+ * const command = new CreateSnapshotCopyGrantCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateSnapshotCopyGrantCommandInput} for command's `input` shape.
+ * @see {@link CreateSnapshotCopyGrantCommandOutput} for command's `response` shape.
+ * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateSnapshotCopyGrantCommand extends $Command<CreateSnapshotCopyGrantCommandInput, CreateSnapshotCopyGrantCommandOutput, RedshiftClientResolvedConfig> {
+    readonly input: CreateSnapshotCopyGrantCommandInput;
+    constructor(input: CreateSnapshotCopyGrantCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSnapshotCopyGrantCommandInput, CreateSnapshotCopyGrantCommandOutput>;
+    private serialize;
+    private deserialize;
+}