@kensio/yulin 0.44.0 → 0.47.0

package/dist/service/dynamodb/expression/filter/sim-dynamodb-filter.d.ts

@@ -0,0 +1,51 @@
+import type { SimDynamoDbItem } from "../../item/sim-dynamodb-item.js";
+import type { SimDynamoDbKeySchema } from "../../table/sim-dynamodb-key-schema.js";
+import type { SimDynamoDbReadView } from "../../table/sim-dynamodb-read-view.js";
+import type { SimDynamoDbCondition } from "../condition/sim-dynamodb-condition.js";
+import type { SimDynamoDbDocumentPath } from "../sim-dynamodb-document-path.js";
+interface SimDynamoDbFilterProperties {
+    readonly condition: SimDynamoDbCondition;
+    readonly paths: readonly SimDynamoDbDocumentPath[];
+}
+/**
+ * The filter a query or a scan drops items by.
+ *
+ * A filter runs after the read rather than during it. The walk is cut to the
+ * `Limit` first, and the filter then drops items from the page that came back,
+ * so a filtered page can be shorter than the limit or empty. It saves nothing:
+ * every item it drops was read.
+ *
+ * It is the ordinary condition grammar, evaluated against each item the way a
+ * conditional write is evaluated against the item it names. An item that does
+ * not have what the filter points at fails it, since there is no third answer.
+ */
+export declare class SimDynamoDbFilter {
+    private readonly condition;
+    private readonly paths;
+    constructor(properties: SimDynamoDbFilterProperties);
+    /**
+     * The items of a page this filter holds for.
+     */
+    applyTo(items: readonly SimDynamoDbItem[]): readonly SimDynamoDbItem[];
+    /**
+     * Refuse a filter naming an attribute the view being read does not carry.
+     *
+     * An index holds only what it projects, so a filter on an attribute outside
+     * that would drop every item rather than the ones it meant. An empty page is
+     * the worst way to fail: it reads as a collection that happens to hold
+     * nothing. Real DynamoDB refuses it, so this does too.
+     */
+    assertNamesOnlyCarried(view: SimDynamoDbReadView): void;
+    /**
+     * Refuse a filter naming a key attribute of what is being read.
+     *
+     * Real DynamoDB refuses this on a query and allows it on a scan. A query has
+     * already narrowed the read to the keys its key condition names, so a filter
+     * on a key attribute is either that condition written twice or a condition
+     * the key condition should have carried. A scan narrows nothing, so there a
+     * key attribute is an attribute like any other.
+     */
+    assertNamesNoKeyAttribute(keySchema: SimDynamoDbKeySchema): void;
+}
+export {};
+//# sourceMappingURL=sim-dynamodb-filter.d.ts.map

package/dist/service/dynamodb/expression/filter/sim-dynamodb-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-filter.d.ts","sourceRoot":"","sources":["../../../../../src/service/dynamodb/expression/filter/sim-dynamodb-filter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wCAAwC,CAAC;AACnF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wCAAwC,CAAC;AACnF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kCAAkC,CAAC;AAGhF,UAAU,2BAA2B;IACnC,QAAQ,CAAC,SAAS,EAAE,oBAAoB,CAAC;IACzC,QAAQ,CAAC,KAAK,EAAE,SAAS,uBAAuB,EAAE,CAAC;CACpD;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAuB;IACjD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqC;IAE3D,YAAY,UAAU,EAAE,2BAA2B,EAGlD;IAED;;OAEG;IACH,OAAO,CAAC,KAAK,EAAE,SAAS,eAAe,EAAE,GAAG,SAAS,eAAe,EAAE,CAIrE;IAED;;;;;;;OAOG;IACH,sBAAsB,CAAC,IAAI,EAAE,mBAAmB,GAAG,IAAI,CAEtD;IAED;;;;;;;;OAQG;IACH,yBAAyB,CAAC,SAAS,EAAE,oBAAoB,GAAG,IAAI,CAU/D;CACF"}

package/dist/service/dynamodb/expression/filter/sim-dynamodb-filter.js

