@aws-sdk/client-rds 3.34.0 → 3.37.0

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

@@ -0,0 +1,43 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { BacktrackDBClusterMessage, DBClusterBacktrack } from "../models/models_0";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface BacktrackDBClusterCommandInput extends BacktrackDBClusterMessage {
+}
+export interface BacktrackDBClusterCommandOutput extends DBClusterBacktrack, __MetadataBearer {
+}
+/**
+ * <p>Backtracks a DB cluster to a specific time, without creating a new DB cluster.</p>
+ *         <p>For more information on backtracking, see
+ *             <a href="https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraMySQL.Managing.Backtrack.html">
+ *                 Backtracking an Aurora DB Cluster</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, BacktrackDBClusterCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, BacktrackDBClusterCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new BacktrackDBClusterCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link BacktrackDBClusterCommandInput} for command's `input` shape.
+ * @see {@link BacktrackDBClusterCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class BacktrackDBClusterCommand extends $Command<BacktrackDBClusterCommandInput, BacktrackDBClusterCommandOutput, RDSClientResolvedConfig> {
+    readonly input: BacktrackDBClusterCommandInput;
+    constructor(input: BacktrackDBClusterCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BacktrackDBClusterCommandInput, BacktrackDBClusterCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CancelExportTaskCommand.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 { CancelExportTaskMessage, ExportTask } from "../models/models_0";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface CancelExportTaskCommandInput extends CancelExportTaskMessage {
+}
+export interface CancelExportTaskCommandOutput extends ExportTask, __MetadataBearer {
+}
+/**
+ * <p>Cancels an export task in progress that is exporting a snapshot to Amazon S3.
+ *             Any data that has already been written to the S3 bucket isn't removed.
+ *         </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RDSClient, CancelExportTaskCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, CancelExportTaskCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new CancelExportTaskCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CancelExportTaskCommandInput} for command's `input` shape.
+ * @see {@link CancelExportTaskCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CancelExportTaskCommand extends $Command<CancelExportTaskCommandInput, CancelExportTaskCommandOutput, RDSClientResolvedConfig> {
+    readonly input: CancelExportTaskCommandInput;
+    constructor(input: CancelExportTaskCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CancelExportTaskCommandInput, CancelExportTaskCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CopyDBClusterParameterGroupCommand.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 { CopyDBClusterParameterGroupMessage, CopyDBClusterParameterGroupResult } from "../models/models_0";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface CopyDBClusterParameterGroupCommandInput extends CopyDBClusterParameterGroupMessage {
+}
+export interface CopyDBClusterParameterGroupCommandOutput extends CopyDBClusterParameterGroupResult, __MetadataBearer {
+}
+/**
+ * <p>Copies the specified DB cluster parameter group.</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, CopyDBClusterParameterGroupCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, CopyDBClusterParameterGroupCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new CopyDBClusterParameterGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CopyDBClusterParameterGroupCommandInput} for command's `input` shape.
+ * @see {@link CopyDBClusterParameterGroupCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CopyDBClusterParameterGroupCommand extends $Command<CopyDBClusterParameterGroupCommandInput, CopyDBClusterParameterGroupCommandOutput, RDSClientResolvedConfig> {
+    readonly input: CopyDBClusterParameterGroupCommandInput;
+    constructor(input: CopyDBClusterParameterGroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CopyDBClusterParameterGroupCommandInput, CopyDBClusterParameterGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,109 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CopyDBClusterSnapshotMessage, CopyDBClusterSnapshotResult } from "../models/models_0";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface CopyDBClusterSnapshotCommandInput extends CopyDBClusterSnapshotMessage {
+}
+export interface CopyDBClusterSnapshotCommandOutput extends CopyDBClusterSnapshotResult, __MetadataBearer {
+}
+/**
+ * <p>Copies a snapshot of a DB cluster.</p>
+ *          <p>To copy a DB cluster snapshot from a shared manual DB cluster snapshot, <code>SourceDBClusterSnapshotIdentifier</code>
+ *           must be the Amazon Resource Name (ARN) of the shared DB cluster snapshot.</p>
+ *
+ *          <p>You can copy an encrypted DB cluster snapshot from another Amazon Web Services Region. In that case, the Amazon Web Services Region where you call the <code>CopyDBClusterSnapshot</code> action
+ *           is the destination Amazon Web Services Region for the encrypted DB cluster snapshot to be copied to. To copy an encrypted DB cluster snapshot from another Amazon Web Services Region,
+ *           you must provide the following values:</p>
+ *
+ *          <ul>
+ *             <li>
+ *                <p>
+ *                   <code>KmsKeyId</code> - The Amazon Web Services Key Management System (Amazon Web Services KMS) key identifier for the key to use to
+ *               encrypt the copy of the DB cluster snapshot in the destination Amazon Web Services Region.</p>
+ *             </li>
+ *             <li>
+ *                <p>
+ *                   <code>PreSignedUrl</code> -  A URL that contains a Signature Version 4 signed request for the
+ *               <code>CopyDBClusterSnapshot</code> action to be called in the source Amazon Web Services Region where the DB cluster snapshot is copied from.
+ *               The pre-signed URL must be a valid request for the <code>CopyDBClusterSnapshot</code> API action that can be executed in the
+ *               source Amazon Web Services Region that contains the encrypted DB cluster snapshot to be copied.</p>
+ *               <p>The pre-signed URL request must contain the following parameter values:</p>
+ *               <ul>
+ *                   <li>
+ *                      <p>
+ *                         <code>KmsKeyId</code> - The Amazon Web Services KMS key identifier for the customer master key (CMK) to use to encrypt the copy of the DB
+ *                       cluster snapshot in the destination Amazon Web Services Region. This is the same identifier for both the <code>CopyDBClusterSnapshot</code>
+ *                       action that is called in the destination Amazon Web Services Region, and the action contained in the pre-signed URL.</p>
+ *                   </li>
+ *                   <li>
+ *                      <p>
+ *                         <code>DestinationRegion</code> - The name of the Amazon Web Services Region that the DB cluster snapshot is to be created in.</p>
+ *                   </li>
+ *                   <li>
+ *                      <p>
+ *                         <code>SourceDBClusterSnapshotIdentifier</code> - The DB cluster snapshot identifier for the encrypted DB cluster
+ *                       snapshot to be copied. This identifier must be in the Amazon Resource Name (ARN) format for the source Amazon Web Services Region. For example,
+ *                       if you are copying an encrypted DB cluster snapshot from the us-west-2 Amazon Web Services Region, then your <code>SourceDBClusterSnapshotIdentifier</code>
+ *                       looks like the following example: <code>arn:aws:rds:us-west-2:123456789012:cluster-snapshot:aurora-cluster1-snapshot-20161115</code>.</p>
+ *                   </li>
+ *                </ul>
+ *               <p>To learn how to generate a Signature Version 4 signed request, see
+ *
+ *                   <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html">
+ *                       Authenticating Requests: Using Query Parameters (Amazon Web Services Signature Version 4)</a> and
+ *                   <a href="https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html">
+ *                       Signature Version 4 Signing Process</a>.</p>
+ *               <note>
+ *                   <p>If you are using an Amazon Web Services SDK tool or the CLI, you can specify <code>SourceRegion</code> (or <code>--source-region</code> for the CLI)
+ *                       instead of specifying <code>PreSignedUrl</code> manually. Specifying <code>SourceRegion</code> autogenerates a pre-signed URL that is a valid
+ *                       request for the operation that can be executed in the source Amazon Web Services Region.</p>
+ *               </note>
+ *             </li>
+ *             <li>
+ *                <p>
+ *                   <code>TargetDBClusterSnapshotIdentifier</code> - The identifier for the new copy of the DB cluster snapshot in the destination Amazon Web Services Region.</p>
+ *             </li>
+ *             <li>
+ *                <p>
+ *                   <code>SourceDBClusterSnapshotIdentifier</code> - The DB cluster snapshot identifier for the encrypted DB cluster snapshot to be copied.
+ *               This identifier must be in the ARN format for the source Amazon Web Services Region and is the same value as the <code>SourceDBClusterSnapshotIdentifier</code> in the pre-signed URL. </p>
+ *             </li>
+ *          </ul>
+ *          <p>To cancel the copy operation once it is in progress, delete the target DB cluster snapshot identified
+ *           by <code>TargetDBClusterSnapshotIdentifier</code> while that DB cluster snapshot is in "copying" status.</p>
+ *          <p>For more information on copying encrypted DB cluster snapshots from one Amazon Web Services Region to another, see
+ *           <a href="https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_CopySnapshot.html">
+ *               Copying a Snapshot</a> in the <i>Amazon Aurora User Guide.</i>
+ *          </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, CopyDBClusterSnapshotCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, CopyDBClusterSnapshotCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new CopyDBClusterSnapshotCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CopyDBClusterSnapshotCommandInput} for command's `input` shape.
+ * @see {@link CopyDBClusterSnapshotCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CopyDBClusterSnapshotCommand extends $Command<CopyDBClusterSnapshotCommandInput, CopyDBClusterSnapshotCommandOutput, RDSClientResolvedConfig> {
+    readonly input: CopyDBClusterSnapshotCommandInput;
+    constructor(input: CopyDBClusterSnapshotCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CopyDBClusterSnapshotCommandInput, CopyDBClusterSnapshotCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CopyDBParameterGroupCommand.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 { CopyDBParameterGroupMessage, CopyDBParameterGroupResult } from "../models/models_0";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface CopyDBParameterGroupCommandInput extends CopyDBParameterGroupMessage {
+}
+export interface CopyDBParameterGroupCommandOutput extends CopyDBParameterGroupResult, __MetadataBearer {
+}
+/**
+ * <p>Copies 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, CopyDBParameterGroupCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, CopyDBParameterGroupCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new CopyDBParameterGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CopyDBParameterGroupCommandInput} for command's `input` shape.
+ * @see {@link CopyDBParameterGroupCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CopyDBParameterGroupCommand extends $Command<CopyDBParameterGroupCommandInput, CopyDBParameterGroupCommandOutput, RDSClientResolvedConfig> {
+    readonly input: CopyDBParameterGroupCommandInput;
+    constructor(input: CopyDBParameterGroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CopyDBParameterGroupCommandInput, CopyDBParameterGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,43 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CopyDBSnapshotMessage, CopyDBSnapshotResult } from "../models/models_0";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface CopyDBSnapshotCommandInput extends CopyDBSnapshotMessage {
+}
+export interface CopyDBSnapshotCommandOutput extends CopyDBSnapshotResult, __MetadataBearer {
+}
+/**
+ * <p>Copies the specified DB snapshot. The source DB snapshot must be in the <code>available</code> state.</p>
+ *
+ *         <p>You can copy a snapshot from one Amazon Web Services Region to another. In that case, the Amazon Web Services Region
+ *             where you call the <code>CopyDBSnapshot</code> action is the destination Amazon Web Services Region for the
+ *             DB snapshot copy. </p>
+ *
+ *         <p>For more information about copying snapshots, see
+ *             <a href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CopySnapshot.html#USER_CopyDBSnapshot">Copying a DB Snapshot</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, CopyDBSnapshotCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, CopyDBSnapshotCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new CopyDBSnapshotCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CopyDBSnapshotCommandInput} for command's `input` shape.
+ * @see {@link CopyDBSnapshotCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CopyDBSnapshotCommand extends $Command<CopyDBSnapshotCommandInput, CopyDBSnapshotCommandOutput, RDSClientResolvedConfig> {
+    readonly input: CopyDBSnapshotCommandInput;
+    constructor(input: CopyDBSnapshotCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CopyDBSnapshotCommandInput, CopyDBSnapshotCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

package/dist-types/commands/CreateCustomAvailabilityZoneCommand.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 { CreateCustomAvailabilityZoneMessage, CreateCustomAvailabilityZoneResult } from "../models/models_0";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface CreateCustomAvailabilityZoneCommandInput extends CreateCustomAvailabilityZoneMessage {
+}
+export interface CreateCustomAvailabilityZoneCommandOutput extends CreateCustomAvailabilityZoneResult, __MetadataBearer {
+}
+/**
+ * <p>Creates 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, CreateCustomAvailabilityZoneCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, CreateCustomAvailabilityZoneCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new CreateCustomAvailabilityZoneCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateCustomAvailabilityZoneCommandInput} for command's `input` shape.
+ * @see {@link CreateCustomAvailabilityZoneCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateCustomAvailabilityZoneCommand extends $Command<CreateCustomAvailabilityZoneCommandInput, CreateCustomAvailabilityZoneCommandOutput, RDSClientResolvedConfig> {
+    readonly input: CreateCustomAvailabilityZoneCommandInput;
+    constructor(input: CreateCustomAvailabilityZoneCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateCustomAvailabilityZoneCommandInput, CreateCustomAvailabilityZoneCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,48 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateDBClusterMessage, CreateDBClusterResult } from "../models/models_0";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface CreateDBClusterCommandInput extends CreateDBClusterMessage {
+}
+export interface CreateDBClusterCommandOutput extends CreateDBClusterResult, __MetadataBearer {
+}
+/**
+ * <p>Creates a new Amazon Aurora DB cluster.</p>
+ *          <p>You can use the <code>ReplicationSourceIdentifier</code> parameter to create the DB
+ *             cluster as a read replica of another DB cluster or Amazon RDS MySQL or PostgreSQL DB instance. For
+ *             cross-region replication where the DB cluster identified by
+ *                 <code>ReplicationSourceIdentifier</code> is encrypted, you must also specify the
+ *                 <code>PreSignedUrl</code> parameter.</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, CreateDBClusterCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, CreateDBClusterCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new CreateDBClusterCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateDBClusterCommandInput} for command's `input` shape.
+ * @see {@link CreateDBClusterCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateDBClusterCommand extends $Command<CreateDBClusterCommandInput, CreateDBClusterCommandOutput, RDSClientResolvedConfig> {
+    readonly input: CreateDBClusterCommandInput;
+    constructor(input: CreateDBClusterCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDBClusterCommandInput, CreateDBClusterCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateDBClusterEndpointCommand.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 { CreateDBClusterEndpointMessage, DBClusterEndpoint } from "../models/models_0";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface CreateDBClusterEndpointCommandInput extends CreateDBClusterEndpointMessage {
+}
+export interface CreateDBClusterEndpointCommandOutput extends DBClusterEndpoint, __MetadataBearer {
+}
+/**
+ * <p>Creates a new custom endpoint and associates it with 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, CreateDBClusterEndpointCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, CreateDBClusterEndpointCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new CreateDBClusterEndpointCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateDBClusterEndpointCommandInput} for command's `input` shape.
+ * @see {@link CreateDBClusterEndpointCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateDBClusterEndpointCommand extends $Command<CreateDBClusterEndpointCommandInput, CreateDBClusterEndpointCommandOutput, RDSClientResolvedConfig> {
+    readonly input: CreateDBClusterEndpointCommandInput;
+    constructor(input: CreateDBClusterEndpointCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDBClusterEndpointCommandInput, CreateDBClusterEndpointCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,66 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateDBClusterParameterGroupMessage, CreateDBClusterParameterGroupResult } from "../models/models_0";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface CreateDBClusterParameterGroupCommandInput extends CreateDBClusterParameterGroupMessage {
+}
+export interface CreateDBClusterParameterGroupCommandOutput extends CreateDBClusterParameterGroupResult, __MetadataBearer {
+}
+/**
+ * <p>Creates a new DB cluster parameter group.</p>
+ *          <p>Parameters in a DB cluster parameter group apply to all of the instances in a DB cluster.</p>
+ *         <p>
+ *             A DB cluster parameter group is initially created with the default parameters for the
+ *             database engine used by instances in the DB cluster. To provide custom values for any of the
+ *             parameters, you must modify the group after creating it using
+ *             <code>ModifyDBClusterParameterGroup</code>. Once you've created a DB cluster parameter group, you need to
+ *             associate it with your DB cluster using <code>ModifyDBCluster</code>. When you associate
+ *             a new DB cluster parameter group with a running DB cluster, you need to reboot the DB
+ *             instances in the DB cluster without failover for the new DB cluster parameter group and
+ *             associated settings to take effect.
+ *         </p>
+ *         <important>
+ *             <p>After you create a DB cluster parameter group, you should wait at least 5 minutes
+ *                 before creating your first DB cluster
+ *                 that uses that DB cluster parameter group as the default parameter
+ *                 group. This allows Amazon RDS to fully complete the create action before the DB cluster parameter
+ *                 group is used as the default for a new DB cluster. This is especially important for parameters
+ *                 that are critical when creating the default database for a DB cluster, 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
+ *                 <code>DescribeDBClusterParameters</code> action to verify
+ *                 that your DB cluster parameter group has been created or modified.</p>
+ *         </important>
+ *
+ *          <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, CreateDBClusterParameterGroupCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, CreateDBClusterParameterGroupCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new CreateDBClusterParameterGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateDBClusterParameterGroupCommandInput} for command's `input` shape.
+ * @see {@link CreateDBClusterParameterGroupCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateDBClusterParameterGroupCommand extends $Command<CreateDBClusterParameterGroupCommandInput, CreateDBClusterParameterGroupCommandOutput, RDSClientResolvedConfig> {
+    readonly input: CreateDBClusterParameterGroupCommandInput;
+    constructor(input: CreateDBClusterParameterGroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDBClusterParameterGroupCommandInput, CreateDBClusterParameterGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,41 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateDBClusterSnapshotMessage, CreateDBClusterSnapshotResult } from "../models/models_0";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface CreateDBClusterSnapshotCommandInput extends CreateDBClusterSnapshotMessage {
+}
+export interface CreateDBClusterSnapshotCommandOutput extends CreateDBClusterSnapshotResult, __MetadataBearer {
+}
+/**
+ * <p>Creates a snapshot of a DB cluster. 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, CreateDBClusterSnapshotCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, CreateDBClusterSnapshotCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new CreateDBClusterSnapshotCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateDBClusterSnapshotCommandInput} for command's `input` shape.
+ * @see {@link CreateDBClusterSnapshotCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateDBClusterSnapshotCommand extends $Command<CreateDBClusterSnapshotCommandInput, CreateDBClusterSnapshotCommandOutput, RDSClientResolvedConfig> {
+    readonly input: CreateDBClusterSnapshotCommandInput;
+    constructor(input: CreateDBClusterSnapshotCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDBClusterSnapshotCommandInput, CreateDBClusterSnapshotCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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