@aws-sdk/client-rds 3.296.0 → 3.298.0

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CopyDBSnapshotMessage, CopyDBSnapshotResult } from "../models/models_0";
 import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
 /**
+ * @public
+ *
  * The input for {@link CopyDBSnapshotCommand}.
  */
 export interface CopyDBSnapshotCommandInput extends CopyDBSnapshotMessage {
 }
 /**
+ * @public
+ *
  * The output of {@link CopyDBSnapshotCommand}.
  */
 export interface CopyDBSnapshotCommandOutput extends CopyDBSnapshotResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Copies the specified DB snapshot. The source DB snapshot must be in the <code>available</code> state.</p>
  *          <p>You can copy a snapshot from one Amazon Web Services Region to another. In that case, the
  *             Amazon Web Services Region where you call the <code>CopyDBSnapshot</code> operation is the destination
@@ -31,6 +36,8 @@ export interface CopyDBSnapshotCommandOutput extends CopyDBSnapshotResult, __Met
  * const response = await client.send(command);
  * ```
  *
+ * @param CopyDBSnapshotCommandInput - {@link CopyDBSnapshotCommandInput}
+ * @returns {@link CopyDBSnapshotCommandOutput}
  * @see {@link CopyDBSnapshotCommandInput} for command's `input` shape.
  * @see {@link CopyDBSnapshotCommandOutput} for command's `response` shape.
  * @see {@link RDSClientResolvedConfig | config} for RDSClient's `config` shape.
@@ -80,11 +87,20 @@ export interface CopyDBSnapshotCommandOutput extends CopyDBSnapshotResult, __Met
 export declare class CopyDBSnapshotCommand extends $Command<CopyDBSnapshotCommandInput, CopyDBSnapshotCommandOutput, RDSClientResolvedConfig> {
     readonly input: CopyDBSnapshotCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CopyDBSnapshotCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CopyDBSnapshotCommandInput, CopyDBSnapshotCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CopyOptionGroupMessage, CopyOptionGroupResult } from "../models/models_0";
 import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
 /**
+ * @public
+ *
  * The input for {@link CopyOptionGroupCommand}.
  */
 export interface CopyOptionGroupCommandInput extends CopyOptionGroupMessage {
 }
 /**
+ * @public
+ *
  * The output of {@link CopyOptionGroupCommand}.
  */
 export interface CopyOptionGroupCommandOutput extends CopyOptionGroupResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Copies the specified option group.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface CopyOptionGroupCommandOutput extends CopyOptionGroupResult, __M
  * const response = await client.send(command);
  * ```
  *
+ * @param CopyOptionGroupCommandInput - {@link CopyOptionGroupCommandInput}
+ * @returns {@link CopyOptionGroupCommandOutput}
  * @see {@link CopyOptionGroupCommandInput} for command's `input` shape.
  * @see {@link CopyOptionGroupCommandOutput} for command's `response` shape.
  * @see {@link RDSClientResolvedConfig | config} for RDSClient's `config` shape.
@@ -61,11 +68,20 @@ export interface CopyOptionGroupCommandOutput extends CopyOptionGroupResult, __M
 export declare class CopyOptionGroupCommand extends $Command<CopyOptionGroupCommandInput, CopyOptionGroupCommandOutput, RDSClientResolvedConfig> {
     readonly input: CopyOptionGroupCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CopyOptionGroupCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CopyOptionGroupCommandInput, CopyOptionGroupCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateBlueGreenDeploymentRequest, CreateBlueGreenDeploymentResponse } from "../models/models_0";
 import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
 /**
+ * @public
+ *
  * The input for {@link CreateBlueGreenDeploymentCommand}.
  */
 export interface CreateBlueGreenDeploymentCommandInput extends CreateBlueGreenDeploymentRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateBlueGreenDeploymentCommand}.
  */
 export interface CreateBlueGreenDeploymentCommandOutput extends CreateBlueGreenDeploymentResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a blue/green deployment.</p>
  *          <p>A blue/green deployment creates a staging environment that copies the production environment.
  *             In a blue/green deployment, the blue environment is the current production environment.