@@ -0,0 +1,58 @@
+import { SimDynamoDbValidationException } from "../../error/dynamodb.error.js";
+import { SimDynamoDbItemSnapshot } from "../sim-dynamodb-item-snapshot.js";
+/**
+ * The filter a query or a scan drops items by.
+ *
+ * A filter runs after the read rather than during it. The walk is cut to the
+ * `Limit` first, and the filter then drops items from the page that came back,
+ * so a filtered page can be shorter than the limit or empty. It saves nothing:
+ * every item it drops was read.
+ *
+ * It is the ordinary condition grammar, evaluated against each item the way a
+ * conditional write is evaluated against the item it names. An item that does
+ * not have what the filter points at fails it, since there is no third answer.
+ */
+export class SimDynamoDbFilter {
+    condition;
+    paths;
+    constructor(properties) {
+        this.condition = properties.condition;
+        this.paths = properties.paths;
+    }
+    /**
+     * The items of a page this filter holds for.
+     */
+    applyTo(items) {
+        return items.filter((item) => this.condition.holdsFor(new SimDynamoDbItemSnapshot(item)));
+    }
+    /**
+     * Refuse a filter naming an attribute the view being read does not carry.
+     *
+     * An index holds only what it projects, so a filter on an attribute outside
+     * that would drop every item rather than the ones it meant. An empty page is
+     * the worst way to fail: it reads as a collection that happens to hold
+     * nothing. Real DynamoDB refuses it, so this does too.
+     */
+    assertNamesOnlyCarried(view) {
+        view.assertCarriesPaths(this.paths);
+    }
+    /**
+     * Refuse a filter naming a key attribute of what is being read.
+     *
+     * Real DynamoDB refuses this on a query and allows it on a scan. A query has
+     * already narrowed the read to the keys its key condition names, so a filter
+     * on a key attribute is either that condition written twice or a condition
+     * the key condition should have carried. A scan narrows nothing, so there a
+     * key attribute is an attribute like any other.
+     */
+    assertNamesNoKeyAttribute(keySchema) {
+        for (const attributeName of keySchema.attributeNames()) {
+            if (this.paths.some((path) => path.startsAt(attributeName))) {
+                throw new SimDynamoDbValidationException(`Filter Expression can not contain key attributes: ` +
+                    `${attributeName} is part of the table's primary key, and a ` +
+                    `query narrows by its KeyConditionExpression instead`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=sim-dynamodb-filter.js.map

package/dist/service/dynamodb/expression/filter/sim-dynamodb-filter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-filter.js","sourceRoot":"","sources":["../../../../../src/service/dynamodb/expression/filter/sim-dynamodb-filter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,8BAA8B,EAAE,MAAM,+BAA+B,CAAC;AAM/E,OAAO,EAAE,uBAAuB,EAAE,MAAM,kCAAkC,CAAC;AAO3E;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,iBAAiB;IACX,SAAS,CAAuB;IAChC,KAAK,CAAqC;IAE3D,YAAY,UAAuC;QACjD,IAAI,CAAC,SAAS,GAAG,UAAU,CAAC,SAAS,CAAC;QACtC,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC;IAChC,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,KAAiC;QACvC,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAC3B,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,uBAAuB,CAAC,IAAI,CAAC,CAAC,CAC3D,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACH,sBAAsB,CAAC,IAAyB;QAC9C,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACtC,CAAC;IAED;;;;;;;;OAQG;IACH,yBAAyB,CAAC,SAA+B;QACvD,KAAK,MAAM,aAAa,IAAI,SAAS,CAAC,cAAc,EAAE,EAAE,CAAC;YACvD,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC;gBAC5D,MAAM,IAAI,8BAA8B,CACtC,oDAAoD;oBAClD,GAAG,aAAa,6CAA6C;oBAC7D,qDAAqD,CACxD,CAAC;YACJ,CAAC;QACH,CAAC;IACH,CAAC;CACF"}

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-begins-with-key-term.d.ts

@@ -0,0 +1,43 @@
+import type { SimDynamoDbScalarAttributeType } from "../../command/table/table.types.js";
+import type { SimDynamoDbValue } from "../../item/sim-dynamodb-value.js";
+import type { SimDynamoDbExpressionTokens } from "../sim-dynamodb-expression-tokens.js";
+import type { SimDynamoDbKeyConditionOperands } from "./sim-dynamodb-key-condition-operands.js";
+import type { SimDynamoDbKeyConditionTerm } from "./sim-dynamodb-key-condition-term.js";
+interface SimDynamoDbBeginsWithKeyTermProperties {
+    readonly attributeName: string;
+    readonly prefix: SimDynamoDbValue;
+}
+interface SimDynamoDbBeginsWithKeyTermSource {
+    readonly tokens: SimDynamoDbExpressionTokens;
+    readonly operands: SimDynamoDbKeyConditionOperands;
+}
+/**
+ * A sort key that starts with a value.
+ */
+export declare class SimDynamoDbBeginsWithKeyTerm implements SimDynamoDbKeyConditionTerm {
+    readonly attributeName: string;
+    readonly operator = "begins_with";
+    private readonly prefix;
+    constructor(properties: SimDynamoDbBeginsWithKeyTermProperties);
+    /**
+     * Read `begins_with(sortKey, :prefix)` out of an expression.
+     *
+     * The call is read here rather than in the parser, since the shape of a call
+     * belongs with the term it makes.
+     */
+    static read(source: SimDynamoDbBeginsWithKeyTermSource): SimDynamoDbBeginsWithKeyTerm;
+    /**
+     * Whether a key value starts with the prefix.
+     */
+    holdsFor(value: SimDynamoDbValue): boolean;
+    /**
+     * Refuse a prefix against a Number sort key.
+     *
+     * A number is stored as a value rather than as the digits it was written
+     * with, so `1E2` and `100` are one key and a prefix of either is meaningless.
+     * Real DynamoDB refuses this too.
+     */
+    assertUsableOn(type: SimDynamoDbScalarAttributeType): void;
+}
+export {};
+//# sourceMappingURL=sim-dynamodb-begins-with-key-term.d.ts.map

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-begins-with-key-term.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-begins-with-key-term.d.ts","sourceRoot":"","sources":["../../../../../src/service/dynamodb/expression/key-condition/sim-dynamodb-begins-with-key-term.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,oCAAoC,CAAC;AAEzF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAGxF,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,0CAA0C,CAAC;AAEhG,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAExF,UAAU,sCAAsC;IAC9C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;CACnC;AAED,UAAU,kCAAkC;IAC1C,QAAQ,CAAC,MAAM,EAAE,2BAA2B,CAAC;IAC7C,QAAQ,CAAC,QAAQ,EAAE,+BAA+B,CAAC;CACpD;AAED;;GAEG;AACH,qBAAa,4BAA6B,YAAW,2BAA2B;IAC9E,SAAgB,aAAa,EAAE,MAAM,CAAC;IACtC,SAAgB,QAAQ,iBAAiB;IAEzC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAmB;IAE1C,YAAY,UAAU,EAAE,sCAAsC,EAG7D;IAED;;;;;OAKG;IACH,MAAM,CAAC,IAAI,CACT,MAAM,EAAE,kCAAkC,GACzC,4BAA4B,CAoB9B;IAED;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAEzC;IAED;;;;;;OAMG;IACH,cAAc,CAAC,IAAI,EAAE,8BAA8B,GAAG,IAAI,CASzD;CACF"}

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-begins-with-key-term.js

@@ -0,0 +1,54 @@
+import { simDynamoDbValueBeginsWith } from "../../item/sim-dynamodb-value-prefix.js";
+import { simDynamoDbKeyConditionError } from "./sim-dynamodb-key-condition-error.js";
+import { assertSimDynamoDbKeyValueType } from "./sim-dynamodb-key-condition-term.js";
+import { simDynamoDbBeginsWithName } from "./sim-dynamodb-key-condition-refusals.js";
+/**
+ * A sort key that starts with a value.
+ */
+export class SimDynamoDbBeginsWithKeyTerm {
+    attributeName;
+    operator = "begins_with";
+    prefix;
+    constructor(properties) {
+        this.attributeName = properties.attributeName;
+        this.prefix = properties.prefix;
+    }
+    /**
+     * Read `begins_with(sortKey, :prefix)` out of an expression.
+     *
+     * The call is read here rather than in the parser, since the shape of a call
+     * belongs with the term it makes.
+     */
+    static read(source) {
+        const { tokens, operands } = source;
+        tokens.next(simDynamoDbBeginsWithName);
+        tokens.next("(");
+        const attributeName = operands.attributeName();
+        tokens.expectSymbol(",", `syntax error; ${simDynamoDbBeginsWithName} takes a key attribute and ` +
+            `a value, separated by a comma`);
+        const prefix = operands.value();
+        tokens.expectSymbol(")", `syntax error; ${simDynamoDbBeginsWithName} is not closed`);
+        return new this({ attributeName, prefix });
+    }
+    /**
+     * Whether a key value starts with the prefix.
+     */
+    holdsFor(value) {
+        return simDynamoDbValueBeginsWith(value, this.prefix);
+    }
+    /**
+     * Refuse a prefix against a Number sort key.
+     *
+     * A number is stored as a value rather than as the digits it was written
+     * with, so `1E2` and `100` are one key and a prefix of either is meaningless.
+     * Real DynamoDB refuses this too.
+     */
+    assertUsableOn(type) {
+        if (type === "N") {
+            throw simDynamoDbKeyConditionError(`begins_with reads a prefix of a String or Binary sort key, and ` +
+                `${this.attributeName} is a Number`);
+        }
+        assertSimDynamoDbKeyValueType(this.attributeName, this.prefix, type);
+    }
+}
+//# sourceMappingURL=sim-dynamodb-begins-with-key-term.js.map

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-begins-with-key-term.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-begins-with-key-term.js","sourceRoot":"","sources":["../../../../../src/service/dynamodb/expression/key-condition/sim-dynamodb-begins-with-key-term.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAC;AAGrF,OAAO,EAAE,4BAA4B,EAAE,MAAM,uCAAuC,CAAC;AACrF,OAAO,EAAE,6BAA6B,EAAE,MAAM,sCAAsC,CAAC;AAErF,OAAO,EAAE,yBAAyB,EAAE,MAAM,0CAA0C,CAAC;AAarF;;GAEG;AACH,MAAM,OAAO,4BAA4B;IACvB,aAAa,CAAS;IACtB,QAAQ,GAAG,aAAa,CAAC;IAExB,MAAM,CAAmB;IAE1C,YAAY,UAAkD;QAC5D,IAAI,CAAC,aAAa,GAAG,UAAU,CAAC,aAAa,CAAC;QAC9C,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC;IAClC,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,IAAI,CACT,MAA0C;QAE1C,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,MAAM,CAAC;QAEpC,MAAM,CAAC,IAAI,CAAC,yBAAyB,CAAC,CAAC;QACvC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAEjB,MAAM,aAAa,GAAG,QAAQ,CAAC,aAAa,EAAE,CAAC;QAC/C,MAAM,CAAC,YAAY,CACjB,GAAG,EACH,iBAAiB,yBAAyB,6BAA6B;YACrE,+BAA+B,CAClC,CAAC;QAEF,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,EAAE,CAAC;QAChC,MAAM,CAAC,YAAY,CACjB,GAAG,EACH,iBAAiB,yBAAyB,gBAAgB,CAC3D,CAAC;QAEF,OAAO,IAAI,IAAI,CAAC,EAAE,aAAa,EAAE,MAAM,EAAE,CAAC,CAAC;IAC7C,CAAC;IAED;;OAEG;IACH,QAAQ,CAAC,KAAuB;QAC9B,OAAO,0BAA0B,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IACxD,CAAC;IAED;;;;;;OAMG;IACH,cAAc,CAAC,IAAoC;QACjD,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;YACjB,MAAM,4BAA4B,CAChC,iEAAiE;gBAC/D,GAAG,IAAI,CAAC,aAAa,cAAc,CACtC,CAAC;QACJ,CAAC;QAED,6BAA6B,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACvE,CAAC;CACF"}

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-between-key-term.d.ts

@@ -0,0 +1,42 @@
+import type { SimDynamoDbScalarAttributeType } from "../../command/table/table.types.js";
+import type { SimDynamoDbValue } from "../../item/sim-dynamodb-value.js";
+import { type SimDynamoDbKeyConditionTerm } from "./sim-dynamodb-key-condition-term.js";
+interface SimDynamoDbBetweenKeyTermProperties {
+    readonly attributeName: string;
+    readonly lower: SimDynamoDbValue;
+    readonly upper: SimDynamoDbValue;
+}
+/**
+ * A sort key between two bounds, both of which count as inside.
+ */
+export declare class SimDynamoDbBetweenKeyTerm implements SimDynamoDbKeyConditionTerm {
+    readonly attributeName: string;
+    readonly operator = "BETWEEN";
+    private readonly lower;
+    private readonly upper;
+    constructor(properties: SimDynamoDbBetweenKeyTermProperties);
+    /**
+     * Whether a key value is at or between the two bounds.
+     *
+     * All three always order. Every one of them is the type the table declared
+     * for the key attribute, which `assertUsableOn` checked before the query ran.
+     */
+    holdsFor(value: SimDynamoDbValue): boolean;
+    /**
+     * Refuse bounds of a type the key attribute was not declared as.
+     *
+     * The two bounds already agree with each other, which is checked when the
+     * term is built, so this is what ties them to the table.
+     */
+    assertUsableOn(type: SimDynamoDbScalarAttributeType): void;
+    /**
+     * Refuse a range that runs backwards, or whose bounds are different types.
+     *
+     * Real DynamoDB refuses both. A backwards range names no items at all, and
+     * bounds of two types have no order to sit between, so either one is a
+     * request that cannot mean what it says.
+     */
+    private assertBoundsOrdered;
+}
+export {};
+//# sourceMappingURL=sim-dynamodb-between-key-term.d.ts.map

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-between-key-term.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-between-key-term.d.ts","sourceRoot":"","sources":["../../../../../src/service/dynamodb/expression/key-condition/sim-dynamodb-between-key-term.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,oCAAoC,CAAC;AAEzF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAEzE,OAAO,EAEL,KAAK,2BAA2B,EACjC,MAAM,sCAAsC,CAAC;AAE9C,UAAU,mCAAmC;IAC3C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;CAClC;AAED;;GAEG;AACH,qBAAa,yBAA0B,YAAW,2BAA2B;IAC3E,SAAgB,aAAa,EAAE,MAAM,CAAC;IACtC,SAAgB,QAAQ,aAAa;IAErC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmB;IACzC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmB;IAEzC,YAAY,UAAU,EAAE,mCAAmC,EAM1D;IAED;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAczC;IAED;;;;;OAKG;IACH,cAAc,CAAC,IAAI,EAAE,8BAA8B,GAAG,IAAI,CAGzD;IAED;;;;;;OAMG;IACH,OAAO,CAAC,mBAAmB;CAiB5B"}

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-between-key-term.js

@@ -0,0 +1,61 @@
+import { assertDefined } from "../../../../util/type-guard/defined.js";
+import { compareSimDynamoDbValues } from "../../item/sim-dynamodb-value-order.js";
+import { simDynamoDbKeyConditionError } from "./sim-dynamodb-key-condition-error.js";
+import { assertSimDynamoDbKeyValueType, } from "./sim-dynamodb-key-condition-term.js";
+/**
+ * A sort key between two bounds, both of which count as inside.
+ */
+export class SimDynamoDbBetweenKeyTerm {
+    attributeName;
+    operator = "BETWEEN";
+    lower;
+    upper;
+    constructor(properties) {
+        this.attributeName = properties.attributeName;
+        this.lower = properties.lower;
+        this.upper = properties.upper;
+        this.assertBoundsOrdered();
+    }
+    /**
+     * Whether a key value is at or between the two bounds.
+     *
+     * All three always order. Every one of them is the type the table declared
+     * for the key attribute, which `assertUsableOn` checked before the query ran.
+     */
+    holdsFor(value) {
+        const aboveLower = compareSimDynamoDbValues(value, this.lower);
+        const belowUpper = compareSimDynamoDbValues(value, this.upper);
+        assertDefined(aboveLower, `order against the ${this.attributeName} lower bound`);
+        assertDefined(belowUpper, `order against the ${this.attributeName} upper bound`);
+        return aboveLower >= 0 && belowUpper <= 0;
+    }
+    /**
+     * Refuse bounds of a type the key attribute was not declared as.
+     *
+     * The two bounds already agree with each other, which is checked when the
+     * term is built, so this is what ties them to the table.
+     */
+    assertUsableOn(type) {
+        assertSimDynamoDbKeyValueType(this.attributeName, this.lower, type);
+        assertSimDynamoDbKeyValueType(this.attributeName, this.upper, type);
+    }
+    /**
+     * Refuse a range that runs backwards, or whose bounds are different types.
+     *
+     * Real DynamoDB refuses both. A backwards range names no items at all, and
+     * bounds of two types have no order to sit between, so either one is a
+     * request that cannot mean what it says.
+     */
+    assertBoundsOrdered() {
+        const order = compareSimDynamoDbValues(this.lower, this.upper);
+        if (order === undefined) {
+            throw simDynamoDbKeyConditionError(`the BETWEEN bounds on ${this.attributeName} are not the same type, ` +
+                `so nothing can sit between them`);
+        }
+        if (order > 0) {
+            throw simDynamoDbKeyConditionError(`the BETWEEN operator on ${this.attributeName} requires an upper ` +
+                `bound at or above its lower bound`);
+        }
+    }
+}
+//# sourceMappingURL=sim-dynamodb-between-key-term.js.map

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-between-key-term.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-between-key-term.js","sourceRoot":"","sources":["../../../../../src/service/dynamodb/expression/key-condition/sim-dynamodb-between-key-term.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAEvE,OAAO,EAAE,wBAAwB,EAAE,MAAM,wCAAwC,CAAC;AAElF,OAAO,EAAE,4BAA4B,EAAE,MAAM,uCAAuC,CAAC;AACrF,OAAO,EACL,6BAA6B,GAE9B,MAAM,sCAAsC,CAAC;AAQ9C;;GAEG;AACH,MAAM,OAAO,yBAAyB;IACpB,aAAa,CAAS;IACtB,QAAQ,GAAG,SAAS,CAAC;IAEpB,KAAK,CAAmB;IACxB,KAAK,CAAmB;IAEzC,YAAY,UAA+C;QACzD,IAAI,CAAC,aAAa,GAAG,UAAU,CAAC,aAAa,CAAC;QAC9C,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC;QAC9B,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC;QAE9B,IAAI,CAAC,mBAAmB,EAAE,CAAC;IAC7B,CAAC;IAED;;;;;OAKG;IACH,QAAQ,CAAC,KAAuB;QAC9B,MAAM,UAAU,GAAG,wBAAwB,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;QAC/D,MAAM,UAAU,GAAG,wBAAwB,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;QAE/D,aAAa,CACX,UAAU,EACV,qBAAqB,IAAI,CAAC,aAAa,cAAc,CACtD,CAAC;QACF,aAAa,CACX,UAAU,EACV,qBAAqB,IAAI,CAAC,aAAa,cAAc,CACtD,CAAC;QAEF,OAAO,UAAU,IAAI,CAAC,IAAI,UAAU,IAAI,CAAC,CAAC;IAC5C,CAAC;IAED;;;;;OAKG;IACH,cAAc,CAAC,IAAoC;QACjD,6BAA6B,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QACpE,6BAA6B,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IACtE,CAAC;IAED;;;;;;OAMG;IACK,mBAAmB;QACzB,MAAM,KAAK,GAAG,wBAAwB,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;QAE/D,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,MAAM,4BAA4B,CAChC,yBAAyB,IAAI,CAAC,aAAa,0BAA0B;gBACnE,iCAAiC,CACpC,CAAC;QACJ,CAAC;QAED,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;YACd,MAAM,4BAA4B,CAChC,2BAA2B,IAAI,CAAC,aAAa,qBAAqB;gBAChE,mCAAmC,CACtC,CAAC;QACJ,CAAC;IACH,CAAC;CACF"}

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-comparison-key-term.d.ts

@@ -0,0 +1,39 @@
+import type { SimDynamoDbScalarAttributeType } from "../../command/table/table.types.js";
+import type { SimDynamoDbValue } from "../../item/sim-dynamodb-value.js";
+import { type SimDynamoDbKeyConditionTerm } from "./sim-dynamodb-key-condition-term.js";
+interface SimDynamoDbComparisonKeyTermProperties {
+    readonly attributeName: string;
+    readonly operator: string;
+    readonly value: SimDynamoDbValue;
+}
+/**
+ * A key attribute compared against one value.
+ *
+ * This is the only term the partition key can carry, and only with `=`, since a
+ * query reads one item collection and a range of partition keys would be
+ * several. The value it holds is therefore also the value a collection is found
+ * by.
+ */
+export declare class SimDynamoDbComparisonKeyTerm implements SimDynamoDbKeyConditionTerm {
+    readonly attributeName: string;
+    readonly operator: string;
+    readonly value: SimDynamoDbValue;
+    constructor(properties: SimDynamoDbComparisonKeyTermProperties);
+    /**
+     * Whether a key value stands in the relation the operator asked for.
+     *
+     * The two sides always order. Both are the type the table declared for the
+     * key attribute: the stored one because a write that broke that was refused,
+     * and the supplied one because `assertUsableOn` refused the query.
+     */
+    holdsFor(value: SimDynamoDbValue): boolean;
+    /**
+     * Refuse a value of a type the key attribute was not declared as.
+     *
+     * Every scalar key type compares and orders, so the operator is always fine.
+     * What has to match is the value it compares against.
+     */
+    assertUsableOn(type: SimDynamoDbScalarAttributeType): void;
+}
+export {};
+//# sourceMappingURL=sim-dynamodb-comparison-key-term.d.ts.map

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-comparison-key-term.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-comparison-key-term.d.ts","sourceRoot":"","sources":["../../../../../src/service/dynamodb/expression/key-condition/sim-dynamodb-comparison-key-term.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,oCAAoC,CAAC;AACzF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EAEL,KAAK,2BAA2B,EACjC,MAAM,sCAAsC,CAAC;AAE9C,UAAU,sCAAsC;IAC9C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;CAClC;AAED;;;;;;;GAOG;AACH,qBAAa,4BAA6B,YAAW,2BAA2B;IAC9E,SAAgB,aAAa,EAAE,MAAM,CAAC;IACtC,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,KAAK,EAAE,gBAAgB,CAAC;IAExC,YAAY,UAAU,EAAE,sCAAsC,EAI7D;IAED;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAUzC;IAED;;;;;OAKG;IACH,cAAc,CAAC,IAAI,EAAE,8BAA8B,GAAG,IAAI,CAEzD;CACF"}

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-comparison-key-term.js

@@ -0,0 +1,47 @@
+import { simDynamoDbValuesEqual } from "../../item/sim-dynamodb-value-comparison.js";
+import { compareSimDynamoDbValues, simDynamoDbOrderHolds, } from "../../item/sim-dynamodb-value-order.js";
+import { assertDefined } from "../../../../util/type-guard/defined.js";
+import { assertSimDynamoDbKeyValueType, } from "./sim-dynamodb-key-condition-term.js";
+/**
+ * A key attribute compared against one value.
+ *
+ * This is the only term the partition key can carry, and only with `=`, since a
+ * query reads one item collection and a range of partition keys would be
+ * several. The value it holds is therefore also the value a collection is found
+ * by.
+ */
+export class SimDynamoDbComparisonKeyTerm {
+    attributeName;
+    operator;
+    value;
+    constructor(properties) {
+        this.attributeName = properties.attributeName;
+        this.operator = properties.operator;
+        this.value = properties.value;
+    }
+    /**
+     * Whether a key value stands in the relation the operator asked for.
+     *
+     * The two sides always order. Both are the type the table declared for the
+     * key attribute: the stored one because a write that broke that was refused,
+     * and the supplied one because `assertUsableOn` refused the query.
+     */
+    holdsFor(value) {
+        if (this.operator === "=") {
+            return simDynamoDbValuesEqual(value, this.value);
+        }
+        const order = compareSimDynamoDbValues(value, this.value);
+        assertDefined(order, `order of two ${this.attributeName} key values`);
+        return simDynamoDbOrderHolds(this.operator, order);
+    }
+    /**
+     * Refuse a value of a type the key attribute was not declared as.
+     *
+     * Every scalar key type compares and orders, so the operator is always fine.
+     * What has to match is the value it compares against.
+     */
+    assertUsableOn(type) {
+        assertSimDynamoDbKeyValueType(this.attributeName, this.value, type);
+    }
+}
+//# sourceMappingURL=sim-dynamodb-comparison-key-term.js.map

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-comparison-key-term.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-comparison-key-term.js","sourceRoot":"","sources":["../../../../../src/service/dynamodb/expression/key-condition/sim-dynamodb-comparison-key-term.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,6CAA6C,CAAC;AACrF,OAAO,EACL,wBAAwB,EACxB,qBAAqB,GACtB,MAAM,wCAAwC,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAGvE,OAAO,EACL,6BAA6B,GAE9B,MAAM,sCAAsC,CAAC;AAQ9C;;;;;;;GAOG;AACH,MAAM,OAAO,4BAA4B;IACvB,aAAa,CAAS;IACtB,QAAQ,CAAS;IACjB,KAAK,CAAmB;IAExC,YAAY,UAAkD;QAC5D,IAAI,CAAC,aAAa,GAAG,UAAU,CAAC,aAAa,CAAC;QAC9C,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC;QACpC,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC;IAChC,CAAC;IAED;;;;;;OAMG;IACH,QAAQ,CAAC,KAAuB;QAC9B,IAAI,IAAI,CAAC,QAAQ,KAAK,GAAG,EAAE,CAAC;YAC1B,OAAO,sBAAsB,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;QACnD,CAAC;QAED,MAAM,KAAK,GAAG,wBAAwB,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;QAE1D,aAAa,CAAC,KAAK,EAAE,gBAAgB,IAAI,CAAC,aAAa,aAAa,CAAC,CAAC;QAEtE,OAAO,qBAAqB,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IACrD,CAAC;IAED;;;;;OAKG;IACH,cAAc,CAAC,IAAoC;QACjD,6BAA6B,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IACtE,CAAC;CACF"}

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-error.d.ts

@@ -0,0 +1,15 @@
+import type { SimDynamoDbValidationException } from "../../error/dynamodb.error.js";
+/**
+ * The request parameter every refusal here names.
+ */
+export declare const keyConditionExpressionName = "KeyConditionExpression";
+/**
+ * Build the error a key condition is refused with.
+ *
+ * A key condition is refused in two places: while it is being read, and again
+ * once the table it names has been reached and its key schema is known. Both go
+ * through this, so a caller reading the failure sees the same wording either
+ * way.
+ */
+export declare function simDynamoDbKeyConditionError(reason: string): SimDynamoDbValidationException;
+//# sourceMappingURL=sim-dynamodb-key-condition-error.d.ts.map

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-key-condition-error.d.ts","sourceRoot":"","sources":["../../../../../src/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-error.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,+BAA+B,CAAC;AAGpF;;GAEG;AACH,eAAO,MAAM,0BAA0B,2BAA2B,CAAC;AAEnE;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,MAAM,GACb,8BAA8B,CAEhC"}

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-error.js

@@ -0,0 +1,17 @@
+import { simDynamoDbExpressionError } from "../sim-dynamodb-expression-error.js";
+/**
+ * The request parameter every refusal here names.
+ */
+export const keyConditionExpressionName = "KeyConditionExpression";
+/**
+ * Build the error a key condition is refused with.
+ *
+ * A key condition is refused in two places: while it is being read, and again
+ * once the table it names has been reached and its key schema is known. Both go
+ * through this, so a caller reading the failure sees the same wording either
+ * way.
+ */
+export function simDynamoDbKeyConditionError(reason) {
+    return simDynamoDbExpressionError(keyConditionExpressionName, reason);
+}
+//# sourceMappingURL=sim-dynamodb-key-condition-error.js.map

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-key-condition-error.js","sourceRoot":"","sources":["../../../../../src/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-error.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,0BAA0B,EAAE,MAAM,qCAAqC,CAAC;AAEjF;;GAEG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,wBAAwB,CAAC;AAEnE;;;;;;;GAOG;AACH,MAAM,UAAU,4BAA4B,CAC1C,MAAc;IAEd,OAAO,0BAA0B,CAAC,0BAA0B,EAAE,MAAM,CAAC,CAAC;AACxE,CAAC"}

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-expression.d.ts

@@ -0,0 +1,19 @@
+import type { SimDynamoDbExpressionParameterInput, SimDynamoDbExpressionParameters } from "../sim-dynamodb-expression-parameters.js";
+import { SimDynamoDbKeyConditionTerms } from "./sim-dynamodb-key-condition-terms.js";
+interface SimDynamoDbKeyConditionRequest extends SimDynamoDbExpressionParameterInput {
+    readonly KeyConditionExpression?: string | undefined;
+}
+/**
+ * Read the key condition a query walks its item collection by.
+ *
+ * A query names one item collection, so unlike every other expression parameter
+ * this one is required rather than optional: a request without it is asking for
+ * a scan.
+ *
+ * The placeholders are passed in rather than gathered here, since a query can
+ * carry a filter alongside its key condition and both draw on the same ones.
+ * They are checked once every expression on the request has been read.
+ */
+export declare function readSimDynamoDbKeyCondition(request: SimDynamoDbKeyConditionRequest, parameters: SimDynamoDbExpressionParameters): SimDynamoDbKeyConditionTerms;
+export {};
+//# sourceMappingURL=sim-dynamodb-key-condition-expression.d.ts.map

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-key-condition-expression.d.ts","sourceRoot":"","sources":["../../../../../src/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-expression.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,mCAAmC,EACnC,+BAA+B,EAChC,MAAM,0CAA0C,CAAC;AAIlD,OAAO,EAAE,4BAA4B,EAAE,MAAM,uCAAuC,CAAC;AAErF,UAAU,8BAA+B,SAAQ,mCAAmC;IAClF,QAAQ,CAAC,sBAAsB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACtD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,8BAA8B,EACvC,UAAU,EAAE,+BAA+B,GAC1C,4BAA4B,CAqB9B"}

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-expression.js

@@ -0,0 +1,30 @@
+import { SimDynamoDbValidationException } from "../../error/dynamodb.error.js";
+import { SimDynamoDbExpressionTokens } from "../sim-dynamodb-expression-tokens.js";
+import { keyConditionExpressionName } from "./sim-dynamodb-key-condition-error.js";
+import { SimDynamoDbKeyConditionParser } from "./sim-dynamodb-key-condition-parser.js";
+import { SimDynamoDbKeyConditionTerms } from "./sim-dynamodb-key-condition-terms.js";
+/**
+ * Read the key condition a query walks its item collection by.
+ *
+ * A query names one item collection, so unlike every other expression parameter
+ * this one is required rather than optional: a request without it is asking for
+ * a scan.
+ *
+ * The placeholders are passed in rather than gathered here, since a query can
+ * carry a filter alongside its key condition and both draw on the same ones.
+ * They are checked once every expression on the request has been read.
+ */
+export function readSimDynamoDbKeyCondition(request, parameters) {
+    const expression = request.KeyConditionExpression;
+    if (expression === undefined) {
+        throw new SimDynamoDbValidationException("A KeyConditionExpression is required, since a query reads the items " +
+            "under one partition key");
+    }
+    const terms = new SimDynamoDbKeyConditionParser({
+        tokens: SimDynamoDbExpressionTokens.of(keyConditionExpressionName, expression, "the expression says nothing, and an expression cannot be empty"),
+        names: parameters.names,
+        values: parameters.values,
+    }).parse();
+    return new SimDynamoDbKeyConditionTerms(terms);
+}
+//# sourceMappingURL=sim-dynamodb-key-condition-expression.js.map

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-expression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-key-condition-expression.js","sourceRoot":"","sources":["../../../../../src/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-expression.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,8BAA8B,EAAE,MAAM,+BAA+B,CAAC;AAK/E,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AACnF,OAAO,EAAE,0BAA0B,EAAE,MAAM,uCAAuC,CAAC;AACnF,OAAO,EAAE,6BAA6B,EAAE,MAAM,wCAAwC,CAAC;AACvF,OAAO,EAAE,4BAA4B,EAAE,MAAM,uCAAuC,CAAC;AAMrF;;;;;;;;;;GAUG;AACH,MAAM,UAAU,2BAA2B,CACzC,OAAuC,EACvC,UAA2C;IAE3C,MAAM,UAAU,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAElD,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;QAC7B,MAAM,IAAI,8BAA8B,CACtC,sEAAsE;YACpE,yBAAyB,CAC5B,CAAC;IACJ,CAAC;IAED,MAAM,KAAK,GAAG,IAAI,6BAA6B,CAAC;QAC9C,MAAM,EAAE,2BAA2B,CAAC,EAAE,CACpC,0BAA0B,EAC1B,UAAU,EACV,gEAAgE,CACjE;QACD,KAAK,EAAE,UAAU,CAAC,KAAK;QACvB,MAAM,EAAE,UAAU,CAAC,MAAM;KAC1B,CAAC,CAAC,KAAK,EAAE,CAAC;IAEX,OAAO,IAAI,4BAA4B,CAAC,KAAK,CAAC,CAAC;AACjD,CAAC"}

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-operands.d.ts

@@ -0,0 +1,49 @@
+import type { SimDynamoDbValue } from "../../item/sim-dynamodb-value.js";
+import type { SimDynamoDbExpressionPlaceholders } from "../sim-dynamodb-expression-placeholders.js";
+import type { SimDynamoDbExpressionTokens } from "../sim-dynamodb-expression-tokens.js";
+import { type SimDynamoDbKeyConditionRefusals } from "./sim-dynamodb-key-condition-refusals.js";
+interface SimDynamoDbKeyConditionOperandsProperties {
+    readonly tokens: SimDynamoDbExpressionTokens;
+    readonly names: SimDynamoDbExpressionPlaceholders<string>;
+    readonly values: SimDynamoDbExpressionPlaceholders<SimDynamoDbValue>;
+    readonly refusals: SimDynamoDbKeyConditionRefusals;
+}
+/**
+ * The three pieces every key condition term is built from: the key attribute,
+ * the comparator, and the value.
+ *
+ * They are read here rather than in the parser, so the parser stays the shape a
+ * key condition is allowed to take.
+ */
+export declare class SimDynamoDbKeyConditionOperands {
+    private readonly tokens;
+    private readonly names;
+    private readonly values;
+    private readonly refusals;
+    constructor(properties: SimDynamoDbKeyConditionOperandsProperties);
+    /**
+     * Read the name of the key attribute a term names.
+     *
+     * A key attribute is a top-level attribute, so this reads one token rather
+     * than a document path: a key is scalar, and nothing in the closed grammar
+     * dereferences one.
+     */
+    attributeName(): string;
+    /**
+     * Read the value a term compares against, which is always supplied.
+     *
+     * Key conditions have no literals, so every value arrives through
+     * `ExpressionAttributeValues`.
+     */
+    value(): SimDynamoDbValue;
+    /**
+     * Read the comparator between a key attribute and a value.
+     */
+    comparator(): string;
+    /**
+     * The attribute a name token stands for, which may be a placeholder.
+     */
+    private nameOf;
+}
+export {};
+//# sourceMappingURL=sim-dynamodb-key-condition-operands.d.ts.map

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-operands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-key-condition-operands.d.ts","sourceRoot":"","sources":["../../../../../src/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-operands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,4CAA4C,CAAC;AACpG,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAExF,OAAO,EAEL,KAAK,+BAA+B,EACrC,MAAM,0CAA0C,CAAC;AAgBlD,UAAU,yCAAyC;IACjD,QAAQ,CAAC,MAAM,EAAE,2BAA2B,CAAC;IAC7C,QAAQ,CAAC,KAAK,EAAE,iCAAiC,CAAC,MAAM,CAAC,CAAC;IAC1D,QAAQ,CAAC,MAAM,EAAE,iCAAiC,CAAC,gBAAgB,CAAC,CAAC;IACrE,QAAQ,CAAC,QAAQ,EAAE,+BAA+B,CAAC;CACpD;AAED;;;;;;GAMG;AACH,qBAAa,+BAA+B;IAC1C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8B;IACrD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA4C;IAClE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsD;IAC7E,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkC;IAE3D,YAAY,UAAU,EAAE,yCAAyC,EAKhE;IAED;;;;;;OAMG;IACH,aAAa,IAAI,MAAM,CAetB;IAED;;;;;OAKG;IACH,KAAK,IAAI,gBAAgB,CAWxB;IAED;;OAEG;IACH,UAAU,IAAI,MAAM,CAWnB;IAED;;OAEG;IACH,OAAO,CAAC,MAAM;CAOf"}