@aws-sdk/client-dynamodb 3.34.0 → 3.35.0

package/dist-types/commands/PutItemCommand.d.ts

@@ -0,0 +1,102 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { PutItemInput, PutItemOutput } from "../models/models_0";
+export interface PutItemCommandInput extends PutItemInput {
+}
+export interface PutItemCommandOutput extends PutItemOutput, __MetadataBearer {
+}
+/**
+ * <p>Creates a new item, or replaces an old item with a new item. If an item that has the same primary key as the new item already exists in the specified table, the new item completely replaces the existing item. You can perform a conditional put operation (add a new item if one with the specified primary key doesn't exist), or replace an existing item if it has certain attribute values. You can return the item's attribute values in the same operation, using the <code>ReturnValues</code> parameter.</p>
+ *          <important>
+ *             <p>This topic provides general information about the <code>PutItem</code> API.</p>
+ *             <p>For information on how to call the <code>PutItem</code> API using the AWS SDK in specific languages, see the following:</p>
+ *             <ul>
+ *                <li>
+ *                   <p>
+ *                         <a href="http://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/PutItem"> PutItem in the AWS Command Line Interface</a>
+ *                     </p>
+ *                </li>
+ *                <li>
+ *                   <p>
+ *                         <a href="http://docs.aws.amazon.com/goto/DotNetSDKV3/dynamodb-2012-08-10/PutItem"> PutItem in the AWS SDK for .NET</a>
+ *                     </p>
+ *                </li>
+ *                <li>
+ *                   <p>
+ *                         <a href="http://docs.aws.amazon.com/goto/SdkForCpp/dynamodb-2012-08-10/PutItem"> PutItem in the AWS SDK for C++</a>
+ *                     </p>
+ *                </li>
+ *                <li>
+ *                   <p>
+ *                         <a href="http://docs.aws.amazon.com/goto/SdkForGoV1/dynamodb-2012-08-10/PutItem"> PutItem in the AWS SDK for Go</a>
+ *                     </p>
+ *                </li>
+ *                <li>
+ *                   <p>
+ *                         <a href="http://docs.aws.amazon.com/goto/SdkForJava/dynamodb-2012-08-10/PutItem"> PutItem in the AWS SDK for Java</a>
+ *                     </p>
+ *                </li>
+ *                <li>
+ *                   <p>
+ *                         <a href="http://docs.aws.amazon.com/goto/AWSJavaScriptSDK/dynamodb-2012-08-10/PutItem"> PutItem in the AWS SDK for JavaScript</a>
+ *                     </p>
+ *                </li>
+ *                <li>
+ *                   <p>
+ *                         <a href="http://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/PutItem"> PutItem in the AWS SDK for PHP V3</a>
+ *                     </p>
+ *                </li>
+ *                <li>
+ *                   <p>
+ *                         <a href="http://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/PutItem">
+ *                             PutItem in the AWS SDK for Python</a>
+ *                     </p>
+ *                </li>
+ *                <li>
+ *                   <p>
+ *                         <a href="http://docs.aws.amazon.com/goto/SdkForRubyV2/dynamodb-2012-08-10/PutItem"> PutItem in the AWS SDK for Ruby V2</a>
+ *                     </p>
+ *                </li>
+ *             </ul>
+ *          </important>
+ *
+ *          <p>When you add an item, the primary key attributes are the only required attributes.
+ *             Attribute values cannot be null.</p>
+ *             <p>Empty String and Binary attribute values are allowed. Attribute values of type String and Binary must have a length greater than zero if the attribute is used as a key attribute for a table or index.
+ *             Set type attributes cannot be empty. </p>
+ *             <p>Invalid Requests with empty values will
+ *             be rejected with a <code>ValidationException</code> exception.</p>
+ *          <note>
+ *             <p>To prevent a new item from replacing an existing item, use a conditional expression
+ *          that contains the <code>attribute_not_exists</code> function with the name of the
+ *          attribute being used as the partition key for the table.  Since every record must contain
+ *          that attribute, the <code>attribute_not_exists</code> function will only succeed if
+ *          no matching item exists.</p>
+ *          </note>
+ *          <p>For more information about <code>PutItem</code>, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html">Working with Items</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, PutItemCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
+ * // const { DynamoDBClient, PutItemCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
+ * const client = new DynamoDBClient(config);
+ * const command = new PutItemCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutItemCommandInput} for command's `input` shape.
+ * @see {@link PutItemCommandOutput} for command's `response` shape.
+ * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PutItemCommand extends $Command<PutItemCommandInput, PutItemCommandOutput, DynamoDBClientResolvedConfig> {
+    readonly input: PutItemCommandInput;
+    constructor(input: PutItemCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutItemCommandInput, PutItemCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/QueryCommand.d.ts

@@ -0,0 +1,90 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { QueryInput, QueryOutput } from "../models/models_0";
+export interface QueryCommandInput extends QueryInput {
+}
+export interface QueryCommandOutput extends QueryOutput, __MetadataBearer {
+}
+/**
+ * <p>The <code>Query</code> operation finds items based on primary key values.
+ *             You can query any table or secondary index that has a composite primary key (a partition
+ *             key and a sort key).
+ *         </p>
+ *         <p>Use the <code>KeyConditionExpression</code> parameter to provide a specific value
+ *             for the partition key. The <code>Query</code> operation will return all of the items
+ *             from the table or index with that partition key value. You can optionally narrow the
+ *             scope of the <code>Query</code> operation by specifying a sort key value and a
+ *             comparison operator in <code>KeyConditionExpression</code>. To further refine the <code>Query</code> results,
+ *             you can optionally provide a <code>FilterExpression</code>. A <code>FilterExpression</code> determines which items
+ *             within the results should be returned to you. All of the other results are discarded.
+ *         </p>
+ *         <p>
+ *             A <code>Query</code> operation always returns a result set. If no matching items are found,
+ *             the result set will be empty. Queries that do not return results consume the minimum number of
+ *             read capacity units for that type of read operation.
+ *         </p>
+ *         <note>
+ *             <p>
+ *                 DynamoDB calculates the number of read capacity units consumed based on item size,
+ *                 not on the amount of data that is returned to an application. The number of capacity
+ *                 units consumed will be the same whether you request all of the attributes (the default behavior)
+ *                 or just some of them (using a projection expression). The number will also be the same
+ *                 whether or not you use a <code>FilterExpression</code>.
+ *             </p>
+ *         </note>
+ *         <p>
+ *             <code>Query</code> results are always sorted by the sort key value. If the data type of the sort key is Number,
+ *             the results are returned in numeric order; otherwise, the results are returned in order of UTF-8 bytes.
+ *             By default, the sort order is ascending. To reverse the order, set the <code>ScanIndexForward</code> parameter
+ *             to false.
+ *         </p>
+ *         <p> A single <code>Query</code> operation will read 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 will need to paginate
+ *             the result set. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html#Query.Pagination">Paginating
+ *                 the Results</a> in the <i>Amazon DynamoDB Developer Guide</i>. </p>
+ *         <p>
+ *             <code>FilterExpression</code> is applied after a <code>Query</code> finishes, but before
+ *             the results are returned.
+ *             A <code>FilterExpression</code> cannot contain partition key or sort key attributes.
+ *             You need to specify those attributes in the <code>KeyConditionExpression</code>.
+ *         </p>
+ *         <note>
+ *             <p>
+ *                 A <code>Query</code> operation can return an empty result set and a <code>LastEvaluatedKey</code>
+ *                 if all the items read for the page of results are filtered out.
+ *             </p>
+ *         </note>
+ *         <p>You can query a table, a local secondary index, or a global secondary index. For a
+ *             query on a table or on a local secondary index, you can set the
+ *                 <code>ConsistentRead</code> parameter to <code>true</code> and obtain a
+ *             strongly consistent result. Global secondary indexes support eventually consistent reads
+ *             only, so do not specify <code>ConsistentRead</code> when querying a global
+ *             secondary index.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DynamoDBClient, QueryCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
+ * // const { DynamoDBClient, QueryCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
+ * const client = new DynamoDBClient(config);
+ * const command = new QueryCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link QueryCommandInput} for command's `input` shape.
+ * @see {@link QueryCommandOutput} for command's `response` shape.
+ * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class QueryCommand extends $Command<QueryCommandInput, QueryCommandOutput, DynamoDBClientResolvedConfig> {
+    readonly input: QueryCommandInput;
+    constructor(input: QueryCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<QueryCommandInput, QueryCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RestoreTableFromBackupCommand.d.ts

@@ -0,0 +1,59 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { RestoreTableFromBackupInput, RestoreTableFromBackupOutput } from "../models/models_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 declare class RestoreTableFromBackupCommand extends $Command<RestoreTableFromBackupCommandInput, RestoreTableFromBackupCommandOutput, DynamoDBClientResolvedConfig> {
+    readonly input: RestoreTableFromBackupCommandInput;
+    constructor(input: RestoreTableFromBackupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RestoreTableFromBackupCommandInput, RestoreTableFromBackupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RestoreTableToPointInTimeCommand.d.ts

@@ -0,0 +1,90 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { RestoreTableToPointInTimeInput, RestoreTableToPointInTimeOutput } from "../models/models_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 declare class RestoreTableToPointInTimeCommand extends $Command<RestoreTableToPointInTimeCommandInput, RestoreTableToPointInTimeCommandOutput, DynamoDBClientResolvedConfig> {
+    readonly input: RestoreTableToPointInTimeCommandInput;
+    constructor(input: RestoreTableToPointInTimeCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RestoreTableToPointInTimeCommandInput, RestoreTableToPointInTimeCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ScanCommand.d.ts

@@ -0,0 +1,59 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { ScanInput, ScanOutput } from "../models/models_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 declare class ScanCommand extends $Command<ScanCommandInput, ScanCommandOutput, DynamoDBClientResolvedConfig> {
+    readonly input: ScanCommandInput;
+    constructor(input: ScanCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ScanCommandInput, ScanCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/TagResourceCommand.d.ts

@@ -0,0 +1,41 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { TagResourceInput } from "../models/models_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 declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, DynamoDBClientResolvedConfig> {
+    readonly input: TagResourceCommandInput;
+    constructor(input: TagResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/TransactGetItemsCommand.d.ts

@@ -0,0 +1,60 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { TransactGetItemsInput, TransactGetItemsOutput } from "../models/models_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 declare class TransactGetItemsCommand extends $Command<TransactGetItemsCommandInput, TransactGetItemsCommandOutput, DynamoDBClientResolvedConfig> {
+    readonly input: TransactGetItemsCommandInput;
+    constructor(input: TransactGetItemsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TransactGetItemsCommandInput, TransactGetItemsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/TransactWriteItemsCommand.d.ts

@@ -0,0 +1,108 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { TransactWriteItemsInput, TransactWriteItemsOutput } from "../models/models_0";
+export interface TransactWriteItemsCommandInput extends TransactWriteItemsInput {
+}
+export interface TransactWriteItemsCommandOutput extends TransactWriteItemsOutput, __MetadataBearer {
+}
+/**
+ * <p>
+ *             <code>TransactWriteItems</code> is a synchronous write operation that groups up to 25
+ *             action requests. These actions can target items in different tables, but not in
+ *             different AWS accounts or Regions, and no two actions can target the same item. For
+ *             example, you cannot both <code>ConditionCheck</code> and <code>Update</code> the same
+ *             item. The aggregate size of the items in the transaction cannot exceed 4 MB.</p>
+ *
+ *          <p>The actions are completed atomically so that either all of
+ *         them succeed, or all of them fail. They are defined by the following objects:</p>
+ *
+ *          <ul>
+ *             <li>
+ *                <p>
+ *                   <code>Put</code>  —   Initiates a <code>PutItem</code> operation to write a new
+ *                     item. This structure specifies the primary key of the item to be written, the
+ *                     name of the table to write it in, an optional condition expression that must be
+ *                     satisfied for the write to succeed, a list of the item's attributes, and a field
+ *                     indicating whether to retrieve the item's attributes if the condition is not
+ *                     met.</p>
+ *             </li>
+ *             <li>
+ *                <p>
+ *                   <code>Update</code>  —   Initiates an <code>UpdateItem</code> operation to
+ *                     update an existing item. This structure specifies the primary key of the item to
+ *                     be updated, the name of the table where it resides, an optional condition
+ *                     expression that must be satisfied for the update to succeed, an expression that
+ *                     defines one or more attributes to be updated, and a field indicating whether to
+ *                     retrieve the item's attributes if the condition is not met.</p>
+ *             </li>
+ *             <li>
+ *                <p>
+ *                   <code>Delete</code>  —   Initiates a <code>DeleteItem</code> operation to
+ *                     delete an existing item. This structure specifies the primary key of the item to
+ *                     be deleted, the name of the table where it resides, an optional condition
+ *                     expression that must be satisfied for the deletion to succeed, and a field
+ *                     indicating whether to retrieve the item's attributes if the condition is not
+ *                     met.</p>
+ *             </li>
+ *             <li>
+ *                <p>
+ *                   <code>ConditionCheck</code>  —   Applies a condition to an item that is not
+ *                     being modified by the transaction. This structure specifies the primary key of
+ *                     the item to be checked, the name of the table where it resides, a condition
+ *                     expression that must be satisfied for the transaction to succeed, and a field
+ *                     indicating whether to retrieve the item's attributes if the condition is not
+ *                     met.</p>
+ *             </li>
+ *          </ul>
+ *
+ *          <p>DynamoDB rejects the entire <code>TransactWriteItems</code> request if any of the following is true:</p>
+ *          <ul>
+ *             <li>
+ *                <p>A condition in one of the condition expressions is not met.</p>
+ *             </li>
+ *             <li>
+ *                <p>An ongoing operation is in the process of updating the same
+ *           item.</p>
+ *             </li>
+ *             <li>
+ *                <p>There is insufficient provisioned capacity for the transaction
+ *           to be completed.</p>
+ *             </li>
+ *             <li>
+ *                <p>An item size becomes too large (bigger than 400 KB), a local secondary index (LSI) becomes too
+ *                     large, or a similar validation error occurs because of changes made by the
+ *                     transaction.</p>
+ *             </li>
+ *             <li>
+ *                <p>The aggregate size of the items in the transaction exceeds 4 MB.</p>
+ *             </li>
+ *             <li>
+ *                <p>There  is a user error, such as an invalid data format.</p>
+ *             </li>
+ *          </ul>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DynamoDBClient, TransactWriteItemsCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
+ * // const { DynamoDBClient, TransactWriteItemsCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
+ * const client = new DynamoDBClient(config);
+ * const command = new TransactWriteItemsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link TransactWriteItemsCommandInput} for command's `input` shape.
+ * @see {@link TransactWriteItemsCommandOutput} for command's `response` shape.
+ * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class TransactWriteItemsCommand extends $Command<TransactWriteItemsCommandInput, TransactWriteItemsCommandOutput, DynamoDBClientResolvedConfig> {
+    readonly input: TransactWriteItemsCommandInput;
+    constructor(input: TransactWriteItemsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TransactWriteItemsCommandInput, TransactWriteItemsCommandOutput>;
+    private serialize;
+    private deserialize;
+}