@aws-sdk/lib-dynamodb 3.131.0 → 3.142.0

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

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

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

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

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

@@ -1,7 +1,7 @@
-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 { BatchWriteItemCommand as __BatchWriteItemCommand, BatchWriteItemCommandInput as __BatchWriteItemCommandInput, BatchWriteItemCommandOutput as __BatchWriteItemCommandOutput, DeleteRequest, ItemCollectionMetrics, PutRequest, WriteRequest } from "@aws-sdk/client-dynamodb";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MiddlewareStack } from "@aws-sdk/types";
 import { NativeAttributeValue } from "@aws-sdk/util-dynamodb";
+import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
 import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
 export declare type BatchWriteCommandInput = Pick<__BatchWriteItemCommandInput, Exclude<keyof __BatchWriteItemCommandInput, "RequestItems">> & {
     RequestItems: Record<string, (Pick<WriteRequest, Exclude<keyof WriteRequest, "PutRequest" | "DeleteRequest">> & {
@@ -27,10 +27,39 @@ export declare type BatchWriteCommandOutput = Pick<__BatchWriteItemCommandOutput
     })[]>;
 };
 
-export declare class BatchWriteCommand extends $Command<BatchWriteCommandInput, BatchWriteCommandOutput, DynamoDBDocumentClientResolvedConfig> {
+export declare class BatchWriteCommand extends DynamoDBDocumentClientCommand<BatchWriteCommandInput, BatchWriteCommandOutput, __BatchWriteItemCommandInput, __BatchWriteItemCommandOutput, DynamoDBDocumentClientResolvedConfig> {
     readonly input: BatchWriteCommandInput;
-    private readonly inputKeyNodes;
-    private readonly outputKeyNodes;
+    protected readonly inputKeyNodes: {
+        key: string;
+        children: {
+            children: {
+                key: string;
+                children: {
+                    key: string;
+                }[];
+            }[];
+        };
+    }[];
+    protected readonly outputKeyNodes: ({
+        key: string;
+        children: {
+            children: {
+                key: string;
+                children: {
+                    key: string;
+                }[];
+            }[];
+        };
+    } | {
+        key: string;
+        children: {
+            children: {
+                key: string;
+            }[];
+        };
+    })[];
+    protected readonly clientCommand: __BatchWriteItemCommand;
+    readonly middlewareStack: MiddlewareStack<BatchWriteCommandInput | __BatchWriteItemCommandInput, BatchWriteCommandOutput | __BatchWriteItemCommandOutput>;
     constructor(input: BatchWriteCommandInput);
     
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BatchWriteCommandInput, BatchWriteCommandOutput>;

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

@@ -1,7 +1,7 @@
-import { DeleteItemCommandInput as __DeleteItemCommandInput, DeleteItemCommandOutput as __DeleteItemCommandOutput, ExpectedAttributeValue, ItemCollectionMetrics } from "@aws-sdk/client-dynamodb";
-import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteItemCommand as __DeleteItemCommand, DeleteItemCommandInput as __DeleteItemCommandInput, DeleteItemCommandOutput as __DeleteItemCommandOutput, ExpectedAttributeValue, ItemCollectionMetrics } from "@aws-sdk/client-dynamodb";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MiddlewareStack } from "@aws-sdk/types";
 import { NativeAttributeValue } from "@aws-sdk/util-dynamodb";
+import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
 import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
 export declare type DeleteCommandInput = Pick<__DeleteItemCommandInput, Exclude<keyof __DeleteItemCommandInput, "Key" | "Expected" | "ExpressionAttributeValues">> & {
     Key: Record<string, NativeAttributeValue> | undefined;
@@ -18,10 +18,30 @@ export declare type DeleteCommandOutput = Pick<__DeleteItemCommandOutput, Exclud
     };
 };
 
-export declare class DeleteCommand extends $Command<DeleteCommandInput, DeleteCommandOutput, DynamoDBDocumentClientResolvedConfig> {
+export declare class DeleteCommand extends DynamoDBDocumentClientCommand<DeleteCommandInput, DeleteCommandOutput, __DeleteItemCommandInput, __DeleteItemCommandOutput, DynamoDBDocumentClientResolvedConfig> {
     readonly input: DeleteCommandInput;
-    private readonly inputKeyNodes;
-    private readonly outputKeyNodes;
+    protected readonly inputKeyNodes: ({
+        key: string;
+        children?: undefined;
+    } | {
+        key: string;
+        children: {
+            children: {
+                key: string;
+            }[];
+        };
+    })[];
+    protected readonly outputKeyNodes: ({
+        key: string;
+        children?: undefined;
+    } | {
+        key: string;
+        children: {
+            key: string;
+        }[];
+    })[];
+    protected readonly clientCommand: __DeleteItemCommand;
+    readonly middlewareStack: MiddlewareStack<DeleteCommandInput | __DeleteItemCommandInput, DeleteCommandOutput | __DeleteItemCommandOutput>;
     constructor(input: DeleteCommandInput);
     
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCommandInput, DeleteCommandOutput>;

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

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

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

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

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

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

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

@@ -1,7 +1,7 @@
-import { ExpectedAttributeValue, ItemCollectionMetrics, PutItemCommandInput as __PutItemCommandInput, PutItemCommandOutput as __PutItemCommandOutput } from "@aws-sdk/client-dynamodb";
-import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ExpectedAttributeValue, ItemCollectionMetrics, PutItemCommand as __PutItemCommand, PutItemCommandInput as __PutItemCommandInput, PutItemCommandOutput as __PutItemCommandOutput } from "@aws-sdk/client-dynamodb";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MiddlewareStack } from "@aws-sdk/types";
 import { NativeAttributeValue } from "@aws-sdk/util-dynamodb";
