@aws-sdk/client-rds 3.34.0 → 3.37.0

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,42 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DescribeDBSnapshotAttributesMessage, DescribeDBSnapshotAttributesResult } from "../models/models_1";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface DescribeDBSnapshotAttributesCommandInput extends DescribeDBSnapshotAttributesMessage {
+}
+export interface DescribeDBSnapshotAttributesCommandOutput extends DescribeDBSnapshotAttributesResult, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of DB snapshot attribute names and values for a manual DB snapshot.</p>
+ *          <p>When sharing snapshots with other Amazon Web Services accounts, <code>DescribeDBSnapshotAttributes</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 snapshot. If <code>all</code> is included in the list of
+ *       values for the <code>restore</code> attribute, then the manual DB 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 snapshot, or to make the
+ *       manual DB snapshot public or private, use the <code>ModifyDBSnapshotAttribute</code> API action.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RDSClient, DescribeDBSnapshotAttributesCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, DescribeDBSnapshotAttributesCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new DescribeDBSnapshotAttributesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeDBSnapshotAttributesCommandInput} for command's `input` shape.
+ * @see {@link DescribeDBSnapshotAttributesCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeDBSnapshotAttributesCommand extends $Command<DescribeDBSnapshotAttributesCommandInput, DescribeDBSnapshotAttributesCommandOutput, RDSClientResolvedConfig> {
+    readonly input: DescribeDBSnapshotAttributesCommandInput;
+    constructor(input: DescribeDBSnapshotAttributesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDBSnapshotAttributesCommandInput, DescribeDBSnapshotAttributesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

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

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DBSubnetGroupMessage, DescribeDBSubnetGroupsMessage } from "../models/models_1";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface DescribeDBSubnetGroupsCommandInput extends DescribeDBSubnetGroupsMessage {
+}
+export interface DescribeDBSubnetGroupsCommandOutput extends DBSubnetGroupMessage, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of DBSubnetGroup descriptions. If a DBSubnetGroupName is specified, the list will contain only the descriptions of the specified DBSubnetGroup.</p>
+ *          <p>For an overview of CIDR ranges, go to the
+ *             <a href="http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing">Wikipedia Tutorial</a>.
+ *         </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RDSClient, DescribeDBSubnetGroupsCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, DescribeDBSubnetGroupsCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new DescribeDBSubnetGroupsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeDBSubnetGroupsCommandInput} for command's `input` shape.
+ * @see {@link DescribeDBSubnetGroupsCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeDBSubnetGroupsCommand extends $Command<DescribeDBSubnetGroupsCommandInput, DescribeDBSubnetGroupsCommandOutput, RDSClientResolvedConfig> {
+    readonly input: DescribeDBSubnetGroupsCommandInput;
+    constructor(input: DescribeDBSubnetGroupsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDBSubnetGroupsCommandInput, DescribeDBSubnetGroupsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DescribeEngineDefaultClusterParametersMessage, DescribeEngineDefaultClusterParametersResult } from "../models/models_1";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface DescribeEngineDefaultClusterParametersCommandInput extends DescribeEngineDefaultClusterParametersMessage {
+}
+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/commands/DescribeEngineDefaultParametersCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DescribeEngineDefaultParametersMessage, DescribeEngineDefaultParametersResult } from "../models/models_1";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface DescribeEngineDefaultParametersCommandInput extends DescribeEngineDefaultParametersMessage {
+}
+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/commands/DescribeEventCategoriesCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DescribeEventCategoriesMessage, EventCategoriesMessage } from "../models/models_1";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface DescribeEventCategoriesCommandInput extends DescribeEventCategoriesMessage {
+}
+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/commands/DescribeEventSubscriptionsCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DescribeEventSubscriptionsMessage, EventSubscriptionsMessage } from "../models/models_1";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface DescribeEventSubscriptionsCommandInput extends DescribeEventSubscriptionsMessage {
+}
+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/commands/DescribeEventsCommand.d.ts

@@ -0,0 +1,40 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DescribeEventsMessage, EventsMessage } from "../models/models_1";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+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/commands/DescribeExportTasksCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DescribeExportTasksMessage, ExportTasksMessage } from "../models/models_1";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface DescribeExportTasksCommandInput extends DescribeExportTasksMessage {
+}
+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/commands/DescribeGlobalClustersCommand.d.ts

@@ -0,0 +1,44 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DescribeGlobalClustersMessage, GlobalClustersMessage } from "../models/models_1";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface DescribeGlobalClustersCommandInput extends DescribeGlobalClustersMessage {
+}
+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/commands/DescribeInstallationMediaCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DescribeInstallationMediaMessage, InstallationMediaMessage } from "../models/models_1";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface DescribeInstallationMediaCommandInput extends DescribeInstallationMediaMessage {
+}
+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/commands/DescribeOptionGroupOptionsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DescribeOptionGroupOptionsMessage, OptionGroupOptionsMessage } from "../models/models_1";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface DescribeOptionGroupOptionsCommandInput extends DescribeOptionGroupOptionsMessage {
+}
+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;
+}