@aws-sdk/client-dynamodb 3.31.0 → 3.35.0

package/src/commands/CreateTableCommand.ts

@@ -0,0 +1,107 @@
+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,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+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";
+
+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/src/commands/DeleteBackupCommand.ts

@@ -0,0 +1,96 @@
+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,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+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";
+
+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/src/commands/DeleteItemCommand.ts

@@ -0,0 +1,100 @@
+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,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+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";
+
+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/src/commands/DeleteTableCommand.ts

@@ -0,0 +1,111 @@
+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,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+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";
+
+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/src/commands/DescribeBackupCommand.ts

@@ -0,0 +1,96 @@
+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,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+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";
+
+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/src/commands/DescribeContinuousBackupsCommand.ts

@@ -0,0 +1,108 @@
+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,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+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";
+
+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
+}