+import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
 import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
 export declare type PutCommandInput = Pick<__PutItemCommandInput, Exclude<keyof __PutItemCommandInput, "Item" | "Expected" | "ExpressionAttributeValues">> & {
     Item: Record<string, NativeAttributeValue> | undefined;
@@ -18,10 +18,30 @@ export declare type PutCommandOutput = Pick<__PutItemCommandOutput, Exclude<keyo
     };
 };
 
-export declare class PutCommand extends $Command<PutCommandInput, PutCommandOutput, DynamoDBDocumentClientResolvedConfig> {
+export declare class PutCommand extends DynamoDBDocumentClientCommand<PutCommandInput, PutCommandOutput, __PutItemCommandInput, __PutItemCommandOutput, DynamoDBDocumentClientResolvedConfig> {
     readonly input: PutCommandInput;
-    private readonly inputKeyNodes;
-    private readonly outputKeyNodes;
+    protected readonly inputKeyNodes: ({
+        key: string;
+        children?: undefined;
+    } | {
+        key: string;
+        children: {
+            children: {
+                key: string;
+            }[];
+        };
+    })[];
+    protected readonly outputKeyNodes: ({
+        key: string;
+        children?: undefined;
+    } | {
+        key: string;
+        children: {
+            key: string;
+        }[];
+    })[];
+    protected readonly clientCommand: __PutItemCommand;
+    readonly middlewareStack: MiddlewareStack<PutCommandInput | __PutItemCommandInput, PutCommandOutput | __PutItemCommandOutput>;
     constructor(input: PutCommandInput);
     
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutCommandInput, PutCommandOutput>;

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

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

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

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

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

@@ -1,7 +1,7 @@
-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 { Get, ItemResponse, TransactGetItem, TransactGetItemsCommand as __TransactGetItemsCommand, TransactGetItemsCommandInput as __TransactGetItemsCommandInput, TransactGetItemsCommandOutput as __TransactGetItemsCommandOutput } from "@aws-sdk/client-dynamodb";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MiddlewareStack } from "@aws-sdk/types";
 import { NativeAttributeValue } from "@aws-sdk/util-dynamodb";
+import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
 import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
 export declare type TransactGetCommandInput = Pick<__TransactGetItemsCommandInput, Exclude<keyof __TransactGetItemsCommandInput, "TransactItems">> & {
     TransactItems: (Pick<TransactGetItem, Exclude<keyof TransactGetItem, "Get">> & {
@@ -16,10 +16,25 @@ export declare type TransactGetCommandOutput = Pick<__TransactGetItemsCommandOut
     })[];
 };
 
-export declare class TransactGetCommand extends $Command<TransactGetCommandInput, TransactGetCommandOutput, DynamoDBDocumentClientResolvedConfig> {
+export declare class TransactGetCommand extends DynamoDBDocumentClientCommand<TransactGetCommandInput, TransactGetCommandOutput, __TransactGetItemsCommandInput, __TransactGetItemsCommandOutput, DynamoDBDocumentClientResolvedConfig> {
     readonly input: TransactGetCommandInput;
-    private readonly inputKeyNodes;
-    private readonly outputKeyNodes;
+    protected readonly inputKeyNodes: {
+        key: string;
+        children: {
+            key: string;
+            children: {
+                key: string;
+            }[];
+        }[];
+    }[];
+    protected readonly outputKeyNodes: {
+        key: string;
+        children: {
+            key: string;
+        }[];
+    }[];
+    protected readonly clientCommand: __TransactGetItemsCommand;
+    readonly middlewareStack: MiddlewareStack<TransactGetCommandInput | __TransactGetItemsCommandInput, TransactGetCommandOutput | __TransactGetItemsCommandOutput>;
     constructor(input: TransactGetCommandInput);
     
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TransactGetCommandInput, TransactGetCommandOutput>;

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

@@ -1,7 +1,7 @@
-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 { ConditionCheck, Delete, ItemCollectionMetrics, Put, TransactWriteItem, TransactWriteItemsCommand as __TransactWriteItemsCommand, TransactWriteItemsCommandInput as __TransactWriteItemsCommandInput, TransactWriteItemsCommandOutput as __TransactWriteItemsCommandOutput, Update } from "@aws-sdk/client-dynamodb";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MiddlewareStack } from "@aws-sdk/types";
 import { NativeAttributeValue } from "@aws-sdk/util-dynamodb";
+import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
 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">> & {
@@ -29,10 +29,27 @@ export declare type TransactWriteCommandOutput = Pick<__TransactWriteItemsComman
     })[]>;
 };
 
