@aws-sdk/client-rds 3.34.0 → 3.37.0

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

@@ -0,0 +1,53 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { PromoteReadReplicaMessage, PromoteReadReplicaResult } from "../models/models_1";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface PromoteReadReplicaCommandInput extends PromoteReadReplicaMessage {
+}
+export interface PromoteReadReplicaCommandOutput extends PromoteReadReplicaResult, __MetadataBearer {
+}
+/**
+ * <p>Promotes a read replica DB instance to a standalone DB instance.</p>
+ *          <note>
+ *             <ul>
+ *                <li>
+ *                   <p>Backup duration is a function of the amount of changes to the database since the previous
+ *                         backup. If you plan to promote a read replica to a standalone instance, we
+ *                         recommend that you enable backups and complete at least one backup prior to
+ *                         promotion. In addition, a read replica cannot be promoted to a standalone
+ *                         instance when it is in the <code>backing-up</code> status. If you have
+ *                         enabled backups on your read replica, configure the automated backup window
+ *                         so that daily backups do not interfere with read replica
+ *                         promotion.</p>
+ *                </li>
+ *                <li>
+ *                   <p>This command doesn't apply to Aurora MySQL and Aurora PostgreSQL.</p>
+ *                </li>
+ *             </ul>
+ *
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RDSClient, PromoteReadReplicaCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, PromoteReadReplicaCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new PromoteReadReplicaCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PromoteReadReplicaCommandInput} for command's `input` shape.
+ * @see {@link PromoteReadReplicaCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PromoteReadReplicaCommand extends $Command<PromoteReadReplicaCommandInput, PromoteReadReplicaCommandOutput, RDSClientResolvedConfig> {
+    readonly input: PromoteReadReplicaCommandInput;
+    constructor(input: PromoteReadReplicaCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PromoteReadReplicaCommandInput, PromoteReadReplicaCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/PromoteReadReplicaDBClusterCommand.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 { PromoteReadReplicaDBClusterMessage, PromoteReadReplicaDBClusterResult } from "../models/models_1";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface PromoteReadReplicaDBClusterCommandInput extends PromoteReadReplicaDBClusterMessage {
+}
+export interface PromoteReadReplicaDBClusterCommandOutput extends PromoteReadReplicaDBClusterResult, __MetadataBearer {
+}
+/**
+ * <p>Promotes a read replica DB cluster to a standalone 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, PromoteReadReplicaDBClusterCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, PromoteReadReplicaDBClusterCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new PromoteReadReplicaDBClusterCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PromoteReadReplicaDBClusterCommandInput} for command's `input` shape.
+ * @see {@link PromoteReadReplicaDBClusterCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PromoteReadReplicaDBClusterCommand extends $Command<PromoteReadReplicaDBClusterCommandInput, PromoteReadReplicaDBClusterCommandOutput, RDSClientResolvedConfig> {
+    readonly input: PromoteReadReplicaDBClusterCommandInput;
+    constructor(input: PromoteReadReplicaDBClusterCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PromoteReadReplicaDBClusterCommandInput, PromoteReadReplicaDBClusterCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

@@ -0,0 +1,46 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { RebootDBInstanceMessage, RebootDBInstanceResult } from "../models/models_1";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface RebootDBInstanceCommandInput extends RebootDBInstanceMessage {
+}
+export interface RebootDBInstanceCommandOutput extends RebootDBInstanceResult, __MetadataBearer {
+}
+/**
+ * <p>You might need to reboot your DB instance, usually for maintenance reasons.
+ *         For example, if you make certain modifications,
+ *         or if you change the DB parameter group associated with the DB instance,
+ *         you must reboot the instance for the changes to take effect.
+ *     </p>
+ *
+ *          <p>Rebooting a DB instance restarts the database engine service.
+ *         Rebooting a DB instance results in a momentary outage, during which the DB instance status is set to rebooting.
+ *     </p>
+ *
+ *          <p>For more information about rebooting, see <a href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_RebootInstance.html">Rebooting a DB Instance</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, RebootDBInstanceCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, RebootDBInstanceCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new RebootDBInstanceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RebootDBInstanceCommandInput} for command's `input` shape.
+ * @see {@link RebootDBInstanceCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RebootDBInstanceCommand extends $Command<RebootDBInstanceCommandInput, RebootDBInstanceCommandOutput, RDSClientResolvedConfig> {
+    readonly input: RebootDBInstanceCommandInput;
+    constructor(input: RebootDBInstanceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RebootDBInstanceCommandInput, RebootDBInstanceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RegisterDBProxyTargetsCommand.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 { RegisterDBProxyTargetsRequest, RegisterDBProxyTargetsResponse } from "../models/models_1";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface RegisterDBProxyTargetsCommandInput extends RegisterDBProxyTargetsRequest {
+}
+export interface RegisterDBProxyTargetsCommandOutput extends RegisterDBProxyTargetsResponse, __MetadataBearer {
+}
+/**
+ * <p>Associate one or more <code>DBProxyTarget</code> data structures with a <code>DBProxyTargetGroup</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RDSClient, RegisterDBProxyTargetsCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, RegisterDBProxyTargetsCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new RegisterDBProxyTargetsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RegisterDBProxyTargetsCommandInput} for command's `input` shape.
+ * @see {@link RegisterDBProxyTargetsCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RegisterDBProxyTargetsCommand extends $Command<RegisterDBProxyTargetsCommandInput, RegisterDBProxyTargetsCommandOutput, RDSClientResolvedConfig> {
+    readonly input: RegisterDBProxyTargetsCommandInput;
+    constructor(input: RegisterDBProxyTargetsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RegisterDBProxyTargetsCommandInput, RegisterDBProxyTargetsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RemoveFromGlobalClusterCommand.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 { RemoveFromGlobalClusterMessage, RemoveFromGlobalClusterResult } from "../models/models_1";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface RemoveFromGlobalClusterCommandInput extends RemoveFromGlobalClusterMessage {
+}
+export interface RemoveFromGlobalClusterCommandOutput extends RemoveFromGlobalClusterResult, __MetadataBearer {
+}
+/**
+ * <p>
+ *         Detaches an Aurora secondary cluster from an Aurora global database cluster. The cluster becomes a
+ *         standalone cluster with read-write capability instead of being read-only and receiving data from a
+ *         primary cluster in a different region.
+ *       </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, RemoveFromGlobalClusterCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, RemoveFromGlobalClusterCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new RemoveFromGlobalClusterCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RemoveFromGlobalClusterCommandInput} for command's `input` shape.
+ * @see {@link RemoveFromGlobalClusterCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RemoveFromGlobalClusterCommand extends $Command<RemoveFromGlobalClusterCommandInput, RemoveFromGlobalClusterCommandOutput, RDSClientResolvedConfig> {
+    readonly input: RemoveFromGlobalClusterCommandInput;
+    constructor(input: RemoveFromGlobalClusterCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RemoveFromGlobalClusterCommandInput, RemoveFromGlobalClusterCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RemoveRoleFromDBClusterCommand.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 { RemoveRoleFromDBClusterMessage } from "../models/models_1";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface RemoveRoleFromDBClusterCommandInput extends RemoveRoleFromDBClusterMessage {
+}
+export interface RemoveRoleFromDBClusterCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Disassociates an Amazon Web Services Identity and Access Management (IAM) role from an Amazon Aurora DB cluster.
+ *             For more information, see <a href="https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraMySQL.Integrating.Authorizing.html">Authorizing Amazon Aurora MySQL
+ *                 to Access Other Amazon Web Services Services on Your Behalf </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, RemoveRoleFromDBClusterCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, RemoveRoleFromDBClusterCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new RemoveRoleFromDBClusterCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RemoveRoleFromDBClusterCommandInput} for command's `input` shape.
+ * @see {@link RemoveRoleFromDBClusterCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RemoveRoleFromDBClusterCommand extends $Command<RemoveRoleFromDBClusterCommandInput, RemoveRoleFromDBClusterCommandOutput, RDSClientResolvedConfig> {
+    readonly input: RemoveRoleFromDBClusterCommandInput;
+    constructor(input: RemoveRoleFromDBClusterCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RemoveRoleFromDBClusterCommandInput, RemoveRoleFromDBClusterCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

package/dist-types/commands/RemoveTagsFromResourceCommand.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 { RemoveTagsFromResourceMessage } from "../models/models_1";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface RemoveTagsFromResourceCommandInput extends RemoveTagsFromResourceMessage {
+}
+export interface RemoveTagsFromResourceCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Removes metadata tags from an Amazon RDS resource.</p>
+ *          <p>For an overview on tagging an Amazon RDS resource,
+ *           see <a href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.Tagging.html">Tagging Amazon RDS Resources</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, RemoveTagsFromResourceCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, RemoveTagsFromResourceCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new RemoveTagsFromResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RemoveTagsFromResourceCommandInput} for command's `input` shape.
+ * @see {@link RemoveTagsFromResourceCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RemoveTagsFromResourceCommand extends $Command<RemoveTagsFromResourceCommandInput, RemoveTagsFromResourceCommandOutput, RDSClientResolvedConfig> {
+    readonly input: RemoveTagsFromResourceCommandInput;
+    constructor(input: RemoveTagsFromResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RemoveTagsFromResourceCommandInput, RemoveTagsFromResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,54 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DBClusterParameterGroupNameMessage, ResetDBClusterParameterGroupMessage } from "../models/models_1";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface ResetDBClusterParameterGroupCommandInput extends ResetDBClusterParameterGroupMessage {
+}
+export interface ResetDBClusterParameterGroupCommandOutput extends DBClusterParameterGroupNameMessage, __MetadataBearer {
+}
+/**
+ * <p>
+ *             Modifies the parameters of a DB cluster parameter group to the default value. To
+ *             reset specific parameters submit a list of the following: <code>ParameterName</code>
+ *             and <code>ApplyMethod</code>. To reset the
+ *             entire DB cluster parameter group, specify the <code>DBClusterParameterGroupName</code>
+ *             and <code>ResetAllParameters</code> parameters.
+ *         </p>
+ *             <p>
+ *             When resetting the entire group, dynamic parameters are updated immediately and static parameters
+ *             are set to <code>pending-reboot</code> to take effect on the next DB instance restart
+ *             or <code>RebootDBInstance</code> request. You must call <code>RebootDBInstance</code> for every
+ *             DB instance in your DB cluster that you want the updated static parameter to apply to.</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, ResetDBClusterParameterGroupCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, ResetDBClusterParameterGroupCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new ResetDBClusterParameterGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ResetDBClusterParameterGroupCommandInput} for command's `input` shape.
+ * @see {@link ResetDBClusterParameterGroupCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ResetDBClusterParameterGroupCommand extends $Command<ResetDBClusterParameterGroupCommandInput, ResetDBClusterParameterGroupCommandOutput, RDSClientResolvedConfig> {
+    readonly input: ResetDBClusterParameterGroupCommandInput;
+    constructor(input: ResetDBClusterParameterGroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ResetDBClusterParameterGroupCommandInput, ResetDBClusterParameterGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ResetDBParameterGroupCommand.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 { DBParameterGroupNameMessage, ResetDBParameterGroupMessage } from "../models/models_1";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface ResetDBParameterGroupCommandInput extends ResetDBParameterGroupMessage {
+}
+export interface ResetDBParameterGroupCommandOutput extends DBParameterGroupNameMessage, __MetadataBearer {
+}
+/**
+ * <p>Modifies the parameters of a DB parameter group to the engine/system default value.
+ *             To reset specific parameters, provide a list of the following:
+ *                 <code>ParameterName</code> and <code>ApplyMethod</code>. To reset the entire DB
+ *             parameter group, specify the <code>DBParameterGroup</code> name and
+ *                 <code>ResetAllParameters</code> parameters. When resetting the entire group, dynamic
+ *             parameters are updated immediately and static parameters are set to
+ *                 <code>pending-reboot</code> to take effect on the next DB instance restart or
+ *                 <code>RebootDBInstance</code> request. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RDSClient, ResetDBParameterGroupCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, ResetDBParameterGroupCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new ResetDBParameterGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ResetDBParameterGroupCommandInput} for command's `input` shape.
+ * @see {@link ResetDBParameterGroupCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ResetDBParameterGroupCommand extends $Command<ResetDBParameterGroupCommandInput, ResetDBParameterGroupCommandOutput, RDSClientResolvedConfig> {
+    readonly input: ResetDBParameterGroupCommandInput;
+    constructor(input: ResetDBParameterGroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ResetDBParameterGroupCommandInput, ResetDBParameterGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,54 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { RestoreDBClusterFromS3Message, RestoreDBClusterFromS3Result } from "../models/models_1";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface RestoreDBClusterFromS3CommandInput extends RestoreDBClusterFromS3Message {
+}
+export interface RestoreDBClusterFromS3CommandOutput extends RestoreDBClusterFromS3Result, __MetadataBearer {
+}
+/**
+ * <p>Creates an Amazon Aurora DB cluster from MySQL data stored in an Amazon S3 bucket.
+ *             Amazon RDS must be authorized to access the Amazon S3 bucket and the data must be
+ *             created using the Percona XtraBackup utility as described in <a href="https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraMySQL.Migrating.ExtMySQL.html#AuroraMySQL.Migrating.ExtMySQL.S3"> Migrating Data from MySQL by Using an Amazon S3 Bucket</a> in the
+ *                 <i>Amazon Aurora User Guide</i>.</p>
+ *         <note>
+ *               <p>This action only restores the DB cluster, not the DB instances for that DB
+ *                   cluster. You must invoke the <code>CreateDBInstance</code> action to create DB
+ *                   instances for the restored DB cluster, specifying the identifier of the restored DB
+ *                   cluster in <code>DBClusterIdentifier</code>. You can create DB instances only after
+ *                   the <code>RestoreDBClusterFromS3</code> action has completed and the DB
+ *                   cluster is available.</p>
+ *         </note>
+ *         <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. The source DB engine must be
+ *                 MySQL.</p>
+ *         </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RDSClient, RestoreDBClusterFromS3Command } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, RestoreDBClusterFromS3Command } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new RestoreDBClusterFromS3Command(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RestoreDBClusterFromS3CommandInput} for command's `input` shape.
+ * @see {@link RestoreDBClusterFromS3CommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RestoreDBClusterFromS3Command extends $Command<RestoreDBClusterFromS3CommandInput, RestoreDBClusterFromS3CommandOutput, RDSClientResolvedConfig> {
+    readonly input: RestoreDBClusterFromS3CommandInput;
+    constructor(input: RestoreDBClusterFromS3CommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RestoreDBClusterFromS3CommandInput, RestoreDBClusterFromS3CommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,54 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { RestoreDBClusterFromSnapshotMessage, RestoreDBClusterFromSnapshotResult } from "../models/models_1";
+import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
+export interface RestoreDBClusterFromSnapshotCommandInput extends RestoreDBClusterFromSnapshotMessage {
+}
+export interface RestoreDBClusterFromSnapshotCommandOutput extends RestoreDBClusterFromSnapshotResult, __MetadataBearer {
+}
+/**
+ * <p>Creates a new DB cluster from a DB snapshot or DB cluster snapshot. This action
+ *             only applies to Aurora DB clusters.</p>
+ *         <p>The target DB cluster is created from the source snapshot with a default
+ *             configuration. If you don't specify a security group, the new DB cluster is
+ *             associated with the default security group.</p>
+ *          <note>
+ *             <p>This action only restores the DB cluster, not the DB instances for that DB
+ *                 cluster. You must invoke the <code>CreateDBInstance</code> action to create DB
+ *                 instances for the restored DB cluster, specifying the identifier of the restored DB
+ *                 cluster in <code>DBClusterIdentifier</code>. You can create DB instances only after
+ *                 the <code>RestoreDBClusterFromSnapshot</code> action has completed and the DB
+ *                 cluster is available.</p>
+ *          </note>
+ *          <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, RestoreDBClusterFromSnapshotCommand } from "@aws-sdk/client-rds"; // ES Modules import
+ * // const { RDSClient, RestoreDBClusterFromSnapshotCommand } = require("@aws-sdk/client-rds"); // CommonJS import
+ * const client = new RDSClient(config);
+ * const command = new RestoreDBClusterFromSnapshotCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RestoreDBClusterFromSnapshotCommandInput} for command's `input` shape.
+ * @see {@link RestoreDBClusterFromSnapshotCommandOutput} for command's `response` shape.
+ * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RestoreDBClusterFromSnapshotCommand extends $Command<RestoreDBClusterFromSnapshotCommandInput, RestoreDBClusterFromSnapshotCommandOutput, RDSClientResolvedConfig> {
+    readonly input: RestoreDBClusterFromSnapshotCommandInput;
+    constructor(input: RestoreDBClusterFromSnapshotCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RestoreDBClusterFromSnapshotCommandInput, RestoreDBClusterFromSnapshotCommandOutput>;
+    private serialize;
+    private deserialize;
+}