@aws-sdk/lib-dynamodb 3.34.0 → 3.37.0

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 → dist-types}/ts3.4/DynamoDBDocumentClient.d.ts

@@ -1,3 +1,7 @@
+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";
@@ -11,10 +15,6 @@ 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 { 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";
 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 = {
@@ -24,52 +24,7 @@ export declare type TranslateConfig = {
 export declare type DynamoDBDocumentClientResolvedConfig = DynamoDBClientResolvedConfig & {
     translateConfig?: TranslateConfig;
 };
-/**
- * The document client simplifies working with items in Amazon DynamoDB by
- * abstracting away the notion of attribute values. This abstraction annotates native
- * JavaScript types supplied as input parameters, as well as converts annotated
- * response data to native JavaScript types.
- *
- * ## Marshalling Input and Unmarshalling Response Data
- *
- * The document client affords developers the use of native JavaScript types
- * instead of `AttributeValue`s to simplify the JavaScript development
- * experience with Amazon DynamoDB. JavaScript objects passed in as parameters
- * are marshalled into `AttributeValue` shapes required by Amazon DynamoDB.
- * Responses from DynamoDB are unmarshalled into plain JavaScript objects
- * by the `DocumentClient`. The `DocumentClient` does not accept
- * `AttributeValue`s in favor of native JavaScript types.
- *
- * |          JavaScript Type          | DynamoDB AttributeValue |
- * | :-------------------------------: | ----------------------- |
- * |              String               | S                       |
- * |          Number / BigInt          | N                       |
- * |              Boolean              | BOOL                    |
- * |               null                | NULL                    |
- * |               Array               | L                       |
- * |              Object               | M                       |
- * |   Set\<Uint8Array, Blob, ...\>    | BS                      |
- * |       Set\<Number, BigInt\>       | NS                      |
- * |           Set\<String\>           | SS                      |
- * | Uint8Array, Buffer, File, Blob... | B                       |
- *
- * ### Example
- *
- * Here is an example list which is sent to DynamoDB client in an operation:
- *
- * ```json
- * { "L": [{ "NULL": true }, { "BOOL": false }, { "N": 1 }, { "S": "two" }] }
- * ```
- *
- * The DynamoDB document client abstracts the attribute values as follows in
- * both input and output:
- *
- * ```json
- * [null, false, 1, "two"]
- * ```
- *
- * @see {@link https://www.npmjs.com/package/@aws-sdk/client-dynamodb @aws-sdk/client-dynamodb}
- */
+
 export declare class DynamoDBDocumentClient extends __Client<__HttpHandlerOptions, ServiceInputTypes, ServiceOutputTypes, DynamoDBDocumentClientResolvedConfig> {
     readonly config: DynamoDBDocumentClientResolvedConfig;
     protected constructor(client: DynamoDBClient, translateConfig?: TranslateConfig);

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

@@ -1,8 +1,8 @@
-import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
-import { BatchStatementRequest, BatchStatementResponse, BatchExecuteStatementCommandInput as __BatchExecuteStatementCommandInput, BatchExecuteStatementCommandOutput as __BatchExecuteStatementCommandOutput } from "@aws-sdk/client-dynamodb";
+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, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
+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[];
@@ -15,20 +15,12 @@ export declare type BatchExecuteStatementCommandOutput = Pick<__BatchExecuteStat
         };
     })[];
 };
-/**
- * Accepts native JavaScript types instead of `AttributeValue`s, and calls
- * BatchExecuteStatementCommand operation from {@link https://www.npmjs.com/package/@aws-sdk/client-dynamodb @aws-sdk/client-dynamodb}.
- *
- * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
- * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
- */
+
 export declare class BatchExecuteStatementCommand extends $Command<BatchExecuteStatementCommandInput, BatchExecuteStatementCommandOutput, DynamoDBDocumentClientResolvedConfig> {
     readonly input: BatchExecuteStatementCommandInput;
     private readonly inputKeyNodes;
     private readonly outputKeyNodes;
     constructor(input: BatchExecuteStatementCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BatchExecuteStatementCommandInput, BatchExecuteStatementCommandOutput>;
 }

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

@@ -1,8 +1,8 @@
-import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
-import { KeysAndAttributes, BatchGetItemCommandInput as __BatchGetItemCommandInput, BatchGetItemCommandOutput as __BatchGetItemCommandOutput } from "@aws-sdk/client-dynamodb";
+import { BatchGetItemCommandInput as __BatchGetItemCommandInput, BatchGetItemCommandOutput as __BatchGetItemCommandOutput, KeysAndAttributes } from "@aws-sdk/client-dynamodb";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
+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">> & {
@@ -26,20 +26,12 @@ export declare type BatchGetCommandOutput = Pick<__BatchGetItemCommandOutput, Ex
         };
     };
 };
-/**
- * Accepts native JavaScript types instead of `AttributeValue`s, and calls
- * BatchGetItemCommand operation from {@link https://www.npmjs.com/package/@aws-sdk/client-dynamodb @aws-sdk/client-dynamodb}.
- *
- * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
- * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
- */
+
 export declare class BatchGetCommand extends $Command<BatchGetCommandInput, BatchGetCommandOutput, DynamoDBDocumentClientResolvedConfig> {
     readonly input: BatchGetCommandInput;
     private readonly inputKeyNodes;
     private readonly outputKeyNodes;
     constructor(input: BatchGetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BatchGetCommandInput, BatchGetCommandOutput>;
 }

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

@@ -1,8 +1,8 @@
-import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
-import { DeleteRequest, ItemCollectionMetrics, PutRequest, WriteRequest, BatchWriteItemCommandInput as __BatchWriteItemCommandInput, BatchWriteItemCommandOutput as __BatchWriteItemCommandOutput } from "@aws-sdk/client-dynamodb";
+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, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
+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">> & {
@@ -42,20 +42,12 @@ export declare type BatchWriteCommandOutput = Pick<__BatchWriteItemCommandOutput
         })[];
     };
 };
-/**
- * Accepts native JavaScript types instead of `AttributeValue`s, and calls
- * BatchWriteItemCommand operation from {@link https://www.npmjs.com/package/@aws-sdk/client-dynamodb @aws-sdk/client-dynamodb}.
- *
- * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
- * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
- */
+
 export declare class BatchWriteCommand extends $Command<BatchWriteCommandInput, BatchWriteCommandOutput, DynamoDBDocumentClientResolvedConfig> {
     readonly input: BatchWriteCommandInput;
     private readonly inputKeyNodes;
     private readonly outputKeyNodes;
     constructor(input: BatchWriteCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BatchWriteCommandInput, BatchWriteCommandOutput>;
 }

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

@@ -1,8 +1,8 @@
-import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
-import { ExpectedAttributeValue, ItemCollectionMetrics, DeleteItemCommandInput as __DeleteItemCommandInput, DeleteItemCommandOutput as __DeleteItemCommandOutput } from "@aws-sdk/client-dynamodb";
+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, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
+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;
@@ -27,20 +27,12 @@ export declare type DeleteCommandOutput = Pick<__DeleteItemCommandOutput, Exclud
         };
     };
 };
-/**
- * Accepts native JavaScript types instead of `AttributeValue`s, and calls
- * DeleteItemCommand operation from {@link https://www.npmjs.com/package/@aws-sdk/client-dynamodb @aws-sdk/client-dynamodb}.
- *
- * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
- * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
- */
+
 export declare class DeleteCommand extends $Command<DeleteCommandInput, DeleteCommandOutput, DynamoDBDocumentClientResolvedConfig> {
     readonly input: DeleteCommandInput;
     private readonly inputKeyNodes;
     private readonly outputKeyNodes;
     constructor(input: DeleteCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCommandInput, DeleteCommandOutput>;
 }

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

@@ -1,8 +1,8 @@
-import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
 import { ExecuteStatementCommandInput as __ExecuteStatementCommandInput, ExecuteStatementCommandOutput as __ExecuteStatementCommandOutput } from "@aws-sdk/client-dynamodb";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
+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[];
 };
@@ -11,20 +11,12 @@ export declare type ExecuteStatementCommandOutput = Pick<__ExecuteStatementComma
         [key: string]: NativeAttributeValue;
     }[];
 };
