@aws-sdk/client-rds 3.34.0 → 3.37.0

package/dist/types/commands/DescribeCustomAvailabilityZonesCommand.d.ts

@@ -1,40 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { CustomAvailabilityZoneMessage, DescribeCustomAvailabilityZonesMessage } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeCustomAvailabilityZonesCommandInput extends DescribeCustomAvailabilityZonesMessage {
-}
-export interface DescribeCustomAvailabilityZonesCommandOutput extends CustomAvailabilityZoneMessage, __MetadataBearer {
-}
-/**
- * <p>Returns information about custom Availability Zones (AZs).</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, DescribeCustomAvailabilityZonesCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeCustomAvailabilityZonesCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeCustomAvailabilityZonesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeCustomAvailabilityZonesCommandInput} for command's `input` shape.
- * @see {@link DescribeCustomAvailabilityZonesCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeCustomAvailabilityZonesCommand extends $Command<DescribeCustomAvailabilityZonesCommandInput, DescribeCustomAvailabilityZonesCommandOutput, RDSClientResolvedConfig> {
-    readonly input: DescribeCustomAvailabilityZonesCommandInput;
-    constructor(input: DescribeCustomAvailabilityZonesCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeCustomAvailabilityZonesCommandInput, DescribeCustomAvailabilityZonesCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DescribeDBClusterBacktracksCommand.d.ts

@@ -1,42 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { DBClusterBacktrackMessage, DescribeDBClusterBacktracksMessage } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeDBClusterBacktracksCommandInput extends DescribeDBClusterBacktracksMessage {
-}
-export interface DescribeDBClusterBacktracksCommandOutput extends DBClusterBacktrackMessage, __MetadataBearer {
-}
-/**
- * <p>Returns information about backtracks for 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>
- *         <note>
- *             <p>This action only applies to Aurora MySQL DB clusters.</p>
- *         </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DescribeDBClusterBacktracksCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeDBClusterBacktracksCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeDBClusterBacktracksCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDBClusterBacktracksCommandInput} for command's `input` shape.
- * @see {@link DescribeDBClusterBacktracksCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeDBClusterBacktracksCommand extends $Command<DescribeDBClusterBacktracksCommandInput, DescribeDBClusterBacktracksCommandOutput, RDSClientResolvedConfig> {
-    readonly input: DescribeDBClusterBacktracksCommandInput;
-    constructor(input: DescribeDBClusterBacktracksCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDBClusterBacktracksCommandInput, DescribeDBClusterBacktracksCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DescribeDBClusterEndpointsCommand.d.ts

@@ -1,38 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { DBClusterEndpointMessage, DescribeDBClusterEndpointsMessage } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeDBClusterEndpointsCommandInput extends DescribeDBClusterEndpointsMessage {
-}
-export interface DescribeDBClusterEndpointsCommandOutput extends DBClusterEndpointMessage, __MetadataBearer {
-}
-/**
- * <p>Returns information about endpoints for 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, DescribeDBClusterEndpointsCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeDBClusterEndpointsCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeDBClusterEndpointsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDBClusterEndpointsCommandInput} for command's `input` shape.
- * @see {@link DescribeDBClusterEndpointsCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeDBClusterEndpointsCommand extends $Command<DescribeDBClusterEndpointsCommandInput, DescribeDBClusterEndpointsCommandOutput, RDSClientResolvedConfig> {
-    readonly input: DescribeDBClusterEndpointsCommandInput;
-    constructor(input: DescribeDBClusterEndpointsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDBClusterEndpointsCommandInput, DescribeDBClusterEndpointsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DescribeDBClusterParameterGroupsCommand.d.ts

@@ -1,46 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { DBClusterParameterGroupsMessage, DescribeDBClusterParameterGroupsMessage } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeDBClusterParameterGroupsCommandInput extends DescribeDBClusterParameterGroupsMessage {
-}
-export interface DescribeDBClusterParameterGroupsCommandOutput extends DBClusterParameterGroupsMessage, __MetadataBearer {
-}
-/**
- * <p>
- *             Returns a list of <code>DBClusterParameterGroup</code> descriptions. If a
- *             <code>DBClusterParameterGroupName</code> parameter is specified,
- *             the list will contain only the description of the specified DB cluster parameter group.
- *         </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, DescribeDBClusterParameterGroupsCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeDBClusterParameterGroupsCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeDBClusterParameterGroupsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDBClusterParameterGroupsCommandInput} for command's `input` shape.
- * @see {@link DescribeDBClusterParameterGroupsCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeDBClusterParameterGroupsCommand extends $Command<DescribeDBClusterParameterGroupsCommandInput, DescribeDBClusterParameterGroupsCommandOutput, RDSClientResolvedConfig> {
-    readonly input: DescribeDBClusterParameterGroupsCommandInput;
-    constructor(input: DescribeDBClusterParameterGroupsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDBClusterParameterGroupsCommandInput, DescribeDBClusterParameterGroupsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DescribeDBClusterParametersCommand.d.ts

@@ -1,42 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { DBClusterParameterGroupDetails, DescribeDBClusterParametersMessage } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeDBClusterParametersCommandInput extends DescribeDBClusterParametersMessage {
-}
-export interface DescribeDBClusterParametersCommandOutput extends DBClusterParameterGroupDetails, __MetadataBearer {
-}
-/**
- * <p>Returns the detailed parameter list for a particular DB cluster parameter group.</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, DescribeDBClusterParametersCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeDBClusterParametersCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeDBClusterParametersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDBClusterParametersCommandInput} for command's `input` shape.
- * @see {@link DescribeDBClusterParametersCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeDBClusterParametersCommand extends $Command<DescribeDBClusterParametersCommandInput, DescribeDBClusterParametersCommandOutput, RDSClientResolvedConfig> {
-    readonly input: DescribeDBClusterParametersCommandInput;
-    constructor(input: DescribeDBClusterParametersCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDBClusterParametersCommandInput, DescribeDBClusterParametersCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DescribeDBClusterSnapshotAttributesCommand.d.ts

@@ -1,45 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { DescribeDBClusterSnapshotAttributesMessage, DescribeDBClusterSnapshotAttributesResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeDBClusterSnapshotAttributesCommandInput extends DescribeDBClusterSnapshotAttributesMessage {
-}
-export interface DescribeDBClusterSnapshotAttributesCommandOutput extends DescribeDBClusterSnapshotAttributesResult, __MetadataBearer {
-}
-/**
- * <p>Returns a list of DB cluster snapshot attribute names and values for a manual DB cluster snapshot.</p>
- *         <p>When sharing snapshots with other Amazon Web Services accounts, <code>DescribeDBClusterSnapshotAttributes</code>
- *             returns the <code>restore</code> attribute and a list of IDs for the Amazon Web Services accounts that are
- *             authorized to copy or restore the manual DB cluster snapshot. If <code>all</code> is included in the list of
- *             values for the <code>restore</code> attribute, then the manual DB cluster snapshot is public and
- *             can be copied or restored by all Amazon Web Services accounts.</p>
- *         <p>To add or remove access for an Amazon Web Services account to copy or restore a manual DB cluster snapshot, or to make the
- *             manual DB cluster snapshot public or private, use the <code>ModifyDBClusterSnapshotAttribute</code> API action.</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, DescribeDBClusterSnapshotAttributesCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeDBClusterSnapshotAttributesCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeDBClusterSnapshotAttributesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDBClusterSnapshotAttributesCommandInput} for command's `input` shape.
- * @see {@link DescribeDBClusterSnapshotAttributesCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeDBClusterSnapshotAttributesCommand extends $Command<DescribeDBClusterSnapshotAttributesCommandInput, DescribeDBClusterSnapshotAttributesCommandOutput, RDSClientResolvedConfig> {
-    readonly input: DescribeDBClusterSnapshotAttributesCommandInput;
-    constructor(input: DescribeDBClusterSnapshotAttributesCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDBClusterSnapshotAttributesCommandInput, DescribeDBClusterSnapshotAttributesCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DescribeDBClusterSnapshotsCommand.d.ts

@@ -1,42 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { DBClusterSnapshotMessage, DescribeDBClusterSnapshotsMessage } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeDBClusterSnapshotsCommandInput extends DescribeDBClusterSnapshotsMessage {
-}
-export interface DescribeDBClusterSnapshotsCommandOutput extends DBClusterSnapshotMessage, __MetadataBearer {
-}
-/**
- * <p>Returns information about DB cluster snapshots. This API action 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, DescribeDBClusterSnapshotsCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeDBClusterSnapshotsCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeDBClusterSnapshotsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDBClusterSnapshotsCommandInput} for command's `input` shape.
- * @see {@link DescribeDBClusterSnapshotsCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeDBClusterSnapshotsCommand extends $Command<DescribeDBClusterSnapshotsCommandInput, DescribeDBClusterSnapshotsCommandOutput, RDSClientResolvedConfig> {
-    readonly input: DescribeDBClusterSnapshotsCommandInput;
-    constructor(input: DescribeDBClusterSnapshotsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDBClusterSnapshotsCommandInput, DescribeDBClusterSnapshotsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DescribeDBClustersCommand.d.ts

@@ -1,42 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { DBClusterMessage, DescribeDBClustersMessage } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeDBClustersCommandInput extends DescribeDBClustersMessage {
-}
-export interface DescribeDBClustersCommandOutput extends DBClusterMessage, __MetadataBearer {
-}
-/**
- * <p>Returns information about provisioned Aurora DB 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 operation can also return information for Amazon Neptune DB instances and Amazon DocumentDB instances.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DescribeDBClustersCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeDBClustersCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeDBClustersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDBClustersCommandInput} for command's `input` shape.
- * @see {@link DescribeDBClustersCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeDBClustersCommand extends $Command<DescribeDBClustersCommandInput, DescribeDBClustersCommandOutput, RDSClientResolvedConfig> {
-    readonly input: DescribeDBClustersCommandInput;
-    constructor(input: DescribeDBClustersCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDBClustersCommandInput, DescribeDBClustersCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DescribeDBEngineVersionsCommand.d.ts

@@ -1,35 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { DBEngineVersionMessage, DescribeDBEngineVersionsMessage } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeDBEngineVersionsCommandInput extends DescribeDBEngineVersionsMessage {
-}
-export interface DescribeDBEngineVersionsCommandOutput extends DBEngineVersionMessage, __MetadataBearer {
-}
-/**
- * <p>Returns a list of the available DB engines.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DescribeDBEngineVersionsCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeDBEngineVersionsCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeDBEngineVersionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDBEngineVersionsCommandInput} for command's `input` shape.
- * @see {@link DescribeDBEngineVersionsCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeDBEngineVersionsCommand extends $Command<DescribeDBEngineVersionsCommandInput, DescribeDBEngineVersionsCommandOutput, RDSClientResolvedConfig> {
-    readonly input: DescribeDBEngineVersionsCommandInput;
-    constructor(input: DescribeDBEngineVersionsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDBEngineVersionsCommandInput, DescribeDBEngineVersionsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DescribeDBInstanceAutomatedBackupsCommand.d.ts

@@ -1,41 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { DBInstanceAutomatedBackupMessage, DescribeDBInstanceAutomatedBackupsMessage } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeDBInstanceAutomatedBackupsCommandInput extends DescribeDBInstanceAutomatedBackupsMessage {
-}
-export interface DescribeDBInstanceAutomatedBackupsCommandOutput extends DBInstanceAutomatedBackupMessage, __MetadataBearer {
-}
-/**
- * <p>Displays backups for both current and deleted
- *             instances. For example, use this operation to
- *             find details about automated backups for previously deleted instances. Current instances
- *             with retention periods greater than zero (0) are returned for both the
- *             <code>DescribeDBInstanceAutomatedBackups</code> and
- *             <code>DescribeDBInstances</code> operations.</p>
- * 	        <p>All parameters are optional.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DescribeDBInstanceAutomatedBackupsCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeDBInstanceAutomatedBackupsCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeDBInstanceAutomatedBackupsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDBInstanceAutomatedBackupsCommandInput} for command's `input` shape.
- * @see {@link DescribeDBInstanceAutomatedBackupsCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeDBInstanceAutomatedBackupsCommand extends $Command<DescribeDBInstanceAutomatedBackupsCommandInput, DescribeDBInstanceAutomatedBackupsCommandOutput, RDSClientResolvedConfig> {
-    readonly input: DescribeDBInstanceAutomatedBackupsCommandInput;
-    constructor(input: DescribeDBInstanceAutomatedBackupsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDBInstanceAutomatedBackupsCommandInput, DescribeDBInstanceAutomatedBackupsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DescribeDBInstancesCommand.d.ts

@@ -1,38 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { DBInstanceMessage, DescribeDBInstancesMessage } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeDBInstancesCommandInput extends DescribeDBInstancesMessage {
-}
-export interface DescribeDBInstancesCommandOutput extends DBInstanceMessage, __MetadataBearer {
-}
-/**
- * <p>Returns information about provisioned RDS instances. This API supports pagination.</p>
- *          <note>
- *             <p>This operation can also return information for Amazon Neptune DB instances and Amazon DocumentDB instances.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DescribeDBInstancesCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeDBInstancesCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeDBInstancesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDBInstancesCommandInput} for command's `input` shape.
- * @see {@link DescribeDBInstancesCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeDBInstancesCommand extends $Command<DescribeDBInstancesCommandInput, DescribeDBInstancesCommandOutput, RDSClientResolvedConfig> {
-    readonly input: DescribeDBInstancesCommandInput;
-    constructor(input: DescribeDBInstancesCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDBInstancesCommandInput, DescribeDBInstancesCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DescribeDBLogFilesCommand.d.ts

@@ -1,35 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { DescribeDBLogFilesMessage, DescribeDBLogFilesResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeDBLogFilesCommandInput extends DescribeDBLogFilesMessage {
-}
-export interface DescribeDBLogFilesCommandOutput extends DescribeDBLogFilesResponse, __MetadataBearer {
-}
-/**
- * <p>Returns a list of DB log files for the DB instance.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DescribeDBLogFilesCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeDBLogFilesCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeDBLogFilesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDBLogFilesCommandInput} for command's `input` shape.
- * @see {@link DescribeDBLogFilesCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeDBLogFilesCommand extends $Command<DescribeDBLogFilesCommandInput, DescribeDBLogFilesCommandOutput, RDSClientResolvedConfig> {
-    readonly input: DescribeDBLogFilesCommandInput;
-    constructor(input: DescribeDBLogFilesCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDBLogFilesCommandInput, DescribeDBLogFilesCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DescribeDBParameterGroupsCommand.d.ts

@@ -1,38 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { DBParameterGroupsMessage, DescribeDBParameterGroupsMessage } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeDBParameterGroupsCommandInput extends DescribeDBParameterGroupsMessage {
-}
-export interface DescribeDBParameterGroupsCommandOutput extends DBParameterGroupsMessage, __MetadataBearer {
-}
-/**
- * <p>
- *         Returns a list of <code>DBParameterGroup</code> descriptions. If a <code>DBParameterGroupName</code> is specified,
- *             the list will contain only the description of the specified DB parameter group.
- *         </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DescribeDBParameterGroupsCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeDBParameterGroupsCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeDBParameterGroupsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDBParameterGroupsCommandInput} for command's `input` shape.
- * @see {@link DescribeDBParameterGroupsCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeDBParameterGroupsCommand extends $Command<DescribeDBParameterGroupsCommandInput, DescribeDBParameterGroupsCommandOutput, RDSClientResolvedConfig> {
-    readonly input: DescribeDBParameterGroupsCommandInput;
-    constructor(input: DescribeDBParameterGroupsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDBParameterGroupsCommandInput, DescribeDBParameterGroupsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DescribeDBParametersCommand.d.ts

@@ -1,35 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { DBParameterGroupDetails, DescribeDBParametersMessage } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeDBParametersCommandInput extends DescribeDBParametersMessage {
-}
-export interface DescribeDBParametersCommandOutput extends DBParameterGroupDetails, __MetadataBearer {
-}
-/**
- * <p>Returns the detailed parameter list for a particular DB parameter group.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DescribeDBParametersCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeDBParametersCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeDBParametersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDBParametersCommandInput} for command's `input` shape.
- * @see {@link DescribeDBParametersCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeDBParametersCommand extends $Command<DescribeDBParametersCommandInput, DescribeDBParametersCommandOutput, RDSClientResolvedConfig> {
-    readonly input: DescribeDBParametersCommandInput;
-    constructor(input: DescribeDBParametersCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDBParametersCommandInput, DescribeDBParametersCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DescribeDBProxiesCommand.d.ts

@@ -1,35 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { DescribeDBProxiesRequest, DescribeDBProxiesResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeDBProxiesCommandInput extends DescribeDBProxiesRequest {
-}
-export interface DescribeDBProxiesCommandOutput extends DescribeDBProxiesResponse, __MetadataBearer {
-}
-/**
- * <p>Returns information about DB proxies.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, DescribeDBProxiesCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, DescribeDBProxiesCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new DescribeDBProxiesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDBProxiesCommandInput} for command's `input` shape.
- * @see {@link DescribeDBProxiesCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeDBProxiesCommand extends $Command<DescribeDBProxiesCommandInput, DescribeDBProxiesCommandOutput, RDSClientResolvedConfig> {
-    readonly input: DescribeDBProxiesCommandInput;
-    constructor(input: DescribeDBProxiesCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDBProxiesCommandInput, DescribeDBProxiesCommandOutput>;
-    private serialize;
-    private deserialize;
-}