-export declare class TransactWriteCommand extends $Command<TransactWriteCommandInput, TransactWriteCommandOutput, DynamoDBDocumentClientResolvedConfig> {
+export declare class TransactWriteCommand extends DynamoDBDocumentClientCommand<TransactWriteCommandInput, TransactWriteCommandOutput, __TransactWriteItemsCommandInput, __TransactWriteItemsCommandOutput, DynamoDBDocumentClientResolvedConfig> {
     readonly input: TransactWriteCommandInput;
-    private readonly inputKeyNodes;
-    private readonly outputKeyNodes;
+    protected readonly inputKeyNodes: {
+        key: string;
+        children: {
+            key: string;
+            children: {
+                key: string;
+            }[];
+        }[];
+    }[];
+    protected readonly outputKeyNodes: {
+        key: string;
+        children: {
+            children: {
+                key: string;
+            }[];
+        };
+    }[];
+    protected readonly clientCommand: __TransactWriteItemsCommand;
+    readonly middlewareStack: MiddlewareStack<TransactWriteCommandInput | __TransactWriteItemsCommandInput, TransactWriteCommandOutput | __TransactWriteItemsCommandOutput>;
     constructor(input: TransactWriteCommandInput);
     
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TransactWriteCommandInput, TransactWriteCommandOutput>;

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

@@ -1,7 +1,7 @@
-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 { AttributeValueUpdate, ExpectedAttributeValue, ItemCollectionMetrics, UpdateItemCommand as __UpdateItemCommand, UpdateItemCommandInput as __UpdateItemCommandInput, UpdateItemCommandOutput as __UpdateItemCommandOutput } from "@aws-sdk/client-dynamodb";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MiddlewareStack } from "@aws-sdk/types";
 import { NativeAttributeValue } from "@aws-sdk/util-dynamodb";
+import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
 import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
 export declare type UpdateCommandInput = Pick<__UpdateItemCommandInput, Exclude<keyof __UpdateItemCommandInput, "Key" | "AttributeUpdates" | "Expected" | "ExpressionAttributeValues">> & {
     Key: Record<string, NativeAttributeValue> | undefined;
@@ -21,10 +21,30 @@ export declare type UpdateCommandOutput = Pick<__UpdateItemCommandOutput, Exclud
     };
 };
 
-export declare class UpdateCommand extends $Command<UpdateCommandInput, UpdateCommandOutput, DynamoDBDocumentClientResolvedConfig> {
+export declare class UpdateCommand extends DynamoDBDocumentClientCommand<UpdateCommandInput, UpdateCommandOutput, __UpdateItemCommandInput, __UpdateItemCommandOutput, DynamoDBDocumentClientResolvedConfig> {
     readonly input: UpdateCommandInput;
-    private readonly inputKeyNodes;
-    private readonly outputKeyNodes;
+    protected readonly inputKeyNodes: ({
+        key: string;
+        children?: undefined;
+    } | {
+        key: string;
+        children: {
+            children: {
+                key: string;
+            }[];
+        };
+    })[];
+    protected readonly outputKeyNodes: ({
+        key: string;
+        children?: undefined;
+    } | {
+        key: string;
+        children: {
+            key: string;
+        }[];
+    })[];
+    protected readonly clientCommand: __UpdateItemCommand;
+    readonly middlewareStack: MiddlewareStack<UpdateCommandInput | __UpdateItemCommandInput, UpdateCommandOutput | __UpdateItemCommandOutput>;
     constructor(input: UpdateCommandInput);
     
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateCommandInput, UpdateCommandOutput>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/lib-dynamodb",
-  "version": "3.131.0",
+  "version": "3.142.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.131.0",
+    "@aws-sdk/util-dynamodb": "3.142.0",
     "tslib": "^2.3.1"
   },
   "peerDependencies": {
@@ -32,8 +32,8 @@
     "@aws-sdk/types": "^3.0.0"
   },
   "devDependencies": {
-    "@aws-sdk/client-dynamodb": "3.131.0",
-    "@aws-sdk/smithy-client": "3.127.0",
+    "@aws-sdk/client-dynamodb": "3.142.0",
+    "@aws-sdk/smithy-client": "3.142.0",
     "@aws-sdk/types": "3.127.0",
     "@tsconfig/recommended": "1.0.1",
     "@types/node": "^14.11.2",