@aws-sdk/client-redshift 3.296.0 → 3.297.0

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateAuthenticationProfileMessage, CreateAuthenticationProfileResult } from "../models/models_0";
 import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
 /**
+ * @public
+ *
  * The input for {@link CreateAuthenticationProfileCommand}.
  */
 export interface CreateAuthenticationProfileCommandInput extends CreateAuthenticationProfileMessage {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateAuthenticationProfileCommand}.
  */
 export interface CreateAuthenticationProfileCommandOutput extends CreateAuthenticationProfileResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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.
@@ -25,6 +30,8 @@ export interface CreateAuthenticationProfileCommandOutput extends CreateAuthenti
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateAuthenticationProfileCommandInput - {@link CreateAuthenticationProfileCommandInput}
+ * @returns {@link CreateAuthenticationProfileCommandOutput}
  * @see {@link CreateAuthenticationProfileCommandInput} for command's `input` shape.
  * @see {@link CreateAuthenticationProfileCommandOutput} for command's `response` shape.
  * @see {@link RedshiftClientResolvedConfig | config} for RedshiftClient's `config` shape.
@@ -45,11 +52,20 @@ export interface CreateAuthenticationProfileCommandOutput extends CreateAuthenti
 export declare class CreateAuthenticationProfileCommand extends $Command<CreateAuthenticationProfileCommandInput, CreateAuthenticationProfileCommandOutput, RedshiftClientResolvedConfig> {
     readonly input: CreateAuthenticationProfileCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateAuthenticationProfileCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateAuthenticationProfileCommandInput, CreateAuthenticationProfileCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateClusterMessage, CreateClusterResult } from "../models/models_0";
 import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
 /**
+ * @public
+ *
  * The input for {@link CreateClusterCommand}.
  */
 export interface CreateClusterCommandInput extends CreateClusterMessage {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateClusterCommand}.
  */
 export interface CreateClusterCommandOutput extends CreateClusterResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -31,6 +36,8 @@ export interface CreateClusterCommandOutput extends CreateClusterResult, __Metad
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateClusterCommandInput - {@link CreateClusterCommandInput}
+ * @returns {@link CreateClusterCommandOutput}
  * @see {@link CreateClusterCommandInput} for command's `input` shape.
  * @see {@link CreateClusterCommandOutput} for command's `response` shape.
  * @see {@link RedshiftClientResolvedConfig | config} for RedshiftClient's `config` shape.
@@ -121,11 +128,20 @@ export interface CreateClusterCommandOutput extends CreateClusterResult, __Metad
 export declare class CreateClusterCommand extends $Command<CreateClusterCommandInput, CreateClusterCommandOutput, RedshiftClientResolvedConfig> {
     readonly input: CreateClusterCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateClusterCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateClusterCommandInput, CreateClusterCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateClusterParameterGroupMessage, CreateClusterParameterGroupResult } from "../models/models_0";
 import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
 /**
+ * @public
+ *
  * The input for {@link CreateClusterParameterGroupCommand}.
  */
 export interface CreateClusterParameterGroupCommandInput extends CreateClusterParameterGroupMessage {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateClusterParameterGroupCommand}.
  */
 export interface CreateClusterParameterGroupCommandOutput extends CreateClusterParameterGroupResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -33,6 +38,8 @@ export interface CreateClusterParameterGroupCommandOutput extends CreateClusterP
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateClusterParameterGroupCommandInput - {@link CreateClusterParameterGroupCommandInput}
+ * @returns {@link CreateClusterParameterGroupCommandOutput}
  * @see {@link CreateClusterParameterGroupCommandInput} for command's `input` shape.
  * @see {@link CreateClusterParameterGroupCommandOutput} for command's `response` shape.
  * @see {@link RedshiftClientResolvedConfig | config} for RedshiftClient's `config` shape.
@@ -58,11 +65,20 @@ export interface CreateClusterParameterGroupCommandOutput extends CreateClusterP
 export declare class CreateClusterParameterGroupCommand extends $Command<CreateClusterParameterGroupCommandInput, CreateClusterParameterGroupCommandOutput, RedshiftClientResolvedConfig> {
     readonly input: CreateClusterParameterGroupCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateClusterParameterGroupCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateClusterParameterGroupCommandInput, CreateClusterParameterGroupCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateClusterSecurityGroupMessage, CreateClusterSecurityGroupResult } from "../models/models_0";
 import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
 /**
+ * @public
+ *
  * The input for {@link CreateClusterSecurityGroupCommand}.
  */
 export interface CreateClusterSecurityGroupCommandInput extends CreateClusterSecurityGroupMessage {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateClusterSecurityGroupCommand}.
  */
 export interface CreateClusterSecurityGroupCommandOutput extends CreateClusterSecurityGroupResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a new Amazon Redshift security group. You use security groups to control access
  *             to non-VPC clusters.</p>
  *          <p>