@@ -39,6 +44,8 @@ export interface CreateBlueGreenDeploymentCommandOutput extends CreateBlueGreenD
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateBlueGreenDeploymentCommandInput - {@link CreateBlueGreenDeploymentCommandInput}
+ * @returns {@link CreateBlueGreenDeploymentCommandOutput}
  * @see {@link CreateBlueGreenDeploymentCommandInput} for command's `input` shape.
  * @see {@link CreateBlueGreenDeploymentCommandOutput} for command's `response` shape.
  * @see {@link RDSClientResolvedConfig | config} for RDSClient's `config` shape.
@@ -89,11 +96,20 @@ export interface CreateBlueGreenDeploymentCommandOutput extends CreateBlueGreenD
 export declare class CreateBlueGreenDeploymentCommand extends $Command<CreateBlueGreenDeploymentCommandInput, CreateBlueGreenDeploymentCommandOutput, RDSClientResolvedConfig> {
     readonly input: CreateBlueGreenDeploymentCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateBlueGreenDeploymentCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateBlueGreenDeploymentCommandInput, CreateBlueGreenDeploymentCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

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

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateDBClusterMessage, CreateDBClusterResult } from "../models/models_0";
 import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
 /**
+ * @public
+ *
  * The input for {@link CreateDBClusterCommand}.
  */
 export interface CreateDBClusterCommandInput extends CreateDBClusterMessage {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateDBClusterCommand}.
  */
 export interface CreateDBClusterCommandOutput extends CreateDBClusterResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a new Amazon Aurora DB cluster or Multi-AZ DB cluster.</p>
  *          <p>You can use the <code>ReplicationSourceIdentifier</code> parameter to create an Amazon
  *             Aurora DB cluster as a read replica of another DB cluster or Amazon RDS MySQL or
@@ -33,6 +38,8 @@ export interface CreateDBClusterCommandOutput extends CreateDBClusterResult, __M
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateDBClusterCommandInput - {@link CreateDBClusterCommandInput}
+ * @returns {@link CreateDBClusterCommandOutput}
  * @see {@link CreateDBClusterCommandInput} for command's `input` shape.
  * @see {@link CreateDBClusterCommandOutput} for command's `response` shape.
  * @see {@link RDSClientResolvedConfig | config} for RDSClient's `config` shape.
@@ -135,11 +142,20 @@ export interface CreateDBClusterCommandOutput extends CreateDBClusterResult, __M
 export declare class CreateDBClusterCommand extends $Command<CreateDBClusterCommandInput, CreateDBClusterCommandOutput, RDSClientResolvedConfig> {
     readonly input: CreateDBClusterCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateDBClusterCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDBClusterCommandInput, CreateDBClusterCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateDBClusterEndpointMessage, DBClusterEndpoint } from "../models/models_0";
 import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
 /**
+ * @public
+ *
  * The input for {@link CreateDBClusterEndpointCommand}.
  */
 export interface CreateDBClusterEndpointCommandInput extends CreateDBClusterEndpointMessage {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateDBClusterEndpointCommand}.
  */
 export interface CreateDBClusterEndpointCommandOutput extends DBClusterEndpoint, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a new custom endpoint and associates it with an Amazon Aurora DB cluster.</p>
  *          <note>
  *             <p>This action applies only to Aurora DB clusters.</p>
@@ -28,6 +33,8 @@ export interface CreateDBClusterEndpointCommandOutput extends DBClusterEndpoint,
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateDBClusterEndpointCommandInput - {@link CreateDBClusterEndpointCommandInput}
+ * @returns {@link CreateDBClusterEndpointCommandOutput}
  * @see {@link CreateDBClusterEndpointCommandInput} for command's `input` shape.
  * @see {@link CreateDBClusterEndpointCommandOutput} for command's `response` shape.
  * @see {@link RDSClientResolvedConfig | config} for RDSClient's `config` shape.
@@ -57,11 +64,20 @@ export interface CreateDBClusterEndpointCommandOutput extends DBClusterEndpoint,
 export declare class CreateDBClusterEndpointCommand extends $Command<CreateDBClusterEndpointCommandInput, CreateDBClusterEndpointCommandOutput, RDSClientResolvedConfig> {
     readonly input: CreateDBClusterEndpointCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateDBClusterEndpointCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDBClusterEndpointCommandInput, CreateDBClusterEndpointCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateDBClusterParameterGroupMessage, CreateDBClusterParameterGroupResult } from "../models/models_0";
 import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
 /**
+ * @public
+ *
  * The input for {@link CreateDBClusterParameterGroupCommand}.
  */
 export interface CreateDBClusterParameterGroupCommandInput extends CreateDBClusterParameterGroupMessage {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateDBClusterParameterGroupCommand}.
  */
 export interface CreateDBClusterParameterGroupCommandOutput extends CreateDBClusterParameterGroupResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a new DB cluster parameter group.</p>
  *          <p>Parameters in a DB cluster parameter group apply to all of the instances in a DB cluster.</p>
  *          <p>A DB cluster parameter group is initially created with the default parameters for the
