@aws-sdk/client-redshift 3.34.0 → 3.37.0

package/dist/types/ts3.4/commands/CreateSnapshotScheduleCommand.d.ts

@@ -1,35 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { CreateSnapshotScheduleMessage, SnapshotSchedule } 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 CreateSnapshotScheduleCommandInput extends CreateSnapshotScheduleMessage {
-}
-export interface CreateSnapshotScheduleCommandOutput extends SnapshotSchedule, __MetadataBearer {
-}
-/**
- * <p>Create a snapshot schedule that can be associated to a cluster and which overrides the default system backup schedule. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RedshiftClient, CreateSnapshotScheduleCommand } from "@aws-sdk/client-redshift"; // ES Modules import
- * // const { RedshiftClient, CreateSnapshotScheduleCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
- * const client = new RedshiftClient(config);
- * const command = new CreateSnapshotScheduleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateSnapshotScheduleCommandInput} for command's `input` shape.
- * @see {@link CreateSnapshotScheduleCommandOutput} for command's `response` shape.
- * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateSnapshotScheduleCommand extends $Command<CreateSnapshotScheduleCommandInput, CreateSnapshotScheduleCommandOutput, RedshiftClientResolvedConfig> {
-    readonly input: CreateSnapshotScheduleCommandInput;
-    constructor(input: CreateSnapshotScheduleCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSnapshotScheduleCommandInput, CreateSnapshotScheduleCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateTagsCommand.d.ts

@@ -1,39 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { CreateTagsMessage } 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 CreateTagsCommandInput extends CreateTagsMessage {
-}
-export interface CreateTagsCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Adds tags to a cluster.</p>
- *         <p>A resource can have up to 50 tags. If you try to create more than 50 tags for a
- *             resource, you will receive an error and the attempt will fail.</p>
- *         <p>If you specify a key that already exists for the resource, the value for that key
- *             will be updated with the new value.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RedshiftClient, CreateTagsCommand } from "@aws-sdk/client-redshift"; // ES Modules import
- * // const { RedshiftClient, CreateTagsCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
- * const client = new RedshiftClient(config);
- * const command = new CreateTagsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateTagsCommandInput} for command's `input` shape.
- * @see {@link CreateTagsCommandOutput} for command's `response` shape.
- * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateTagsCommand extends $Command<CreateTagsCommandInput, CreateTagsCommandOutput, RedshiftClientResolvedConfig> {
-    readonly input: CreateTagsCommandInput;
-    constructor(input: CreateTagsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTagsCommandInput, CreateTagsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateUsageLimitCommand.d.ts

@@ -1,36 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { CreateUsageLimitMessage, UsageLimit } 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 CreateUsageLimitCommandInput extends CreateUsageLimitMessage {
-}
-export interface CreateUsageLimitCommandOutput extends UsageLimit, __MetadataBearer {
-}
-/**
- * <p>Creates a usage limit for a specified Amazon Redshift feature on a cluster.
- *             The usage limit is identified by the returned usage limit identifier.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RedshiftClient, CreateUsageLimitCommand } from "@aws-sdk/client-redshift"; // ES Modules import
- * // const { RedshiftClient, CreateUsageLimitCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
- * const client = new RedshiftClient(config);
- * const command = new CreateUsageLimitCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateUsageLimitCommandInput} for command's `input` shape.
- * @see {@link CreateUsageLimitCommandOutput} for command's `response` shape.
- * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateUsageLimitCommand extends $Command<CreateUsageLimitCommandInput, CreateUsageLimitCommandOutput, RedshiftClientResolvedConfig> {
-    readonly input: CreateUsageLimitCommandInput;
-    constructor(input: CreateUsageLimitCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateUsageLimitCommandInput, CreateUsageLimitCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeauthorizeDataShareCommand.d.ts

@@ -1,35 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { DataShare, DeauthorizeDataShareMessage } 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 DeauthorizeDataShareCommandInput extends DeauthorizeDataShareMessage {
-}
-export interface DeauthorizeDataShareCommandOutput extends DataShare, __MetadataBearer {
-}
-/**
- * <p>From the producer account, removes authorization from the specified datashare. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RedshiftClient, DeauthorizeDataShareCommand } from "@aws-sdk/client-redshift"; // ES Modules import
- * // const { RedshiftClient, DeauthorizeDataShareCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
- * const client = new RedshiftClient(config);
- * const command = new DeauthorizeDataShareCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeauthorizeDataShareCommandInput} for command's `input` shape.
- * @see {@link DeauthorizeDataShareCommandOutput} for command's `response` shape.
- * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeauthorizeDataShareCommand extends $Command<DeauthorizeDataShareCommandInput, DeauthorizeDataShareCommandOutput, RedshiftClientResolvedConfig> {
-    readonly input: DeauthorizeDataShareCommandInput;
-    constructor(input: DeauthorizeDataShareCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeauthorizeDataShareCommandInput, DeauthorizeDataShareCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteAuthenticationProfileCommand.d.ts

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

package/dist/types/ts3.4/commands/DeleteClusterCommand.d.ts

@@ -1,50 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { DeleteClusterMessage, DeleteClusterResult } 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 DeleteClusterCommandInput extends DeleteClusterMessage {
-}
-export interface DeleteClusterCommandOutput extends DeleteClusterResult, __MetadataBearer {
-}
-/**
- * <p>Deletes a previously provisioned cluster without its final snapshot being created. A successful response from the web
- *             service indicates that the request was received correctly. Use <a>DescribeClusters</a> to monitor the status of the deletion. The delete
- *             operation cannot be canceled or reverted once submitted.
- * For more information about managing clusters, go to
- * <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>
- *         <p>If you want to shut down the cluster and retain it for future use, set
- *                 <i>SkipFinalClusterSnapshot</i> to <code>false</code> and specify a
- *             name for <i>FinalClusterSnapshotIdentifier</i>. You can later restore this
- *             snapshot to resume using the cluster. If a final cluster snapshot is requested, the
- *             status of the cluster will be "final-snapshot" while the snapshot is being taken, then
- *             it's "deleting" once Amazon Redshift begins deleting the cluster. </p>
- *         <p>
- * 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, DeleteClusterCommand } from "@aws-sdk/client-redshift"; // ES Modules import
- * // const { RedshiftClient, DeleteClusterCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
- * const client = new RedshiftClient(config);
- * const command = new DeleteClusterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteClusterCommandInput} for command's `input` shape.
- * @see {@link DeleteClusterCommandOutput} for command's `response` shape.
- * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteClusterCommand extends $Command<DeleteClusterCommandInput, DeleteClusterCommandOutput, RedshiftClientResolvedConfig> {
-    readonly input: DeleteClusterCommandInput;
-    constructor(input: DeleteClusterCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteClusterCommandInput, DeleteClusterCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteClusterParameterGroupCommand.d.ts

@@ -1,39 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { DeleteClusterParameterGroupMessage } 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 DeleteClusterParameterGroupCommandInput extends DeleteClusterParameterGroupMessage {
-}
-export interface DeleteClusterParameterGroupCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Deletes a specified Amazon Redshift parameter group.</p>
- *         <note>
- *             <p>You cannot delete a parameter group if it is associated with a
- *                 cluster.</p>
- *         </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RedshiftClient, DeleteClusterParameterGroupCommand } from "@aws-sdk/client-redshift"; // ES Modules import
- * // const { RedshiftClient, DeleteClusterParameterGroupCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
- * const client = new RedshiftClient(config);
- * const command = new DeleteClusterParameterGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteClusterParameterGroupCommandInput} for command's `input` shape.
- * @see {@link DeleteClusterParameterGroupCommandOutput} for command's `response` shape.
- * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteClusterParameterGroupCommand extends $Command<DeleteClusterParameterGroupCommandInput, DeleteClusterParameterGroupCommandOutput, RedshiftClientResolvedConfig> {
-    readonly input: DeleteClusterParameterGroupCommandInput;
-    constructor(input: DeleteClusterParameterGroupCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteClusterParameterGroupCommandInput, DeleteClusterParameterGroupCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteClusterSecurityGroupCommand.d.ts

@@ -1,43 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { DeleteClusterSecurityGroupMessage } 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 DeleteClusterSecurityGroupCommandInput extends DeleteClusterSecurityGroupMessage {
-}
-export interface DeleteClusterSecurityGroupCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Deletes an Amazon Redshift security group.</p>
- *         <note>
- *             <p>You cannot delete a security group that is associated with any clusters. You
- *                 cannot delete the default security group.</p>
- *         </note>
- *         <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, DeleteClusterSecurityGroupCommand } from "@aws-sdk/client-redshift"; // ES Modules import
- * // const { RedshiftClient, DeleteClusterSecurityGroupCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
- * const client = new RedshiftClient(config);
- * const command = new DeleteClusterSecurityGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteClusterSecurityGroupCommandInput} for command's `input` shape.
- * @see {@link DeleteClusterSecurityGroupCommandOutput} for command's `response` shape.
- * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteClusterSecurityGroupCommand extends $Command<DeleteClusterSecurityGroupCommandInput, DeleteClusterSecurityGroupCommandOutput, RedshiftClientResolvedConfig> {
-    readonly input: DeleteClusterSecurityGroupCommandInput;
-    constructor(input: DeleteClusterSecurityGroupCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteClusterSecurityGroupCommandInput, DeleteClusterSecurityGroupCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteClusterSnapshotCommand.d.ts

@@ -1,41 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { DeleteClusterSnapshotMessage, DeleteClusterSnapshotResult } 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 DeleteClusterSnapshotCommandInput extends DeleteClusterSnapshotMessage {
-}
-export interface DeleteClusterSnapshotCommandOutput extends DeleteClusterSnapshotResult, __MetadataBearer {
-}
-/**
- * <p>Deletes the specified manual snapshot. The snapshot must be in the
- *                 <code>available</code> state, with no other users authorized to access the snapshot. </p>
- *         <p>Unlike automated snapshots, manual snapshots are retained even after you delete
- *             your cluster. Amazon Redshift does not delete your manual snapshots. You must delete manual
- *             snapshot explicitly to avoid getting charged. If other accounts are authorized to access
- *             the snapshot, you must revoke all of the authorizations before you can delete the
- *             snapshot.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RedshiftClient, DeleteClusterSnapshotCommand } from "@aws-sdk/client-redshift"; // ES Modules import
- * // const { RedshiftClient, DeleteClusterSnapshotCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
- * const client = new RedshiftClient(config);
- * const command = new DeleteClusterSnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteClusterSnapshotCommandInput} for command's `input` shape.
- * @see {@link DeleteClusterSnapshotCommandOutput} for command's `response` shape.
- * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteClusterSnapshotCommand extends $Command<DeleteClusterSnapshotCommandInput, DeleteClusterSnapshotCommandOutput, RedshiftClientResolvedConfig> {
-    readonly input: DeleteClusterSnapshotCommandInput;
-    constructor(input: DeleteClusterSnapshotCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteClusterSnapshotCommandInput, DeleteClusterSnapshotCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteClusterSubnetGroupCommand.d.ts

@@ -1,35 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { DeleteClusterSubnetGroupMessage } 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 DeleteClusterSubnetGroupCommandInput extends DeleteClusterSubnetGroupMessage {
-}
-export interface DeleteClusterSubnetGroupCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Deletes the specified cluster subnet group.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RedshiftClient, DeleteClusterSubnetGroupCommand } from "@aws-sdk/client-redshift"; // ES Modules import
- * // const { RedshiftClient, DeleteClusterSubnetGroupCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
- * const client = new RedshiftClient(config);
- * const command = new DeleteClusterSubnetGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteClusterSubnetGroupCommandInput} for command's `input` shape.
- * @see {@link DeleteClusterSubnetGroupCommandOutput} for command's `response` shape.
- * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteClusterSubnetGroupCommand extends $Command<DeleteClusterSubnetGroupCommandInput, DeleteClusterSubnetGroupCommandOutput, RedshiftClientResolvedConfig> {
-    readonly input: DeleteClusterSubnetGroupCommandInput;
-    constructor(input: DeleteClusterSubnetGroupCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteClusterSubnetGroupCommandInput, DeleteClusterSubnetGroupCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteEndpointAccessCommand.d.ts

@@ -1,35 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { DeleteEndpointAccessMessage, 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 DeleteEndpointAccessCommandInput extends DeleteEndpointAccessMessage {
-}
-export interface DeleteEndpointAccessCommandOutput extends EndpointAccess, __MetadataBearer {
-}
-/**
- * <p>Deletes 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, DeleteEndpointAccessCommand } from "@aws-sdk/client-redshift"; // ES Modules import
- * // const { RedshiftClient, DeleteEndpointAccessCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
- * const client = new RedshiftClient(config);
- * const command = new DeleteEndpointAccessCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteEndpointAccessCommandInput} for command's `input` shape.
- * @see {@link DeleteEndpointAccessCommandOutput} for command's `response` shape.
- * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteEndpointAccessCommand extends $Command<DeleteEndpointAccessCommandInput, DeleteEndpointAccessCommandOutput, RedshiftClientResolvedConfig> {
-    readonly input: DeleteEndpointAccessCommandInput;
-    constructor(input: DeleteEndpointAccessCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEndpointAccessCommandInput, DeleteEndpointAccessCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteEventSubscriptionCommand.d.ts

@@ -1,35 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { DeleteEventSubscriptionMessage } 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 DeleteEventSubscriptionCommandInput extends DeleteEventSubscriptionMessage {
-}
-export interface DeleteEventSubscriptionCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Deletes an Amazon Redshift event notification subscription.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RedshiftClient, DeleteEventSubscriptionCommand } from "@aws-sdk/client-redshift"; // ES Modules import
- * // const { RedshiftClient, DeleteEventSubscriptionCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
- * const client = new RedshiftClient(config);
- * const command = new DeleteEventSubscriptionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteEventSubscriptionCommandInput} for command's `input` shape.
- * @see {@link DeleteEventSubscriptionCommandOutput} for command's `response` shape.
- * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteEventSubscriptionCommand extends $Command<DeleteEventSubscriptionCommandInput, DeleteEventSubscriptionCommandOutput, RedshiftClientResolvedConfig> {
-    readonly input: DeleteEventSubscriptionCommandInput;
-    constructor(input: DeleteEventSubscriptionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEventSubscriptionCommandInput, DeleteEventSubscriptionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteHsmClientCertificateCommand.d.ts

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

package/dist/types/ts3.4/commands/DeleteHsmConfigurationCommand.d.ts

@@ -1,35 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { DeleteHsmConfigurationMessage } 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 DeleteHsmConfigurationCommandInput extends DeleteHsmConfigurationMessage {
-}
-export interface DeleteHsmConfigurationCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Deletes the specified Amazon Redshift HSM configuration.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RedshiftClient, DeleteHsmConfigurationCommand } from "@aws-sdk/client-redshift"; // ES Modules import
- * // const { RedshiftClient, DeleteHsmConfigurationCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
- * const client = new RedshiftClient(config);
- * const command = new DeleteHsmConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteHsmConfigurationCommandInput} for command's `input` shape.
- * @see {@link DeleteHsmConfigurationCommandOutput} for command's `response` shape.
- * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteHsmConfigurationCommand extends $Command<DeleteHsmConfigurationCommandInput, DeleteHsmConfigurationCommandOutput, RedshiftClientResolvedConfig> {
-    readonly input: DeleteHsmConfigurationCommandInput;
-    constructor(input: DeleteHsmConfigurationCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteHsmConfigurationCommandInput, DeleteHsmConfigurationCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeletePartnerCommand.d.ts

@@ -1,35 +0,0 @@
-import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
-import { PartnerIntegrationInputMessage, PartnerIntegrationOutputMessage } 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 DeletePartnerCommandInput extends PartnerIntegrationInputMessage {
-}
-export interface DeletePartnerCommandOutput extends PartnerIntegrationOutputMessage, __MetadataBearer {
-}
-/**
- * <p>Deletes a partner integration from a cluster. Data can still flow to the cluster until the integration is deleted at the partner's website.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RedshiftClient, DeletePartnerCommand } from "@aws-sdk/client-redshift"; // ES Modules import
- * // const { RedshiftClient, DeletePartnerCommand } = require("@aws-sdk/client-redshift"); // CommonJS import
- * const client = new RedshiftClient(config);
- * const command = new DeletePartnerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeletePartnerCommandInput} for command's `input` shape.
- * @see {@link DeletePartnerCommandOutput} for command's `response` shape.
- * @see {@link RedshiftClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeletePartnerCommand extends $Command<DeletePartnerCommandInput, DeletePartnerCommandOutput, RedshiftClientResolvedConfig> {
-    readonly input: DeletePartnerCommandInput;
-    constructor(input: DeletePartnerCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeletePartnerCommandInput, DeletePartnerCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteScheduledActionCommand.d.ts

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