@@ -30,6 +35,8 @@ export interface CreateClusterSecurityGroupCommandOutput extends CreateClusterSe
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateClusterSecurityGroupCommandInput - {@link CreateClusterSecurityGroupCommandInput}
+ * @returns {@link CreateClusterSecurityGroupCommandOutput}
  * @see {@link CreateClusterSecurityGroupCommandInput} for command's `input` shape.
  * @see {@link CreateClusterSecurityGroupCommandOutput} for command's `response` shape.
  * @see {@link RedshiftClientResolvedConfig | config} for RedshiftClient's `config` shape.
@@ -55,11 +62,20 @@ export interface CreateClusterSecurityGroupCommandOutput extends CreateClusterSe
 export declare class CreateClusterSecurityGroupCommand extends $Command<CreateClusterSecurityGroupCommandInput, CreateClusterSecurityGroupCommandOutput, RedshiftClientResolvedConfig> {
     readonly input: CreateClusterSecurityGroupCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateClusterSecurityGroupCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateClusterSecurityGroupCommandInput, CreateClusterSecurityGroupCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateClusterSnapshotMessage, CreateClusterSnapshotResult } from "../models/models_0";
 import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
 /**
+ * @public
+ *
  * The input for {@link CreateClusterSnapshotCommand}.
  */
 export interface CreateClusterSnapshotCommandInput extends CreateClusterSnapshotMessage {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateClusterSnapshotCommand}.
  */
 export interface CreateClusterSnapshotCommandOutput extends CreateClusterSnapshotResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a manual snapshot of the specified cluster. The cluster must be in the
  *                 <code>available</code> state. </p>
  *          <p>
@@ -30,6 +35,8 @@ export interface CreateClusterSnapshotCommandOutput extends CreateClusterSnapsho
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateClusterSnapshotCommandInput - {@link CreateClusterSnapshotCommandInput}
+ * @returns {@link CreateClusterSnapshotCommandOutput}
  * @see {@link CreateClusterSnapshotCommandInput} for command's `input` shape.
  * @see {@link CreateClusterSnapshotCommandOutput} for command's `response` shape.
  * @see {@link RedshiftClientResolvedConfig | config} for RedshiftClient's `config` shape.
@@ -64,11 +71,20 @@ export interface CreateClusterSnapshotCommandOutput extends CreateClusterSnapsho
 export declare class CreateClusterSnapshotCommand extends $Command<CreateClusterSnapshotCommandInput, CreateClusterSnapshotCommandOutput, RedshiftClientResolvedConfig> {
     readonly input: CreateClusterSnapshotCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateClusterSnapshotCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateClusterSnapshotCommandInput, CreateClusterSnapshotCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateClusterSubnetGroupMessage, CreateClusterSubnetGroupResult } from "../models/models_0";
 import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
 /**
+ * @public
+ *
  * The input for {@link CreateClusterSubnetGroupCommand}.
  */
 export interface CreateClusterSubnetGroupCommandInput extends CreateClusterSubnetGroupMessage {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateClusterSubnetGroupCommand}.
  */
 export interface CreateClusterSubnetGroupCommandOutput extends CreateClusterSubnetGroupResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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>
@@ -31,6 +36,8 @@ export interface CreateClusterSubnetGroupCommandOutput extends CreateClusterSubn
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateClusterSubnetGroupCommandInput - {@link CreateClusterSubnetGroupCommandInput}
+ * @returns {@link CreateClusterSubnetGroupCommandOutput}
  * @see {@link CreateClusterSubnetGroupCommandInput} for command's `input` shape.
  * @see {@link CreateClusterSubnetGroupCommandOutput} for command's `response` shape.
  * @see {@link RedshiftClientResolvedConfig | config} for RedshiftClient's `config` shape.
