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

package/dist-es/DynamoDBDocument.js

@@ -0,0 +1,214 @@
+import { BatchExecuteStatementCommand, } from "./commands/BatchExecuteStatementCommand";
+import { BatchGetCommand } from "./commands/BatchGetCommand";
+import { BatchWriteCommand } from "./commands/BatchWriteCommand";
+import { DeleteCommand } from "./commands/DeleteCommand";
+import { ExecuteStatementCommand, } from "./commands/ExecuteStatementCommand";
+import { ExecuteTransactionCommand, } from "./commands/ExecuteTransactionCommand";
+import { GetCommand } from "./commands/GetCommand";
+import { PutCommand } from "./commands/PutCommand";
+import { QueryCommand } from "./commands/QueryCommand";
+import { ScanCommand } from "./commands/ScanCommand";
+import { TransactGetCommand } from "./commands/TransactGetCommand";
+import { TransactWriteCommand, } from "./commands/TransactWriteCommand";
+import { UpdateCommand } from "./commands/UpdateCommand";
+import { DynamoDBDocumentClient } from "./DynamoDBDocumentClient";
+export class DynamoDBDocument extends DynamoDBDocumentClient {
+    static from(client, translateConfig) {
+        return new DynamoDBDocument(client, translateConfig);
+    }
+    batchExecuteStatement(args, optionsOrCb, cb) {
+        const command = new BatchExecuteStatementCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object") {
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            }
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    batchGet(args, optionsOrCb, cb) {
+        const command = new BatchGetCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object") {
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            }
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    batchWrite(args, optionsOrCb, cb) {
+        const command = new BatchWriteCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object") {
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            }
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    delete(args, optionsOrCb, cb) {
+        const command = new DeleteCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object") {
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            }
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    executeStatement(args, optionsOrCb, cb) {
+        const command = new ExecuteStatementCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object") {
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            }
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    executeTransaction(args, optionsOrCb, cb) {
+        const command = new ExecuteTransactionCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object") {
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            }
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    get(args, optionsOrCb, cb) {
+        const command = new GetCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object") {
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            }
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    put(args, optionsOrCb, cb) {
+        const command = new PutCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object") {
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            }
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    query(args, optionsOrCb, cb) {
+        const command = new QueryCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object") {
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            }
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    scan(args, optionsOrCb, cb) {
+        const command = new ScanCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object") {
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            }
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    transactGet(args, optionsOrCb, cb) {
+        const command = new TransactGetCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object") {
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            }
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    transactWrite(args, optionsOrCb, cb) {
+        const command = new TransactWriteCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object") {
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            }
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    update(args, optionsOrCb, cb) {
+        const command = new UpdateCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object") {
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            }
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+}

package/dist-es/DynamoDBDocumentClient.js

@@ -0,0 +1,20 @@
+import { Client as __Client } from "@smithy/smithy-client";
+export { __Client };
+export class DynamoDBDocumentClient extends __Client {
+    config;
+    constructor(client, translateConfig) {
+        super(client.config);
+        this.config = client.config;
+        this.config.translateConfig = translateConfig;
+        this.middlewareStack = client.middlewareStack;
+        if (this.config?.cacheMiddleware) {
+            throw new Error("@aws-sdk/lib-dynamodb - cacheMiddleware=true is not compatible with the"
+                + " DynamoDBDocumentClient. This option must be set to false.");
+        }
+    }
+    static from(client, translateConfig) {
+        return new DynamoDBDocumentClient(client, translateConfig);
+    }
+    destroy() {
+    }
+}

package/dist-es/baseCommand/DynamoDBDocumentClientCommand.js

@@ -0,0 +1,32 @@
+import { setFeature } from "@aws-sdk/core";
+import { Command as $Command } from "@smithy/smithy-client";
+import { marshallInput, unmarshallOutput } from "../commands/utils";
+export class DynamoDBDocumentClientCommand extends $Command {
+    addMarshallingMiddleware(configuration) {
+        const { marshallOptions = {}, unmarshallOptions = {} } = configuration.translateConfig || {};
+        marshallOptions.convertTopLevelContainer = marshallOptions.convertTopLevelContainer ?? true;
+        unmarshallOptions.convertWithoutMapWrapper = unmarshallOptions.convertWithoutMapWrapper ?? true;
+        this.clientCommand.middlewareStack.addRelativeTo((next, context) => async (args) => {
+            setFeature(context, "DDB_MAPPER", "d");
+            return next({
+                ...args,
+                input: marshallInput(args.input, this.inputKeyNodes, marshallOptions),
+            });
+        }, {
+            name: "DocumentMarshall",
+            relation: "before",
+            toMiddleware: "serializerMiddleware",
+            override: true,
+        });
+        this.clientCommand.middlewareStack.addRelativeTo((next, context) => async (args) => {
+            const deserialized = await next(args);
+            deserialized.output = unmarshallOutput(deserialized.output, this.outputKeyNodes, unmarshallOptions);
+            return deserialized;
+        }, {
+            name: "DocumentUnmarshall",
+            relation: "before",
+            toMiddleware: "deserializerMiddleware",
+            override: true,
+        });
+    }
+}

