@aws-sdk/client-redshift-serverless 3.296.0 → 3.298.0

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { ConvertRecoveryPointToSnapshotRequest, ConvertRecoveryPointToSnapshotResponse } from "../models/models_0";
 import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
 /**
+ * @public
+ *
  * The input for {@link ConvertRecoveryPointToSnapshotCommand}.
  */
 export interface ConvertRecoveryPointToSnapshotCommandInput extends ConvertRecoveryPointToSnapshotRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ConvertRecoveryPointToSnapshotCommand}.
  */
 export interface ConvertRecoveryPointToSnapshotCommandOutput extends ConvertRecoveryPointToSnapshotResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Converts a recovery point to a snapshot. For more information about recovery points and snapshots,
  *          see <a href="https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-snapshots-recovery.html">Working with snapshots and recovery points</a>.</p>
  * @example
@@ -26,6 +31,8 @@ export interface ConvertRecoveryPointToSnapshotCommandOutput extends ConvertReco
  * const response = await client.send(command);
  * ```
  *
+ * @param ConvertRecoveryPointToSnapshotCommandInput - {@link ConvertRecoveryPointToSnapshotCommandInput}
+ * @returns {@link ConvertRecoveryPointToSnapshotCommandOutput}
  * @see {@link ConvertRecoveryPointToSnapshotCommandInput} for command's `input` shape.
  * @see {@link ConvertRecoveryPointToSnapshotCommandOutput} for command's `response` shape.
  * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
@@ -53,11 +60,20 @@ export interface ConvertRecoveryPointToSnapshotCommandOutput extends ConvertReco
 export declare class ConvertRecoveryPointToSnapshotCommand extends $Command<ConvertRecoveryPointToSnapshotCommandInput, ConvertRecoveryPointToSnapshotCommandOutput, RedshiftServerlessClientResolvedConfig> {
     readonly input: ConvertRecoveryPointToSnapshotCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ConvertRecoveryPointToSnapshotCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ConvertRecoveryPointToSnapshotCommandInput, ConvertRecoveryPointToSnapshotCommandOutput>;
+    /**
+     * @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 { CreateEndpointAccessRequest, CreateEndpointAccessResponse } from "../models/models_0";
 import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
 /**
+ * @public
+ *
  * The input for {@link CreateEndpointAccessCommand}.
  */
 export interface CreateEndpointAccessCommandInput extends CreateEndpointAccessRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateEndpointAccessCommand}.
  */
 export interface CreateEndpointAccessCommandOutput extends CreateEndpointAccessResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates an Amazon Redshift Serverless 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 CreateEndpointAccessR
  * 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 RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
@@ -52,11 +59,20 @@ export interface CreateEndpointAccessCommandOutput extends CreateEndpointAccessR
 export declare class CreateEndpointAccessCommand extends $Command<CreateEndpointAccessCommandInput, CreateEndpointAccessCommandOutput, RedshiftServerlessClientResolvedConfig> {
     readonly input: CreateEndpointAccessCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateEndpointAccessCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateEndpointAccessCommandInput, CreateEndpointAccessCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateNamespaceRequest, CreateNamespaceResponse } from "../models/models_0";
 import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
 /**
+ * @public
+ *
  * The input for {@link CreateNamespaceCommand}.
  */
 export interface CreateNamespaceCommandInput extends CreateNamespaceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateNamespaceCommand}.
  */
 export interface CreateNamespaceCommandOutput extends CreateNamespaceResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a namespace in Amazon Redshift Serverless.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface CreateNamespaceCommandOutput extends CreateNamespaceResponse, _
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateNamespaceCommandInput - {@link CreateNamespaceCommandInput}
+ * @returns {@link CreateNamespaceCommandOutput}
  * @see {@link CreateNamespaceCommandInput} for command's `input` shape.
  * @see {@link CreateNamespaceCommandOutput} for command's `response` shape.
  * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
@@ -46,11 +53,20 @@ export interface CreateNamespaceCommandOutput extends CreateNamespaceResponse, _
 export declare class CreateNamespaceCommand extends $Command<CreateNamespaceCommandInput, CreateNamespaceCommandOutput, RedshiftServerlessClientResolvedConfig> {
     readonly input: CreateNamespaceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateNamespaceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNamespaceCommandInput, CreateNamespaceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateSnapshotRequest, CreateSnapshotResponse } from "../models/models_0";
 import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
 /**
+ * @public
+ *
  * The input for {@link CreateSnapshotCommand}.
  */
 export interface CreateSnapshotCommandInput extends CreateSnapshotRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateSnapshotCommand}.
  */
 export interface CreateSnapshotCommandOutput extends CreateSnapshotResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a snapshot of all databases in a namespace.
  *          For more information about snapshots, see
  *          <a href="https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-snapshots-recovery.html">
@@ -28,6 +33,8 @@ export interface CreateSnapshotCommandOutput extends CreateSnapshotResponse, __M
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateSnapshotCommandInput - {@link CreateSnapshotCommandInput}
+ * @returns {@link CreateSnapshotCommandOutput}
  * @see {@link CreateSnapshotCommandInput} for command's `input` shape.
  * @see {@link CreateSnapshotCommandOutput} for command's `response` shape.
  * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
@@ -55,11 +62,20 @@ export interface CreateSnapshotCommandOutput extends CreateSnapshotResponse, __M
 export declare class CreateSnapshotCommand extends $Command<CreateSnapshotCommandInput, CreateSnapshotCommandOutput, RedshiftServerlessClientResolvedConfig> {
     readonly input: CreateSnapshotCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateSnapshotCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSnapshotCommandInput, CreateSnapshotCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateUsageLimitRequest, CreateUsageLimitResponse } from "../models/models_0";
 import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
 /**
+ * @public
+ *
  * The input for {@link CreateUsageLimitCommand}.
  */
 export interface CreateUsageLimitCommandInput extends CreateUsageLimitRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateUsageLimitCommand}.
  */
 export interface CreateUsageLimitCommandOutput extends CreateUsageLimitResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a usage limit for a specified Amazon Redshift Serverless usage type. The usage limit is identified by the returned usage limit identifier.
  *       </p>
  * @example
@@ -26,6 +31,8 @@ export interface CreateUsageLimitCommandOutput extends CreateUsageLimitResponse,
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateUsageLimitCommandInput - {@link CreateUsageLimitCommandInput}
+ * @returns {@link CreateUsageLimitCommandOutput}
  * @see {@link CreateUsageLimitCommandInput} for command's `input` shape.
  * @see {@link CreateUsageLimitCommandOutput} for command's `response` shape.
  * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
@@ -50,11 +57,20 @@ export interface CreateUsageLimitCommandOutput extends CreateUsageLimitResponse,
 export declare class CreateUsageLimitCommand extends $Command<CreateUsageLimitCommandInput, CreateUsageLimitCommandOutput, RedshiftServerlessClientResolvedConfig> {
     readonly input: CreateUsageLimitCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateUsageLimitCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateUsageLimitCommandInput, CreateUsageLimitCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateWorkgroupRequest, CreateWorkgroupResponse } from "../models/models_0";
 import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
 /**
+ * @public
+ *
  * The input for {@link CreateWorkgroupCommand}.
  */
 export interface CreateWorkgroupCommandInput extends CreateWorkgroupRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateWorkgroupCommand}.
  */
 export interface CreateWorkgroupCommandOutput extends CreateWorkgroupResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates an workgroup in Amazon Redshift Serverless.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface CreateWorkgroupCommandOutput extends CreateWorkgroupResponse, _
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateWorkgroupCommandInput - {@link CreateWorkgroupCommandInput}
+ * @returns {@link CreateWorkgroupCommandOutput}
  * @see {@link CreateWorkgroupCommandInput} for command's `input` shape.
  * @see {@link CreateWorkgroupCommandOutput} for command's `response` shape.
  * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
@@ -52,11 +59,20 @@ export interface CreateWorkgroupCommandOutput extends CreateWorkgroupResponse, _
 export declare class CreateWorkgroupCommand extends $Command<CreateWorkgroupCommandInput, CreateWorkgroupCommandOutput, RedshiftServerlessClientResolvedConfig> {
     readonly input: CreateWorkgroupCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateWorkgroupCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateWorkgroupCommandInput, CreateWorkgroupCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteEndpointAccessRequest, DeleteEndpointAccessResponse } from "../models/models_0";
 import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteEndpointAccessCommand}.
  */
 export interface DeleteEndpointAccessCommandInput extends DeleteEndpointAccessRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteEndpointAccessCommand}.
  */
 export interface DeleteEndpointAccessCommandOutput extends DeleteEndpointAccessResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes an Amazon Redshift Serverless 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 DeleteEndpointAccessCommandOutput extends DeleteEndpointAccessR
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteEndpointAccessCommandInput - {@link DeleteEndpointAccessCommandInput}
+ * @returns {@link DeleteEndpointAccessCommandOutput}
  * @see {@link DeleteEndpointAccessCommandInput} for command's `input` shape.
  * @see {@link DeleteEndpointAccessCommandOutput} for command's `response` shape.
  * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
@@ -46,11 +53,20 @@ export interface DeleteEndpointAccessCommandOutput extends DeleteEndpointAccessR
 export declare class DeleteEndpointAccessCommand extends $Command<DeleteEndpointAccessCommandInput, DeleteEndpointAccessCommandOutput, RedshiftServerlessClientResolvedConfig> {
     readonly input: DeleteEndpointAccessCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteEndpointAccessCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEndpointAccessCommandInput, DeleteEndpointAccessCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteNamespaceRequest, DeleteNamespaceResponse } from "../models/models_0";
 import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteNamespaceCommand}.
  */
 export interface DeleteNamespaceCommandInput extends DeleteNamespaceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteNamespaceCommand}.
  */
 export interface DeleteNamespaceCommandOutput extends DeleteNamespaceResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes a namespace from Amazon Redshift Serverless.
  *          Before you delete the namespace, you can create a final snapshot that has all of the data within the namespace.</p>
  * @example
@@ -26,6 +31,8 @@ export interface DeleteNamespaceCommandOutput extends DeleteNamespaceResponse, _
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteNamespaceCommandInput - {@link DeleteNamespaceCommandInput}
+ * @returns {@link DeleteNamespaceCommandOutput}
  * @see {@link DeleteNamespaceCommandInput} for command's `input` shape.
  * @see {@link DeleteNamespaceCommandOutput} for command's `response` shape.
  * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
@@ -47,11 +54,20 @@ export interface DeleteNamespaceCommandOutput extends DeleteNamespaceResponse, _
 export declare class DeleteNamespaceCommand extends $Command<DeleteNamespaceCommandInput, DeleteNamespaceCommandOutput, RedshiftServerlessClientResolvedConfig> {
     readonly input: DeleteNamespaceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteNamespaceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteNamespaceCommandInput, DeleteNamespaceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteResourcePolicyRequest, DeleteResourcePolicyResponse } from "../models/models_0";
 import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteResourcePolicyCommand}.
  */
 export interface DeleteResourcePolicyCommandInput extends DeleteResourcePolicyRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteResourcePolicyCommand}.
  */
 export interface DeleteResourcePolicyCommandOutput extends DeleteResourcePolicyResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the specified resource policy.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteResourcePolicyCommandOutput extends DeleteResourcePolicyR
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteResourcePolicyCommandInput - {@link DeleteResourcePolicyCommandInput}
+ * @returns {@link DeleteResourcePolicyCommandOutput}
  * @see {@link DeleteResourcePolicyCommandInput} for command's `input` shape.
  * @see {@link DeleteResourcePolicyCommandOutput} for command's `response` shape.
  * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
@@ -43,11 +50,20 @@ export interface DeleteResourcePolicyCommandOutput extends DeleteResourcePolicyR
 export declare class DeleteResourcePolicyCommand extends $Command<DeleteResourcePolicyCommandInput, DeleteResourcePolicyCommandOutput, RedshiftServerlessClientResolvedConfig> {
     readonly input: DeleteResourcePolicyCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteResourcePolicyCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteResourcePolicyCommandInput, DeleteResourcePolicyCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteSnapshotRequest, DeleteSnapshotResponse } from "../models/models_0";
 import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteSnapshotCommand}.
  */
 export interface DeleteSnapshotCommandInput extends DeleteSnapshotRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteSnapshotCommand}.
  */
 export interface DeleteSnapshotCommandOutput extends DeleteSnapshotResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes a snapshot from Amazon Redshift Serverless.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteSnapshotCommandOutput extends DeleteSnapshotResponse, __M
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteSnapshotCommandInput - {@link DeleteSnapshotCommandInput}
+ * @returns {@link DeleteSnapshotCommandOutput}
  * @see {@link DeleteSnapshotCommandInput} for command's `input` shape.
  * @see {@link DeleteSnapshotCommandOutput} for command's `response` shape.
  * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
@@ -46,11 +53,20 @@ export interface DeleteSnapshotCommandOutput extends DeleteSnapshotResponse, __M
 export declare class DeleteSnapshotCommand extends $Command<DeleteSnapshotCommandInput, DeleteSnapshotCommandOutput, RedshiftServerlessClientResolvedConfig> {
     readonly input: DeleteSnapshotCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteSnapshotCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSnapshotCommandInput, DeleteSnapshotCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteUsageLimitRequest, DeleteUsageLimitResponse } from "../models/models_0";
 import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteUsageLimitCommand}.
  */
 export interface DeleteUsageLimitCommandInput extends DeleteUsageLimitRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteUsageLimitCommand}.
  */
 export interface DeleteUsageLimitCommandOutput extends DeleteUsageLimitResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes a usage limit from Amazon Redshift Serverless.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteUsageLimitCommandOutput extends DeleteUsageLimitResponse,
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteUsageLimitCommandInput - {@link DeleteUsageLimitCommandInput}
+ * @returns {@link DeleteUsageLimitCommandOutput}
  * @see {@link DeleteUsageLimitCommandInput} for command's `input` shape.
  * @see {@link DeleteUsageLimitCommandOutput} for command's `response` shape.
  * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
@@ -46,11 +53,20 @@ export interface DeleteUsageLimitCommandOutput extends DeleteUsageLimitResponse,
 export declare class DeleteUsageLimitCommand extends $Command<DeleteUsageLimitCommandInput, DeleteUsageLimitCommandOutput, RedshiftServerlessClientResolvedConfig> {
     readonly input: DeleteUsageLimitCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteUsageLimitCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteUsageLimitCommandInput, DeleteUsageLimitCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteWorkgroupRequest, DeleteWorkgroupResponse } from "../models/models_0";
 import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteWorkgroupCommand}.
  */
 export interface DeleteWorkgroupCommandInput extends DeleteWorkgroupRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteWorkgroupCommand}.
  */
 export interface DeleteWorkgroupCommandOutput extends DeleteWorkgroupResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes a workgroup.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteWorkgroupCommandOutput extends DeleteWorkgroupResponse, _
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteWorkgroupCommandInput - {@link DeleteWorkgroupCommandInput}
+ * @returns {@link DeleteWorkgroupCommandOutput}
  * @see {@link DeleteWorkgroupCommandInput} for command's `input` shape.
  * @see {@link DeleteWorkgroupCommandOutput} for command's `response` shape.
  * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
@@ -46,11 +53,20 @@ export interface DeleteWorkgroupCommandOutput extends DeleteWorkgroupResponse, _
 export declare class DeleteWorkgroupCommand extends $Command<DeleteWorkgroupCommandInput, DeleteWorkgroupCommandOutput, RedshiftServerlessClientResolvedConfig> {
     readonly input: DeleteWorkgroupCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteWorkgroupCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteWorkgroupCommandInput, DeleteWorkgroupCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { GetCredentialsRequest, GetCredentialsResponse } from "../models/models_0";
 import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
 /**
+ * @public
+ *
  * The input for {@link GetCredentialsCommand}.
  */
 export interface GetCredentialsCommandInput extends GetCredentialsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link GetCredentialsCommand}.
  */
 export interface GetCredentialsCommandOutput extends GetCredentialsResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Returns a database user name and temporary password with
  *          temporary authorization to log in to Amazon Redshift Serverless.</p>
  *          <p>By default, the temporary credentials expire in 900 seconds.
@@ -35,6 +40,8 @@ export interface GetCredentialsCommandOutput extends GetCredentialsResponse, __M
  * const response = await client.send(command);
  * ```
  *
+ * @param GetCredentialsCommandInput - {@link GetCredentialsCommandInput}
+ * @returns {@link GetCredentialsCommandOutput}
  * @see {@link GetCredentialsCommandInput} for command's `input` shape.
  * @see {@link GetCredentialsCommandOutput} for command's `response` shape.
  * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
@@ -53,11 +60,20 @@ export interface GetCredentialsCommandOutput extends GetCredentialsResponse, __M
 export declare class GetCredentialsCommand extends $Command<GetCredentialsCommandInput, GetCredentialsCommandOutput, RedshiftServerlessClientResolvedConfig> {
     readonly input: GetCredentialsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: GetCredentialsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCredentialsCommandInput, GetCredentialsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }