@depup/aws-sdk__lib-dynamodb 3.1005.0-depup.0

package/dist-es/commands/TransactGetCommand.js

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
+import { ALL_VALUES } from "../commands/utils";
+import { TransactGetItemsCommand as __TransactGetItemsCommand } from "@aws-sdk/client-dynamodb";
+export { DynamoDBDocumentClientCommand, $Command };
+export class TransactGetCommand extends DynamoDBDocumentClientCommand {
+    input;
+    inputKeyNodes = {
+        'TransactItems': {
+            '*': {
+                'Get': {
+                    'Key': ALL_VALUES,
+                },
+            }
+        },
+    };
+    outputKeyNodes = {
+        'Responses': {
+            '*': {
+                'Item': ALL_VALUES,
+            }
+        },
+    };
+    clientCommand;
+    middlewareStack;
+    constructor(input) {
+        super();
+        this.input = input;
+        this.clientCommand = new __TransactGetItemsCommand(this.input);
+        this.middlewareStack = this.clientCommand.middlewareStack;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.addMarshallingMiddleware(configuration);
+        const stack = clientStack.concat(this.middlewareStack);
+        const handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
+        return async () => handler(this.clientCommand);
+    }
+}

package/dist-es/commands/TransactWriteCommand.js

@@ -0,0 +1,53 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
+import { ALL_VALUES } from "../commands/utils";
+import { TransactWriteItemsCommand as __TransactWriteItemsCommand } from "@aws-sdk/client-dynamodb";
+export { DynamoDBDocumentClientCommand, $Command };
+export class TransactWriteCommand extends DynamoDBDocumentClientCommand {
+    input;
+    inputKeyNodes = {
+        'TransactItems': {
+            '*': {
+                'ConditionCheck': {
+                    'Key': ALL_VALUES,
+                    'ExpressionAttributeValues': ALL_VALUES,
+                },
+                'Put': {
+                    'Item': ALL_VALUES,
+                    'ExpressionAttributeValues': ALL_VALUES,
+                },
+                'Delete': {
+                    'Key': ALL_VALUES,
+                    'ExpressionAttributeValues': ALL_VALUES,
+                },
+                'Update': {
+                    'Key': ALL_VALUES,
+                    'ExpressionAttributeValues': ALL_VALUES,
+                },
+            }
+        },
+    };
+    outputKeyNodes = {
+        'ItemCollectionMetrics': {
+            '*': {
+                '*': {
+                    'ItemCollectionKey': ALL_VALUES,
+                }
+            }
+        },
+    };
+    clientCommand;
+    middlewareStack;
+    constructor(input) {
+        super();
+        this.input = input;
+        this.clientCommand = new __TransactWriteItemsCommand(this.input);
+        this.middlewareStack = this.clientCommand.middlewareStack;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.addMarshallingMiddleware(configuration);
+        const stack = clientStack.concat(this.middlewareStack);
+        const handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
+        return async () => handler(this.clientCommand);
+    }
+}

package/dist-es/commands/UpdateCommand.js

@@ -0,0 +1,43 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
+import { ALL_MEMBERS, ALL_VALUES, SELF } from "../commands/utils";
+import { UpdateItemCommand as __UpdateItemCommand } from "@aws-sdk/client-dynamodb";
+export { DynamoDBDocumentClientCommand, $Command };
+export class UpdateCommand extends DynamoDBDocumentClientCommand {
+    input;
+    inputKeyNodes = {
+        'Key': ALL_VALUES,
+        'AttributeUpdates': {
+            '*': {
+                'Value': SELF,
+            }
+        },
+        'Expected': {
+            '*': {
+                'Value': SELF,
+                'AttributeValueList': ALL_MEMBERS,
+            }
+        },
+        'ExpressionAttributeValues': ALL_VALUES,
+    };
+    outputKeyNodes = {
+        'Attributes': ALL_VALUES,
+        'ItemCollectionMetrics': {
+            'ItemCollectionKey': ALL_VALUES,
+        },
+    };
+    clientCommand;
+    middlewareStack;
+    constructor(input) {
+        super();
+        this.input = input;
+        this.clientCommand = new __UpdateItemCommand(this.input);
+        this.middlewareStack = this.clientCommand.middlewareStack;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.addMarshallingMiddleware(configuration);
+        const stack = clientStack.concat(this.middlewareStack);
+        const handler = this.clientCommand.resolveMiddleware(stack, configuration, options);
+        return async () => handler(this.clientCommand);
+    }
+}

package/dist-es/commands/index.js

@@ -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-es/commands/utils.js

@@ -0,0 +1,80 @@
+import { marshall, unmarshall } from "@aws-sdk/util-dynamodb";
+export const SELF = null;
+export const ALL_VALUES = {};
+export const ALL_MEMBERS = [];
+const NEXT_LEVEL = "*";
+const processObj = (obj, processFunc, keyNodes) => {
+    if (obj !== undefined) {
+        if (keyNodes == null) {
+            return processFunc(obj);
+        }
+        else {
+            const keys = Object.keys(keyNodes);
+            const goToNextLevel = keys.length === 1 && keys[0] === NEXT_LEVEL;
+            const someChildren = keys.length >= 1 && !goToNextLevel;
+            const allChildren = keys.length === 0;
+            if (someChildren) {
+                return processKeysInObj(obj, processFunc, keyNodes);
+            }
+            else if (allChildren) {
+                return processAllKeysInObj(obj, processFunc, SELF);
+            }
+            else if (goToNextLevel) {
+                return Object.entries(obj ?? {}).reduce((acc, [k, v]) => {
+                    if (typeof v !== "function") {
+                        acc[k] = processObj(v, processFunc, keyNodes[NEXT_LEVEL]);
+                    }
+                    return acc;
+                }, (Array.isArray(obj) ? [] : {}));
+            }
+        }
+    }
+    return undefined;
+};
+const processKeysInObj = (obj, processFunc, keyNodes) => {
+    let accumulator;
+    if (Array.isArray(obj)) {
+        accumulator = obj.filter((item) => typeof item !== "function");
+    }
+    else {
+        accumulator = {};
+        for (const [k, v] of Object.entries(obj)) {
+            if (typeof v !== "function") {
+                accumulator[k] = v;
+            }
+        }
+    }
+    for (const [nodeKey, nodes] of Object.entries(keyNodes)) {
+        if (typeof obj[nodeKey] === "function") {
+            continue;
+        }
+        const processedValue = processObj(obj[nodeKey], processFunc, nodes);
+        if (processedValue !== undefined && typeof processedValue !== "function") {
+            accumulator[nodeKey] = processedValue;
+        }
+    }
+    return accumulator;
+};
+const processAllKeysInObj = (obj, processFunc, keyNodes) => {
+    if (Array.isArray(obj)) {
+        return obj.filter((item) => typeof item !== "function").map((item) => processObj(item, processFunc, keyNodes));
+    }
+    return Object.entries(obj).reduce((acc, [key, value]) => {
+        if (typeof value === "function") {
+            return acc;
+        }
+        const processedValue = processObj(value, processFunc, keyNodes);
+        if (processedValue !== undefined && typeof processedValue !== "function") {
+            acc[key] = processedValue;
+        }
+        return acc;
+    }, {});
+};
+export const marshallInput = (obj, keyNodes, options) => {
+    const marshallFunc = (toMarshall) => marshall(toMarshall, options);
+    return processKeysInObj(obj, marshallFunc, keyNodes);
+};
+export const unmarshallOutput = (obj, keyNodes, options) => {
+    const unmarshallFunc = (toMarshall) => unmarshall(toMarshall, options);
+    return processKeysInObj(obj, unmarshallFunc, keyNodes);
+};

package/dist-es/index.js

@@ -0,0 +1,5 @@
+export * from './commands';
+export * from './pagination';
+export * from './DynamoDBDocumentClient';
+export * from './DynamoDBDocument';
+export { NumberValueImpl as NumberValue } from "@aws-sdk/util-dynamodb";

package/dist-es/pagination/Interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist-es/pagination/QueryPaginator.js

@@ -0,0 +1,4 @@
+import { createPaginator } from "@smithy/core";
+import { QueryCommand } from "../commands/QueryCommand";
+import { DynamoDBDocumentClient } from "../DynamoDBDocumentClient";
+export const paginateQuery = createPaginator(DynamoDBDocumentClient, QueryCommand, "ExclusiveStartKey", "LastEvaluatedKey", "Limit");

package/dist-es/pagination/ScanPaginator.js

@@ -0,0 +1,4 @@
+import { createPaginator } from "@smithy/core";
+import { ScanCommand } from "../commands/ScanCommand";
+import { DynamoDBDocumentClient } from "../DynamoDBDocumentClient";
+export const paginateScan = createPaginator(DynamoDBDocumentClient, ScanCommand, "ExclusiveStartKey", "LastEvaluatedKey", "Limit");

package/dist-es/pagination/index.js

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

package/dist-types/DynamoDBDocument.d.ts

@@ -0,0 +1,195 @@
+import type { HttpHandlerOptions as __HttpHandlerOptions } from "@smithy/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";
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+/**
+ * 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 DynamoDBDocument extends DynamoDBDocumentClient {
+    static from(client: DynamoDBClient, translateConfig?: TranslateConfig): DynamoDBDocument;
+    /**
+     * Accepts native JavaScript types instead of `AttributeValue`s, and calls
+     * BatchExecuteStatementCommand operation from {@link @aws-sdk/client-dynamodb#BatchExecuteStatementCommand}.
+     *
+     * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
+     * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
+     */
+    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;
+    /**
+     * Accepts native JavaScript types instead of `AttributeValue`s, and calls
+     * BatchGetItemCommand operation from {@link @aws-sdk/client-dynamodb#BatchGetItemCommand}.
+     *
+     * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
+     * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
+     */
+    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;
+    /**
+     * Accepts native JavaScript types instead of `AttributeValue`s, and calls
+     * BatchWriteItemCommand operation from {@link @aws-sdk/client-dynamodb#BatchWriteItemCommand}.
+     *
+     * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
+     * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
+     */
+    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;
+    /**
+     * Accepts native JavaScript types instead of `AttributeValue`s, and calls
+     * DeleteItemCommand operation from {@link @aws-sdk/client-dynamodb#DeleteItemCommand}.
+     *
+     * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
+     * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
+     */
+    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;
+    /**
+     * Accepts native JavaScript types instead of `AttributeValue`s, and calls
+     * ExecuteStatementCommand operation from {@link @aws-sdk/client-dynamodb#ExecuteStatementCommand}.
+     *
+     * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
+     * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
+     */
+    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;
+    /**
+     * Accepts native JavaScript types instead of `AttributeValue`s, and calls
+     * ExecuteTransactionCommand operation from {@link @aws-sdk/client-dynamodb#ExecuteTransactionCommand}.
+     *
+     * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
+     * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
+     */
+    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;
+    /**
+     * Accepts native JavaScript types instead of `AttributeValue`s, and calls
+     * GetItemCommand operation from {@link @aws-sdk/client-dynamodb#GetItemCommand}.
+     *
+     * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
+     * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
+     */
+    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;
+    /**
+     * Accepts native JavaScript types instead of `AttributeValue`s, and calls
+     * PutItemCommand operation from {@link @aws-sdk/client-dynamodb#PutItemCommand}.
+     *
+     * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
+     * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
+     */
+    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;
+    /**
+     * Accepts native JavaScript types instead of `AttributeValue`s, and calls
+     * QueryCommand operation from {@link @aws-sdk/client-dynamodb#QueryCommand}.
+     *
+     * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
+     * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
+     */
+    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;
+    /**
+     * Accepts native JavaScript types instead of `AttributeValue`s, and calls
+     * ScanCommand operation from {@link @aws-sdk/client-dynamodb#ScanCommand}.
+     *
+     * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
+     * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
+     */
+    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;
+    /**
+     * Accepts native JavaScript types instead of `AttributeValue`s, and calls
+     * TransactGetItemsCommand operation from {@link @aws-sdk/client-dynamodb#TransactGetItemsCommand}.
+     *
+     * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
+     * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
+     */
+    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;
+    /**
+     * Accepts native JavaScript types instead of `AttributeValue`s, and calls
+     * TransactWriteItemsCommand operation from {@link @aws-sdk/client-dynamodb#TransactWriteItemsCommand}.
+     *
+     * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
+     * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
+     */
+    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;
+    /**
+     * Accepts native JavaScript types instead of `AttributeValue`s, and calls
+     * UpdateItemCommand operation from {@link @aws-sdk/client-dynamodb#UpdateItemCommand}.
+     *
+     * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
+     * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
+     */
+    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/DynamoDBDocumentClient.d.ts

@@ -0,0 +1,96 @@
+import { Client as __Client } from "@smithy/smithy-client";
+import type { HttpHandlerOptions as __HttpHandlerOptions } from "@smithy/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 { DynamoDBClient, DynamoDBClientResolvedConfig, ServiceInputTypes as __ServiceInputTypes, ServiceOutputTypes as __ServiceOutputTypes } from "@aws-sdk/client-dynamodb";
+import { marshallOptions, unmarshallOptions } from "@aws-sdk/util-dynamodb";
+/**
+ * @public
+ */
+export { __Client };
+/**
+ * @public
+ */
+export type ServiceInputTypes = __ServiceInputTypes | BatchExecuteStatementCommandInput | BatchGetCommandInput | BatchWriteCommandInput | DeleteCommandInput | ExecuteStatementCommandInput | ExecuteTransactionCommandInput | GetCommandInput | PutCommandInput | QueryCommandInput | ScanCommandInput | TransactGetCommandInput | TransactWriteCommandInput | UpdateCommandInput;
+/**
+ * @public
+ */
+export type ServiceOutputTypes = __ServiceOutputTypes | BatchExecuteStatementCommandOutput | BatchGetCommandOutput | BatchWriteCommandOutput | DeleteCommandOutput | ExecuteStatementCommandOutput | ExecuteTransactionCommandOutput | GetCommandOutput | PutCommandOutput | QueryCommandOutput | ScanCommandOutput | TransactGetCommandOutput | TransactWriteCommandOutput | UpdateCommandOutput;
+/**
+ * @public
+ */
+export type TranslateConfig = {
+    marshallOptions?: marshallOptions;
+    unmarshallOptions?: unmarshallOptions;
+};
+/**
+ * @public
+ */
+export 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}
+ *
+ * @public
+ */
+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/baseCommand/DynamoDBDocumentClientCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MiddlewareStack } from "@smithy/types";
+import { KeyNodeChildren } from "../commands/utils";
+import { DynamoDBDocumentClientResolvedConfig } from "../DynamoDBDocumentClient";
+/**
+ * Base class for Commands in lib-dynamodb used to pass middleware to
+ * the underlying DynamoDBClient Commands.
+ *
+ * @public
+ */
+export declare abstract class DynamoDBDocumentClientCommand<Input extends object, Output extends object, BaseInput extends object, BaseOutput extends object, ResolvedClientConfiguration> extends $Command<Input | BaseInput, Output | BaseOutput, ResolvedClientConfiguration> {
+    protected abstract readonly inputKeyNodes: KeyNodeChildren;
+    protected abstract readonly outputKeyNodes: KeyNodeChildren;
+    protected abstract clientCommand: $Command<Input | BaseInput, Output | BaseOutput, ResolvedClientConfiguration>;
+    abstract middlewareStack: MiddlewareStack<Input | BaseInput, Output | BaseOutput>;
+    protected addMarshallingMiddleware(configuration: DynamoDBDocumentClientResolvedConfig): void;
+}

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

@@ -0,0 +1,66 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { type HttpHandlerOptions as __HttpHandlerOptions, Handler, MiddlewareStack } from "@smithy/types";
+import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
+import { DynamoDBDocumentClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBDocumentClient";
+import { BatchExecuteStatementCommand as __BatchExecuteStatementCommand } from "@aws-sdk/client-dynamodb";
+/**
+ * @public
+ */
+export { DynamoDBDocumentClientCommand, $Command };
+/**
+ * @public
+ */
+export type BatchExecuteStatementCommandInput = Omit<__BatchExecuteStatementCommandInput, 'Statements'> & {
+    Statements: (Omit<BatchStatementRequest, 'Parameters'> & {
+        Parameters?: (NativeAttributeValue)[] | undefined;
+    })[] | undefined;
+};
+/**
+ * @public
+ */
+export type BatchExecuteStatementCommandOutput = Omit<__BatchExecuteStatementCommandOutput, 'Responses'> & {
+    Responses?: (Omit<BatchStatementResponse, 'Error' | 'Item'> & {
+        Error?: Omit<BatchStatementError, 'Item'> & {
+            Item?: Record<string, NativeAttributeValue> | undefined;
+        } | undefined;
+        Item?: Record<string, NativeAttributeValue> | undefined;
+    })[] | undefined;
+};
+/**
+ * Accepts native JavaScript types instead of `AttributeValue`s, and calls
+ * BatchExecuteStatementCommand operation from {@link @aws-sdk/client-dynamodb#BatchExecuteStatementCommand}.
+ *
+ * JavaScript objects passed in as parameters are marshalled into `AttributeValue` shapes
+ * required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects.
+ *
+ * @public
+ */
+export declare class BatchExecuteStatementCommand extends DynamoDBDocumentClientCommand<BatchExecuteStatementCommandInput, BatchExecuteStatementCommandOutput, __BatchExecuteStatementCommandInput, __BatchExecuteStatementCommandOutput, DynamoDBDocumentClientResolvedConfig> {
+    readonly input: BatchExecuteStatementCommandInput;
+    protected readonly inputKeyNodes: {
+        Statements: {
+            '*': {
+                Parameters: import("../commands/utils").KeyNodeChildren;
+            };
+        };
+    };
+    protected readonly outputKeyNodes: {
+        Responses: {
+            '*': {
+                Error: {
+                    Item: import("../commands/utils").KeyNodeChildren;
+                };
+                Item: import("../commands/utils").KeyNodeChildren;
+            };
+        };
+    };
+    protected readonly clientCommand: __BatchExecuteStatementCommand;
+    readonly middlewareStack: MiddlewareStack<BatchExecuteStatementCommandInput | __BatchExecuteStatementCommandInput, BatchExecuteStatementCommandOutput | __BatchExecuteStatementCommandOutput>;
+    constructor(input: BatchExecuteStatementCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBDocumentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BatchExecuteStatementCommandInput, BatchExecuteStatementCommandOutput>;
+}
+import type { BatchExecuteStatementCommandInput as __BatchExecuteStatementCommandInput, BatchExecuteStatementCommandOutput as __BatchExecuteStatementCommandOutput, BatchStatementError, BatchStatementRequest, BatchStatementResponse } from "@aws-sdk/client-dynamodb";
+import type { NativeAttributeValue } from "@aws-sdk/util-dynamodb";