@aws-sdk/lib-dynamodb 3.50.0 → 3.51.0

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.51.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.50.0...v3.51.0) (2022-02-12)
+
+**Note:** Version bump only for package @aws-sdk/lib-dynamodb
+
+
+
+
+
 # [3.50.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.49.0...v3.50.0) (2022-02-08)
 
 **Note:** Version bump only for package @aws-sdk/lib-dynamodb

package/dist-types/ts3.4/DynamoDBDocument.d.ts

@@ -0,0 +1,72 @@
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
+import { BatchExecuteStatementCommandInput, BatchExecuteStatementCommandOutput } from "./commands/BatchExecuteStatementCommand";
+import { BatchGetCommandInput, BatchGetCommandOutput } from "./commands/BatchGetCommand";
+import { BatchWriteCommandInput, BatchWriteCommandOutput } from "./commands/BatchWriteCommand";
+import { DeleteCommandInput, DeleteCommandOutput } from "./commands/DeleteCommand";
+import { ExecuteStatementCommandInput, ExecuteStatementCommandOutput } from "./commands/ExecuteStatementCommand";
+import { ExecuteTransactionCommandInput, ExecuteTransactionCommandOutput } from "./commands/ExecuteTransactionCommand";
+import { GetCommandInput, GetCommandOutput } from "./commands/GetCommand";
+import { PutCommandInput, PutCommandOutput } from "./commands/PutCommand";
+import { QueryCommandInput, QueryCommandOutput } from "./commands/QueryCommand";
+import { ScanCommandInput, ScanCommandOutput } from "./commands/ScanCommand";
+import { TransactGetCommandInput, TransactGetCommandOutput } from "./commands/TransactGetCommand";
+import { TransactWriteCommandInput, TransactWriteCommandOutput } from "./commands/TransactWriteCommand";
+import { UpdateCommandInput, UpdateCommandOutput } from "./commands/UpdateCommand";
+import { DynamoDBDocumentClient, TranslateConfig } from "./DynamoDBDocumentClient";
+
+export declare class DynamoDBDocument extends DynamoDBDocumentClient {
+    static from(client: DynamoDBClient, translateConfig?: TranslateConfig): DynamoDBDocument;
+    
+    batchExecuteStatement(args: BatchExecuteStatementCommandInput, options?: __HttpHandlerOptions): Promise<BatchExecuteStatementCommandOutput>;
+    batchExecuteStatement(args: BatchExecuteStatementCommandInput, cb: (err: any, data?: BatchExecuteStatementCommandOutput) => void): void;
+    batchExecuteStatement(args: BatchExecuteStatementCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: BatchExecuteStatementCommandOutput) => void): void;
+    
+    batchGet(args: BatchGetCommandInput, options?: __HttpHandlerOptions): Promise<BatchGetCommandOutput>;
+    batchGet(args: BatchGetCommandInput, cb: (err: any, data?: BatchGetCommandOutput) => void): void;
+    batchGet(args: BatchGetCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: BatchGetCommandOutput) => void): void;
+    
+    batchWrite(args: BatchWriteCommandInput, options?: __HttpHandlerOptions): Promise<BatchWriteCommandOutput>;
+    batchWrite(args: BatchWriteCommandInput, cb: (err: any, data?: BatchWriteCommandOutput) => void): void;
+    batchWrite(args: BatchWriteCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: BatchWriteCommandOutput) => void): void;
+    
+    delete(args: DeleteCommandInput, options?: __HttpHandlerOptions): Promise<DeleteCommandOutput>;
+    delete(args: DeleteCommandInput, cb: (err: any, data?: DeleteCommandOutput) => void): void;
+    delete(args: DeleteCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteCommandOutput) => void): void;
+    
+    executeStatement(args: ExecuteStatementCommandInput, options?: __HttpHandlerOptions): Promise<ExecuteStatementCommandOutput>;
+    executeStatement(args: ExecuteStatementCommandInput, cb: (err: any, data?: ExecuteStatementCommandOutput) => void): void;
+    executeStatement(args: ExecuteStatementCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ExecuteStatementCommandOutput) => void): void;
+    
+    executeTransaction(args: ExecuteTransactionCommandInput, options?: __HttpHandlerOptions): Promise<ExecuteTransactionCommandOutput>;
+    executeTransaction(args: ExecuteTransactionCommandInput, cb: (err: any, data?: ExecuteTransactionCommandOutput) => void): void;
+    executeTransaction(args: ExecuteTransactionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ExecuteTransactionCommandOutput) => void): void;
+    
+    get(args: GetCommandInput, options?: __HttpHandlerOptions): Promise<GetCommandOutput>;
+    get(args: GetCommandInput, cb: (err: any, data?: GetCommandOutput) => void): void;
+    get(args: GetCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetCommandOutput) => void): void;
+    
+    put(args: PutCommandInput, options?: __HttpHandlerOptions): Promise<PutCommandOutput>;
+    put(args: PutCommandInput, cb: (err: any, data?: PutCommandOutput) => void): void;
+    put(args: PutCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: PutCommandOutput) => void): void;
+    
+    query(args: QueryCommandInput, options?: __HttpHandlerOptions): Promise<QueryCommandOutput>;
+    query(args: QueryCommandInput, cb: (err: any, data?: QueryCommandOutput) => void): void;
+    query(args: QueryCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: QueryCommandOutput) => void): void;
+    
+    scan(args: ScanCommandInput, options?: __HttpHandlerOptions): Promise<ScanCommandOutput>;
+    scan(args: ScanCommandInput, cb: (err: any, data?: ScanCommandOutput) => void): void;
+    scan(args: ScanCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ScanCommandOutput) => void): void;
+    
+    transactGet(args: TransactGetCommandInput, options?: __HttpHandlerOptions): Promise<TransactGetCommandOutput>;
+    transactGet(args: TransactGetCommandInput, cb: (err: any, data?: TransactGetCommandOutput) => void): void;
+    transactGet(args: TransactGetCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: TransactGetCommandOutput) => void): void;
+    
+    transactWrite(args: TransactWriteCommandInput, options?: __HttpHandlerOptions): Promise<TransactWriteCommandOutput>;
+    transactWrite(args: TransactWriteCommandInput, cb: (err: any, data?: TransactWriteCommandOutput) => void): void;
+    transactWrite(args: TransactWriteCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: TransactWriteCommandOutput) => void): void;
+    
+    update(args: UpdateCommandInput, options?: __HttpHandlerOptions): Promise<UpdateCommandOutput>;
+    update(args: UpdateCommandInput, cb: (err: any, data?: UpdateCommandOutput) => void): void;
+    update(args: UpdateCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateCommandOutput) => void): void;
+}