@@ -54,6 +59,8 @@ export interface CreateDBClusterParameterGroupCommandOutput extends CreateDBClus
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateDBClusterParameterGroupCommandInput - {@link CreateDBClusterParameterGroupCommandInput}
+ * @returns {@link CreateDBClusterParameterGroupCommandOutput}
  * @see {@link CreateDBClusterParameterGroupCommandInput} for command's `input` shape.
  * @see {@link CreateDBClusterParameterGroupCommandOutput} for command's `response` shape.
  * @see {@link RDSClientResolvedConfig | config} for RDSClient's `config` shape.
@@ -88,11 +95,20 @@ export interface CreateDBClusterParameterGroupCommandOutput extends CreateDBClus
 export declare class CreateDBClusterParameterGroupCommand extends $Command<CreateDBClusterParameterGroupCommandInput, CreateDBClusterParameterGroupCommandOutput, RDSClientResolvedConfig> {
     readonly input: CreateDBClusterParameterGroupCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateDBClusterParameterGroupCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDBClusterParameterGroupCommandInput, CreateDBClusterParameterGroupCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateDBClusterSnapshotMessage, CreateDBClusterSnapshotResult } from "../models/models_0";
 import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
 /**
+ * @public
+ *
  * The input for {@link CreateDBClusterSnapshotCommand}.
  */
 export interface CreateDBClusterSnapshotCommandInput extends CreateDBClusterSnapshotMessage {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateDBClusterSnapshotCommand}.
  */
 export interface CreateDBClusterSnapshotCommandOutput extends CreateDBClusterSnapshotResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a snapshot of a DB cluster.</p>
  *          <p>For more information on Amazon Aurora, see <a href="https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html"> What is Amazon
  *                 Aurora?</a> in the <i>Amazon Aurora User Guide</i>.</p>
@@ -30,6 +35,8 @@ export interface CreateDBClusterSnapshotCommandOutput extends CreateDBClusterSna
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateDBClusterSnapshotCommandInput - {@link CreateDBClusterSnapshotCommandInput}
+ * @returns {@link CreateDBClusterSnapshotCommandOutput}
  * @see {@link CreateDBClusterSnapshotCommandInput} for command's `input` shape.
  * @see {@link CreateDBClusterSnapshotCommandOutput} for command's `response` shape.
  * @see {@link RDSClientResolvedConfig | config} for RDSClient's `config` shape.
@@ -73,11 +80,20 @@ export interface CreateDBClusterSnapshotCommandOutput extends CreateDBClusterSna
 export declare class CreateDBClusterSnapshotCommand extends $Command<CreateDBClusterSnapshotCommandInput, CreateDBClusterSnapshotCommandOutput, RDSClientResolvedConfig> {
     readonly input: CreateDBClusterSnapshotCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateDBClusterSnapshotCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDBClusterSnapshotCommandInput, CreateDBClusterSnapshotCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateDBInstanceMessage, CreateDBInstanceResult } from "../models/models_0";
 import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
 /**
+ * @public
+ *
  * The input for {@link CreateDBInstanceCommand}.
  */
 export interface CreateDBInstanceCommandInput extends CreateDBInstanceMessage {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateDBInstanceCommand}.
  */
 export interface CreateDBInstanceCommandOutput extends CreateDBInstanceResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a new DB instance.</p>
  *          <p>The new DB instance can be an RDS DB instance, or it can be a DB instance in an Aurora DB cluster.
  *            For an Aurora DB cluster, you can call this operation multiple times to add more than one DB instance
