@aws-sdk/client-rds 3.34.0 → 3.37.0

package/commands/CopyOptionGroupCommand.ts

@@ -1,94 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { CopyOptionGroupMessage, CopyOptionGroupResult } from "../models/models_0";
-import {
-  deserializeAws_queryCopyOptionGroupCommand,
-  serializeAws_queryCopyOptionGroupCommand,
-} from "../protocols/Aws_query";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-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 class CopyOptionGroupCommand extends $Command<
-  CopyOptionGroupCommandInput,
-  CopyOptionGroupCommandOutput,
-  RDSClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CopyOptionGroupCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: RDSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CopyOptionGroupCommandInput, CopyOptionGroupCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "RDSClient";
-    const commandName = "CopyOptionGroupCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CopyOptionGroupMessage.filterSensitiveLog,
-      outputFilterSensitiveLog: CopyOptionGroupResult.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CopyOptionGroupCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_queryCopyOptionGroupCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CopyOptionGroupCommandOutput> {
-    return deserializeAws_queryCopyOptionGroupCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/CreateCustomAvailabilityZoneCommand.ts

@@ -1,104 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { CreateCustomAvailabilityZoneMessage, CreateCustomAvailabilityZoneResult } from "../models/models_0";
-import {
-  deserializeAws_queryCreateCustomAvailabilityZoneCommand,
-  serializeAws_queryCreateCustomAvailabilityZoneCommand,
-} from "../protocols/Aws_query";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-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 class CreateCustomAvailabilityZoneCommand extends $Command<
-  CreateCustomAvailabilityZoneCommandInput,
-  CreateCustomAvailabilityZoneCommandOutput,
-  RDSClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateCustomAvailabilityZoneCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: RDSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateCustomAvailabilityZoneCommandInput, CreateCustomAvailabilityZoneCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "RDSClient";
-    const commandName = "CreateCustomAvailabilityZoneCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateCustomAvailabilityZoneMessage.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateCustomAvailabilityZoneResult.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateCustomAvailabilityZoneCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_queryCreateCustomAvailabilityZoneCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<CreateCustomAvailabilityZoneCommandOutput> {
-    return deserializeAws_queryCreateCustomAvailabilityZoneCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/CreateDBClusterCommand.ts

@@ -1,109 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { CreateDBClusterMessage, CreateDBClusterResult } from "../models/models_0";
-import {
-  deserializeAws_queryCreateDBClusterCommand,
-  serializeAws_queryCreateDBClusterCommand,
-} from "../protocols/Aws_query";
-import { getCrossRegionPresignedUrlPlugin } from "@aws-sdk/middleware-sdk-rds";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-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 class CreateDBClusterCommand extends $Command<
-  CreateDBClusterCommandInput,
-  CreateDBClusterCommandOutput,
-  RDSClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateDBClusterCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: RDSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateDBClusterCommandInput, CreateDBClusterCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-    this.middlewareStack.use(getCrossRegionPresignedUrlPlugin(configuration));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "RDSClient";
-    const commandName = "CreateDBClusterCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateDBClusterMessage.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateDBClusterResult.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateDBClusterCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_queryCreateDBClusterCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateDBClusterCommandOutput> {
-    return deserializeAws_queryCreateDBClusterCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/CreateDBClusterEndpointCommand.ts

@@ -1,97 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { CreateDBClusterEndpointMessage, DBClusterEndpoint } from "../models/models_0";
-import {
-  deserializeAws_queryCreateDBClusterEndpointCommand,
-  serializeAws_queryCreateDBClusterEndpointCommand,
-} from "../protocols/Aws_query";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-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 class CreateDBClusterEndpointCommand extends $Command<
-  CreateDBClusterEndpointCommandInput,
-  CreateDBClusterEndpointCommandOutput,
-  RDSClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateDBClusterEndpointCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: RDSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateDBClusterEndpointCommandInput, CreateDBClusterEndpointCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "RDSClient";
-    const commandName = "CreateDBClusterEndpointCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateDBClusterEndpointMessage.filterSensitiveLog,
-      outputFilterSensitiveLog: DBClusterEndpoint.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateDBClusterEndpointCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_queryCreateDBClusterEndpointCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateDBClusterEndpointCommandOutput> {
-    return deserializeAws_queryCreateDBClusterEndpointCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/CreateDBClusterParameterGroupCommand.ts

@@ -1,130 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { CreateDBClusterParameterGroupMessage, CreateDBClusterParameterGroupResult } from "../models/models_0";
-import {
-  deserializeAws_queryCreateDBClusterParameterGroupCommand,
-  serializeAws_queryCreateDBClusterParameterGroupCommand,
-} from "../protocols/Aws_query";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-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 class CreateDBClusterParameterGroupCommand extends $Command<
-  CreateDBClusterParameterGroupCommandInput,
-  CreateDBClusterParameterGroupCommandOutput,
-  RDSClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateDBClusterParameterGroupCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: RDSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateDBClusterParameterGroupCommandInput, CreateDBClusterParameterGroupCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "RDSClient";
-    const commandName = "CreateDBClusterParameterGroupCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateDBClusterParameterGroupMessage.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateDBClusterParameterGroupResult.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateDBClusterParameterGroupCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_queryCreateDBClusterParameterGroupCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<CreateDBClusterParameterGroupCommandOutput> {
-    return deserializeAws_queryCreateDBClusterParameterGroupCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/CreateDBClusterSnapshotCommand.ts

@@ -1,100 +0,0 @@
-import { RDSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RDSClient";
-import { CreateDBClusterSnapshotMessage, CreateDBClusterSnapshotResult } from "../models/models_0";
-import {
-  deserializeAws_queryCreateDBClusterSnapshotCommand,
-  serializeAws_queryCreateDBClusterSnapshotCommand,
-} from "../protocols/Aws_query";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-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 class CreateDBClusterSnapshotCommand extends $Command<
-  CreateDBClusterSnapshotCommandInput,
-  CreateDBClusterSnapshotCommandOutput,
-  RDSClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateDBClusterSnapshotCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: RDSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateDBClusterSnapshotCommandInput, CreateDBClusterSnapshotCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "RDSClient";
-    const commandName = "CreateDBClusterSnapshotCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateDBClusterSnapshotMessage.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateDBClusterSnapshotResult.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateDBClusterSnapshotCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_queryCreateDBClusterSnapshotCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateDBClusterSnapshotCommandOutput> {
-    return deserializeAws_queryCreateDBClusterSnapshotCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}