@aws-sdk/client-dynamodb 3.34.0 → 3.35.0

package/commands/CreateTableCommand.ts

@@ -1,106 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { CreateTableInput, CreateTableOutput } from "../models/models_0";
-import {
-  deserializeAws_json1_0CreateTableCommand,
-  serializeAws_json1_0CreateTableCommand,
-} from "../protocols/Aws_json1_0";
-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 CreateTableCommandInput extends CreateTableInput {}
-export interface CreateTableCommandOutput extends CreateTableOutput, __MetadataBearer {}
-
-/**
- * <p>The <code>CreateTable</code> operation adds a new table to your account. In an AWS
- *             account, table names must be unique within each Region. That is, you can have two tables
- *             with same name if you create the tables in different Regions.</p>
- *          <p>
- *             <code>CreateTable</code> is an asynchronous operation. Upon receiving a <code>CreateTable</code> request,
- *       DynamoDB immediately returns a response with a <code>TableStatus</code> of <code>CREATING</code>. After
- *       the table is created, DynamoDB sets the <code>TableStatus</code> to <code>ACTIVE</code>. You can
- *       perform read and write operations only on an <code>ACTIVE</code> table. </p>
- *          <p>You can optionally define secondary indexes on the new table, as part of the <code>CreateTable</code>
- *       operation. If you want to create multiple tables with secondary indexes on them, you must create the
- *       tables sequentially. Only one table with secondary indexes can be in the <code>CREATING</code> state at
- *       any given time.</p>
- *          <p>You can use the <code>DescribeTable</code> action to check the table status.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DynamoDBClient, CreateTableCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
- * // const { DynamoDBClient, CreateTableCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
- * const client = new DynamoDBClient(config);
- * const command = new CreateTableCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateTableCommandInput} for command's `input` shape.
- * @see {@link CreateTableCommandOutput} for command's `response` shape.
- * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateTableCommand extends $Command<
-  CreateTableCommandInput,
-  CreateTableCommandOutput,
-  DynamoDBClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateTableCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: DynamoDBClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateTableCommandInput, CreateTableCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "DynamoDBClient";
-    const commandName = "CreateTableCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateTableInput.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateTableOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateTableCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_0CreateTableCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateTableCommandOutput> {
-    return deserializeAws_json1_0CreateTableCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/DeleteBackupCommand.ts

@@ -1,95 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { DeleteBackupInput, DeleteBackupOutput } from "../models/models_0";
-import {
-  deserializeAws_json1_0DeleteBackupCommand,
-  serializeAws_json1_0DeleteBackupCommand,
-} from "../protocols/Aws_json1_0";
-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 DeleteBackupCommandInput extends DeleteBackupInput {}
-export interface DeleteBackupCommandOutput extends DeleteBackupOutput, __MetadataBearer {}
-
-/**
- * <p>Deletes an existing backup of a table.</p>
- *          <p>You can call <code>DeleteBackup</code> at a maximum rate of 10 times per second.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DynamoDBClient, DeleteBackupCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
- * // const { DynamoDBClient, DeleteBackupCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
- * const client = new DynamoDBClient(config);
- * const command = new DeleteBackupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteBackupCommandInput} for command's `input` shape.
- * @see {@link DeleteBackupCommandOutput} for command's `response` shape.
- * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class DeleteBackupCommand extends $Command<
-  DeleteBackupCommandInput,
-  DeleteBackupCommandOutput,
-  DynamoDBClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: DeleteBackupCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: DynamoDBClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DeleteBackupCommandInput, DeleteBackupCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "DynamoDBClient";
-    const commandName = "DeleteBackupCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: DeleteBackupInput.filterSensitiveLog,
-      outputFilterSensitiveLog: DeleteBackupOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: DeleteBackupCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_0DeleteBackupCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DeleteBackupCommandOutput> {
-    return deserializeAws_json1_0DeleteBackupCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/DeleteItemCommand.ts

@@ -1,99 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { DeleteItemInput, DeleteItemOutput } from "../models/models_0";
-import {
-  deserializeAws_json1_0DeleteItemCommand,
-  serializeAws_json1_0DeleteItemCommand,
-} from "../protocols/Aws_json1_0";
-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 DeleteItemCommandInput extends DeleteItemInput {}
-export interface DeleteItemCommandOutput extends DeleteItemOutput, __MetadataBearer {}
-
-/**
- * <p>Deletes a single item in a table by primary key. You can perform a conditional delete operation that deletes the item if it exists, or if it has an expected attribute value.</p>
- *          <p>In addition to deleting an item, you can also return the item's attribute values in the same
- *       operation, using the <code>ReturnValues</code> parameter.</p>
- *          <p>Unless you specify conditions, the <code>DeleteItem</code> is an idempotent operation; running it
- *       multiple times on the same item or attribute does <i>not</i> result in an error response.</p>
- *          <p>Conditional deletes are useful for deleting items only if specific conditions are met. If those conditions are met, DynamoDB performs the delete. Otherwise, the item is not deleted.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DynamoDBClient, DeleteItemCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
- * // const { DynamoDBClient, DeleteItemCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
- * const client = new DynamoDBClient(config);
- * const command = new DeleteItemCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteItemCommandInput} for command's `input` shape.
- * @see {@link DeleteItemCommandOutput} for command's `response` shape.
- * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class DeleteItemCommand extends $Command<
-  DeleteItemCommandInput,
-  DeleteItemCommandOutput,
-  DynamoDBClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: DeleteItemCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: DynamoDBClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DeleteItemCommandInput, DeleteItemCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "DynamoDBClient";
-    const commandName = "DeleteItemCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: DeleteItemInput.filterSensitiveLog,
-      outputFilterSensitiveLog: DeleteItemOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: DeleteItemCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_0DeleteItemCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DeleteItemCommandOutput> {
-    return deserializeAws_json1_0DeleteItemCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/DeleteTableCommand.ts

@@ -1,110 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { DeleteTableInput, DeleteTableOutput } from "../models/models_0";
-import {
-  deserializeAws_json1_0DeleteTableCommand,
-  serializeAws_json1_0DeleteTableCommand,
-} from "../protocols/Aws_json1_0";
-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 DeleteTableCommandInput extends DeleteTableInput {}
-export interface DeleteTableCommandOutput extends DeleteTableOutput, __MetadataBearer {}
-
-/**
- * <p>The <code>DeleteTable</code> operation deletes a table and all of its items. After a
- *         <code>DeleteTable</code> request, the specified table is in the <code>DELETING</code> state until
- *       DynamoDB completes the deletion. If the table is in the <code>ACTIVE</code> state, you can delete
- *       it. If a table is in <code>CREATING</code> or <code>UPDATING</code> states, then DynamoDB returns
- *       a <code>ResourceInUseException</code>. If the specified table does not exist, DynamoDB returns a
- *         <code>ResourceNotFoundException</code>. If table is already in the <code>DELETING</code> state, no
- *       error is returned. </p>
- *          <note>
- *             <p>DynamoDB might continue to accept data read and write operations, such as <code>GetItem</code> and
- *           <code>PutItem</code>, on a table in the <code>DELETING</code> state until the table deletion is
- *         complete.</p>
- *          </note>
- *          <p>When you delete a table, any indexes on that table are also deleted.</p>
- *          <p>If you have DynamoDB Streams enabled on the table, then the corresponding stream on that table goes
- *       into the <code>DISABLED</code> state, and the stream is automatically deleted after 24 hours.</p>
- *
- *          <p>Use the <code>DescribeTable</code> action to check the status of the table. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DynamoDBClient, DeleteTableCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
- * // const { DynamoDBClient, DeleteTableCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
- * const client = new DynamoDBClient(config);
- * const command = new DeleteTableCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteTableCommandInput} for command's `input` shape.
- * @see {@link DeleteTableCommandOutput} for command's `response` shape.
- * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class DeleteTableCommand extends $Command<
-  DeleteTableCommandInput,
-  DeleteTableCommandOutput,
-  DynamoDBClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: DeleteTableCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: DynamoDBClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DeleteTableCommandInput, DeleteTableCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "DynamoDBClient";
-    const commandName = "DeleteTableCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: DeleteTableInput.filterSensitiveLog,
-      outputFilterSensitiveLog: DeleteTableOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: DeleteTableCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_0DeleteTableCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DeleteTableCommandOutput> {
-    return deserializeAws_json1_0DeleteTableCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/DescribeBackupCommand.ts

@@ -1,95 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { DescribeBackupInput, DescribeBackupOutput } from "../models/models_0";
-import {
-  deserializeAws_json1_0DescribeBackupCommand,
-  serializeAws_json1_0DescribeBackupCommand,
-} from "../protocols/Aws_json1_0";
-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 DescribeBackupCommandInput extends DescribeBackupInput {}
-export interface DescribeBackupCommandOutput extends DescribeBackupOutput, __MetadataBearer {}
-
-/**
- * <p>Describes an existing backup of a table.</p>
- *          <p>You can call <code>DescribeBackup</code> at a maximum rate of 10 times per second.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DynamoDBClient, DescribeBackupCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
- * // const { DynamoDBClient, DescribeBackupCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
- * const client = new DynamoDBClient(config);
- * const command = new DescribeBackupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeBackupCommandInput} for command's `input` shape.
- * @see {@link DescribeBackupCommandOutput} for command's `response` shape.
- * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class DescribeBackupCommand extends $Command<
-  DescribeBackupCommandInput,
-  DescribeBackupCommandOutput,
-  DynamoDBClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: DescribeBackupCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: DynamoDBClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DescribeBackupCommandInput, DescribeBackupCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "DynamoDBClient";
-    const commandName = "DescribeBackupCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: DescribeBackupInput.filterSensitiveLog,
-      outputFilterSensitiveLog: DescribeBackupOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: DescribeBackupCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_0DescribeBackupCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DescribeBackupCommandOutput> {
-    return deserializeAws_json1_0DescribeBackupCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/DescribeContinuousBackupsCommand.ts

@@ -1,107 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { DescribeContinuousBackupsInput, DescribeContinuousBackupsOutput } from "../models/models_0";
-import {
-  deserializeAws_json1_0DescribeContinuousBackupsCommand,
-  serializeAws_json1_0DescribeContinuousBackupsCommand,
-} from "../protocols/Aws_json1_0";
-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 DescribeContinuousBackupsCommandInput extends DescribeContinuousBackupsInput {}
-export interface DescribeContinuousBackupsCommandOutput extends DescribeContinuousBackupsOutput, __MetadataBearer {}
-
-/**
- * <p>Checks the status of continuous backups and point in time recovery on the specified table.
- *       Continuous backups are <code>ENABLED</code> on all tables at table creation.
- *       If point in time recovery is enabled, <code>PointInTimeRecoveryStatus</code> will be set to ENABLED.</p>
- *          <p> After continuous backups and point in time recovery are enabled, you can restore to any
- *             point in time within <code>EarliestRestorableDateTime</code> and
- *                 <code>LatestRestorableDateTime</code>. </p>
- *          <p>
- *             <code>LatestRestorableDateTime</code> is typically 5 minutes before the current time. You can restore your table to any point
- *        in time during the last 35 days.
- *      </p>
- *          <p>You can call <code>DescribeContinuousBackups</code> at a maximum rate of 10 times per second.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DynamoDBClient, DescribeContinuousBackupsCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
- * // const { DynamoDBClient, DescribeContinuousBackupsCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
- * const client = new DynamoDBClient(config);
- * const command = new DescribeContinuousBackupsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeContinuousBackupsCommandInput} for command's `input` shape.
- * @see {@link DescribeContinuousBackupsCommandOutput} for command's `response` shape.
- * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class DescribeContinuousBackupsCommand extends $Command<
-  DescribeContinuousBackupsCommandInput,
-  DescribeContinuousBackupsCommandOutput,
-  DynamoDBClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: DescribeContinuousBackupsCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: DynamoDBClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DescribeContinuousBackupsCommandInput, DescribeContinuousBackupsCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "DynamoDBClient";
-    const commandName = "DescribeContinuousBackupsCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: DescribeContinuousBackupsInput.filterSensitiveLog,
-      outputFilterSensitiveLog: DescribeContinuousBackupsOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: DescribeContinuousBackupsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_0DescribeContinuousBackupsCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<DescribeContinuousBackupsCommandOutput> {
-    return deserializeAws_json1_0DescribeContinuousBackupsCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}