package/dist-types/ts3.4/DynamoDBDocumentClient.d.ts

@@ -0,0 +1,33 @@
+import { DynamoDBClient, DynamoDBClientResolvedConfig, ServiceInputTypes as __ServiceInputTypes, ServiceOutputTypes as __ServiceOutputTypes } from "@aws-sdk/client-dynamodb";
+import { Client as __Client } from "@aws-sdk/smithy-client";
+import { HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
+import { marshallOptions, unmarshallOptions } from "@aws-sdk/util-dynamodb";
+import { BatchExecuteStatementCommandInput, BatchExecuteStatementCommandOutput } from "./commands/BatchExecuteStatementCommand";
+import { BatchGetCommandInput, BatchGetCommandOutput } from "./commands/BatchGetCommand";
+import { BatchWriteCommandInput, BatchWriteCommandOutput } from "./commands/BatchWriteCommand";
+import { DeleteCommandInput, DeleteCommandOutput } from "./commands/DeleteCommand";
+import { ExecuteStatementCommandInput, ExecuteStatementCommandOutput } from "./commands/ExecuteStatementCommand";
+import { ExecuteTransactionCommandInput, ExecuteTransactionCommandOutput } from "./commands/ExecuteTransactionCommand";
+import { GetCommandInput, GetCommandOutput } from "./commands/GetCommand";
+import { PutCommandInput, PutCommandOutput } from "./commands/PutCommand";
+import { QueryCommandInput, QueryCommandOutput } from "./commands/QueryCommand";
+import { ScanCommandInput, ScanCommandOutput } from "./commands/ScanCommand";
+import { TransactGetCommandInput, TransactGetCommandOutput } from "./commands/TransactGetCommand";
+import { TransactWriteCommandInput, TransactWriteCommandOutput } from "./commands/TransactWriteCommand";
+import { UpdateCommandInput, UpdateCommandOutput } from "./commands/UpdateCommand";
+export declare type ServiceInputTypes = __ServiceInputTypes | BatchExecuteStatementCommandInput | BatchGetCommandInput | BatchWriteCommandInput | DeleteCommandInput | ExecuteStatementCommandInput | ExecuteTransactionCommandInput | GetCommandInput | PutCommandInput | QueryCommandInput | ScanCommandInput | TransactGetCommandInput | TransactWriteCommandInput | UpdateCommandInput;
+export declare type ServiceOutputTypes = __ServiceOutputTypes | BatchExecuteStatementCommandOutput | BatchGetCommandOutput | BatchWriteCommandOutput | DeleteCommandOutput | ExecuteStatementCommandOutput | ExecuteTransactionCommandOutput | GetCommandOutput | PutCommandOutput | QueryCommandOutput | ScanCommandOutput | TransactGetCommandOutput | TransactWriteCommandOutput | UpdateCommandOutput;
+export declare type TranslateConfig = {
+    marshallOptions?: marshallOptions;
+    unmarshallOptions?: unmarshallOptions;
+};
+export declare type DynamoDBDocumentClientResolvedConfig = DynamoDBClientResolvedConfig & {
+    translateConfig?: TranslateConfig;
+};
+
+export declare class DynamoDBDocumentClient extends __Client<__HttpHandlerOptions, ServiceInputTypes, ServiceOutputTypes, DynamoDBDocumentClientResolvedConfig> {
+    readonly config: DynamoDBDocumentClientResolvedConfig;
+    protected constructor(client: DynamoDBClient, translateConfig?: TranslateConfig);
+    static from(client: DynamoDBClient, translateConfig?: TranslateConfig): DynamoDBDocumentClient;
+    destroy(): void;
+}

package/dist-types/ts3.4/commands/BatchExecuteStatementCommand.d.ts

@@ -0,0 +1,26 @@
+import { BatchExecuteStatementCommandInput as __BatchExecuteStatementCommandInput, BatchExecuteStatementCommandOutput as __BatchExecuteStatementCommandOutput, BatchStatementRequest, BatchStatementResponse } from "@aws-sdk/client-dynamodb";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MiddlewareStack } from "@aws-sdk/types";
+import { NativeAttributeValue } from "@aws-sdk/util-dynamodb";
+import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
+export declare type BatchExecuteStatementCommandInput = Pick<__BatchExecuteStatementCommandInput, Exclude<keyof __BatchExecuteStatementCommandInput, "Statements">> & {
+    Statements: (Pick<BatchStatementRequest, Exclude<keyof BatchStatementRequest, "Parameters">> & {
+        Parameters?: NativeAttributeValue[];
+    })[] | undefined;
+};
+export declare type BatchExecuteStatementCommandOutput = Pick<__BatchExecuteStatementCommandOutput, Exclude<keyof __BatchExecuteStatementCommandOutput, "Responses">> & {
+    Responses?: (Pick<BatchStatementResponse, Exclude<keyof BatchStatementResponse, "Item">> & {
+        Item?: {
+            [key: string]: NativeAttributeValue;
+        };
+    })[];
+};
+
+export declare class BatchExecuteStatementCommand extends $Command<BatchExecuteStatementCommandInput, BatchExecuteStatementCommandOutput, DynamoDBDocumentClientResolvedConfig> {
+    readonly input: BatchExecuteStatementCommandInput;
+    private readonly inputKeyNodes;
+    private readonly outputKeyNodes;
+    constructor(input: BatchExecuteStatementCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BatchExecuteStatementCommandInput, BatchExecuteStatementCommandOutput>;
+}

package/dist-types/ts3.4/commands/BatchGetCommand.d.ts

@@ -0,0 +1,37 @@
+import { BatchGetItemCommandInput as __BatchGetItemCommandInput, BatchGetItemCommandOutput as __BatchGetItemCommandOutput, KeysAndAttributes } from "@aws-sdk/client-dynamodb";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MiddlewareStack } from "@aws-sdk/types";
+import { NativeAttributeValue } from "@aws-sdk/util-dynamodb";
+import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
+export declare type BatchGetCommandInput = Pick<__BatchGetItemCommandInput, Exclude<keyof __BatchGetItemCommandInput, "RequestItems">> & {
+    RequestItems: {
+        [key: string]: Pick<KeysAndAttributes, Exclude<keyof KeysAndAttributes, "Keys">> & {
+            Keys: {
+                [key: string]: NativeAttributeValue;
+            }[] | undefined;
+        };
+    } | undefined;
+};
+export declare type BatchGetCommandOutput = Pick<__BatchGetItemCommandOutput, Exclude<keyof __BatchGetItemCommandOutput, "Responses" | "UnprocessedKeys">> & {
+    Responses?: {
+        [key: string]: {
+            [key: string]: NativeAttributeValue;
+        }[];
+    };
+    UnprocessedKeys?: {
+        [key: string]: Pick<KeysAndAttributes, Exclude<keyof KeysAndAttributes, "Keys">> & {
+            Keys: {
+                [key: string]: NativeAttributeValue;
+            }[] | undefined;
+        };
+    };
+};
+
+export declare class BatchGetCommand extends $Command<BatchGetCommandInput, BatchGetCommandOutput, DynamoDBDocumentClientResolvedConfig> {
+    readonly input: BatchGetCommandInput;
+    private readonly inputKeyNodes;
+    private readonly outputKeyNodes;
+    constructor(input: BatchGetCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BatchGetCommandInput, BatchGetCommandOutput>;
+}

package/dist-types/ts3.4/commands/BatchWriteCommand.d.ts

@@ -0,0 +1,53 @@
+import { BatchWriteItemCommandInput as __BatchWriteItemCommandInput, BatchWriteItemCommandOutput as __BatchWriteItemCommandOutput, DeleteRequest, ItemCollectionMetrics, PutRequest, WriteRequest } from "@aws-sdk/client-dynamodb";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MiddlewareStack } from "@aws-sdk/types";
+import { NativeAttributeValue } from "@aws-sdk/util-dynamodb";
+import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
+export declare type BatchWriteCommandInput = Pick<__BatchWriteItemCommandInput, Exclude<keyof __BatchWriteItemCommandInput, "RequestItems">> & {
+    RequestItems: {
+        [key: string]: (Pick<WriteRequest, Exclude<keyof WriteRequest, "PutRequest" | "DeleteRequest">> & {
+            PutRequest?: Pick<PutRequest, Exclude<keyof PutRequest, "Item">> & {
+                Item: {
+                    [key: string]: NativeAttributeValue;
+                } | undefined;
+            };
+            DeleteRequest?: Pick<DeleteRequest, Exclude<keyof DeleteRequest, "Key">> & {
+                Key: {
+                    [key: string]: NativeAttributeValue;
+                } | undefined;
+            };
+        })[];
+    } | undefined;
+};
+export declare type BatchWriteCommandOutput = Pick<__BatchWriteItemCommandOutput, Exclude<keyof __BatchWriteItemCommandOutput, "UnprocessedItems" | "ItemCollectionMetrics">> & {
+    UnprocessedItems?: {
+        [key: string]: (Pick<WriteRequest, Exclude<keyof WriteRequest, "PutRequest" | "DeleteRequest">> & {
+            PutRequest?: Pick<PutRequest, Exclude<keyof PutRequest, "Item">> & {
+                Item: {
+                    [key: string]: NativeAttributeValue;
+                } | undefined;
+            };
+            DeleteRequest?: Pick<DeleteRequest, Exclude<keyof DeleteRequest, "Key">> & {
+                Key: {
+                    [key: string]: NativeAttributeValue;
+                } | undefined;
+            };
+        })[];
+    };
+    ItemCollectionMetrics?: {
+        [key: string]: (Pick<ItemCollectionMetrics, Exclude<keyof ItemCollectionMetrics, "ItemCollectionKey">> & {
+            ItemCollectionKey?: {
+                [key: string]: NativeAttributeValue;
+            };
+        })[];
+    };
+};
+
+export declare class BatchWriteCommand extends $Command<BatchWriteCommandInput, BatchWriteCommandOutput, DynamoDBDocumentClientResolvedConfig> {
+    readonly input: BatchWriteCommandInput;
+    private readonly inputKeyNodes;
+    private readonly outputKeyNodes;
+    constructor(input: BatchWriteCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BatchWriteCommandInput, BatchWriteCommandOutput>;
+}

package/dist-types/ts3.4/commands/DeleteCommand.d.ts

@@ -0,0 +1,38 @@
+import { DeleteItemCommandInput as __DeleteItemCommandInput, DeleteItemCommandOutput as __DeleteItemCommandOutput, ExpectedAttributeValue, ItemCollectionMetrics } from "@aws-sdk/client-dynamodb";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MiddlewareStack } from "@aws-sdk/types";
+import { NativeAttributeValue } from "@aws-sdk/util-dynamodb";
+import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
+export declare type DeleteCommandInput = Pick<__DeleteItemCommandInput, Exclude<keyof __DeleteItemCommandInput, "Key" | "Expected" | "ExpressionAttributeValues">> & {
+    Key: {
+        [key: string]: NativeAttributeValue;
+    } | undefined;
+    Expected?: {
+        [key: string]: Pick<ExpectedAttributeValue, Exclude<keyof ExpectedAttributeValue, "Value" | "AttributeValueList">> & {
+            Value?: NativeAttributeValue;
+            AttributeValueList?: NativeAttributeValue[];
+        };
+    };
+    ExpressionAttributeValues?: {
+        [key: string]: NativeAttributeValue;
+    };
+};
+export declare type DeleteCommandOutput = Pick<__DeleteItemCommandOutput, Exclude<keyof __DeleteItemCommandOutput, "Attributes" | "ItemCollectionMetrics">> & {
+    Attributes?: {
+        [key: string]: NativeAttributeValue;
+    };
+    ItemCollectionMetrics?: Pick<ItemCollectionMetrics, Exclude<keyof ItemCollectionMetrics, "ItemCollectionKey">> & {
+        ItemCollectionKey?: {
+            [key: string]: NativeAttributeValue;
+        };
+    };
+};
+
+export declare class DeleteCommand extends $Command<DeleteCommandInput, DeleteCommandOutput, DynamoDBDocumentClientResolvedConfig> {
+    readonly input: DeleteCommandInput;
+    private readonly inputKeyNodes;
+    private readonly outputKeyNodes;
+    constructor(input: DeleteCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCommandInput, DeleteCommandOutput>;
+}

package/dist-types/ts3.4/commands/ExecuteStatementCommand.d.ts

@@ -0,0 +1,22 @@
+import { ExecuteStatementCommandInput as __ExecuteStatementCommandInput, ExecuteStatementCommandOutput as __ExecuteStatementCommandOutput } from "@aws-sdk/client-dynamodb";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MiddlewareStack } from "@aws-sdk/types";
+import { NativeAttributeValue } from "@aws-sdk/util-dynamodb";
+import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
+export declare type ExecuteStatementCommandInput = Pick<__ExecuteStatementCommandInput, Exclude<keyof __ExecuteStatementCommandInput, "Parameters">> & {
+    Parameters?: NativeAttributeValue[];
+};
+export declare type ExecuteStatementCommandOutput = Pick<__ExecuteStatementCommandOutput, Exclude<keyof __ExecuteStatementCommandOutput, "Items">> & {
+    Items?: {
+        [key: string]: NativeAttributeValue;
+    }[];
+};
+
+export declare class ExecuteStatementCommand extends $Command<ExecuteStatementCommandInput, ExecuteStatementCommandOutput, DynamoDBDocumentClientResolvedConfig> {
+    readonly input: ExecuteStatementCommandInput;
+    private readonly inputKeyNodes;
+    private readonly outputKeyNodes;
+    constructor(input: ExecuteStatementCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ExecuteStatementCommandInput, ExecuteStatementCommandOutput>;
+}

package/dist-types/ts3.4/commands/ExecuteTransactionCommand.d.ts

@@ -0,0 +1,26 @@
+import { ExecuteTransactionCommandInput as __ExecuteTransactionCommandInput, ExecuteTransactionCommandOutput as __ExecuteTransactionCommandOutput, ItemResponse, ParameterizedStatement } from "@aws-sdk/client-dynamodb";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MiddlewareStack } from "@aws-sdk/types";
+import { NativeAttributeValue } from "@aws-sdk/util-dynamodb";
+import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
+export declare type ExecuteTransactionCommandInput = Pick<__ExecuteTransactionCommandInput, Exclude<keyof __ExecuteTransactionCommandInput, "TransactStatements">> & {
+    TransactStatements: (Pick<ParameterizedStatement, Exclude<keyof ParameterizedStatement, "Parameters">> & {
+        Parameters?: NativeAttributeValue[];
+    })[] | undefined;
+};
+export declare type ExecuteTransactionCommandOutput = Pick<__ExecuteTransactionCommandOutput, Exclude<keyof __ExecuteTransactionCommandOutput, "Responses">> & {
+    Responses?: (Pick<ItemResponse, Exclude<keyof ItemResponse, "Item">> & {
+        Item?: {
+            [key: string]: NativeAttributeValue;
+        };
+    })[];
+};
+
+export declare class ExecuteTransactionCommand extends $Command<ExecuteTransactionCommandInput, ExecuteTransactionCommandOutput, DynamoDBDocumentClientResolvedConfig> {
+    readonly input: ExecuteTransactionCommandInput;
+    private readonly inputKeyNodes;
+    private readonly outputKeyNodes;
+    constructor(input: ExecuteTransactionCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ExecuteTransactionCommandInput, ExecuteTransactionCommandOutput>;
+}

package/dist-types/ts3.4/commands/GetCommand.d.ts

@@ -0,0 +1,24 @@
+import { GetItemCommandInput as __GetItemCommandInput, GetItemCommandOutput as __GetItemCommandOutput } from "@aws-sdk/client-dynamodb";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MiddlewareStack } from "@aws-sdk/types";
+import { NativeAttributeValue } from "@aws-sdk/util-dynamodb";
+import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
+export declare type GetCommandInput = Pick<__GetItemCommandInput, Exclude<keyof __GetItemCommandInput, "Key">> & {
+    Key: {
+        [key: string]: NativeAttributeValue;
+    } | undefined;
+};
+export declare type GetCommandOutput = Pick<__GetItemCommandOutput, Exclude<keyof __GetItemCommandOutput, "Item">> & {
+    Item?: {
+        [key: string]: NativeAttributeValue;
+    };
+};
+
+export declare class GetCommand extends $Command<GetCommandInput, GetCommandOutput, DynamoDBDocumentClientResolvedConfig> {
+    readonly input: GetCommandInput;
+    private readonly inputKeyNodes;
+    private readonly outputKeyNodes;
+    constructor(input: GetCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCommandInput, GetCommandOutput>;
+}

package/dist-types/ts3.4/commands/PutCommand.d.ts

@@ -0,0 +1,38 @@
+import { ExpectedAttributeValue, ItemCollectionMetrics, PutItemCommandInput as __PutItemCommandInput, PutItemCommandOutput as __PutItemCommandOutput } from "@aws-sdk/client-dynamodb";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MiddlewareStack } from "@aws-sdk/types";
+import { NativeAttributeValue } from "@aws-sdk/util-dynamodb";
+import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
+export declare type PutCommandInput = Pick<__PutItemCommandInput, Exclude<keyof __PutItemCommandInput, "Item" | "Expected" | "ExpressionAttributeValues">> & {
+    Item: {
+        [key: string]: NativeAttributeValue;
+    } | undefined;
+    Expected?: {
+        [key: string]: Pick<ExpectedAttributeValue, Exclude<keyof ExpectedAttributeValue, "Value" | "AttributeValueList">> & {
+            Value?: NativeAttributeValue;
+            AttributeValueList?: NativeAttributeValue[];
+        };
+    };
+    ExpressionAttributeValues?: {
+        [key: string]: NativeAttributeValue;
+    };
+};
+export declare type PutCommandOutput = Pick<__PutItemCommandOutput, Exclude<keyof __PutItemCommandOutput, "Attributes" | "ItemCollectionMetrics">> & {
+    Attributes?: {
+        [key: string]: NativeAttributeValue;
+    };
+    ItemCollectionMetrics?: Pick<ItemCollectionMetrics, Exclude<keyof ItemCollectionMetrics, "ItemCollectionKey">> & {
+        ItemCollectionKey?: {
+            [key: string]: NativeAttributeValue;
+        };
+    };
+};
+
+export declare class PutCommand extends $Command<PutCommandInput, PutCommandOutput, DynamoDBDocumentClientResolvedConfig> {
+    readonly input: PutCommandInput;
+    private readonly inputKeyNodes;
+    private readonly outputKeyNodes;
+    constructor(input: PutCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutCommandInput, PutCommandOutput>;
+}

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

@@ -0,0 +1,40 @@
+import { Condition, QueryCommandInput as __QueryCommandInput, QueryCommandOutput as __QueryCommandOutput } from "@aws-sdk/client-dynamodb";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MiddlewareStack } from "@aws-sdk/types";
+import { NativeAttributeValue } from "@aws-sdk/util-dynamodb";
+import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
+export declare type QueryCommandInput = Pick<__QueryCommandInput, Exclude<keyof __QueryCommandInput, "KeyConditions" | "QueryFilter" | "ExclusiveStartKey" | "ExpressionAttributeValues">> & {
+    KeyConditions?: {
+        [key: string]: Pick<Condition, Exclude<keyof Condition, "AttributeValueList">> & {
+            AttributeValueList?: NativeAttributeValue[];
+        };
+    };
+    QueryFilter?: {
+        [key: string]: Pick<Condition, Exclude<keyof Condition, "AttributeValueList">> & {
+            AttributeValueList?: NativeAttributeValue[];
+        };
+    };
+    ExclusiveStartKey?: {
+        [key: string]: NativeAttributeValue;
+    };
+    ExpressionAttributeValues?: {
+        [key: string]: NativeAttributeValue;
+    };
+};
+export declare type QueryCommandOutput = Pick<__QueryCommandOutput, Exclude<keyof __QueryCommandOutput, "Items" | "LastEvaluatedKey">> & {
+    Items?: {
+        [key: string]: NativeAttributeValue;
+    }[];
+    LastEvaluatedKey?: {
+        [key: string]: NativeAttributeValue;
+    };
+};
+
+export declare class QueryCommand extends $Command<QueryCommandInput, QueryCommandOutput, DynamoDBDocumentClientResolvedConfig> {
+    readonly input: QueryCommandInput;
+    private readonly inputKeyNodes;
+    private readonly outputKeyNodes;
+    constructor(input: QueryCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<QueryCommandInput, QueryCommandOutput>;
+}

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

@@ -0,0 +1,35 @@
+import { Condition, ScanCommandInput as __ScanCommandInput, ScanCommandOutput as __ScanCommandOutput } from "@aws-sdk/client-dynamodb";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MiddlewareStack } from "@aws-sdk/types";
+import { NativeAttributeValue } from "@aws-sdk/util-dynamodb";
+import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
+export declare type ScanCommandInput = Pick<__ScanCommandInput, Exclude<keyof __ScanCommandInput, "ScanFilter" | "ExclusiveStartKey" | "ExpressionAttributeValues">> & {
+    ScanFilter?: {
+        [key: string]: Pick<Condition, Exclude<keyof Condition, "AttributeValueList">> & {
+            AttributeValueList?: NativeAttributeValue[];
+        };
+    };
+    ExclusiveStartKey?: {
+        [key: string]: NativeAttributeValue;
+    };
+    ExpressionAttributeValues?: {
+        [key: string]: NativeAttributeValue;
+    };
+};
+export declare type ScanCommandOutput = Pick<__ScanCommandOutput, Exclude<keyof __ScanCommandOutput, "Items" | "LastEvaluatedKey">> & {
+    Items?: {
+        [key: string]: NativeAttributeValue;
+    }[];
+    LastEvaluatedKey?: {
+        [key: string]: NativeAttributeValue;
+    };
+};
+
+export declare class ScanCommand extends $Command<ScanCommandInput, ScanCommandOutput, DynamoDBDocumentClientResolvedConfig> {
+    readonly input: ScanCommandInput;
+    private readonly inputKeyNodes;
+    private readonly outputKeyNodes;
+    constructor(input: ScanCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ScanCommandInput, ScanCommandOutput>;
+}

package/dist-types/ts3.4/commands/TransactGetCommand.d.ts

@@ -0,0 +1,30 @@
+import { Get, ItemResponse, TransactGetItem, TransactGetItemsCommandInput as __TransactGetItemsCommandInput, TransactGetItemsCommandOutput as __TransactGetItemsCommandOutput } from "@aws-sdk/client-dynamodb";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MiddlewareStack } from "@aws-sdk/types";
+import { NativeAttributeValue } from "@aws-sdk/util-dynamodb";
+import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
+export declare type TransactGetCommandInput = Pick<__TransactGetItemsCommandInput, Exclude<keyof __TransactGetItemsCommandInput, "TransactItems">> & {
+    TransactItems: (Pick<TransactGetItem, Exclude<keyof TransactGetItem, "Get">> & {
+        Get: (Pick<Get, Exclude<keyof Get, "Key">> & {
+            Key: {
+                [key: string]: NativeAttributeValue;
+            } | undefined;
+        }) | undefined;
+    })[] | undefined;
+};
+export declare type TransactGetCommandOutput = Pick<__TransactGetItemsCommandOutput, Exclude<keyof __TransactGetItemsCommandOutput, "Responses">> & {
+    Responses?: (Pick<ItemResponse, Exclude<keyof ItemResponse, "Item">> & {
+        Item?: {
+            [key: string]: NativeAttributeValue;
+        };
+    })[];
+};
+
+export declare class TransactGetCommand extends $Command<TransactGetCommandInput, TransactGetCommandOutput, DynamoDBDocumentClientResolvedConfig> {
+    readonly input: TransactGetCommandInput;
+    private readonly inputKeyNodes;
+    private readonly outputKeyNodes;
+    constructor(input: TransactGetCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TransactGetCommandInput, TransactGetCommandOutput>;
+}

package/dist-types/ts3.4/commands/TransactWriteCommand.d.ts

@@ -0,0 +1,59 @@
+import { ConditionCheck, Delete, ItemCollectionMetrics, Put, TransactWriteItem, TransactWriteItemsCommandInput as __TransactWriteItemsCommandInput, TransactWriteItemsCommandOutput as __TransactWriteItemsCommandOutput, Update } from "@aws-sdk/client-dynamodb";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MiddlewareStack } from "@aws-sdk/types";
+import { NativeAttributeValue } from "@aws-sdk/util-dynamodb";
+import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
+export declare type TransactWriteCommandInput = Pick<__TransactWriteItemsCommandInput, Exclude<keyof __TransactWriteItemsCommandInput, "TransactItems">> & {
+    TransactItems: (Pick<TransactWriteItem, Exclude<keyof TransactWriteItem, "ConditionCheck" | "Put" | "Delete" | "Update">> & {
+        ConditionCheck?: Pick<ConditionCheck, Exclude<keyof ConditionCheck, "Key" | "ExpressionAttributeValues">> & {
+            Key: {
+                [key: string]: NativeAttributeValue;
+            } | undefined;
+            ExpressionAttributeValues?: {
+                [key: string]: NativeAttributeValue;
+            };
+        };
+        Put?: Pick<Put, Exclude<keyof Put, "Item" | "ExpressionAttributeValues">> & {
+            Item: {
+                [key: string]: NativeAttributeValue;
+            } | undefined;
+            ExpressionAttributeValues?: {
+                [key: string]: NativeAttributeValue;
+            };
+        };
+        Delete?: Pick<Delete, Exclude<keyof Delete, "Key" | "ExpressionAttributeValues">> & {
+            Key: {
+                [key: string]: NativeAttributeValue;
+            } | undefined;
+            ExpressionAttributeValues?: {
+                [key: string]: NativeAttributeValue;
+            };
+        };
+        Update?: Pick<Update, Exclude<keyof Update, "Key" | "ExpressionAttributeValues">> & {
+            Key: {
+                [key: string]: NativeAttributeValue;
+            } | undefined;
+            ExpressionAttributeValues?: {
+                [key: string]: NativeAttributeValue;
+            };
+        };
+    })[] | undefined;
+};
+export declare type TransactWriteCommandOutput = Pick<__TransactWriteItemsCommandOutput, Exclude<keyof __TransactWriteItemsCommandOutput, "ItemCollectionMetrics">> & {
+    ItemCollectionMetrics?: {
+        [key: string]: (Pick<ItemCollectionMetrics, Exclude<keyof ItemCollectionMetrics, "ItemCollectionKey">> & {
+            ItemCollectionKey?: {
+                [key: string]: NativeAttributeValue;
+            };
+        })[];
+    };
+};
+
+export declare class TransactWriteCommand extends $Command<TransactWriteCommandInput, TransactWriteCommandOutput, DynamoDBDocumentClientResolvedConfig> {
+    readonly input: TransactWriteCommandInput;
+    private readonly inputKeyNodes;
+    private readonly outputKeyNodes;
+    constructor(input: TransactWriteCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TransactWriteCommandInput, TransactWriteCommandOutput>;
+}

package/dist-types/ts3.4/commands/UpdateCommand.d.ts

@@ -0,0 +1,43 @@
+import { AttributeValueUpdate, ExpectedAttributeValue, ItemCollectionMetrics, UpdateItemCommandInput as __UpdateItemCommandInput, UpdateItemCommandOutput as __UpdateItemCommandOutput } from "@aws-sdk/client-dynamodb";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MiddlewareStack } from "@aws-sdk/types";
+import { NativeAttributeValue } from "@aws-sdk/util-dynamodb";
+import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
+export declare type UpdateCommandInput = Pick<__UpdateItemCommandInput, Exclude<keyof __UpdateItemCommandInput, "Key" | "AttributeUpdates" | "Expected" | "ExpressionAttributeValues">> & {
+    Key: {
+        [key: string]: NativeAttributeValue;
+    } | undefined;
+    AttributeUpdates?: {
+        [key: string]: Pick<AttributeValueUpdate, Exclude<keyof AttributeValueUpdate, "Value">> & {
+            Value?: NativeAttributeValue;
+        };
+    };
+    Expected?: {
+        [key: string]: Pick<ExpectedAttributeValue, Exclude<keyof ExpectedAttributeValue, "Value" | "AttributeValueList">> & {
+            Value?: NativeAttributeValue;
+            AttributeValueList?: NativeAttributeValue[];
+        };
+    };
+    ExpressionAttributeValues?: {
+        [key: string]: NativeAttributeValue;
+    };
+};
+export declare type UpdateCommandOutput = Pick<__UpdateItemCommandOutput, Exclude<keyof __UpdateItemCommandOutput, "Attributes" | "ItemCollectionMetrics">> & {
+    Attributes?: {
+        [key: string]: NativeAttributeValue;
+    };
+    ItemCollectionMetrics?: Pick<ItemCollectionMetrics, Exclude<keyof ItemCollectionMetrics, "ItemCollectionKey">> & {
+        ItemCollectionKey?: {
+            [key: string]: NativeAttributeValue;
+        };
+    };
+};
+
+export declare class UpdateCommand extends $Command<UpdateCommandInput, UpdateCommandOutput, DynamoDBDocumentClientResolvedConfig> {
+    readonly input: UpdateCommandInput;
+    private readonly inputKeyNodes;
+    private readonly outputKeyNodes;
+    constructor(input: UpdateCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateCommandInput, UpdateCommandOutput>;
+}

package/dist-types/ts3.4/commands/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./BatchExecuteStatementCommand";
+export * from "./BatchGetCommand";
+export * from "./BatchWriteCommand";
+export * from "./DeleteCommand";
+export * from "./ExecuteStatementCommand";
+export * from "./ExecuteTransactionCommand";
+export * from "./GetCommand";
+export * from "./PutCommand";
+export * from "./QueryCommand";
+export * from "./ScanCommand";
+export * from "./TransactGetCommand";
+export * from "./TransactWriteCommand";
+export * from "./UpdateCommand";

package/dist-types/ts3.4/commands/utils.d.ts

@@ -0,0 +1,10 @@
+import { marshallOptions, unmarshallOptions } from "@aws-sdk/util-dynamodb";
+export declare type KeyNode = {
+    key: string;
+    children?: KeyNode[] | AllNodes;
+};
+export declare type AllNodes = {
+    children?: KeyNode[] | AllNodes;
+};
+export declare const marshallInput: (obj: any, keyNodes: KeyNode[], options?: marshallOptions | undefined) => any;
+export declare const unmarshallOutput: (obj: any, keyNodes: KeyNode[], options?: unmarshallOptions | undefined) => any;

package/dist-types/ts3.4/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./DynamoDBDocument";
+export * from "./DynamoDBDocumentClient";
+export * from "./commands";
+export * from "./pagination";

package/dist-types/ts3.4/pagination/Interfaces.d.ts

@@ -0,0 +1,6 @@
+import { PaginationConfiguration } from "@aws-sdk/types";
+import { DynamoDBDocument } from "../DynamoDBDocument";
+import { DynamoDBDocumentClient } from "../DynamoDBDocumentClient";
+export interface DynamoDBDocumentPaginationConfiguration extends PaginationConfiguration {
+    client: DynamoDBDocument | DynamoDBDocumentClient;
+}

package/dist-types/ts3.4/pagination/QueryPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { QueryCommandInput, QueryCommandOutput } from "../commands/QueryCommand";
+import { DynamoDBDocumentPaginationConfiguration } from "./Interfaces";
+export declare function paginateQuery(config: DynamoDBDocumentPaginationConfiguration, input: QueryCommandInput, ...additionalArguments: any): Paginator<QueryCommandOutput>;

package/dist-types/ts3.4/pagination/ScanPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ScanCommandInput, ScanCommandOutput } from "../commands/ScanCommand";
+import { DynamoDBDocumentPaginationConfiguration } from "./Interfaces";
+export declare function paginateScan(config: DynamoDBDocumentPaginationConfiguration, input: ScanCommandInput, ...additionalArguments: any): Paginator<ScanCommandOutput>;

package/dist-types/ts3.4/pagination/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Interfaces";
+export * from "./QueryPaginator";
+export * from "./ScanPaginator";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/lib-dynamodb",
-  "version": "3.50.0",
+  "version": "3.51.0",
   "description": "The document client simplifies working with items in Amazon DynamoDB by abstracting away the notion of attribute values.",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
@@ -23,7 +23,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@aws-sdk/util-dynamodb": "3.50.0",
+    "@aws-sdk/util-dynamodb": "3.51.0",
     "tslib": "^2.3.0"
   },
   "peerDependencies": {
@@ -32,7 +32,7 @@
     "@aws-sdk/types": "^3.0.0"
   },
   "devDependencies": {
-    "@aws-sdk/client-dynamodb": "3.50.0",
+    "@aws-sdk/client-dynamodb": "3.51.0",
     "@aws-sdk/smithy-client": "3.50.0",
     "@aws-sdk/types": "3.50.0",
     "@tsconfig/recommended": "1.0.1",