@@ -75,11 +82,20 @@ export interface CreateClusterSubnetGroupCommandOutput extends CreateClusterSubn
 export declare class CreateClusterSubnetGroupCommand extends $Command<CreateClusterSubnetGroupCommandInput, CreateClusterSubnetGroupCommandOutput, RedshiftClientResolvedConfig> {
     readonly input: CreateClusterSubnetGroupCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateClusterSubnetGroupCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateClusterSubnetGroupCommandInput, CreateClusterSubnetGroupCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateEndpointAccessMessage, EndpointAccess } from "../models/models_0";
 import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
 /**
+ * @public
+ *
  * The input for {@link CreateEndpointAccessCommand}.
  */
 export interface CreateEndpointAccessCommandInput extends CreateEndpointAccessMessage {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateEndpointAccessCommand}.
  */
 export interface CreateEndpointAccessCommandOutput extends EndpointAccess, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a Redshift-managed VPC endpoint.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface CreateEndpointAccessCommandOutput extends EndpointAccess, __Met
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateEndpointAccessCommandInput - {@link CreateEndpointAccessCommandInput}
+ * @returns {@link CreateEndpointAccessCommandOutput}
  * @see {@link CreateEndpointAccessCommandInput} for command's `input` shape.
  * @see {@link CreateEndpointAccessCommandOutput} for command's `response` shape.
  * @see {@link RedshiftClientResolvedConfig | config} for RedshiftClient's `config` shape.
@@ -66,11 +73,20 @@ export interface CreateEndpointAccessCommandOutput extends EndpointAccess, __Met
 export declare class CreateEndpointAccessCommand extends $Command<CreateEndpointAccessCommandInput, CreateEndpointAccessCommandOutput, RedshiftClientResolvedConfig> {
     readonly input: CreateEndpointAccessCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateEndpointAccessCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateEndpointAccessCommandInput, CreateEndpointAccessCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateEventSubscriptionMessage, CreateEventSubscriptionResult } from "../models/models_0";
 import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
 /**
+ * @public
+ *
  * The input for {@link CreateEventSubscriptionCommand}.
  */
 export interface CreateEventSubscriptionCommandInput extends CreateEventSubscriptionMessage {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateEventSubscriptionCommand}.
  */
 export interface CreateEventSubscriptionCommandOutput extends CreateEventSubscriptionResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -41,6 +46,8 @@ export interface CreateEventSubscriptionCommandOutput extends CreateEventSubscri
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateEventSubscriptionCommandInput - {@link CreateEventSubscriptionCommandInput}
+ * @returns {@link CreateEventSubscriptionCommandOutput}
  * @see {@link CreateEventSubscriptionCommandInput} for command's `input` shape.
  * @see {@link CreateEventSubscriptionCommandOutput} for command's `response` shape.
  * @see {@link RedshiftClientResolvedConfig | config} for RedshiftClient's `config` shape.
@@ -94,11 +101,20 @@ export interface CreateEventSubscriptionCommandOutput extends CreateEventSubscri
 export declare class CreateEventSubscriptionCommand extends $Command<CreateEventSubscriptionCommandInput, CreateEventSubscriptionCommandOutput, RedshiftClientResolvedConfig> {
     readonly input: CreateEventSubscriptionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateEventSubscriptionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateEventSubscriptionCommandInput, CreateEventSubscriptionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateHsmClientCertificateMessage, CreateHsmClientCertificateResult } from "../models/models_0";
 import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
 /**
+ * @public
+ *
  * The input for {@link CreateHsmClientCertificateCommand}.
  */
 export interface CreateHsmClientCertificateCommandInput extends CreateHsmClientCertificateMessage {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateHsmClientCertificateCommand}.
  */
 export interface CreateHsmClientCertificateCommandOutput extends CreateHsmClientCertificateResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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>
@@ -32,6 +37,8 @@ export interface CreateHsmClientCertificateCommandOutput extends CreateHsmClient
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateHsmClientCertificateCommandInput - {@link CreateHsmClientCertificateCommandInput}
+ * @returns {@link CreateHsmClientCertificateCommandOutput}
  * @see {@link CreateHsmClientCertificateCommandInput} for command's `input` shape.
  * @see {@link CreateHsmClientCertificateCommandOutput} for command's `response` shape.
  * @see {@link RedshiftClientResolvedConfig | config} for RedshiftClient's `config` shape.
