@aws-sdk/client-redshift 3.34.0 → 3.37.0

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

@@ -1,35 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { BatchModifyClusterSnapshotsMessage, BatchModifyClusterSnapshotsOutputMessage } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,35 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { CancelResizeMessage, ResizeProgressMessage } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,46 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { CopyClusterSnapshotMessage, CopyClusterSnapshotResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,35 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { CreateAuthenticationProfileMessage, CreateAuthenticationProfileResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,41 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { CreateClusterMessage, CreateClusterResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,43 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { CreateClusterParameterGroupMessage, CreateClusterParameterGroupResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,40 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { CreateClusterSecurityGroupMessage, CreateClusterSecurityGroupResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,40 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { CreateClusterSnapshotMessage, CreateClusterSnapshotResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,41 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { CreateClusterSubnetGroupMessage, CreateClusterSubnetGroupResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,35 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { CreateEndpointAccessMessage, EndpointAccess } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,51 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { CreateEventSubscriptionMessage, CreateEventSubscriptionResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,42 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { CreateHsmClientCertificateMessage, CreateHsmClientCertificateResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,41 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { CreateHsmConfigurationMessage, CreateHsmConfigurationResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,37 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { CreateScheduledActionMessage, ScheduledAction } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,42 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { CreateSnapshotCopyGrantMessage, CreateSnapshotCopyGrantResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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;
-}