@aws-sdk/client-rds 3.36.0 → 3.39.0

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

@@ -6,33 +6,11 @@ export interface DescribeEngineDefaultClusterParametersCommandInput extends Desc
 }
 export interface DescribeEngineDefaultClusterParametersCommandOutput extends DescribeEngineDefaultClusterParametersResult, __MetadataBearer {
 }
-/**
- * <p>Returns the default engine and system parameter information for the cluster database engine.</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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DescribeEngineDefaultClusterParametersCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeEngineDefaultClusterParametersCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeEngineDefaultClusterParametersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeEngineDefaultClusterParametersCommandInput} for command's `input` shape.
- * @see {@link DescribeEngineDefaultClusterParametersCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeEngineDefaultClusterParametersCommand extends $Command<DescribeEngineDefaultClusterParametersCommandInput, DescribeEngineDefaultClusterParametersCommandOutput, RDSClientResolvedConfig> {
     readonly input: DescribeEngineDefaultClusterParametersCommandInput;
     constructor(input: DescribeEngineDefaultClusterParametersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeEngineDefaultClusterParametersCommandInput, DescribeEngineDefaultClusterParametersCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeEngineDefaultParametersCommandInput extends DescribeEng
 }
 export interface DescribeEngineDefaultParametersCommandOutput extends DescribeEngineDefaultParametersResult, __MetadataBearer {
 }
-/**
- * <p>Returns the default engine and system parameter information for the specified database engine.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DescribeEngineDefaultParametersCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeEngineDefaultParametersCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeEngineDefaultParametersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeEngineDefaultParametersCommandInput} for command's `input` shape.
- * @see {@link DescribeEngineDefaultParametersCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeEngineDefaultParametersCommand extends $Command<DescribeEngineDefaultParametersCommandInput, DescribeEngineDefaultParametersCommandOutput, RDSClientResolvedConfig> {
     readonly input: DescribeEngineDefaultParametersCommandInput;
     constructor(input: DescribeEngineDefaultParametersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeEngineDefaultParametersCommandInput, DescribeEngineDefaultParametersCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DescribeEventCategoriesCommandInput extends DescribeEventCatego
 }
 export interface DescribeEventCategoriesCommandOutput extends EventCategoriesMessage, __MetadataBearer {
 }
-/**
- * <p>Displays a list of categories for all event source types, or, if specified, for a specified source type.
- *             You can see a list of the event categories and source types
- *             in <a href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Events.html">
- *                 Events</a> in the <i>Amazon RDS User Guide.</i>
- *          </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DescribeEventCategoriesCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeEventCategoriesCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeEventCategoriesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeEventCategoriesCommandInput} for command's `input` shape.
- * @see {@link DescribeEventCategoriesCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeEventCategoriesCommand extends $Command<DescribeEventCategoriesCommandInput, DescribeEventCategoriesCommandOutput, RDSClientResolvedConfig> {
     readonly input: DescribeEventCategoriesCommandInput;
     constructor(input: DescribeEventCategoriesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeEventCategoriesCommandInput, DescribeEventCategoriesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeEventSubscriptionsCommandInput extends DescribeEventSub
 }
 export interface DescribeEventSubscriptionsCommandOutput extends EventSubscriptionsMessage, __MetadataBearer {
 }
-/**
- * <p>Lists all the subscription descriptions for a customer account. The description for a subscription includes
- *           <code>SubscriptionName</code>, <code>SNSTopicARN</code>, <code>CustomerID</code>, <code>SourceType</code>, <code>SourceID</code>, <code>CreationTime</code>, and <code>Status</code>.</p>
- *          <p>If you specify a <code>SubscriptionName</code>, lists the description for that subscription.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DescribeEventSubscriptionsCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeEventSubscriptionsCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeEventSubscriptionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeEventSubscriptionsCommandInput} for command's `input` shape.
- * @see {@link DescribeEventSubscriptionsCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeEventSubscriptionsCommand extends $Command<DescribeEventSubscriptionsCommandInput, DescribeEventSubscriptionsCommandOutput, RDSClientResolvedConfig> {
     readonly input: DescribeEventSubscriptionsCommandInput;
     constructor(input: DescribeEventSubscriptionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeEventSubscriptionsCommandInput, DescribeEventSubscriptionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface DescribeEventsCommandInput extends DescribeEventsMessage {
 }
 export interface DescribeEventsCommandOutput extends EventsMessage, __MetadataBearer {
 }
-/**
- * <p>Returns events related to DB instances, DB clusters, DB parameter groups, DB security groups, DB snapshots, and DB cluster snapshots for the past 14 days.
- *           Events specific to a particular DB instances, DB clusters, DB parameter groups, DB security groups, DB snapshots, and DB cluster snapshots group can be
- *           obtained by providing the name as a parameter.</p>
- *          <note>
- *             <p>By default, the past hour of events are returned.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DescribeEventsCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeEventsCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeEventsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeEventsCommandInput} for command's `input` shape.
- * @see {@link DescribeEventsCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeEventsCommand extends $Command<DescribeEventsCommandInput, DescribeEventsCommandOutput, RDSClientResolvedConfig> {
     readonly input: DescribeEventsCommandInput;
     constructor(input: DescribeEventsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeEventsCommandInput, DescribeEventsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeExportTasksCommandInput extends DescribeExportTasksMess
 }
 export interface DescribeExportTasksCommandOutput extends ExportTasksMessage, __MetadataBearer {
 }
-/**
- * <p>Returns information about a snapshot export to Amazon S3. This API operation supports
- *             pagination. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DescribeExportTasksCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeExportTasksCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeExportTasksCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeExportTasksCommandInput} for command's `input` shape.
- * @see {@link DescribeExportTasksCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeExportTasksCommand extends $Command<DescribeExportTasksCommandInput, DescribeExportTasksCommandOutput, RDSClientResolvedConfig> {
     readonly input: DescribeExportTasksCommandInput;
     constructor(input: DescribeExportTasksCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeExportTasksCommandInput, DescribeExportTasksCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,38 +6,11 @@ export interface DescribeGlobalClustersCommandInput extends DescribeGlobalCluste
 }
 export interface DescribeGlobalClustersCommandOutput extends GlobalClustersMessage, __MetadataBearer {
 }
-/**
- * <p>
- *         Returns information about Aurora global database clusters. This API supports pagination.
- *       </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, DescribeGlobalClustersCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeGlobalClustersCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeGlobalClustersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeGlobalClustersCommandInput} for command's `input` shape.
- * @see {@link DescribeGlobalClustersCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeGlobalClustersCommand extends $Command<DescribeGlobalClustersCommandInput, DescribeGlobalClustersCommandOutput, RDSClientResolvedConfig> {
     readonly input: DescribeGlobalClustersCommandInput;
     constructor(input: DescribeGlobalClustersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeGlobalClustersCommandInput, DescribeGlobalClustersCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeInstallationMediaCommandInput extends DescribeInstallat
 }
 export interface DescribeInstallationMediaCommandOutput extends InstallationMediaMessage, __MetadataBearer {
 }
-/**
- * <p>Describes the available installation media for a DB engine that requires an
- *           on-premises customer provided license, such as Microsoft SQL Server.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DescribeInstallationMediaCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeInstallationMediaCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeInstallationMediaCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeInstallationMediaCommandInput} for command's `input` shape.
- * @see {@link DescribeInstallationMediaCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeInstallationMediaCommand extends $Command<DescribeInstallationMediaCommandInput, DescribeInstallationMediaCommandOutput, RDSClientResolvedConfig> {
     readonly input: DescribeInstallationMediaCommandInput;
     constructor(input: DescribeInstallationMediaCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeInstallationMediaCommandInput, DescribeInstallationMediaCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,29 +6,11 @@ export interface DescribeOrderableDBInstanceOptionsCommandInput extends Describe
 }
 export interface DescribeOrderableDBInstanceOptionsCommandOutput extends OrderableDBInstanceOptionsMessage, __MetadataBearer {
 }
-/**
- * <p>Returns a list of orderable DB instance options for the specified engine.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DescribeOrderableDBInstanceOptionsCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeOrderableDBInstanceOptionsCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeOrderableDBInstanceOptionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeOrderableDBInstanceOptionsCommandInput} for command's `input` shape.
- * @see {@link DescribeOrderableDBInstanceOptionsCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeOrderableDBInstanceOptionsCommand extends $Command<DescribeOrderableDBInstanceOptionsCommandInput, DescribeOrderableDBInstanceOptionsCommandOutput, RDSClientResolvedConfig> {
     readonly input: DescribeOrderableDBInstanceOptionsCommandInput;
     constructor(input: DescribeOrderableDBInstanceOptionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeOrderableDBInstanceOptionsCommandInput, DescribeOrderableDBInstanceOptionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribePendingMaintenanceActionsCommandInput extends DescribeP
 }
 export interface DescribePendingMaintenanceActionsCommandOutput extends PendingMaintenanceActionsMessage, __MetadataBearer {
 }
-/**
- * <p>Returns a list of resources (for example, DB instances) that have at least one pending maintenance action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DescribePendingMaintenanceActionsCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribePendingMaintenanceActionsCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribePendingMaintenanceActionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribePendingMaintenanceActionsCommandInput} for command's `input` shape.
- * @see {@link DescribePendingMaintenanceActionsCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribePendingMaintenanceActionsCommand extends $Command<DescribePendingMaintenanceActionsCommandInput, DescribePendingMaintenanceActionsCommandOutput, RDSClientResolvedConfig> {
     readonly input: DescribePendingMaintenanceActionsCommandInput;
     constructor(input: DescribePendingMaintenanceActionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribePendingMaintenanceActionsCommandInput, DescribePendingMaintenanceActionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeReservedDBInstancesCommandInput extends DescribeReserve
 }
 export interface DescribeReservedDBInstancesCommandOutput extends ReservedDBInstanceMessage, __MetadataBearer {
 }
-/**
- * <p>Returns information about reserved DB instances for this account, or about a specified reserved DB instance.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DescribeReservedDBInstancesCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeReservedDBInstancesCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeReservedDBInstancesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeReservedDBInstancesCommandInput} for command's `input` shape.
- * @see {@link DescribeReservedDBInstancesCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeReservedDBInstancesCommand extends $Command<DescribeReservedDBInstancesCommandInput, DescribeReservedDBInstancesCommandOutput, RDSClientResolvedConfig> {
     readonly input: DescribeReservedDBInstancesCommandInput;
     constructor(input: DescribeReservedDBInstancesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeReservedDBInstancesCommandInput, DescribeReservedDBInstancesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeReservedDBInstancesOfferingsCommandInput extends Descri
 }
 export interface DescribeReservedDBInstancesOfferingsCommandOutput extends ReservedDBInstancesOfferingMessage, __MetadataBearer {
 }
-/**
- * <p>Lists available reserved DB instance offerings.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DescribeReservedDBInstancesOfferingsCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeReservedDBInstancesOfferingsCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeReservedDBInstancesOfferingsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeReservedDBInstancesOfferingsCommandInput} for command's `input` shape.
- * @see {@link DescribeReservedDBInstancesOfferingsCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeReservedDBInstancesOfferingsCommand extends $Command<DescribeReservedDBInstancesOfferingsCommandInput, DescribeReservedDBInstancesOfferingsCommandOutput, RDSClientResolvedConfig> {
     readonly input: DescribeReservedDBInstancesOfferingsCommandInput;
     constructor(input: DescribeReservedDBInstancesOfferingsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeReservedDBInstancesOfferingsCommandInput, DescribeReservedDBInstancesOfferingsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeSourceRegionsCommandInput extends DescribeSourceRegions
 }
 export interface DescribeSourceRegionsCommandOutput extends SourceRegionMessage, __MetadataBearer {
 }
-/**
- * <p>Returns a list of the source Amazon Web Services Regions where the current Amazon Web Services Region can create a read replica,
- *          copy a DB snapshot from, or replicate automated backups from. This API action supports pagination.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DescribeSourceRegionsCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeSourceRegionsCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeSourceRegionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeSourceRegionsCommandInput} for command's `input` shape.
- * @see {@link DescribeSourceRegionsCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeSourceRegionsCommand extends $Command<DescribeSourceRegionsCommandInput, DescribeSourceRegionsCommandOutput, RDSClientResolvedConfig> {
     readonly input: DescribeSourceRegionsCommandInput;
     constructor(input: DescribeSourceRegionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeSourceRegionsCommandInput, DescribeSourceRegionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DescribeValidDBInstanceModificationsCommandInput extends Descri
 }
 export interface DescribeValidDBInstanceModificationsCommandOutput extends DescribeValidDBInstanceModificationsResult, __MetadataBearer {
 }
-/**
- * <p>You can call <code>DescribeValidDBInstanceModifications</code>
- *             to learn what modifications you can make to your DB instance.
- *             You can use this information when you call
- *             <code>ModifyDBInstance</code>.
- *         </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DescribeValidDBInstanceModificationsCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeValidDBInstanceModificationsCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeValidDBInstanceModificationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeValidDBInstanceModificationsCommandInput} for command's `input` shape.
- * @see {@link DescribeValidDBInstanceModificationsCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeValidDBInstanceModificationsCommand extends $Command<DescribeValidDBInstanceModificationsCommandInput, DescribeValidDBInstanceModificationsCommandOutput, RDSClientResolvedConfig> {
     readonly input: DescribeValidDBInstanceModificationsCommandInput;
     constructor(input: DescribeValidDBInstanceModificationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeValidDBInstanceModificationsCommandInput, DescribeValidDBInstanceModificationsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DownloadDBLogFilePortionCommandInput extends DownloadDBLogFileP
 }
 export interface DownloadDBLogFilePortionCommandOutput extends DownloadDBLogFilePortionDetails, __MetadataBearer {
 }
-/**
- * <p>Downloads all or a portion of the specified log file, up to 1 MB in size.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DownloadDBLogFilePortionCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DownloadDBLogFilePortionCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DownloadDBLogFilePortionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DownloadDBLogFilePortionCommandInput} for command's `input` shape.
- * @see {@link DownloadDBLogFilePortionCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DownloadDBLogFilePortionCommand extends $Command<DownloadDBLogFilePortionCommandInput, DownloadDBLogFilePortionCommandOutput, RDSClientResolvedConfig> {
     readonly input: DownloadDBLogFilePortionCommandInput;
     constructor(input: DownloadDBLogFilePortionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DownloadDBLogFilePortionCommandInput, DownloadDBLogFilePortionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,42 +6,11 @@ export interface FailoverDBClusterCommandInput extends FailoverDBClusterMessage
 }
 export interface FailoverDBClusterCommandOutput extends FailoverDBClusterResult, __MetadataBearer {
 }
-/**
- * <p>Forces a failover for a DB cluster.</p>
- *          <p>A failover for a DB cluster promotes one of the Aurora Replicas (read-only instances)
- *           in the DB cluster to be the primary instance (the cluster writer).</p>
- *          <p>Amazon Aurora will automatically fail over to an Aurora Replica, if one exists,
- *           when the primary instance fails. You can force a failover when you want to simulate a failure of a primary instance for testing.
- *           Because each instance in a DB cluster has its own endpoint address, you will need to clean up and re-establish any existing
- *           connections that use those endpoint addresses when the failover is complete.</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, FailoverDBClusterCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, FailoverDBClusterCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new FailoverDBClusterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link FailoverDBClusterCommandInput} for command's `input` shape.
- * @see {@link FailoverDBClusterCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class FailoverDBClusterCommand extends $Command<FailoverDBClusterCommandInput, FailoverDBClusterCommandOutput, RDSClientResolvedConfig> {
     readonly input: FailoverDBClusterCommandInput;
     constructor(input: FailoverDBClusterCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<FailoverDBClusterCommandInput, FailoverDBClusterCommandOutput>;
     private serialize;
     private deserialize;