@@ -33,6 +38,8 @@ export interface CreateDBInstanceCommandOutput extends CreateDBInstanceResult, _
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateDBInstanceCommandInput - {@link CreateDBInstanceCommandInput}
+ * @returns {@link CreateDBInstanceCommandOutput}
  * @see {@link CreateDBInstanceCommandInput} for command's `input` shape.
  * @see {@link CreateDBInstanceCommandOutput} for command's `response` shape.
  * @see {@link RDSClientResolvedConfig | config} for RDSClient's `config` shape.
@@ -141,11 +148,20 @@ export interface CreateDBInstanceCommandOutput extends CreateDBInstanceResult, _
 export declare class CreateDBInstanceCommand extends $Command<CreateDBInstanceCommandInput, CreateDBInstanceCommandOutput, RDSClientResolvedConfig> {
     readonly input: CreateDBInstanceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateDBInstanceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDBInstanceCommandInput, CreateDBInstanceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateDBInstanceReadReplicaMessage, CreateDBInstanceReadReplicaResult } from "../models/models_0";
 import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
 /**
+ * @public
+ *
  * The input for {@link CreateDBInstanceReadReplicaCommand}.
  */
 export interface CreateDBInstanceReadReplicaCommandInput extends CreateDBInstanceReadReplicaMessage {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateDBInstanceReadReplicaCommand}.
  */
 export interface CreateDBInstanceReadReplicaCommandOutput extends CreateDBInstanceReadReplicaResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a new DB instance that acts as a read replica for an existing source DB
  *             instance. You can create a read replica for a DB instance running MySQL, MariaDB,
  *             Oracle, PostgreSQL, or SQL Server. For more information, see <a href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ReadRepl.html">Working with Read
@@ -36,6 +41,8 @@ export interface CreateDBInstanceReadReplicaCommandOutput extends CreateDBInstan
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateDBInstanceReadReplicaCommandInput - {@link CreateDBInstanceReadReplicaCommandInput}
+ * @returns {@link CreateDBInstanceReadReplicaCommandOutput}
  * @see {@link CreateDBInstanceReadReplicaCommandInput} for command's `input` shape.
  * @see {@link CreateDBInstanceReadReplicaCommandOutput} for command's `response` shape.
  * @see {@link RDSClientResolvedConfig | config} for RDSClient's `config` shape.
@@ -146,11 +153,20 @@ export interface CreateDBInstanceReadReplicaCommandOutput extends CreateDBInstan
 export declare class CreateDBInstanceReadReplicaCommand extends $Command<CreateDBInstanceReadReplicaCommandInput, CreateDBInstanceReadReplicaCommandOutput, RDSClientResolvedConfig> {
     readonly input: CreateDBInstanceReadReplicaCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateDBInstanceReadReplicaCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDBInstanceReadReplicaCommandInput, CreateDBInstanceReadReplicaCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateDBParameterGroupMessage, CreateDBParameterGroupResult } from "../models/models_0";
 import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
 /**
+ * @public
+ *
  * The input for {@link CreateDBParameterGroupCommand}.
  */
 export interface CreateDBParameterGroupCommandInput extends CreateDBParameterGroupMessage {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateDBParameterGroupCommand}.
  */
 export interface CreateDBParameterGroupCommandOutput extends CreateDBParameterGroupResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a new DB parameter group.</p>
  *          <p>A DB parameter group is initially created with the default parameters for the
  *             database engine used by the DB instance. To provide custom values for any of the
@@ -44,6 +49,8 @@ export interface CreateDBParameterGroupCommandOutput extends CreateDBParameterGr
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateDBParameterGroupCommandInput - {@link CreateDBParameterGroupCommandInput}
+ * @returns {@link CreateDBParameterGroupCommandOutput}
  * @see {@link CreateDBParameterGroupCommandInput} for command's `input` shape.
  * @see {@link CreateDBParameterGroupCommandOutput} for command's `response` shape.
  * @see {@link RDSClientResolvedConfig | config} for RDSClient's `config` shape.
@@ -78,11 +85,20 @@ export interface CreateDBParameterGroupCommandOutput extends CreateDBParameterGr
 export declare class CreateDBParameterGroupCommand extends $Command<CreateDBParameterGroupCommandInput, CreateDBParameterGroupCommandOutput, RDSClientResolvedConfig> {
     readonly input: CreateDBParameterGroupCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateDBParameterGroupCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDBParameterGroupCommandInput, CreateDBParameterGroupCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

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