@aws-sdk/client-rds 3.36.0 → 3.39.0

package/dist-types/ts3.4/commands/CreateDBProxyEndpointCommand.d.ts

@@ -6,33 +6,11 @@ export interface CreateDBProxyEndpointCommandInput extends CreateDBProxyEndpoint
 }
 export interface CreateDBProxyEndpointCommandOutput extends CreateDBProxyEndpointResponse, __MetadataBearer {
 }
-/**
- * <p>
- *         Creates a <code>DBProxyEndpoint</code>. Only applies to proxies that are associated with Aurora DB clusters.
- *         You can use DB proxy endpoints to specify read/write or read-only access to the DB cluster. You can also use
- *         DB proxy endpoints to access a DB proxy through a different VPC than the proxy's default VPC.
- *       </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, CreateDBProxyEndpointCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, CreateDBProxyEndpointCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new CreateDBProxyEndpointCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateDBProxyEndpointCommandInput} for command's `input` shape.
- * @see {@link CreateDBProxyEndpointCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateDBProxyEndpointCommand extends $Command<CreateDBProxyEndpointCommandInput, CreateDBProxyEndpointCommandOutput, RDSClientResolvedConfig> {
     readonly input: CreateDBProxyEndpointCommandInput;
     constructor(input: CreateDBProxyEndpointCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDBProxyEndpointCommandInput, CreateDBProxyEndpointCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateDBSecurityGroupCommand.d.ts

@@ -6,32 +6,11 @@ export interface CreateDBSecurityGroupCommandInput extends CreateDBSecurityGroup
 }
 export interface CreateDBSecurityGroupCommandOutput extends CreateDBSecurityGroupResult, __MetadataBearer {
 }
-/**
- * <p>Creates a new DB security group. DB security groups control access to a DB instance.</p>
- *          <note>
- *             <p>A DB security group controls access to EC2-Classic DB instances that are not in a VPC.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, CreateDBSecurityGroupCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, CreateDBSecurityGroupCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new CreateDBSecurityGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateDBSecurityGroupCommandInput} for command's `input` shape.
- * @see {@link CreateDBSecurityGroupCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateDBSecurityGroupCommand extends $Command<CreateDBSecurityGroupCommandInput, CreateDBSecurityGroupCommandOutput, RDSClientResolvedConfig> {
     readonly input: CreateDBSecurityGroupCommandInput;
     constructor(input: CreateDBSecurityGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDBSecurityGroupCommandInput, CreateDBSecurityGroupCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateDBSnapshotCommand.d.ts

@@ -6,30 +6,11 @@ export interface CreateDBSnapshotCommandInput extends CreateDBSnapshotMessage {
 }
 export interface CreateDBSnapshotCommandOutput extends CreateDBSnapshotResult, __MetadataBearer {
 }
-/**
- * <p>Creates a snapshot of a DB instance. The source DB instance must be in the <code>available</code> or
- *                 <code>storage-optimization</code> state.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, CreateDBSnapshotCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, CreateDBSnapshotCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new CreateDBSnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateDBSnapshotCommandInput} for command's `input` shape.
- * @see {@link CreateDBSnapshotCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateDBSnapshotCommand extends $Command<CreateDBSnapshotCommandInput, CreateDBSnapshotCommandOutput, RDSClientResolvedConfig> {
     readonly input: CreateDBSnapshotCommandInput;
     constructor(input: CreateDBSnapshotCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDBSnapshotCommandInput, CreateDBSnapshotCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateDBSubnetGroupCommand.d.ts

@@ -6,29 +6,11 @@ export interface CreateDBSubnetGroupCommandInput extends CreateDBSubnetGroupMess
 }
 export interface CreateDBSubnetGroupCommandOutput extends CreateDBSubnetGroupResult, __MetadataBearer {
 }
-/**
- * <p>Creates a new DB subnet group. DB subnet groups must contain at least one subnet in at least two AZs in the Amazon Web Services Region.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, CreateDBSubnetGroupCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, CreateDBSubnetGroupCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new CreateDBSubnetGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateDBSubnetGroupCommandInput} for command's `input` shape.
- * @see {@link CreateDBSubnetGroupCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateDBSubnetGroupCommand extends $Command<CreateDBSubnetGroupCommandInput, CreateDBSubnetGroupCommandOutput, RDSClientResolvedConfig> {
     readonly input: CreateDBSubnetGroupCommandInput;
     constructor(input: CreateDBSubnetGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDBSubnetGroupCommandInput, CreateDBSubnetGroupCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,51 +6,11 @@ export interface CreateEventSubscriptionCommandInput extends CreateEventSubscrip
 }
 export interface CreateEventSubscriptionCommandOutput extends CreateEventSubscriptionResult, __MetadataBearer {
 }
-/**
- * <p>Creates an RDS event notification subscription. This action requires a topic Amazon
- *             Resource Name (ARN) created by either the RDS console, the SNS console, or the SNS API.
- *             To obtain an ARN with SNS, you must create a topic in Amazon SNS and subscribe to the
- *             topic. The ARN is displayed in the SNS console.</p>
- *          <p>You can specify the type of source (<code>SourceType</code>) that you want to be
- *             notified of and provide a list of RDS sources (<code>SourceIds</code>) that triggers the
- *             events. You can also provide a list of event categories (<code>EventCategories</code>)
- *             for events that you want to be notified of. For example, you can specify
- *                 <code>SourceType</code> = <code>db-instance</code>, <code>SourceIds</code> =
- *                 <code>mydbinstance1</code>, <code>mydbinstance2</code> and
- *                 <code>EventCategories</code> = <code>Availability</code>,
- *             <code>Backup</code>.</p>
- *
- *          <p>If you specify both the <code>SourceType</code> and <code>SourceIds</code>, such as <code>SourceType</code> = <code>db-instance</code>
- *           and <code>SourceIdentifier</code> = <code>myDBInstance1</code>, you are notified of all the <code>db-instance</code> events for
- *           the specified source. If you specify a <code>SourceType</code> but do not specify a <code>SourceIdentifier</code>,
- *           you receive notice of the events for that source type for all your RDS sources. If you
- *           don't specify either the SourceType or the <code>SourceIdentifier</code>, you are notified of events
- *           generated from all RDS sources belonging to your customer account.</p>
- *          <note>
- *             <p>RDS event notification is only available for unencrypted SNS topics. If you specify an
- *               encrypted SNS topic, event notifications aren't sent for the topic.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, CreateEventSubscriptionCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, CreateEventSubscriptionCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new CreateEventSubscriptionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateEventSubscriptionCommandInput} for command's `input` shape.
- * @see {@link CreateEventSubscriptionCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateEventSubscriptionCommand extends $Command<CreateEventSubscriptionCommandInput, CreateEventSubscriptionCommandOutput, RDSClientResolvedConfig> {
     readonly input: CreateEventSubscriptionCommandInput;
     constructor(input: CreateEventSubscriptionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateEventSubscriptionCommandInput, CreateEventSubscriptionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateGlobalClusterCommand.d.ts

@@ -6,45 +6,11 @@ export interface CreateGlobalClusterCommandInput extends CreateGlobalClusterMess
 }
 export interface CreateGlobalClusterCommandOutput extends CreateGlobalClusterResult, __MetadataBearer {
 }
-/**
- * <p>
- *         Creates an Aurora global database
- *         spread across multiple Amazon Web Services Regions. The global database
- *         contains a single primary cluster with read-write capability,
- *         and a read-only secondary cluster that receives
- *         data from the primary cluster through high-speed replication
- *         performed by the Aurora storage subsystem.
- *       </p>
- *          <p>
- *         You can create a global database that is initially empty, and then
- *         add a primary cluster and a secondary cluster to it.
- *         Or you can specify an existing Aurora cluster during the create operation,
- *         and this cluster becomes the primary cluster of the global database.
- *       </p>
- *          <note>
- *            <p>This action only applies to Aurora DB clusters.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, CreateGlobalClusterCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, CreateGlobalClusterCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new CreateGlobalClusterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateGlobalClusterCommandInput} for command's `input` shape.
- * @see {@link CreateGlobalClusterCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateGlobalClusterCommand extends $Command<CreateGlobalClusterCommandInput, CreateGlobalClusterCommandOutput, RDSClientResolvedConfig> {
     readonly input: CreateGlobalClusterCommandInput;
     constructor(input: CreateGlobalClusterCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateGlobalClusterCommandInput, CreateGlobalClusterCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateOptionGroupCommand.d.ts

@@ -6,29 +6,11 @@ export interface CreateOptionGroupCommandInput extends CreateOptionGroupMessage
 }
 export interface CreateOptionGroupCommandOutput extends CreateOptionGroupResult, __MetadataBearer {
 }
-/**
- * <p>Creates a new option group. You can create up to 20 option groups.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, CreateOptionGroupCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, CreateOptionGroupCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new CreateOptionGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateOptionGroupCommandInput} for command's `input` shape.
- * @see {@link CreateOptionGroupCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateOptionGroupCommand extends $Command<CreateOptionGroupCommandInput, CreateOptionGroupCommandOutput, RDSClientResolvedConfig> {
     readonly input: CreateOptionGroupCommandInput;
     constructor(input: CreateOptionGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateOptionGroupCommandInput, CreateOptionGroupCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteCustomAvailabilityZoneCommand.d.ts

@@ -6,34 +6,11 @@ export interface DeleteCustomAvailabilityZoneCommandInput extends DeleteCustomAv
 }
 export interface DeleteCustomAvailabilityZoneCommandOutput extends DeleteCustomAvailabilityZoneResult, __MetadataBearer {
 }
-/**
- * <p>Deletes a custom Availability Zone (AZ).</p>
- *         <p>A custom AZ is an on-premises AZ that is integrated with a VMware vSphere cluster.</p>
- *         <p>For more information about RDS on VMware, see the
- *             <a href="https://docs.aws.amazon.com/AmazonRDS/latest/RDSonVMwareUserGuide/rds-on-vmware.html">
- *                 RDS on VMware User Guide.</a>
- *          </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DeleteCustomAvailabilityZoneCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DeleteCustomAvailabilityZoneCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DeleteCustomAvailabilityZoneCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteCustomAvailabilityZoneCommandInput} for command's `input` shape.
- * @see {@link DeleteCustomAvailabilityZoneCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteCustomAvailabilityZoneCommand extends $Command<DeleteCustomAvailabilityZoneCommandInput, DeleteCustomAvailabilityZoneCommandOutput, RDSClientResolvedConfig> {
     readonly input: DeleteCustomAvailabilityZoneCommandInput;
     constructor(input: DeleteCustomAvailabilityZoneCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCustomAvailabilityZoneCommandInput, DeleteCustomAvailabilityZoneCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteCustomDBEngineVersionCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DBEngineVersion, DeleteCustomDBEngineVersionMessage } from "../models/models_0";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface DeleteCustomDBEngineVersionCommandInput extends DeleteCustomDBEngineVersionMessage {
+}
+export interface DeleteCustomDBEngineVersionCommandOutput extends DBEngineVersion, __MetadataBearer {
+}
+
+export declare class DeleteCustomDBEngineVersionCommand extends $Command<DeleteCustomDBEngineVersionCommandInput, DeleteCustomDBEngineVersionCommandOutput, RDSClientResolvedConfig> {
+    readonly input: DeleteCustomDBEngineVersionCommandInput;
+    constructor(input: DeleteCustomDBEngineVersionCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCustomDBEngineVersionCommandInput, DeleteCustomDBEngineVersionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DeleteDBClusterCommand.d.ts

@@ -6,39 +6,11 @@ export interface DeleteDBClusterCommandInput extends DeleteDBClusterMessage {
 }
 export interface DeleteDBClusterCommandOutput extends DeleteDBClusterResult, __MetadataBearer {
 }
-/**
- * <p>The DeleteDBCluster action deletes a previously provisioned DB cluster.
- *           When you delete a DB cluster, all automated backups for that DB cluster are deleted and can't be recovered.
- *           Manual DB cluster snapshots of the specified DB cluster are not deleted.</p>
- *          <p></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>
- *          <note>
- *             <p>This action only applies to Aurora DB clusters.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DeleteDBClusterCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DeleteDBClusterCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DeleteDBClusterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteDBClusterCommandInput} for command's `input` shape.
- * @see {@link DeleteDBClusterCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteDBClusterCommand extends $Command<DeleteDBClusterCommandInput, DeleteDBClusterCommandOutput, RDSClientResolvedConfig> {
     readonly input: DeleteDBClusterCommandInput;
     constructor(input: DeleteDBClusterCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDBClusterCommandInput, DeleteDBClusterCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteDBClusterEndpointCommand.d.ts

@@ -6,32 +6,11 @@ export interface DeleteDBClusterEndpointCommandInput extends DeleteDBClusterEndp
 }
 export interface DeleteDBClusterEndpointCommandOutput extends DBClusterEndpoint, __MetadataBearer {
 }
-/**
- * <p>Deletes a custom endpoint and removes it from an Amazon Aurora DB cluster.</p>
- *          <note>
- *            <p>This action only applies to Aurora DB clusters.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DeleteDBClusterEndpointCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DeleteDBClusterEndpointCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DeleteDBClusterEndpointCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteDBClusterEndpointCommandInput} for command's `input` shape.
- * @see {@link DeleteDBClusterEndpointCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteDBClusterEndpointCommand extends $Command<DeleteDBClusterEndpointCommandInput, DeleteDBClusterEndpointCommandOutput, RDSClientResolvedConfig> {
     readonly input: DeleteDBClusterEndpointCommandInput;
     constructor(input: DeleteDBClusterEndpointCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDBClusterEndpointCommandInput, DeleteDBClusterEndpointCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteDBClusterParameterGroupCommand.d.ts

@@ -6,36 +6,11 @@ export interface DeleteDBClusterParameterGroupCommandInput extends DeleteDBClust
 }
 export interface DeleteDBClusterParameterGroupCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes a specified DB cluster parameter group. The DB cluster parameter group to be deleted can't be associated with any DB clusters.</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>
- *          <note>
- *             <p>This action only applies to Aurora DB clusters.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DeleteDBClusterParameterGroupCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DeleteDBClusterParameterGroupCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DeleteDBClusterParameterGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteDBClusterParameterGroupCommandInput} for command's `input` shape.
- * @see {@link DeleteDBClusterParameterGroupCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteDBClusterParameterGroupCommand extends $Command<DeleteDBClusterParameterGroupCommandInput, DeleteDBClusterParameterGroupCommandOutput, RDSClientResolvedConfig> {
     readonly input: DeleteDBClusterParameterGroupCommandInput;
     constructor(input: DeleteDBClusterParameterGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDBClusterParameterGroupCommandInput, DeleteDBClusterParameterGroupCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteDBClusterSnapshotCommand.d.ts

@@ -6,40 +6,11 @@ export interface DeleteDBClusterSnapshotCommandInput extends DeleteDBClusterSnap
 }
 export interface DeleteDBClusterSnapshotCommandOutput extends DeleteDBClusterSnapshotResult, __MetadataBearer {
 }
-/**
- * <p>Deletes a DB cluster snapshot. If the snapshot is being copied, the copy operation is terminated.</p>
- *          <note>
- *             <p>The DB cluster snapshot must be in the <code>available</code> state to be
- *             deleted.</p>
- *          </note>
- *          <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>
- *          <note>
- *             <p>This action only applies to Aurora DB clusters.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DeleteDBClusterSnapshotCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DeleteDBClusterSnapshotCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DeleteDBClusterSnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteDBClusterSnapshotCommandInput} for command's `input` shape.
- * @see {@link DeleteDBClusterSnapshotCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteDBClusterSnapshotCommand extends $Command<DeleteDBClusterSnapshotCommandInput, DeleteDBClusterSnapshotCommandOutput, RDSClientResolvedConfig> {
     readonly input: DeleteDBClusterSnapshotCommandInput;
     constructor(input: DeleteDBClusterSnapshotCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDBClusterSnapshotCommandInput, DeleteDBClusterSnapshotCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteDBInstanceAutomatedBackupCommand.d.ts

@@ -6,29 +6,11 @@ export interface DeleteDBInstanceAutomatedBackupCommandInput extends DeleteDBIns
 }
 export interface DeleteDBInstanceAutomatedBackupCommandOutput extends DeleteDBInstanceAutomatedBackupResult, __MetadataBearer {
 }
-/**
- * <p>Deletes automated backups using the <code>DbiResourceId</code> value of the source DB instance or the Amazon Resource Name (ARN) of the automated backups.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DeleteDBInstanceAutomatedBackupCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DeleteDBInstanceAutomatedBackupCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DeleteDBInstanceAutomatedBackupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteDBInstanceAutomatedBackupCommandInput} for command's `input` shape.
- * @see {@link DeleteDBInstanceAutomatedBackupCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteDBInstanceAutomatedBackupCommand extends $Command<DeleteDBInstanceAutomatedBackupCommandInput, DeleteDBInstanceAutomatedBackupCommandOutput, RDSClientResolvedConfig> {
     readonly input: DeleteDBInstanceAutomatedBackupCommandInput;
     constructor(input: DeleteDBInstanceAutomatedBackupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDBInstanceAutomatedBackupCommandInput, DeleteDBInstanceAutomatedBackupCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteDBInstanceCommand.d.ts

@@ -6,54 +6,11 @@ export interface DeleteDBInstanceCommandInput extends DeleteDBInstanceMessage {
 }
 export interface DeleteDBInstanceCommandOutput extends DeleteDBInstanceResult, __MetadataBearer {
 }
-/**
- * <p>The DeleteDBInstance action deletes a previously provisioned DB instance.
- *           When you delete a DB instance, all automated backups for that instance are deleted and can't be recovered.
- *           Manual DB snapshots of the DB instance to be deleted by <code>DeleteDBInstance</code> are not deleted.</p>
- *          <p>
- *         If you request a final DB snapshot
- *         the status of the Amazon RDS DB instance is <code>deleting</code> until the DB snapshot is created. The API action <code>DescribeDBInstance</code>
- *         is used to monitor the status of this operation. The action can't be canceled or reverted once submitted.
- *         </p>
- *          <p>When a DB instance is in a failure state and has a status of <code>failed</code>, <code>incompatible-restore</code>,
- *           or <code>incompatible-network</code>, you can only delete it when you skip creation of the final snapshot with the <code>SkipFinalSnapshot</code> parameter.</p>
- *
- *          <p>If the specified DB instance is part of an Amazon Aurora DB cluster, you can't delete the DB instance if both of the following
- *       conditions are true:</p>
- *          <ul>
- *             <li>
- *                <p>The DB cluster is a read replica of another Amazon Aurora DB cluster.</p>
- *             </li>
- *             <li>
- *                <p>The DB instance is the only instance in the DB cluster.</p>
- *             </li>
- *          </ul>
- *          <p>To delete a DB instance in this case, first call the
- *                 <code>PromoteReadReplicaDBCluster</code> API action to promote the DB cluster so
- *             it's no longer a read replica. After the promotion completes, then call the
- *                 <code>DeleteDBInstance</code> API action to delete the final instance in the DB
- *             cluster.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DeleteDBInstanceCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DeleteDBInstanceCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DeleteDBInstanceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteDBInstanceCommandInput} for command's `input` shape.
- * @see {@link DeleteDBInstanceCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteDBInstanceCommand extends $Command<DeleteDBInstanceCommandInput, DeleteDBInstanceCommandOutput, RDSClientResolvedConfig> {
     readonly input: DeleteDBInstanceCommandInput;
     constructor(input: DeleteDBInstanceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDBInstanceCommandInput, DeleteDBInstanceCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteDBParameterGroupCommand.d.ts

@@ -6,29 +6,11 @@ export interface DeleteDBParameterGroupCommandInput extends DeleteDBParameterGro
 }
 export interface DeleteDBParameterGroupCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes a specified DB parameter group. The DB parameter group to be deleted can't be associated with any DB instances.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DeleteDBParameterGroupCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DeleteDBParameterGroupCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DeleteDBParameterGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteDBParameterGroupCommandInput} for command's `input` shape.
- * @see {@link DeleteDBParameterGroupCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteDBParameterGroupCommand extends $Command<DeleteDBParameterGroupCommandInput, DeleteDBParameterGroupCommandOutput, RDSClientResolvedConfig> {
     readonly input: DeleteDBParameterGroupCommandInput;
     constructor(input: DeleteDBParameterGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDBParameterGroupCommandInput, DeleteDBParameterGroupCommandOutput>;
     private serialize;
     private deserialize;