package/dist-es/commands/BatchExecuteStatementCommand.js

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
+import { ALL_MEMBERS, ALL_VALUES } from "../commands/utils";
+import { BatchExecuteStatementCommand as __BatchExecuteStatementCommand } from "@aws-sdk/client-dynamodb";
+export { DynamoDBDocumentClientCommand, $Command };
+export class BatchExecuteStatementCommand extends DynamoDBDocumentClientCommand {
+    input;
+    inputKeyNodes = {
+        'Statements': {
+            '*': {
+                'Parameters': ALL_MEMBERS,
+            }
+        },
+    };
+    outputKeyNodes = {
+        'Responses': {
+            '*': {
+                'Error': {
+                    'Item': ALL_VALUES,
+                },
+                'Item': ALL_VALUES,
+            }
+        },
+    };
+    clientCommand;
+    middlewareStack;
+    constructor(input) {
+        super();
+        this.input = input;
+        this.clientCommand = new __BatchExecuteStatementCommand(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/BatchGetCommand.js

@@ -0,0 +1,45 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
+import { ALL_VALUES } from "../commands/utils";
+import { BatchGetItemCommand as __BatchGetItemCommand } from "@aws-sdk/client-dynamodb";
+export { DynamoDBDocumentClientCommand, $Command };
+export class BatchGetCommand extends DynamoDBDocumentClientCommand {
+    input;
+    inputKeyNodes = {
+        'RequestItems': {
+            '*': {
+                'Keys': {
+                    '*': ALL_VALUES
+                },
+            }
+        },
+    };
+    outputKeyNodes = {
+        'Responses': {
+            '*': {
+                '*': ALL_VALUES
+            }
+        },
+        'UnprocessedKeys': {
+            '*': {
+                'Keys': {
+                    '*': ALL_VALUES
+                },
+            }
+        },
+    };
+    clientCommand;
+    middlewareStack;
+    constructor(input) {
+        super();
+        this.input = input;
+        this.clientCommand = new __BatchGetItemCommand(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/BatchWriteCommand.js

@@ -0,0 +1,57 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
+import { ALL_VALUES } from "../commands/utils";
+import { BatchWriteItemCommand as __BatchWriteItemCommand } from "@aws-sdk/client-dynamodb";
+export { DynamoDBDocumentClientCommand, $Command };
+export class BatchWriteCommand extends DynamoDBDocumentClientCommand {
+    input;
+    inputKeyNodes = {
+        'RequestItems': {
+            '*': {
+                '*': {
+                    'PutRequest': {
+                        'Item': ALL_VALUES,
+                    },
+                    'DeleteRequest': {
+                        'Key': ALL_VALUES,
+                    },
+                }
+            }
+        },
+    };
+    outputKeyNodes = {
+        'UnprocessedItems': {
+            '*': {
+                '*': {
+                    'PutRequest': {
+                        'Item': ALL_VALUES,
+                    },
+                    'DeleteRequest': {
+                        'Key': ALL_VALUES,
+                    },
+                }
+            }
+        },
+        'ItemCollectionMetrics': {
+            '*': {
+                '*': {
+                    'ItemCollectionKey': ALL_VALUES,
+                }
+            }
+        },
+    };
+    clientCommand;
+    middlewareStack;
+    constructor(input) {
+        super();
+        this.input = input;
+        this.clientCommand = new __BatchWriteItemCommand(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/DeleteCommand.js

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
+import { ALL_MEMBERS, ALL_VALUES, SELF } from "../commands/utils";
+import { DeleteItemCommand as __DeleteItemCommand } from "@aws-sdk/client-dynamodb";
+export { DynamoDBDocumentClientCommand, $Command };
+export class DeleteCommand extends DynamoDBDocumentClientCommand {
+    input;
+    inputKeyNodes = {
+        'Key': ALL_VALUES,
+        '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 __DeleteItemCommand(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/ExecuteStatementCommand.js

@@ -0,0 +1,31 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
+import { ALL_MEMBERS, ALL_VALUES } from "../commands/utils";
+import { ExecuteStatementCommand as __ExecuteStatementCommand } from "@aws-sdk/client-dynamodb";
+export { DynamoDBDocumentClientCommand, $Command };
+export class ExecuteStatementCommand extends DynamoDBDocumentClientCommand {
+    input;
+    inputKeyNodes = {
+        'Parameters': ALL_MEMBERS,
+    };
+    outputKeyNodes = {
+        'Items': {
+            '*': ALL_VALUES
+        },
+        'LastEvaluatedKey': ALL_VALUES,
+    };
+    clientCommand;
+    middlewareStack;
+    constructor(input) {
+        super();
+        this.input = input;
+        this.clientCommand = new __ExecuteStatementCommand(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/ExecuteTransactionCommand.js

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
+import { ALL_MEMBERS, ALL_VALUES } from "../commands/utils";
+import { ExecuteTransactionCommand as __ExecuteTransactionCommand } from "@aws-sdk/client-dynamodb";
+export { DynamoDBDocumentClientCommand, $Command };
+export class ExecuteTransactionCommand extends DynamoDBDocumentClientCommand {
+    input;
+    inputKeyNodes = {
+        'TransactStatements': {
+            '*': {
+                'Parameters': ALL_MEMBERS,
+            }
+        },
+    };
+    outputKeyNodes = {
+        'Responses': {
+            '*': {
+                'Item': ALL_VALUES,
+            }
+        },
+    };
+    clientCommand;
+    middlewareStack;
+    constructor(input) {
+        super();
+        this.input = input;
+        this.clientCommand = new __ExecuteTransactionCommand(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/GetCommand.js

@@ -0,0 +1,28 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
+import { ALL_VALUES } from "../commands/utils";
+import { GetItemCommand as __GetItemCommand } from "@aws-sdk/client-dynamodb";
+export { DynamoDBDocumentClientCommand, $Command };
+export class GetCommand extends DynamoDBDocumentClientCommand {
+    input;
+    inputKeyNodes = {
+        'Key': ALL_VALUES,
+    };
+    outputKeyNodes = {
+        'Item': ALL_VALUES,
+    };
+    clientCommand;
+    middlewareStack;
+    constructor(input) {
+        super();
+        this.input = input;
+        this.clientCommand = new __GetItemCommand(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/PutCommand.js

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
+import { ALL_MEMBERS, ALL_VALUES, SELF } from "../commands/utils";
+import { PutItemCommand as __PutItemCommand } from "@aws-sdk/client-dynamodb";
+export { DynamoDBDocumentClientCommand, $Command };
+export class PutCommand extends DynamoDBDocumentClientCommand {
+    input;
+    inputKeyNodes = {
+        'Item': ALL_VALUES,
+        '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 __PutItemCommand(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/QueryCommand.js

@@ -0,0 +1,42 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
+import { ALL_MEMBERS, ALL_VALUES } from "../commands/utils";
+import { QueryCommand as __QueryCommand } from "@aws-sdk/client-dynamodb";
+export { DynamoDBDocumentClientCommand, $Command };
+export class QueryCommand extends DynamoDBDocumentClientCommand {
+    input;
+    inputKeyNodes = {
+        'KeyConditions': {
+            '*': {
+                'AttributeValueList': ALL_MEMBERS,
+            }
+        },
+        'QueryFilter': {
+            '*': {
+                'AttributeValueList': ALL_MEMBERS,
+            }
+        },
+        'ExclusiveStartKey': ALL_VALUES,
+        'ExpressionAttributeValues': ALL_VALUES,
+    };
+    outputKeyNodes = {
+        'Items': {
+            '*': ALL_VALUES
+        },
+        'LastEvaluatedKey': ALL_VALUES,
+    };
+    clientCommand;
+    middlewareStack;
+    constructor(input) {
+        super();
+        this.input = input;
+        this.clientCommand = new __QueryCommand(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/ScanCommand.js

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { DynamoDBDocumentClientCommand } from "../baseCommand/DynamoDBDocumentClientCommand";
+import { ALL_MEMBERS, ALL_VALUES } from "../commands/utils";
+import { ScanCommand as __ScanCommand } from "@aws-sdk/client-dynamodb";
+export { DynamoDBDocumentClientCommand, $Command };
+export class ScanCommand extends DynamoDBDocumentClientCommand {
+    input;
+    inputKeyNodes = {
+        'ScanFilter': {
+            '*': {
+                'AttributeValueList': ALL_MEMBERS,
+            }
+        },
+        'ExclusiveStartKey': ALL_VALUES,
+        'ExpressionAttributeValues': ALL_VALUES,
+    };
+    outputKeyNodes = {
+        'Items': {
+            '*': ALL_VALUES
+        },
+        'LastEvaluatedKey': ALL_VALUES,
+    };
+    clientCommand;
+    middlewareStack;
+    constructor(input) {
+        super();
+        this.input = input;
+        this.clientCommand = new __ScanCommand(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);
+    }
+}