-/**
- * Accepts native JavaScript types instead of `AttributeValue`s, and calls
- * ExecuteStatementCommand operation from {@link https://www.npmjs.com/package/@aws-sdk/client-dynamodb @aws-sdk/client-dynamodb}.
- *
- * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
- * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
- */
+
 export declare class ExecuteStatementCommand extends $Command<ExecuteStatementCommandInput, ExecuteStatementCommandOutput, DynamoDBDocumentClientResolvedConfig> {
     readonly input: ExecuteStatementCommandInput;
     private readonly inputKeyNodes;
     private readonly outputKeyNodes;
     constructor(input: ExecuteStatementCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ExecuteStatementCommandInput, ExecuteStatementCommandOutput>;
 }

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

@@ -1,8 +1,8 @@
-import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
-import { ItemResponse, ParameterizedStatement, ExecuteTransactionCommandInput as __ExecuteTransactionCommandInput, ExecuteTransactionCommandOutput as __ExecuteTransactionCommandOutput } from "@aws-sdk/client-dynamodb";
+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, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
+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[];
@@ -15,20 +15,12 @@ export declare type ExecuteTransactionCommandOutput = Pick<__ExecuteTransactionC
         };
     })[];
 };
-/**
- * Accepts native JavaScript types instead of `AttributeValue`s, and calls
- * ExecuteTransactionCommand operation from {@link https://www.npmjs.com/package/@aws-sdk/client-dynamodb @aws-sdk/client-dynamodb}.
- *
- * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
- * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
- */
+
 export declare class ExecuteTransactionCommand extends $Command<ExecuteTransactionCommandInput, ExecuteTransactionCommandOutput, DynamoDBDocumentClientResolvedConfig> {
     readonly input: ExecuteTransactionCommandInput;
     private readonly inputKeyNodes;
     private readonly outputKeyNodes;
     constructor(input: ExecuteTransactionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ExecuteTransactionCommandInput, ExecuteTransactionCommandOutput>;
 }

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

@@ -1,8 +1,8 @@
-import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
 import { GetItemCommandInput as __GetItemCommandInput, GetItemCommandOutput as __GetItemCommandOutput } from "@aws-sdk/client-dynamodb";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
+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;
@@ -13,20 +13,12 @@ export declare type GetCommandOutput = Pick<__GetItemCommandOutput, Exclude<keyo
         [key: string]: NativeAttributeValue;
     };
 };
-/**
- * Accepts native JavaScript types instead of `AttributeValue`s, and calls
- * GetItemCommand operation from {@link https://www.npmjs.com/package/@aws-sdk/client-dynamodb @aws-sdk/client-dynamodb}.
- *
- * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
- * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
- */
+
 export declare class GetCommand extends $Command<GetCommandInput, GetCommandOutput, DynamoDBDocumentClientResolvedConfig> {
     readonly input: GetCommandInput;
     private readonly inputKeyNodes;
     private readonly outputKeyNodes;
     constructor(input: GetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCommandInput, GetCommandOutput>;
 }

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

@@ -1,8 +1,8 @@
-import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
 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, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
+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;
@@ -27,20 +27,12 @@ export declare type PutCommandOutput = Pick<__PutItemCommandOutput, Exclude<keyo
         };
     };
 };
-/**
- * Accepts native JavaScript types instead of `AttributeValue`s, and calls
- * PutItemCommand operation from {@link https://www.npmjs.com/package/@aws-sdk/client-dynamodb @aws-sdk/client-dynamodb}.
- *
- * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
- * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
- */
+
 export declare class PutCommand extends $Command<PutCommandInput, PutCommandOutput, DynamoDBDocumentClientResolvedConfig> {
     readonly input: PutCommandInput;
     private readonly inputKeyNodes;
     private readonly outputKeyNodes;
     constructor(input: PutCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutCommandInput, PutCommandOutput>;
 }

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

@@ -1,8 +1,8 @@
-import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
 import { Condition, QueryCommandInput as __QueryCommandInput, QueryCommandOutput as __QueryCommandOutput } from "@aws-sdk/client-dynamodb";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
+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">> & {
@@ -29,20 +29,12 @@ export declare type QueryCommandOutput = Pick<__QueryCommandOutput, Exclude<keyo
         [key: string]: NativeAttributeValue;
     };
 };