@@ -57,11 +64,20 @@ export interface CreateHsmClientCertificateCommandOutput extends CreateHsmClient
 export declare class CreateHsmClientCertificateCommand extends $Command<CreateHsmClientCertificateCommandInput, CreateHsmClientCertificateCommandOutput, RedshiftClientResolvedConfig> {
     readonly input: CreateHsmClientCertificateCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateHsmClientCertificateCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateHsmClientCertificateCommandInput, CreateHsmClientCertificateCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateHsmConfigurationMessage, CreateHsmConfigurationResult } from "../models/models_0";
 import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
 /**
+ * @public
+ *
  * The input for {@link CreateHsmConfigurationCommand}.
  */
 export interface CreateHsmConfigurationCommandInput extends CreateHsmConfigurationMessage {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateHsmConfigurationCommand}.
  */
 export interface CreateHsmConfigurationCommandOutput extends CreateHsmConfigurationResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -31,6 +36,8 @@ export interface CreateHsmConfigurationCommandOutput extends CreateHsmConfigurat
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateHsmConfigurationCommandInput - {@link CreateHsmConfigurationCommandInput}
+ * @returns {@link CreateHsmConfigurationCommandOutput}
  * @see {@link CreateHsmConfigurationCommandInput} for command's `input` shape.
  * @see {@link CreateHsmConfigurationCommandOutput} for command's `response` shape.
  * @see {@link RedshiftClientResolvedConfig | config} for RedshiftClient's `config` shape.
@@ -56,11 +63,20 @@ export interface CreateHsmConfigurationCommandOutput extends CreateHsmConfigurat
 export declare class CreateHsmConfigurationCommand extends $Command<CreateHsmConfigurationCommandInput, CreateHsmConfigurationCommandOutput, RedshiftClientResolvedConfig> {
     readonly input: CreateHsmConfigurationCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateHsmConfigurationCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateHsmConfigurationCommandInput, CreateHsmConfigurationCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateScheduledActionMessage, ScheduledAction } from "../models/models_0";
 import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
 /**
+ * @public
+ *
  * The input for {@link CreateScheduledActionCommand}.
  */
 export interface CreateScheduledActionCommandInput extends CreateScheduledActionMessage {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateScheduledActionCommand}.
  */
 export interface CreateScheduledActionCommandOutput extends ScheduledAction, __MetadataBearer {
 }
 /**
+ * @public
  * <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>
@@ -27,6 +32,8 @@ export interface CreateScheduledActionCommandOutput extends ScheduledAction, __M
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateScheduledActionCommandInput - {@link CreateScheduledActionCommandInput}
+ * @returns {@link CreateScheduledActionCommandOutput}
  * @see {@link CreateScheduledActionCommandInput} for command's `input` shape.
  * @see {@link CreateScheduledActionCommandOutput} for command's `response` shape.
  * @see {@link RedshiftClientResolvedConfig | config} for RedshiftClient's `config` shape.
@@ -54,11 +61,20 @@ export interface CreateScheduledActionCommandOutput extends ScheduledAction, __M
 export declare class CreateScheduledActionCommand extends $Command<CreateScheduledActionCommandInput, CreateScheduledActionCommandOutput, RedshiftClientResolvedConfig> {
     readonly input: CreateScheduledActionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateScheduledActionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateScheduledActionCommandInput, CreateScheduledActionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateSnapshotCopyGrantMessage, CreateSnapshotCopyGrantResult } from "../models/models_0";
 import { RedshiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftClient";
 /**
+ * @public
+ *
  * The input for {@link CreateSnapshotCopyGrantCommand}.
  */
 export interface CreateSnapshotCopyGrantCommandInput extends CreateSnapshotCopyGrantMessage {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateSnapshotCopyGrantCommand}.
  */
 export interface CreateSnapshotCopyGrantCommandOutput extends CreateSnapshotCopyGrantResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a snapshot copy grant that permits Amazon Redshift to use an encrypted symmetric key
  *             from Key Management Service (KMS) to encrypt copied snapshots in a
  *             destination region.</p>
@@ -32,6 +37,8 @@ export interface CreateSnapshotCopyGrantCommandOutput extends CreateSnapshotCopy
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateSnapshotCopyGrantCommandInput - {@link CreateSnapshotCopyGrantCommandInput}
+ * @returns {@link CreateSnapshotCopyGrantCommandOutput}
  * @see {@link CreateSnapshotCopyGrantCommandInput} for command's `input` shape.
  * @see {@link CreateSnapshotCopyGrantCommandOutput} for command's `response` shape.
  * @see {@link RedshiftClientResolvedConfig | config} for RedshiftClient's `config` shape.
@@ -62,11 +69,20 @@ export interface CreateSnapshotCopyGrantCommandOutput extends CreateSnapshotCopy
 export declare class CreateSnapshotCopyGrantCommand extends $Command<CreateSnapshotCopyGrantCommandInput, CreateSnapshotCopyGrantCommandOutput, RedshiftClientResolvedConfig> {
     readonly input: CreateSnapshotCopyGrantCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateSnapshotCopyGrantCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSnapshotCopyGrantCommandInput, CreateSnapshotCopyGrantCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }