@aws-sdk/client-redshift-serverless 3.295.0 → 3.297.0

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;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { GetEndpointAccessRequest, GetEndpointAccessResponse } from "../models/models_0";
 import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
 /**
+ * @public
+ *
  * The input for {@link GetEndpointAccessCommand}.
  */
 export interface GetEndpointAccessCommandInput extends GetEndpointAccessRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link GetEndpointAccessCommand}.
  */
 export interface GetEndpointAccessCommandOutput extends GetEndpointAccessResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Returns information, such as the name, about a 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 GetEndpointAccessCommandOutput extends GetEndpointAccessRespons
  * const response = await client.send(command);
  * ```
  *
+ * @param GetEndpointAccessCommandInput - {@link GetEndpointAccessCommandInput}
+ * @returns {@link GetEndpointAccessCommandOutput}
  * @see {@link GetEndpointAccessCommandInput} for command's `input` shape.
  * @see {@link GetEndpointAccessCommandOutput} for command's `response` shape.
  * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
@@ -46,11 +53,20 @@ export interface GetEndpointAccessCommandOutput extends GetEndpointAccessRespons
 export declare class GetEndpointAccessCommand extends $Command<GetEndpointAccessCommandInput, GetEndpointAccessCommandOutput, RedshiftServerlessClientResolvedConfig> {
     readonly input: GetEndpointAccessCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: GetEndpointAccessCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEndpointAccessCommandInput, GetEndpointAccessCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { GetNamespaceRequest, GetNamespaceResponse } from "../models/models_0";
 import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
 /**
+ * @public
+ *
  * The input for {@link GetNamespaceCommand}.
  */
 export interface GetNamespaceCommandInput extends GetNamespaceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link GetNamespaceCommand}.
  */
 export interface GetNamespaceCommandOutput extends GetNamespaceResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Returns information about 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 GetNamespaceCommandOutput extends GetNamespaceResponse, __Metad
  * const response = await client.send(command);
  * ```
  *
+ * @param GetNamespaceCommandInput - {@link GetNamespaceCommandInput}
+ * @returns {@link GetNamespaceCommandOutput}
  * @see {@link GetNamespaceCommandInput} for command's `input` shape.
  * @see {@link GetNamespaceCommandOutput} for command's `response` shape.
  * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
@@ -43,11 +50,20 @@ export interface GetNamespaceCommandOutput extends GetNamespaceResponse, __Metad
 export declare class GetNamespaceCommand extends $Command<GetNamespaceCommandInput, GetNamespaceCommandOutput, RedshiftServerlessClientResolvedConfig> {
     readonly input: GetNamespaceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: GetNamespaceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetNamespaceCommandInput, GetNamespaceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

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

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { GetResourcePolicyRequest, GetResourcePolicyResponse } from "../models/models_0";
 import { RedshiftServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RedshiftServerlessClient";
 /**
+ * @public
+ *
  * The input for {@link GetResourcePolicyCommand}.
  */
 export interface GetResourcePolicyCommandInput extends GetResourcePolicyRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link GetResourcePolicyCommand}.
  */
 export interface GetResourcePolicyCommandOutput extends GetResourcePolicyResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Returns a 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 GetResourcePolicyCommandOutput extends GetResourcePolicyRespons
  * const response = await client.send(command);
  * ```
  *
+ * @param GetResourcePolicyCommandInput - {@link GetResourcePolicyCommandInput}
+ * @returns {@link GetResourcePolicyCommandOutput}
  * @see {@link GetResourcePolicyCommandInput} for command's `input` shape.
  * @see {@link GetResourcePolicyCommandOutput} for command's `response` shape.
  * @see {@link RedshiftServerlessClientResolvedConfig | config} for RedshiftServerlessClient's `config` shape.
@@ -43,11 +50,20 @@ export interface GetResourcePolicyCommandOutput extends GetResourcePolicyRespons
 export declare class GetResourcePolicyCommand extends $Command<GetResourcePolicyCommandInput, GetResourcePolicyCommandOutput, RedshiftServerlessClientResolvedConfig> {
     readonly input: GetResourcePolicyCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: GetResourcePolicyCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RedshiftServerlessClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetResourcePolicyCommandInput, GetResourcePolicyCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

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