-/**
- * Accepts native JavaScript types instead of `AttributeValue`s, and calls
- * QueryCommand operation from {@link https://www.npmjs.com/package/@aws-sdk/client-dynamodb @aws-sdk/client-dynamodb}.
- *
- * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
- * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
- */
+
 export declare class QueryCommand extends $Command<QueryCommandInput, QueryCommandOutput, DynamoDBDocumentClientResolvedConfig> {
     readonly input: QueryCommandInput;
     private readonly inputKeyNodes;
     private readonly outputKeyNodes;
     constructor(input: QueryCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<QueryCommandInput, QueryCommandOutput>;
 }

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

@@ -1,8 +1,8 @@
-import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
 import { Condition, ScanCommandInput as __ScanCommandInput, ScanCommandOutput as __ScanCommandOutput } from "@aws-sdk/client-dynamodb";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
+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">> & {
@@ -24,20 +24,12 @@ export declare type ScanCommandOutput = Pick<__ScanCommandOutput, Exclude<keyof
         [key: string]: NativeAttributeValue;
     };
 };
-/**
- * Accepts native JavaScript types instead of `AttributeValue`s, and calls
- * ScanCommand operation from {@link https://www.npmjs.com/package/@aws-sdk/client-dynamodb @aws-sdk/client-dynamodb}.
- *
- * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
- * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
- */
+
 export declare class ScanCommand extends $Command<ScanCommandInput, ScanCommandOutput, DynamoDBDocumentClientResolvedConfig> {
     readonly input: ScanCommandInput;
     private readonly inputKeyNodes;
     private readonly outputKeyNodes;
     constructor(input: ScanCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ScanCommandInput, ScanCommandOutput>;
 }

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

@@ -1,8 +1,8 @@
-import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
 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, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
+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">> & {
@@ -19,20 +19,12 @@ export declare type TransactGetCommandOutput = Pick<__TransactGetItemsCommandOut
         };
     })[];
 };
-/**
- * Accepts native JavaScript types instead of `AttributeValue`s, and calls
- * TransactGetItemsCommand operation from {@link https://www.npmjs.com/package/@aws-sdk/client-dynamodb @aws-sdk/client-dynamodb}.
- *
- * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
- * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
- */
+
 export declare class TransactGetCommand extends $Command<TransactGetCommandInput, TransactGetCommandOutput, DynamoDBDocumentClientResolvedConfig> {
     readonly input: TransactGetCommandInput;
     private readonly inputKeyNodes;
     private readonly outputKeyNodes;
     constructor(input: TransactGetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TransactGetCommandInput, TransactGetCommandOutput>;
 }

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

@@ -1,8 +1,8 @@
-import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
-import { ConditionCheck, Delete, ItemCollectionMetrics, Put, TransactWriteItem, Update, TransactWriteItemsCommandInput as __TransactWriteItemsCommandInput, TransactWriteItemsCommandOutput as __TransactWriteItemsCommandOutput } from "@aws-sdk/client-dynamodb";
+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, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
+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">> & {
@@ -48,20 +48,12 @@ export declare type TransactWriteCommandOutput = Pick<__TransactWriteItemsComman
         })[];
     };
 };
-/**
- * Accepts native JavaScript types instead of `AttributeValue`s, and calls
- * TransactWriteItemsCommand operation from {@link https://www.npmjs.com/package/@aws-sdk/client-dynamodb @aws-sdk/client-dynamodb}.
- *
- * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
- * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
- */
+
 export declare class TransactWriteCommand extends $Command<TransactWriteCommandInput, TransactWriteCommandOutput, DynamoDBDocumentClientResolvedConfig> {
     readonly input: TransactWriteCommandInput;
     private readonly inputKeyNodes;
     private readonly outputKeyNodes;
     constructor(input: TransactWriteCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TransactWriteCommandInput, TransactWriteCommandOutput>;
 }

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

@@ -1,8 +1,8 @@
-import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
 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, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
+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;
@@ -32,20 +32,12 @@ export declare type UpdateCommandOutput = Pick<__UpdateItemCommandOutput, Exclud
         };
     };
 };
-/**
- * Accepts native JavaScript types instead of `AttributeValue`s, and calls
- * UpdateItemCommand operation from {@link https://www.npmjs.com/package/@aws-sdk/client-dynamodb @aws-sdk/client-dynamodb}.
- *
- * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
- * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
- */
+
 export declare class UpdateCommand extends $Command<UpdateCommandInput, UpdateCommandOutput, DynamoDBDocumentClientResolvedConfig> {
     readonly input: UpdateCommandInput;
     private readonly inputKeyNodes;
     private readonly outputKeyNodes;
     constructor(input: UpdateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateCommandInput, UpdateCommandOutput>;
 }