@aws-sdk/client-rds 3.34.0 → 3.37.0

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

@@ -0,0 +1,50 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateDBInstanceReadReplicaMessage, CreateDBInstanceReadReplicaResult } from "../models/models_0";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface CreateDBInstanceReadReplicaCommandInput extends CreateDBInstanceReadReplicaMessage {
+}
+export interface CreateDBInstanceReadReplicaCommandOutput extends CreateDBInstanceReadReplicaResult, __MetadataBearer {
+}
+/**
+ * <p>Creates a new DB instance that acts as a read replica for an existing source DB
+ *             instance. You can create a read replica for a DB instance running MySQL, MariaDB,
+ *             Oracle, PostgreSQL, or SQL Server. For more information, see <a href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ReadRepl.html">Working with Read
+ *                 Replicas</a> in the <i>Amazon RDS User Guide</i>. </p>
+ *
+ *          <p>Amazon Aurora doesn't support this action. Call the <code>CreateDBInstance</code>
+ *             action to create a DB instance for an Aurora DB cluster.</p>
+ *
+ *          <p>All read replica DB instances are created with backups disabled. All other DB
+ *             instance attributes (including DB security groups and DB parameter groups) are inherited
+ *             from the source DB instance, except as specified.</p>
+ *
+ *          <important>
+ *             <p>Your source DB instance must have backup retention enabled.
+ *          </p>
+ *          </important>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RDSClient, CreateDBInstanceReadReplicaCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, CreateDBInstanceReadReplicaCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new CreateDBInstanceReadReplicaCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateDBInstanceReadReplicaCommandInput} for command's `input` shape.
+ * @see {@link CreateDBInstanceReadReplicaCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateDBInstanceReadReplicaCommand extends $Command<CreateDBInstanceReadReplicaCommandInput, CreateDBInstanceReadReplicaCommandOutput, RDSClientResolvedConfig> {
+    readonly input: CreateDBInstanceReadReplicaCommandInput;
+    constructor(input: CreateDBInstanceReadReplicaCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDBInstanceReadReplicaCommandInput, CreateDBInstanceReadReplicaCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,55 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateDBParameterGroupMessage, CreateDBParameterGroupResult } from "../models/models_0";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface CreateDBParameterGroupCommandInput extends CreateDBParameterGroupMessage {
+}
+export interface CreateDBParameterGroupCommandOutput extends CreateDBParameterGroupResult, __MetadataBearer {
+}
+/**
+ * <p>Creates a new DB parameter group.</p>
+ *          <p>
+ *             A DB parameter group is initially created with the default parameters for the
+ *             database engine used by the DB instance. To provide custom values for any of the
+ *             parameters, you must modify the group after creating it using
+ *             <i>ModifyDBParameterGroup</i>. Once you've created a DB parameter group, you need to
+ *             associate it with your DB instance using <i>ModifyDBInstance</i>. When you associate
+ *             a new DB parameter group with a running DB instance, you need to reboot the DB
+ *             instance without failover for the new DB parameter group and associated settings to take effect.
+ *         </p>
+ *          <important>
+ *             <p>After you create a DB parameter group, you should wait at least 5 minutes
+ *                 before creating your first DB instance that uses that DB parameter group as the default parameter
+ *                 group. This allows Amazon RDS to fully complete the create action before the parameter
+ *                 group is used as the default for a new DB instance. This is especially important for parameters
+ *                 that are critical when creating the default database for a DB instance, such as the character set
+ *                 for the default database defined by the <code>character_set_database</code> parameter. You can use the
+ *                 <i>Parameter Groups</i> option of the <a href="https://console.aws.amazon.com/rds/">Amazon RDS console</a> or the
+ *                 <i>DescribeDBParameters</i> command to verify
+ *                 that your DB parameter group has been created or modified.</p>
+ *          </important>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RDSClient, CreateDBParameterGroupCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, CreateDBParameterGroupCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new CreateDBParameterGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateDBParameterGroupCommandInput} for command's `input` shape.
+ * @see {@link CreateDBParameterGroupCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateDBParameterGroupCommand extends $Command<CreateDBParameterGroupCommandInput, CreateDBParameterGroupCommandOutput, RDSClientResolvedConfig> {
+    readonly input: CreateDBParameterGroupCommandInput;
+    constructor(input: CreateDBParameterGroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDBParameterGroupCommandInput, CreateDBParameterGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateDBProxyCommand.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 { CreateDBProxyRequest, CreateDBProxyResponse } from "../models/models_0";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface CreateDBProxyCommandInput extends CreateDBProxyRequest {
+}
+export interface CreateDBProxyCommandOutput extends CreateDBProxyResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a new DB proxy.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RDSClient, CreateDBProxyCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, CreateDBProxyCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new CreateDBProxyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateDBProxyCommandInput} for command's `input` shape.
+ * @see {@link CreateDBProxyCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateDBProxyCommand extends $Command<CreateDBProxyCommandInput, CreateDBProxyCommandOutput, RDSClientResolvedConfig> {
+    readonly input: CreateDBProxyCommandInput;
+    constructor(input: CreateDBProxyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDBProxyCommandInput, CreateDBProxyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,45 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteDBClusterMessage, DeleteDBClusterResult } from "../models/models_0";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface DeleteDBClusterCommandInput extends DeleteDBClusterMessage {
+}
+export interface DeleteDBClusterCommandOutput extends DeleteDBClusterResult, __MetadataBearer {
+}
+/**
+ * <p>The DeleteDBCluster action deletes a previously provisioned DB cluster.
+ *           When you delete a DB cluster, all automated backups for that DB cluster are deleted and can't be recovered.
+ *           Manual DB cluster snapshots of the specified DB cluster are not deleted.</p>
+ *          <p></p>
+ *          <p>For more information on Amazon Aurora, see
+ *           <a href="https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html">
+ *               What Is Amazon Aurora?</a> in the <i>Amazon Aurora User Guide.</i>
+ *          </p>
+ *          <note>
+ *             <p>This action only applies to Aurora DB clusters.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RDSClient, DeleteDBClusterCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, DeleteDBClusterCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new DeleteDBClusterCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteDBClusterCommandInput} for command's `input` shape.
+ * @see {@link DeleteDBClusterCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteDBClusterCommand extends $Command<DeleteDBClusterCommandInput, DeleteDBClusterCommandOutput, RDSClientResolvedConfig> {
+    readonly input: DeleteDBClusterCommandInput;
+    constructor(input: DeleteDBClusterCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDBClusterCommandInput, DeleteDBClusterCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

package/dist-types/commands/DeleteDBClusterParameterGroupCommand.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 { DeleteDBClusterParameterGroupMessage } from "../models/models_0";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface DeleteDBClusterParameterGroupCommandInput extends DeleteDBClusterParameterGroupMessage {
+}
+export interface DeleteDBClusterParameterGroupCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Deletes a specified DB cluster parameter group. The DB cluster parameter group to be deleted can't be associated with any DB clusters.</p>
+ *          <p>For more information on Amazon Aurora, see
+ *           <a href="https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html">
+ *               What Is Amazon Aurora?</a> in the <i>Amazon Aurora User Guide.</i>
+ *          </p>
+ *          <note>
+ *             <p>This action only applies to Aurora DB clusters.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RDSClient, DeleteDBClusterParameterGroupCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, DeleteDBClusterParameterGroupCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new DeleteDBClusterParameterGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteDBClusterParameterGroupCommandInput} for command's `input` shape.
+ * @see {@link DeleteDBClusterParameterGroupCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteDBClusterParameterGroupCommand extends $Command<DeleteDBClusterParameterGroupCommandInput, DeleteDBClusterParameterGroupCommandOutput, RDSClientResolvedConfig> {
+    readonly input: DeleteDBClusterParameterGroupCommandInput;
+    constructor(input: DeleteDBClusterParameterGroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDBClusterParameterGroupCommandInput, DeleteDBClusterParameterGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}