@aws-sdk/client-rds 3.34.0 → 3.37.0

package/dist/types/ts3.4/commands/ModifyDBClusterEndpointCommand.d.ts

@@ -1,39 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { DBClusterEndpoint } from "../models/models_0";
-import { ModifyDBClusterEndpointMessage } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ModifyDBClusterEndpointCommandInput extends ModifyDBClusterEndpointMessage {
-}
-export interface ModifyDBClusterEndpointCommandOutput extends DBClusterEndpoint, __MetadataBearer {
-}
-/**
- * <p>Modifies the properties of an endpoint in 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, ModifyDBClusterEndpointCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, ModifyDBClusterEndpointCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new ModifyDBClusterEndpointCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyDBClusterEndpointCommandInput} for command's `input` shape.
- * @see {@link ModifyDBClusterEndpointCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ModifyDBClusterEndpointCommand extends $Command<ModifyDBClusterEndpointCommandInput, ModifyDBClusterEndpointCommandOutput, RDSClientResolvedConfig> {
-    readonly input: ModifyDBClusterEndpointCommandInput;
-    constructor(input: ModifyDBClusterEndpointCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyDBClusterEndpointCommandInput, ModifyDBClusterEndpointCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ModifyDBClusterParameterGroupCommand.d.ts

@@ -1,62 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { DBClusterParameterGroupNameMessage, ModifyDBClusterParameterGroupMessage } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ModifyDBClusterParameterGroupCommandInput extends ModifyDBClusterParameterGroupMessage {
-}
-export interface ModifyDBClusterParameterGroupCommandOutput extends DBClusterParameterGroupNameMessage, __MetadataBearer {
-}
-/**
- * <p>
- *             Modifies the parameters of a DB cluster parameter group. To modify more than one parameter,
- *             submit a list of the following: <code>ParameterName</code>, <code>ParameterValue</code>,
- *             and <code>ApplyMethod</code>. A maximum of 20
- *             parameters can be modified in a single request.
- *         </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>
- *         <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 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>
- *             <p>If the modified DB cluster parameter group is used by an Aurora Serverless cluster, Aurora
- *                applies the update immediately. The cluster restart might interrupt your workload. In that case,
- *                your application must reopen any connections and retry any transactions that were active
- *                when the parameter changes took effect.</p>
- *         </important>
- *          <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, ModifyDBClusterParameterGroupCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, ModifyDBClusterParameterGroupCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new ModifyDBClusterParameterGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyDBClusterParameterGroupCommandInput} for command's `input` shape.
- * @see {@link ModifyDBClusterParameterGroupCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ModifyDBClusterParameterGroupCommand extends $Command<ModifyDBClusterParameterGroupCommandInput, ModifyDBClusterParameterGroupCommandOutput, RDSClientResolvedConfig> {
-    readonly input: ModifyDBClusterParameterGroupCommandInput;
-    constructor(input: ModifyDBClusterParameterGroupCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyDBClusterParameterGroupCommandInput, ModifyDBClusterParameterGroupCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ModifyDBClusterSnapshotAttributeCommand.d.ts

@@ -1,56 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { ModifyDBClusterSnapshotAttributeMessage, ModifyDBClusterSnapshotAttributeResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ModifyDBClusterSnapshotAttributeCommandInput extends ModifyDBClusterSnapshotAttributeMessage {
-}
-export interface ModifyDBClusterSnapshotAttributeCommandOutput extends ModifyDBClusterSnapshotAttributeResult, __MetadataBearer {
-}
-/**
- * <p>Adds an attribute and values to, or removes an attribute and values from, a manual DB cluster snapshot.</p>
- *         <p>To share a manual DB cluster snapshot with other Amazon Web Services accounts, specify
- *                 <code>restore</code> as the <code>AttributeName</code> and use the
- *                 <code>ValuesToAdd</code> parameter to add a list of IDs of the Amazon Web Services accounts that are
- *             authorized to restore the manual DB cluster snapshot. Use the value <code>all</code> to
- *             make the manual DB cluster snapshot public, which means that it can be copied or
- *             restored by all Amazon Web Services accounts.</p>
- *         <note>
- *             <p>Don't add the <code>all</code> value for any manual DB cluster snapshots
- *                 that contain private information that you don't want available to all Amazon Web Services
- *                 accounts.</p>
- *         </note>
- *         <p>If a manual DB cluster snapshot is encrypted, it can be shared, but only by
- *             specifying a list of authorized Amazon Web Services account IDs for the <code>ValuesToAdd</code>
- *             parameter. You can't use <code>all</code> as a value for that parameter in this
- *             case.</p>
- *         <p>To view which Amazon Web Services accounts have access to copy or restore a manual DB cluster
- *             snapshot, or whether a manual DB cluster snapshot is public or private, use the <a>DescribeDBClusterSnapshotAttributes</a> API action. The accounts are
- *             returned as values for the <code>restore</code> attribute.</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, ModifyDBClusterSnapshotAttributeCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, ModifyDBClusterSnapshotAttributeCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new ModifyDBClusterSnapshotAttributeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyDBClusterSnapshotAttributeCommandInput} for command's `input` shape.
- * @see {@link ModifyDBClusterSnapshotAttributeCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ModifyDBClusterSnapshotAttributeCommand extends $Command<ModifyDBClusterSnapshotAttributeCommandInput, ModifyDBClusterSnapshotAttributeCommandOutput, RDSClientResolvedConfig> {
-    readonly input: ModifyDBClusterSnapshotAttributeCommandInput;
-    constructor(input: ModifyDBClusterSnapshotAttributeCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyDBClusterSnapshotAttributeCommandInput, ModifyDBClusterSnapshotAttributeCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ModifyDBInstanceCommand.d.ts

@@ -1,40 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { ModifyDBInstanceMessage, ModifyDBInstanceResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ModifyDBInstanceCommandInput extends ModifyDBInstanceMessage {
-}
-export interface ModifyDBInstanceCommandOutput extends ModifyDBInstanceResult, __MetadataBearer {
-}
-/**
- * <p>Modifies settings for a DB instance.
- *           You can change one or more database configuration parameters by specifying these parameters and the new values in the request.
- *             To learn what modifications you can make to your DB instance,
- *             call <code>DescribeValidDBInstanceModifications</code>
- *             before you call <code>ModifyDBInstance</code>.
- *       </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, ModifyDBInstanceCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, ModifyDBInstanceCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new ModifyDBInstanceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyDBInstanceCommandInput} for command's `input` shape.
- * @see {@link ModifyDBInstanceCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ModifyDBInstanceCommand extends $Command<ModifyDBInstanceCommandInput, ModifyDBInstanceCommandOutput, RDSClientResolvedConfig> {
-    readonly input: ModifyDBInstanceCommandInput;
-    constructor(input: ModifyDBInstanceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyDBInstanceCommandInput, ModifyDBInstanceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ModifyDBParameterGroupCommand.d.ts

@@ -1,50 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { DBParameterGroupNameMessage, ModifyDBParameterGroupMessage } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ModifyDBParameterGroupCommandInput extends ModifyDBParameterGroupMessage {
-}
-export interface ModifyDBParameterGroupCommandOutput extends DBParameterGroupNameMessage, __MetadataBearer {
-}
-/**
- * <p>
- *         Modifies the parameters of a DB parameter group. To modify more than one parameter,
- *         submit a list of the following: <code>ParameterName</code>, <code>ParameterValue</code>, and
- *         <code>ApplyMethod</code>. A maximum of 20 parameters can be modified in a single request.
- *         </p>
- *          <important>
- *             <p>After you modify 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 modify 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, ModifyDBParameterGroupCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, ModifyDBParameterGroupCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new ModifyDBParameterGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyDBParameterGroupCommandInput} for command's `input` shape.
- * @see {@link ModifyDBParameterGroupCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ModifyDBParameterGroupCommand extends $Command<ModifyDBParameterGroupCommandInput, ModifyDBParameterGroupCommandOutput, RDSClientResolvedConfig> {
-    readonly input: ModifyDBParameterGroupCommandInput;
-    constructor(input: ModifyDBParameterGroupCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyDBParameterGroupCommandInput, ModifyDBParameterGroupCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ModifyDBProxyCommand.d.ts

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

package/dist/types/ts3.4/commands/ModifyDBProxyEndpointCommand.d.ts

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

package/dist/types/ts3.4/commands/ModifyDBProxyTargetGroupCommand.d.ts

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

package/dist/types/ts3.4/commands/ModifyDBSnapshotAttributeCommand.d.ts

@@ -1,51 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { ModifyDBSnapshotAttributeMessage, ModifyDBSnapshotAttributeResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ModifyDBSnapshotAttributeCommandInput extends ModifyDBSnapshotAttributeMessage {
-}
-export interface ModifyDBSnapshotAttributeCommandOutput extends ModifyDBSnapshotAttributeResult, __MetadataBearer {
-}
-/**
- * <p>Adds an attribute and values to, or removes an attribute and values from, a manual DB snapshot.</p>
- *          <p>To share a manual DB snapshot with other Amazon Web Services accounts, specify <code>restore</code>
- *             as the <code>AttributeName</code> and use the <code>ValuesToAdd</code> parameter to add
- *             a list of IDs of the Amazon Web Services accounts that are authorized to restore the manual DB snapshot.
- *             Uses the value <code>all</code> to make the manual DB snapshot public, which means it
- *             can be copied or restored by all Amazon Web Services accounts.</p>
- *         <note>
- *             <p>Don't add the <code>all</code> value for any manual DB snapshots that
- *                 contain private information that you don't want available to all Amazon Web Services
- *                 accounts.</p>
- *         </note>
- *         <p>If the manual DB snapshot is encrypted, it can be shared, but only by specifying a
- *             list of authorized Amazon Web Services account IDs for the <code>ValuesToAdd</code> parameter. You
- *             can't use <code>all</code> as a value for that parameter in this case.</p>
- *          <p>To view which Amazon Web Services accounts have access to copy or restore a manual DB snapshot, or
- *             whether a manual DB snapshot public or private, use the <a>DescribeDBSnapshotAttributes</a> API action. The accounts are returned as
- *             values for the <code>restore</code> attribute.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, ModifyDBSnapshotAttributeCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, ModifyDBSnapshotAttributeCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new ModifyDBSnapshotAttributeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyDBSnapshotAttributeCommandInput} for command's `input` shape.
- * @see {@link ModifyDBSnapshotAttributeCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ModifyDBSnapshotAttributeCommand extends $Command<ModifyDBSnapshotAttributeCommandInput, ModifyDBSnapshotAttributeCommandOutput, RDSClientResolvedConfig> {
-    readonly input: ModifyDBSnapshotAttributeCommandInput;
-    constructor(input: ModifyDBSnapshotAttributeCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyDBSnapshotAttributeCommandInput, ModifyDBSnapshotAttributeCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ModifyDBSnapshotCommand.d.ts

@@ -1,41 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { ModifyDBSnapshotMessage, ModifyDBSnapshotResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ModifyDBSnapshotCommandInput extends ModifyDBSnapshotMessage {
-}
-export interface ModifyDBSnapshotCommandOutput extends ModifyDBSnapshotResult, __MetadataBearer {
-}
-/**
- * <p>Updates a manual DB snapshot with a new engine version. The snapshot can be encrypted
- *             or unencrypted, but not shared or public.
- *
- *         </p>
- *
- *          <p>Amazon RDS supports upgrading DB snapshots for MySQL, Oracle, and PostgreSQL.
- *       </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, ModifyDBSnapshotCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, ModifyDBSnapshotCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new ModifyDBSnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyDBSnapshotCommandInput} for command's `input` shape.
- * @see {@link ModifyDBSnapshotCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ModifyDBSnapshotCommand extends $Command<ModifyDBSnapshotCommandInput, ModifyDBSnapshotCommandOutput, RDSClientResolvedConfig> {
-    readonly input: ModifyDBSnapshotCommandInput;
-    constructor(input: ModifyDBSnapshotCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyDBSnapshotCommandInput, ModifyDBSnapshotCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ModifyDBSubnetGroupCommand.d.ts

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

package/dist/types/ts3.4/commands/ModifyEventSubscriptionCommand.d.ts

@@ -1,39 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { ModifyEventSubscriptionMessage, ModifyEventSubscriptionResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ModifyEventSubscriptionCommandInput extends ModifyEventSubscriptionMessage {
-}
-export interface ModifyEventSubscriptionCommandOutput extends ModifyEventSubscriptionResult, __MetadataBearer {
-}
-/**
- * <p>Modifies an existing RDS event notification subscription. You can't modify the source identifiers using this call. To change
- *         source identifiers for a subscription, use the <code>AddSourceIdentifierToSubscription</code> and <code>RemoveSourceIdentifierFromSubscription</code> calls.</p>
- *          <p>You can see a list of the event categories for a given source type (<code>SourceType</code>)
- *           in <a href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Events.html">Events</a> in the <i>Amazon RDS User Guide</i>
- *             or by using the <code>DescribeEventCategories</code> operation.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RDSClient, ModifyEventSubscriptionCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, ModifyEventSubscriptionCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new ModifyEventSubscriptionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyEventSubscriptionCommandInput} for command's `input` shape.
- * @see {@link ModifyEventSubscriptionCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ModifyEventSubscriptionCommand extends $Command<ModifyEventSubscriptionCommandInput, ModifyEventSubscriptionCommandOutput, RDSClientResolvedConfig> {
-    readonly input: ModifyEventSubscriptionCommandInput;
-    constructor(input: ModifyEventSubscriptionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyEventSubscriptionCommandInput, ModifyEventSubscriptionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ModifyGlobalClusterCommand.d.ts

@@ -1,43 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { ModifyGlobalClusterMessage, ModifyGlobalClusterResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ModifyGlobalClusterCommandInput extends ModifyGlobalClusterMessage {
-}
-export interface ModifyGlobalClusterCommandOutput extends ModifyGlobalClusterResult, __MetadataBearer {
-}
-/**
- * <p>
- *         Modify a setting for an Amazon Aurora global cluster. You can change one or more database configuration
- *         parameters by specifying these parameters and the new values in the request. 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, ModifyGlobalClusterCommand } from "@aws-sdk/client-rds"; // ES Modules import
- * // const { RDSClient, ModifyGlobalClusterCommand } = require("@aws-sdk/client-rds"); // CommonJS import
- * const client = new RDSClient(config);
- * const command = new ModifyGlobalClusterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyGlobalClusterCommandInput} for command's `input` shape.
- * @see {@link ModifyGlobalClusterCommandOutput} for command's `response` shape.
- * @see {@link RDSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ModifyGlobalClusterCommand extends $Command<ModifyGlobalClusterCommandInput, ModifyGlobalClusterCommandOutput, RDSClientResolvedConfig> {
-    readonly input: ModifyGlobalClusterCommandInput;
-    constructor(input: ModifyGlobalClusterCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RDSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyGlobalClusterCommandInput, ModifyGlobalClusterCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ModifyOptionGroupCommand.d.ts

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