@aws-sdk/client-dynamodb 3.34.0 → 3.35.0

package/src/commands/RestoreTableFromBackupCommand.ts

@@ -0,0 +1,119 @@
+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 { RestoreTableFromBackupInput, RestoreTableFromBackupOutput } from "../models/models_0";
+import {
+  deserializeAws_json1_0RestoreTableFromBackupCommand,
+  serializeAws_json1_0RestoreTableFromBackupCommand,
+} from "../protocols/Aws_json1_0";
+
+export interface RestoreTableFromBackupCommandInput extends RestoreTableFromBackupInput {}
+export interface RestoreTableFromBackupCommandOutput extends RestoreTableFromBackupOutput, __MetadataBearer {}
+
+/**
+ * <p>Creates a new table from an existing backup. Any number of users can execute up to 4 concurrent restores
+ *         (any type of restore) in a given account.
+ *       </p>
+ *          <p>You can call <code>RestoreTableFromBackup</code> at a maximum rate of 10 times per second.</p>
+ *          <p>You must manually set up the following on the restored table:</p>
+ *          <ul>
+ *             <li>
+ *                  <p>Auto scaling policies</p>
+ *              </li>
+ *             <li>
+ *                  <p>IAM policies</p>
+ *              </li>
+ *             <li>
+ *                  <p>Amazon CloudWatch metrics and alarms</p>
+ *              </li>
+ *             <li>
+ *                  <p>Tags</p>
+ *              </li>
+ *             <li>
+ *                  <p>Stream settings</p>
+ *              </li>
+ *             <li>
+ *                  <p>Time to Live (TTL) settings</p>
+ *              </li>
+ *          </ul>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DynamoDBClient, RestoreTableFromBackupCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
+ * // const { DynamoDBClient, RestoreTableFromBackupCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
+ * const client = new DynamoDBClient(config);
+ * const command = new RestoreTableFromBackupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RestoreTableFromBackupCommandInput} for command's `input` shape.
+ * @see {@link RestoreTableFromBackupCommandOutput} for command's `response` shape.
+ * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class RestoreTableFromBackupCommand extends $Command<
+  RestoreTableFromBackupCommandInput,
+  RestoreTableFromBackupCommandOutput,
+  DynamoDBClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: RestoreTableFromBackupCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DynamoDBClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<RestoreTableFromBackupCommandInput, RestoreTableFromBackupCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DynamoDBClient";
+    const commandName = "RestoreTableFromBackupCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: RestoreTableFromBackupInput.filterSensitiveLog,
+      outputFilterSensitiveLog: RestoreTableFromBackupOutput.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: RestoreTableFromBackupCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_0RestoreTableFromBackupCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<RestoreTableFromBackupCommandOutput> {
+    return deserializeAws_json1_0RestoreTableFromBackupCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/RestoreTableToPointInTimeCommand.ts

@@ -0,0 +1,153 @@
+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 { RestoreTableToPointInTimeInput, RestoreTableToPointInTimeOutput } from "../models/models_0";
+import {
+  deserializeAws_json1_0RestoreTableToPointInTimeCommand,
+  serializeAws_json1_0RestoreTableToPointInTimeCommand,
+} from "../protocols/Aws_json1_0";
+
+export interface RestoreTableToPointInTimeCommandInput extends RestoreTableToPointInTimeInput {}
+export interface RestoreTableToPointInTimeCommandOutput extends RestoreTableToPointInTimeOutput, __MetadataBearer {}
+
+/**
+ * <p>Restores the specified table to the specified point in time within
+ *         <code>EarliestRestorableDateTime</code> and <code>LatestRestorableDateTime</code>.
+ *         You can restore your table to any point in time during the last 35 days.
+ *         Any number of users can execute up to 4 concurrent restores (any type of restore) in a given account.
+ *       </p>
+ *          <p>
+ *      When you restore using point in time recovery, DynamoDB restores your table data to the state based on
+ *      the selected date and time (day:hour:minute:second) to a new table.
+ *      </p>
+ *          <p>
+ *     Along with data, the following are also included on the new restored table using point in time recovery:
+ *     </p>
+ *         <ul>
+ *             <li>
+ *                  <p>Global secondary indexes (GSIs)</p>
+ *              </li>
+ *             <li>
+ *                  <p>Local secondary indexes (LSIs)</p>
+ *              </li>
+ *             <li>
+ *                  <p>Provisioned read and write capacity</p>
+ *              </li>
+ *             <li>
+ *                  <p>Encryption settings</p>
+ *                <important>
+ *                   <p>
+ *                  All these settings come from the current settings of the source table at the time of restore.
+ *              </p>
+ *                </important>
+ *              </li>
+ *          </ul>
+ *
+ *            <p>You must manually set up the following on the restored table:</p>
+ *          <ul>
+ *             <li>
+ *                  <p>Auto scaling policies</p>
+ *              </li>
+ *             <li>
+ *                  <p>IAM policies</p>
+ *              </li>
+ *             <li>
+ *                  <p>Amazon CloudWatch metrics and alarms</p>
+ *              </li>
+ *             <li>
+ *                  <p>Tags</p>
+ *              </li>
+ *             <li>
+ *                  <p>Stream settings</p>
+ *              </li>
+ *             <li>
+ *                  <p>Time to Live (TTL) settings</p>
+ *              </li>
+ *             <li>
+ *                  <p>Point in time recovery settings</p>
+ *              </li>
+ *          </ul>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DynamoDBClient, RestoreTableToPointInTimeCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
+ * // const { DynamoDBClient, RestoreTableToPointInTimeCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
+ * const client = new DynamoDBClient(config);
+ * const command = new RestoreTableToPointInTimeCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RestoreTableToPointInTimeCommandInput} for command's `input` shape.
+ * @see {@link RestoreTableToPointInTimeCommandOutput} for command's `response` shape.
+ * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class RestoreTableToPointInTimeCommand extends $Command<
+  RestoreTableToPointInTimeCommandInput,
+  RestoreTableToPointInTimeCommandOutput,
+  DynamoDBClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: RestoreTableToPointInTimeCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DynamoDBClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<RestoreTableToPointInTimeCommandInput, RestoreTableToPointInTimeCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DynamoDBClient";
+    const commandName = "RestoreTableToPointInTimeCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: RestoreTableToPointInTimeInput.filterSensitiveLog,
+      outputFilterSensitiveLog: RestoreTableToPointInTimeOutput.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: RestoreTableToPointInTimeCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_0RestoreTableToPointInTimeCommand(input, context);
+  }
+
+  private deserialize(
+    output: __HttpResponse,
+    context: __SerdeContext
+  ): Promise<RestoreTableToPointInTimeCommandOutput> {
+    return deserializeAws_json1_0RestoreTableToPointInTimeCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/ScanCommand.ts

@@ -0,0 +1,112 @@
+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 { ScanInput, ScanOutput } from "../models/models_0";
+import { deserializeAws_json1_0ScanCommand, serializeAws_json1_0ScanCommand } from "../protocols/Aws_json1_0";
+
+export interface ScanCommandInput extends ScanInput {}
+export interface ScanCommandOutput extends ScanOutput, __MetadataBearer {}
+
+/**
+ * <p>The <code>Scan</code> operation returns one or more items and item attributes by accessing every
+ *       item in a table or a secondary index. To have DynamoDB return fewer items, you can provide a <code>FilterExpression</code> operation.</p>
+ *          <p>If the total number of scanned items exceeds the maximum dataset size limit of 1 MB, the
+ *             scan stops and results are returned to the user as a <code>LastEvaluatedKey</code> value
+ *             to continue the scan in a subsequent operation. The results also include the number of
+ *             items exceeding the limit. A scan can result in no table data meeting the filter
+ *             criteria. </p>
+ *          <p>A single <code>Scan</code> operation reads up to the maximum number of items set (if
+ *             using the <code>Limit</code> parameter) or a maximum of 1 MB of data and then apply any
+ *             filtering to the results using <code>FilterExpression</code>. If
+ *                 <code>LastEvaluatedKey</code> is present in the response, you need to paginate the
+ *             result set. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html#Scan.Pagination">Paginating the
+ *                 Results</a> in the <i>Amazon DynamoDB Developer Guide</i>. </p>
+ *          <p>
+ *             <code>Scan</code> operations proceed sequentially; however, for faster performance on
+ *             a large table or secondary index, applications can request a parallel <code>Scan</code>
+ *             operation by providing the <code>Segment</code> and <code>TotalSegments</code>
+ *             parameters. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html#Scan.ParallelScan">Parallel
+ *                 Scan</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+ *          <p>
+ *             <code>Scan</code> uses eventually consistent reads when accessing the data in a
+ *             table; therefore, the result set might not include the changes to data in the table
+ *             immediately before the operation began. If you need a consistent copy of the data, as of
+ *             the time that the <code>Scan</code> begins, you can set the <code>ConsistentRead</code>
+ *             parameter to <code>true</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DynamoDBClient, ScanCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
+ * // const { DynamoDBClient, ScanCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
+ * const client = new DynamoDBClient(config);
+ * const command = new ScanCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ScanCommandInput} for command's `input` shape.
+ * @see {@link ScanCommandOutput} for command's `response` shape.
+ * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class ScanCommand extends $Command<ScanCommandInput, ScanCommandOutput, DynamoDBClientResolvedConfig> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: ScanCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DynamoDBClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<ScanCommandInput, ScanCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DynamoDBClient";
+    const commandName = "ScanCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: ScanInput.filterSensitiveLog,
+      outputFilterSensitiveLog: ScanOutput.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: ScanCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_0ScanCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ScanCommandOutput> {
+    return deserializeAws_json1_0ScanCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/TagResourceCommand.ts

@@ -0,0 +1,101 @@
+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 { TagResourceInput } from "../models/models_0";
+import {
+  deserializeAws_json1_0TagResourceCommand,
+  serializeAws_json1_0TagResourceCommand,
+} from "../protocols/Aws_json1_0";
+
+export interface TagResourceCommandInput extends TagResourceInput {}
+export interface TagResourceCommandOutput extends __MetadataBearer {}
+
+/**
+ * <p>Associate a set of tags with an Amazon DynamoDB resource. You can then activate these
+ *             user-defined tags so that they appear on the Billing and Cost Management console for
+ *             cost allocation tracking. You can call TagResource up to five times per second, per
+ *             account. </p>
+ *          <p>For an overview on tagging DynamoDB resources, see
+ *       <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html">Tagging for DynamoDB</a>
+ *       in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DynamoDBClient, TagResourceCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
+ * // const { DynamoDBClient, TagResourceCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
+ * const client = new DynamoDBClient(config);
+ * const command = new TagResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link TagResourceCommandInput} for command's `input` shape.
+ * @see {@link TagResourceCommandOutput} for command's `response` shape.
+ * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class TagResourceCommand extends $Command<
+  TagResourceCommandInput,
+  TagResourceCommandOutput,
+  DynamoDBClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: TagResourceCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DynamoDBClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<TagResourceCommandInput, TagResourceCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DynamoDBClient";
+    const commandName = "TagResourceCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: TagResourceInput.filterSensitiveLog,
+      outputFilterSensitiveLog: (output: any) => output,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: TagResourceCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_0TagResourceCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<TagResourceCommandOutput> {
+    return deserializeAws_json1_0TagResourceCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/TransactGetItemsCommand.ts

@@ -0,0 +1,120 @@
+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 { TransactGetItemsInput, TransactGetItemsOutput } from "../models/models_0";
+import {
+  deserializeAws_json1_0TransactGetItemsCommand,
+  serializeAws_json1_0TransactGetItemsCommand,
+} from "../protocols/Aws_json1_0";
+
+export interface TransactGetItemsCommandInput extends TransactGetItemsInput {}
+export interface TransactGetItemsCommandOutput extends TransactGetItemsOutput, __MetadataBearer {}
+
+/**
+ * <p>
+ *             <code>TransactGetItems</code> is a synchronous operation that atomically retrieves
+ *             multiple items from one or more tables (but not from indexes) in a single account and
+ *             Region. A <code>TransactGetItems</code> call can contain up to 25
+ *                 <code>TransactGetItem</code> objects, each of which contains a <code>Get</code>
+ *             structure that specifies an item to retrieve from a table in the account and Region. A
+ *             call to <code>TransactGetItems</code> cannot retrieve items from tables in more than one
+ *             AWS account or Region. The aggregate size of the items in the transaction cannot exceed
+ *             4 MB.</p>
+ *          <p>DynamoDB rejects the entire <code>TransactGetItems</code> request if any of the following is true:</p>
+ *          <ul>
+ *             <li>
+ *                <p>A conflicting operation is in the process of updating an
+ *           item to be read.</p>
+ *             </li>
+ *             <li>
+ *                <p>There is insufficient provisioned capacity for the transaction
+ *           to be completed.</p>
+ *             </li>
+ *             <li>
+ *                <p>There is a user error, such as an invalid data format.</p>
+ *             </li>
+ *             <li>
+ *                <p>The aggregate size of the items in the transaction cannot exceed 4 MB.</p>
+ *             </li>
+ *          </ul>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DynamoDBClient, TransactGetItemsCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
+ * // const { DynamoDBClient, TransactGetItemsCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
+ * const client = new DynamoDBClient(config);
+ * const command = new TransactGetItemsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link TransactGetItemsCommandInput} for command's `input` shape.
+ * @see {@link TransactGetItemsCommandOutput} for command's `response` shape.
+ * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class TransactGetItemsCommand extends $Command<
+  TransactGetItemsCommandInput,
+  TransactGetItemsCommandOutput,
+  DynamoDBClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: TransactGetItemsCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DynamoDBClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<TransactGetItemsCommandInput, TransactGetItemsCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DynamoDBClient";
+    const commandName = "TransactGetItemsCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: TransactGetItemsInput.filterSensitiveLog,
+      outputFilterSensitiveLog: TransactGetItemsOutput.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: TransactGetItemsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_0TransactGetItemsCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<TransactGetItemsCommandOutput> {
+    return deserializeAws_json1_0TransactGetItemsCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}