@infra-blocks/aws-dynamodb 0.67.0 → 0.68.0-alpha.0

package/lib/cjs/commands/expressions/comparisons/between.d.ts

@@ -0,0 +1,22 @@
+import { type Brand, type Phantom } from "@infra-blocks/types";
+import { ExpressionFormatter } from "../formatter.js";
+import { Operand, type OperandInput } from "../operands/index.js";
+import type { ComparableValue } from "./comparable.js";
+export type BetweenInput<OI extends OperandInput<ComparableValue> = OperandInput<ComparableValue>> = [OI, "BETWEEN", OI, "AND", OI];
+export declare function isBetweenInput<OI extends OperandInput<ComparableValue> = OperandInput<ComparableValue>>(value: unknown): value is BetweenInput<OI>;
+export type Between<O extends Operand<ComparableValue> = Operand<ComparableValue>> = ExpressionFormatter & Brand<"Between"> & Phantom<O>;
+export declare const Between: {
+    /**
+     * Returns a comparison that uses the `BETWEEN` operator.
+     *
+     * Both bounds are inclusive.
+     *
+     * @param input - The parameters of the `BETWEEN` comparison. The first element contains the left-hand side operand,
+     * the third element contains the lower inclusive bound, and the fifth element contains the upper inclusive bound.
+     *
+     * @returns A {@link Between} that evaluates to true if this operand is within the provided bounds.
+     *
+     * @see https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Comparators
+     */
+    from<O extends Operand<ComparableValue>, OI extends OperandInput<ComparableValue>>(input: BetweenInput<OI>): Between<O>;
+};

package/lib/cjs/commands/expressions/{condition/comparisons → comparisons}/between.js

@@ -3,16 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Between = void 0;
 exports.isBetweenInput = isBetweenInput;
 const types_1 = require("@infra-blocks/types");
-const formatter_js_1 = require("../../formatter.js");
-const operand_js_1 = require("../operand.js");
+const formatter_js_1 = require("../formatter.js");
+const index_js_1 = require("../operands/index.js");
 function isBetweenInput(value) {
-    return value[1] === "BETWEEN" && value[3] === "AND";
+    return (Array.isArray(value) &&
+        value.length === 5 &&
+        (0, index_js_1.isOperandInput)(value[0]) &&
+        value[1] === "BETWEEN" &&
+        (0, index_js_1.isOperandInput)(value[2]) &&
+        value[3] === "AND" &&
+        (0, index_js_1.isOperandInput)(value[4]));
 }
 exports.Between = {
     /**
-     * Returns a condition that uses the `BETWEEN` operator.
+     * Returns a comparison that uses the `BETWEEN` operator.
      *
-     * Both bounds are inclusive, meaning that the returned condition corresponds to `lower <= lhs <= upper`.
+     * Both bounds are inclusive.
      *
      * @param input - The parameters of the `BETWEEN` comparison. The first element contains the left-hand side operand,
      * the third element contains the lower inclusive bound, and the fifth element contains the upper inclusive bound.
@@ -22,9 +28,9 @@ exports.Between = {
      * @see https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Comparators
      */
     from(input) {
-        const lhs = operand_js_1.ConditionOperand.normalize(input[0]);
-        const lower = operand_js_1.ConditionOperand.normalize(input[2]);
-        const upper = operand_js_1.ConditionOperand.normalize(input[4]);
+        const lhs = index_js_1.Operand.normalize(input[0]);
+        const lower = index_js_1.Operand.normalize(input[2]);
+        const upper = index_js_1.Operand.normalize(input[4]);
         return (0, types_1.trusted)(formatter_js_1.ExpressionFormatter.from(({ names, values }) => `${lhs.format({ names, values })} BETWEEN ${lower.format({ names, values })} AND ${upper.format({ names, values })}`));
     },
 };

package/lib/cjs/commands/expressions/comparisons/between.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"between.js","sourceRoot":"","sources":["../../../../../src/commands/expressions/comparisons/between.ts"],"names":[],"mappings":";;;AAaA,wCAYC;AAzBD,+CAAwE;AACxE,kDAAsD;AACtD,mDAI8B;AAO9B,SAAgB,cAAc,CAE5B,KAAc;IACd,OAAO,CACL,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QACpB,KAAK,CAAC,MAAM,KAAK,CAAC;QAClB,IAAA,yBAAc,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACxB,KAAK,CAAC,CAAC,CAAC,KAAK,SAAS;QACtB,IAAA,yBAAc,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACxB,KAAK,CAAC,CAAC,CAAC,KAAK,KAAK;QAClB,IAAA,yBAAc,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CACzB,CAAC;AACJ,CAAC;AAMY,QAAA,OAAO,GAAG;IACrB;;;;;;;;;;;OAWG;IACH,IAAI,CAGF,KAAuB;QACvB,MAAM,GAAG,GAAG,kBAAO,CAAC,SAAS,CAAkB,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QACzD,MAAM,KAAK,GAAG,kBAAO,CAAC,SAAS,CAAkB,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3D,MAAM,KAAK,GAAG,kBAAO,CAAC,SAAS,CAAkB,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAE3D,OAAO,IAAA,eAAO,EACZ,kCAAmB,CAAC,IAAI,CACtB,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,CACpB,GAAG,GAAG,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,YAAY,KAAK,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,QAAQ,KAAK,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,CACvH,CACF,CAAC;IACJ,CAAC;CACF,CAAC"}

package/lib/cjs/commands/expressions/comparisons/binary.d.ts

@@ -0,0 +1,4 @@
+import type { AttributeValue } from "../../../types.js";
+import { ExpressionFormatter } from "../formatter.js";
+import { type OperandInput } from "../operands/index.js";
+export declare function binaryOperation<OI extends OperandInput<AttributeValue>>(params: [OI, string, OI]): ExpressionFormatter;

package/lib/cjs/commands/expressions/{condition/comparisons → comparisons}/binary.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.binaryOperation = binaryOperation;
-const formatter_js_1 = require("../../formatter.js");
-const operand_js_1 = require("../operand.js");
+const formatter_js_1 = require("../formatter.js");
+const index_js_1 = require("../operands/index.js");
 function binaryOperation(params) {
-    const lhs = operand_js_1.ConditionOperand.normalize(params[0]);
-    const rhs = operand_js_1.ConditionOperand.normalize(params[2]);
+    const lhs = index_js_1.Operand.normalize(params[0]);
+    const rhs = index_js_1.Operand.normalize(params[2]);
     return formatter_js_1.ExpressionFormatter.from(({ names, values }) => `${lhs.format({ names, values })} ${params[1]} ${rhs.format({ names, values })}`);
 }
 //# sourceMappingURL=binary.js.map

package/lib/cjs/commands/expressions/comparisons/binary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary.js","sourceRoot":"","sources":["../../../../../src/commands/expressions/comparisons/binary.ts"],"names":[],"mappings":";;AAIA,0CAUC;AAbD,kDAAsD;AACtD,mDAAkE;AAElE,SAAgB,eAAe,CAC7B,MAAwB;IAExB,MAAM,GAAG,GAAG,kBAAO,CAAC,SAAS,CAAiB,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IACzD,MAAM,GAAG,GAAG,kBAAO,CAAC,SAAS,CAAiB,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IAEzD,OAAO,kCAAmB,CAAC,IAAI,CAC7B,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,CACpB,GAAG,GAAG,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,CACnF,CAAC;AACJ,CAAC"}

package/lib/cjs/commands/expressions/comparisons/comparable.d.ts

@@ -0,0 +1,5 @@
+import type { NativeBinary, NativeNumber, NativeString } from "../../../types.js";
+import type { Operand, OperandInput } from "../operands/operand.js";
+export type ComparableValue = NativeBinary | NativeNumber | NativeString;
+export type ComparableOperandInput = OperandInput<ComparableValue>;
+export type ComparableOperand = Operand<ComparableValue>;

package/lib/cjs/commands/expressions/{condition/comparisons/operand.js → comparisons/comparable.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=operand.js.map
+//# sourceMappingURL=comparable.js.map

package/lib/cjs/commands/expressions/comparisons/comparable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"comparable.js","sourceRoot":"","sources":["../../../../../src/commands/expressions/comparisons/comparable.ts"],"names":[],"mappings":""}

package/lib/cjs/commands/expressions/comparisons/equals.d.ts

@@ -0,0 +1,20 @@
+import { type Brand, type Phantom } from "@infra-blocks/types";
+import type { AttributeValue } from "../../../types.js";
+import type { ExpressionFormatter } from "../formatter.js";
+import { type Operand, type OperandInput } from "../operands/index.js";
+export type EqualsInput<OI extends OperandInput<AttributeValue> = OperandInput<AttributeValue>> = [OI, "=", OI];
+export declare function isEqualsInput<OI extends OperandInput<AttributeValue> = OperandInput<AttributeValue>>(value: unknown): value is EqualsInput<OI>;
+export type Equals<O extends Operand<AttributeValue> = Operand<AttributeValue>> = ExpressionFormatter & Brand<"Equals"> & Phantom<O>;
+export declare const Equals: {
+    /**
+     * Returns a condition that uses the `=` operator.
+     *
+     * @param input - The parameters of the `=` comparison. The first element contains the left-hand side operand,
+     * and the third element contains the right-hand side operand.
+     *
+     * @returns An {@link Equals} that evaluates to true if this operand is equal to the provided one.
+     *
+     * @see https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Comparators
+     */
+    from<O extends Operand<AttributeValue>, OI extends OperandInput<AttributeValue>>(input: EqualsInput<OI>): Equals<O>;
+};

package/lib/cjs/commands/expressions/{condition/comparisons → comparisons}/equals.js

@@ -3,7 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Equals = void 0;
 exports.isEqualsInput = isEqualsInput;
 const types_1 = require("@infra-blocks/types");
+const index_js_1 = require("../operands/index.js");
 const binary_js_1 = require("./binary.js");
+function isEqualsInput(value) {
+    return (Array.isArray(value) &&
+        value.length === 3 &&
+        (0, index_js_1.isOperandInput)(value[0]) &&
+        value[1] === "=" &&
+        (0, index_js_1.isOperandInput)(value[1]));
+}
 exports.Equals = {
     /**
      * Returns a condition that uses the `=` operator.
@@ -19,7 +27,4 @@ exports.Equals = {
         return (0, types_1.trusted)((0, binary_js_1.binaryOperation)(input));
     },
 };
-function isEqualsInput(value) {
-    return value[1] === "=";
-}
 //# sourceMappingURL=equals.js.map

package/lib/cjs/commands/expressions/comparisons/equals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"equals.js","sourceRoot":"","sources":["../../../../../src/commands/expressions/comparisons/equals.ts"],"names":[],"mappings":";;;AAcA,sCAUC;AAxBD,+CAAwE;AAGxE,mDAI8B;AAC9B,2CAA8C;AAM9C,SAAgB,aAAa,CAE3B,KAAc;IACd,OAAO,CACL,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QACpB,KAAK,CAAC,MAAM,KAAK,CAAC;QAClB,IAAA,yBAAc,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACxB,KAAK,CAAC,CAAC,CAAC,KAAK,GAAG;QAChB,IAAA,yBAAc,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CACzB,CAAC;AACJ,CAAC;AAMY,QAAA,MAAM,GAAG;IACpB;;;;;;;;;OASG;IACH,IAAI,CAGF,KAAsB;QACtB,OAAO,IAAA,eAAO,EAAC,IAAA,2BAAe,EAAC,KAAK,CAAC,CAAC,CAAC;IACzC,CAAC;CACF,CAAC"}

package/lib/cjs/commands/expressions/comparisons/greater-than-or-equals.d.ts

@@ -0,0 +1,20 @@
+import { type Brand, type Phantom } from "@infra-blocks/types";
+import type { ExpressionFormatter } from "../formatter.js";
+import { type Operand, type OperandInput } from "../operands/index.js";
+import type { ComparableValue } from "./comparable.js";
+export type GreaterThanOrEqualsInput<OI extends OperandInput<ComparableValue> = OperandInput<ComparableValue>> = [OI, ">=", OI];
+export declare function isGreaterThanOrEqualsInput<OI extends OperandInput<ComparableValue> = OperandInput<ComparableValue>>(value: unknown): value is GreaterThanOrEqualsInput<OI>;
+export type GreaterThanOrEquals<O extends Operand<ComparableValue> = Operand<ComparableValue>> = ExpressionFormatter & Brand<"GreaterThanOrEquals"> & Phantom<O>;
+export declare const GreaterThanOrEquals: {
+    /**
+     * Returns a condition that uses the `>=` operator.
+     *
+     * @param input - The parameters of the `>=` comparison. The first element contains the left-hand side operand,
+     * the third element contains the right-hand side operand.
+     *
+     * @returns A {@link GreaterThanOrEquals} that evaluates to true if this operand is greater than or equal to the provided one.
+     *
+     * @see https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Comparators
+     */
+    from<OI extends OperandInput<ComparableValue> = OperandInput<ComparableValue>, O extends Operand<ComparableValue> = Operand<ComparableValue>>(input: GreaterThanOrEqualsInput<OI>): GreaterThanOrEquals<O>;
+};

package/lib/cjs/commands/expressions/{condition/comparisons → comparisons}/greater-than-or-equals.js

@@ -3,7 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GreaterThanOrEquals = void 0;
 exports.isGreaterThanOrEqualsInput = isGreaterThanOrEqualsInput;
 const types_1 = require("@infra-blocks/types");
+const index_js_1 = require("../operands/index.js");
 const binary_js_1 = require("./binary.js");
+function isGreaterThanOrEqualsInput(value) {
+    return (Array.isArray(value) &&
+        value.length === 3 &&
+        (0, index_js_1.isOperandInput)(value[0]) &&
+        value[1] === ">=" &&
+        (0, index_js_1.isOperandInput)(value[1]));
+}
 exports.GreaterThanOrEquals = {
     /**
      * Returns a condition that uses the `>=` operator.
@@ -19,7 +27,4 @@ exports.GreaterThanOrEquals = {
         return (0, types_1.trusted)((0, binary_js_1.binaryOperation)(input));
     },
 };
-function isGreaterThanOrEqualsInput(value) {
-    return value[1] === ">=";
-}
 //# sourceMappingURL=greater-than-or-equals.js.map

package/lib/cjs/commands/expressions/comparisons/greater-than-or-equals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"greater-than-or-equals.js","sourceRoot":"","sources":["../../../../../src/commands/expressions/comparisons/greater-than-or-equals.ts"],"names":[],"mappings":";;;AAcA,gEAUC;AAxBD,+CAAwE;AAExE,mDAI8B;AAC9B,2CAA8C;AAO9C,SAAgB,0BAA0B,CAExC,KAAc;IACd,OAAO,CACL,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QACpB,KAAK,CAAC,MAAM,KAAK,CAAC;QAClB,IAAA,yBAAc,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACxB,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI;QACjB,IAAA,yBAAc,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CACzB,CAAC;AACJ,CAAC;AAMY,QAAA,mBAAmB,GAAG;IACjC;;;;;;;;;OASG;IACH,IAAI,CAGF,KAAmC;QACnC,OAAO,IAAA,eAAO,EAAC,IAAA,2BAAe,EAAC,KAAK,CAAC,CAAC,CAAC;IACzC,CAAC;CACF,CAAC"}

package/lib/cjs/commands/expressions/comparisons/greater-than.d.ts

@@ -0,0 +1,20 @@
+import { type Brand, type Phantom } from "@infra-blocks/types";
+import type { ExpressionFormatter } from "../formatter.js";
+import { type Operand, type OperandInput } from "../operands/index.js";
+import type { ComparableValue } from "./comparable.js";
+export type GreaterThanInput<OI extends OperandInput<ComparableValue> = OperandInput<ComparableValue>> = [OI, ">", OI];
+export declare function isGreaterThanInput<OI extends OperandInput<ComparableValue> = OperandInput<ComparableValue>>(value: unknown): value is GreaterThanInput<OI>;
+export type GreaterThan<O extends Operand<ComparableValue> = Operand<ComparableValue>> = ExpressionFormatter & Brand<"GreaterThan"> & Phantom<O>;
+export declare const GreaterThan: {
+    /**
+     * Returns a condition that uses the `>` operator.
+     *
+     * @param input - The parameters of the `>` comparison. The first element contains the left-hand side operand,
+     * the third element contains the right-hand side operand.
+     *
+     * @returns A {@link GreaterThan} that evaluates to true if this operand is greater than or equal to the provided one.
+     *
+     * @see https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Comparators
+     */
+    from<OI extends OperandInput<ComparableValue> = OperandInput<ComparableValue>, O extends Operand<ComparableValue> = Operand<ComparableValue>>(input: GreaterThanInput<OI>): GreaterThan<O>;
+};

package/lib/cjs/commands/expressions/{condition/comparisons → comparisons}/greater-than.js

@@ -1,17 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GreatThan = void 0;
+exports.GreaterThan = void 0;
 exports.isGreaterThanInput = isGreaterThanInput;
 const types_1 = require("@infra-blocks/types");
+const index_js_1 = require("../operands/index.js");
 const binary_js_1 = require("./binary.js");
-exports.GreatThan = {
+function isGreaterThanInput(value) {
+    return (Array.isArray(value) &&
+        value.length === 3 &&
+        (0, index_js_1.isOperandInput)(value[0]) &&
+        value[1] === ">" &&
+        (0, index_js_1.isOperandInput)(value[1]));
+}
+exports.GreaterThan = {
     /**
      * Returns a condition that uses the `>` operator.
      *
      * @param input - The parameters of the `>` comparison. The first element contains the left-hand side operand,
      * the third element contains the right-hand side operand.
      *
-     * @returns A {@link GreaterThan} that evaluates to true if this operand is greater than the provided one.
+     * @returns A {@link GreaterThan} that evaluates to true if this operand is greater than or equal to the provided one.
      *
      * @see https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Comparators
      */
@@ -19,7 +27,4 @@ exports.GreatThan = {
         return (0, types_1.trusted)((0, binary_js_1.binaryOperation)(input));
     },
 };
-function isGreaterThanInput(value) {
-    return value[1] === ">";
-}
 //# sourceMappingURL=greater-than.js.map

package/lib/cjs/commands/expressions/comparisons/greater-than.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"greater-than.js","sourceRoot":"","sources":["../../../../../src/commands/expressions/comparisons/greater-than.ts"],"names":[],"mappings":";;;AAcA,gDAUC;AAxBD,+CAAwE;AAExE,mDAI8B;AAC9B,2CAA8C;AAO9C,SAAgB,kBAAkB,CAEhC,KAAc;IACd,OAAO,CACL,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QACpB,KAAK,CAAC,MAAM,KAAK,CAAC;QAClB,IAAA,yBAAc,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACxB,KAAK,CAAC,CAAC,CAAC,KAAK,GAAG;QAChB,IAAA,yBAAc,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CACzB,CAAC;AACJ,CAAC;AAMY,QAAA,WAAW,GAAG;IACzB;;;;;;;;;OASG;IACH,IAAI,CAGF,KAA2B;QAC3B,OAAO,IAAA,eAAO,EAAC,IAAA,2BAAe,EAAC,KAAK,CAAC,CAAC,CAAC;IACzC,CAAC;CACF,CAAC"}

package/lib/cjs/commands/expressions/comparisons/in.d.ts

@@ -0,0 +1,22 @@
+import { type Brand, type Phantom } from "@infra-blocks/types";
+import { ExpressionFormatter } from "../formatter.js";
+import { Operand, type OperandInput } from "../operands/operand.js";
+import type { ComparableValue } from "./comparable.js";
+export type InInput<OI extends OperandInput<ComparableValue> = OperandInput<ComparableValue>> = [OI, "IN", OI[]];
+export declare function isInInput<OI extends OperandInput<ComparableValue> = OperandInput<ComparableValue>>(value: unknown): value is InInput<OI>;
+export type In<O extends Operand<ComparableValue> = Operand<ComparableValue>> = ExpressionFormatter & Brand<"In"> & Phantom<O>;
+export declare const In: {
+    /**
+     * Returns a condition that uses the `IN` operator.
+     *
+     * This function throws if the list of elements to compared against is empty or exceeds 100 elements.
+     *
+     * @param input - The parameters of the `IN` comparison. The first element contains the left-hand side operand,
+     * the third element contains the list of elements to compare against.
+     *
+     * @returns An {@link In} that evaluates to true if this operand is equal to any of the provided ones.
+     *
+     * @see https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Comparators
+     */
+    from<O extends Operand<ComparableValue> = Operand<ComparableValue>, OI extends OperandInput<ComparableValue> = OperandInput<ComparableValue>>(input: InInput<OI>): In<O>;
+};

package/lib/cjs/commands/expressions/{condition/comparisons → comparisons}/in.js

@@ -3,8 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.In = void 0;
 exports.isInInput = isInInput;
 const types_1 = require("@infra-blocks/types");
-const formatter_js_1 = require("../../formatter.js");
-const operand_js_1 = require("../operand.js");
+const formatter_js_1 = require("../formatter.js");
+const operand_js_1 = require("../operands/operand.js");
+function isInInput(value) {
+    return (Array.isArray(value) &&
+        value.length === 3 &&
+        (0, operand_js_1.isOperandInput)(value[0]) &&
+        value[1] === "IN" &&
+        (0, operand_js_1.isOperandInput)(value[1]));
+}
 exports.In = {
     /**
      * Returns a condition that uses the `IN` operator.
@@ -21,22 +28,18 @@ exports.In = {
     from(input) {
         // TODO: unit test those limits
         if (input[2].length === 0) {
-            throw new Error("the IN operator requires at least one operand.");
+            throw new Error("the IN operator requires at least one value in rhs operand.");
         }
         if (input[2].length > 100) {
-            throw new Error(`up to 100 operands are support for the IN operator, got ${input[2].length}`);
+            throw new Error(`up to 100 values are support for the rhs operand of the IN operator, got ${input[2].length}`);
         }
-        const element = operand_js_1.ConditionOperand.normalize(input[0]);
-        const elements = input[2].map((operand_js_1.ConditionOperand.normalize));
+        const element = operand_js_1.Operand.normalize(input[0]);
+        const elements = input[2].map((operand_js_1.Operand.normalize));
         return (0, types_1.trusted)(formatter_js_1.ExpressionFormatter.from(({ names, values }) => {
-            const elementsString = elements
+            return `${element.format({ names, values })} IN (${elements
                 .map((operand) => operand.format({ names, values }))
-                .join(",");
-            return `${element.format({ names, values })} IN (${elementsString})`;
+                .join(",")})`;
         }));
     },
 };
-function isInInput(value) {
-    return value[1] === "IN";
-}
 //# sourceMappingURL=in.js.map

package/lib/cjs/commands/expressions/comparisons/in.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"in.js","sourceRoot":"","sources":["../../../../../src/commands/expressions/comparisons/in.ts"],"names":[],"mappings":";;;AAaA,8BAUC;AAvBD,+CAAwE;AACxE,kDAAsD;AACtD,uDAIgC;AAOhC,SAAgB,SAAS,CAEvB,KAAc;IACd,OAAO,CACL,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QACpB,KAAK,CAAC,MAAM,KAAK,CAAC;QAClB,IAAA,2BAAc,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACxB,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI;QACjB,IAAA,2BAAc,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CACzB,CAAC;AACJ,CAAC;AAKY,QAAA,EAAE,GAAG;IAChB;;;;;;;;;;;OAWG;IACH,IAAI,CAGF,KAAkB;QAClB,+BAA+B;QAC/B,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CACb,6DAA6D,CAC9D,CAAC;QACJ,CAAC;QACD,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,GAAG,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CACb,4EAA4E,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAC9F,CAAC;QACJ,CAAC;QAED,MAAM,OAAO,GAAG,oBAAO,CAAC,SAAS,CAAkB,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7D,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA,oBAAO,CAAC,SAA0B,CAAA,CAAC,CAAC;QAClE,OAAO,IAAA,eAAO,EACZ,kCAAmB,CAAC,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE;YAC7C,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,QAAQ,QAAQ;iBACxD,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;iBACnD,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;QAClB,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;CACF,CAAC"}

package/lib/cjs/commands/expressions/comparisons/index.d.ts

@@ -0,0 +1,29 @@
+import { Between, type BetweenInput } from "./between.js";
+import { Equals, type EqualsInput } from "./equals.js";
+import { GreaterThan, type GreaterThanInput } from "./greater-than.js";
+import { GreaterThanOrEquals, type GreaterThanOrEqualsInput } from "./greater-than-or-equals.js";
+import { In, type InInput } from "./in.js";
+import { LowerThan, type LowerThanInput } from "./lower-than.js";
+import { LowerThanOrEquals, type LowerThanOrEqualsInput } from "./lower-than-or-equals.js";
+import { NotEquals, type NotEqualsInput } from "./not-equals.js";
+export * from "./between.js";
+export * from "./comparable.js";
+export * from "./equals.js";
+export * from "./greater-than.js";
+export * from "./greater-than-or-equals.js";
+export * from "./in.js";
+export * from "./lower-than.js";
+export * from "./lower-than-or-equals.js";
+export * from "./not-equals.js";
+/**
+ * A type aggregating anything that can be turned into a comparison.
+ */
+export type ComparisonInput = BetweenInput | EqualsInput | GreaterThanInput | GreaterThanOrEqualsInput | InInput | LowerThanInput | LowerThanOrEqualsInput | NotEqualsInput;
+export declare function isComparisonInput(value: unknown): value is ComparisonInput;
+/**
+ * A type aggregating all comparisons.
+ */
+export type Comparison = Between | Equals | GreaterThan | GreaterThanOrEquals | In | LowerThan | LowerThanOrEquals | NotEquals;
+export declare const Comparison: {
+    from(input: ComparisonInput): Comparison;
+};

package/lib/cjs/commands/expressions/comparisons/index.js

@@ -0,0 +1,76 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Comparison = void 0;
+exports.isComparisonInput = isComparisonInput;
+const types_1 = require("@infra-blocks/types");
+const between_js_1 = require("./between.js");
+const equals_js_1 = require("./equals.js");
+const greater_than_js_1 = require("./greater-than.js");
+const greater_than_or_equals_js_1 = require("./greater-than-or-equals.js");
+const in_js_1 = require("./in.js");
+const lower_than_js_1 = require("./lower-than.js");
+const lower_than_or_equals_js_1 = require("./lower-than-or-equals.js");
+const not_equals_js_1 = require("./not-equals.js");
+__exportStar(require("./between.js"), exports);
+__exportStar(require("./comparable.js"), exports);
+__exportStar(require("./equals.js"), exports);
+__exportStar(require("./greater-than.js"), exports);
+__exportStar(require("./greater-than-or-equals.js"), exports);
+__exportStar(require("./in.js"), exports);
+__exportStar(require("./lower-than.js"), exports);
+__exportStar(require("./lower-than-or-equals.js"), exports);
+__exportStar(require("./not-equals.js"), exports);
+function isComparisonInput(value) {
+    return ((0, between_js_1.isBetweenInput)(value) ||
+        (0, equals_js_1.isEqualsInput)(value) ||
+        (0, greater_than_js_1.isGreaterThanInput)(value) ||
+        (0, greater_than_or_equals_js_1.isGreaterThanOrEqualsInput)(value) ||
+        (0, in_js_1.isInInput)(value) ||
+        (0, lower_than_js_1.isLowerThanInput)(value) ||
+        (0, lower_than_or_equals_js_1.isLowerThanOrEqualsInput)(value) ||
+        (0, not_equals_js_1.isNotEqualsInput)(value));
+}
+exports.Comparison = {
+    from(input) {
+        if ((0, between_js_1.isBetweenInput)(input)) {
+            return between_js_1.Between.from(input);
+        }
+        if ((0, equals_js_1.isEqualsInput)(input)) {
+            return equals_js_1.Equals.from(input);
+        }
+        if ((0, greater_than_js_1.isGreaterThanInput)(input)) {
+            return greater_than_js_1.GreaterThan.from(input);
+        }
+        if ((0, greater_than_or_equals_js_1.isGreaterThanOrEqualsInput)(input)) {
+            return greater_than_or_equals_js_1.GreaterThanOrEquals.from(input);
+        }
+        if ((0, in_js_1.isInInput)(input)) {
+            return in_js_1.In.from(input);
+        }
+        if ((0, lower_than_js_1.isLowerThanInput)(input)) {
+            return lower_than_js_1.LowerThan.from(input);
+        }
+        if ((0, lower_than_or_equals_js_1.isLowerThanOrEqualsInput)(input)) {
+            return lower_than_or_equals_js_1.LowerThanOrEquals.from(input);
+        }
+        if ((0, not_equals_js_1.isNotEqualsInput)(input)) {
+            return not_equals_js_1.NotEquals.from(input);
+        }
+        (0, types_1.unreachable)(input);
+    },
+};
+//# sourceMappingURL=index.js.map

package/lib/cjs/commands/expressions/comparisons/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/commands/expressions/comparisons/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAsDA,8CAWC;AAjED,+CAAkD;AAClD,6CAA0E;AAC1E,2CAAsE;AACtE,uDAI2B;AAC3B,2EAIqC;AACrC,mCAAsD;AACtD,mDAIyB;AACzB,uEAImC;AACnC,mDAIyB;AAEzB,+CAA6B;AAC7B,kDAAgC;AAChC,8CAA4B;AAC5B,oDAAkC;AAClC,8DAA4C;AAC5C,0CAAwB;AACxB,kDAAgC;AAChC,4DAA0C;AAC1C,kDAAgC;AAgBhC,SAAgB,iBAAiB,CAAC,KAAc;IAC9C,OAAO,CACL,IAAA,2BAAc,EAAC,KAAK,CAAC;QACrB,IAAA,yBAAa,EAAC,KAAK,CAAC;QACpB,IAAA,oCAAkB,EAAC,KAAK,CAAC;QACzB,IAAA,sDAA0B,EAAC,KAAK,CAAC;QACjC,IAAA,iBAAS,EAAC,KAAK,CAAC;QAChB,IAAA,gCAAgB,EAAC,KAAK,CAAC;QACvB,IAAA,kDAAwB,EAAC,KAAK,CAAC;QAC/B,IAAA,gCAAgB,EAAC,KAAK,CAAC,CACxB,CAAC;AACJ,CAAC;AAeY,QAAA,UAAU,GAAG;IACxB,IAAI,CAAC,KAAsB;QACzB,IAAI,IAAA,2BAAc,EAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,oBAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC7B,CAAC;QACD,IAAI,IAAA,yBAAa,EAAC,KAAK,CAAC,EAAE,CAAC;YACzB,OAAO,kBAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC5B,CAAC;QACD,IAAI,IAAA,oCAAkB,EAAC,KAAK,CAAC,EAAE,CAAC;YAC9B,OAAO,6BAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACjC,CAAC;QACD,IAAI,IAAA,sDAA0B,EAAC,KAAK,CAAC,EAAE,CAAC;YACtC,OAAO,+CAAmB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACzC,CAAC;QACD,IAAI,IAAA,iBAAS,EAAC,KAAK,CAAC,EAAE,CAAC;YACrB,OAAO,UAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACxB,CAAC;QACD,IAAI,IAAA,gCAAgB,EAAC,KAAK,CAAC,EAAE,CAAC;YAC5B,OAAO,yBAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC/B,CAAC;QACD,IAAI,IAAA,kDAAwB,EAAC,KAAK,CAAC,EAAE,CAAC;YACpC,OAAO,2CAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACvC,CAAC;QACD,IAAI,IAAA,gCAAgB,EAAC,KAAK,CAAC,EAAE,CAAC;YAC5B,OAAO,yBAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC/B,CAAC;QACD,IAAA,mBAAW,EAAC,KAAK,CAAC,CAAC;IACrB,CAAC;CACF,CAAC"}

package/lib/cjs/commands/expressions/comparisons/lower-than-or-equals.d.ts

@@ -0,0 +1,20 @@
+import { type Brand, type Phantom } from "@infra-blocks/types";
+import type { ExpressionFormatter } from "../formatter.js";
+import { type Operand, type OperandInput } from "../operands/index.js";
+import type { ComparableValue } from "./comparable.js";
+export type LowerThanOrEqualsInput<OI extends OperandInput<ComparableValue> = OperandInput<ComparableValue>> = [OI, "<=", OI];
+export declare function isLowerThanOrEqualsInput<OI extends OperandInput<ComparableValue> = OperandInput<ComparableValue>>(value: unknown): value is LowerThanOrEqualsInput<OI>;
+export type LowerThanOrEquals<O extends Operand<ComparableValue> = Operand<ComparableValue>> = ExpressionFormatter & Brand<"LowerThanOrEquals"> & Phantom<O>;
+export declare const LowerThanOrEquals: {
+    /**
+     * Returns a condition that uses the `>` operator.
+     *
+     * @param input - The parameters of the `>` comparison. The first element contains the left-hand side operand,
+     * the third element contains the right-hand side operand.
+     *
+     * @returns A {@link LowerThanOrEquals} that evaluates to true if this operand is lower than or equal to the provided one.
+     *
+     * @see https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Comparators
+     */
+    from<OI extends OperandInput<ComparableValue> = OperandInput<ComparableValue>, O extends Operand<ComparableValue> = Operand<ComparableValue>>(input: LowerThanOrEqualsInput<OI>): LowerThanOrEquals<O>;
+};

package/lib/cjs/commands/expressions/{condition/comparisons → comparisons}/lower-than-or-equals.js

@@ -3,12 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LowerThanOrEquals = void 0;
 exports.isLowerThanOrEqualsInput = isLowerThanOrEqualsInput;
 const types_1 = require("@infra-blocks/types");
+const index_js_1 = require("../operands/index.js");
 const binary_js_1 = require("./binary.js");
+function isLowerThanOrEqualsInput(value) {
+    return (Array.isArray(value) &&
+        value.length === 3 &&
+        (0, index_js_1.isOperandInput)(value[0]) &&
+        value[1] === "<=" &&
+        (0, index_js_1.isOperandInput)(value[1]));
+}
 exports.LowerThanOrEquals = {
     /**
-     * Returns a condition that uses the `<=` operator.
+     * Returns a condition that uses the `>` operator.
      *
-     * @param input - The parameters of the `<=` comparison. The first element contains the left-hand side operand,
+     * @param input - The parameters of the `>` comparison. The first element contains the left-hand side operand,
      * the third element contains the right-hand side operand.
      *
      * @returns A {@link LowerThanOrEquals} that evaluates to true if this operand is lower than or equal to the provided one.
@@ -19,7 +27,4 @@ exports.LowerThanOrEquals = {
         return (0, types_1.trusted)((0, binary_js_1.binaryOperation)(input));
     },
 };
-function isLowerThanOrEqualsInput(value) {
-    return value[1] === "<=";
-}
 //# sourceMappingURL=lower-than-or-equals.js.map

package/lib/cjs/commands/expressions/comparisons/lower-than-or-equals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lower-than-or-equals.js","sourceRoot":"","sources":["../../../../../src/commands/expressions/comparisons/lower-than-or-equals.ts"],"names":[],"mappings":";;;AAcA,4DAUC;AAxBD,+CAAwE;AAExE,mDAI8B;AAC9B,2CAA8C;AAO9C,SAAgB,wBAAwB,CAEtC,KAAc;IACd,OAAO,CACL,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QACpB,KAAK,CAAC,MAAM,KAAK,CAAC;QAClB,IAAA,yBAAc,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACxB,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI;QACjB,IAAA,yBAAc,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CACzB,CAAC;AACJ,CAAC;AAMY,QAAA,iBAAiB,GAAG;IAC/B;;;;;;;;;OASG;IACH,IAAI,CAGF,KAAiC;QACjC,OAAO,IAAA,eAAO,EAAC,IAAA,2BAAe,EAAC,KAAK,CAAC,CAAC,CAAC;IACzC,CAAC;CACF,CAAC"}

package/lib/cjs/commands/expressions/comparisons/lower-than.d.ts

@@ -0,0 +1,20 @@
+import { type Brand, type Phantom } from "@infra-blocks/types";
+import type { ExpressionFormatter } from "../formatter.js";
+import { type Operand, type OperandInput } from "../operands/index.js";
+import type { ComparableValue } from "./comparable.js";
+export type LowerThanInput<OI extends OperandInput<ComparableValue> = OperandInput<ComparableValue>> = [OI, "<", OI];
+export declare function isLowerThanInput<OI extends OperandInput<ComparableValue> = OperandInput<ComparableValue>>(value: unknown): value is LowerThanInput<OI>;
+export type LowerThan<O extends Operand<ComparableValue> = Operand<ComparableValue>> = ExpressionFormatter & Brand<"LowerThan"> & Phantom<O>;
+export declare const LowerThan: {
+    /**
+     * Returns a condition that uses the `>` operator.
+     *
+     * @param input - The parameters of the `>` comparison. The first element contains the left-hand side operand,
+     * the third element contains the right-hand side operand.
+     *
+     * @returns A {@link LowerThan} that evaluates to true if this operand is lower than or equal to the provided one.
+     *
+     * @see https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Comparators
+     */
+    from<OI extends OperandInput<ComparableValue> = OperandInput<ComparableValue>, O extends Operand<ComparableValue> = Operand<ComparableValue>>(input: LowerThanInput<OI>): LowerThan<O>;
+};

package/lib/cjs/commands/expressions/{condition/comparisons → comparisons}/lower-than.js

@@ -3,15 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LowerThan = void 0;
 exports.isLowerThanInput = isLowerThanInput;
 const types_1 = require("@infra-blocks/types");
+const index_js_1 = require("../operands/index.js");
 const binary_js_1 = require("./binary.js");
+function isLowerThanInput(value) {
+    return (Array.isArray(value) &&
+        value.length === 3 &&
+        (0, index_js_1.isOperandInput)(value[0]) &&
+        value[1] === "<" &&
+        (0, index_js_1.isOperandInput)(value[1]));
+}
 exports.LowerThan = {
     /**
-     * Returns a condition that uses the `<` operator
+     * Returns a condition that uses the `>` operator.
      *
-     * @param input - The parameters of the `<` comparison. The first element contains the left-hand side operand,
+     * @param input - The parameters of the `>` comparison. The first element contains the left-hand side operand,
      * the third element contains the right-hand side operand.
      *
-     * @returns A {@link LowerThan} that evaluates to true if this operand is lower than the provided one.
+     * @returns A {@link LowerThan} that evaluates to true if this operand is lower than or equal to the provided one.
      *
      * @see https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Comparators
      */
@@ -19,7 +27,4 @@ exports.LowerThan = {
         return (0, types_1.trusted)((0, binary_js_1.binaryOperation)(input));
     },
 };
-function isLowerThanInput(value) {
-    return value[1] === "<";
-}
 //# sourceMappingURL=lower-than.js.map

package/lib/cjs/commands/expressions/comparisons/lower-than.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lower-than.js","sourceRoot":"","sources":["../../../../../src/commands/expressions/comparisons/lower-than.ts"],"names":[],"mappings":";;;AAcA,4CAUC;AAxBD,+CAAwE;AAExE,mDAI8B;AAC9B,2CAA8C;AAO9C,SAAgB,gBAAgB,CAE9B,KAAc;IACd,OAAO,CACL,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QACpB,KAAK,CAAC,MAAM,KAAK,CAAC;QAClB,IAAA,yBAAc,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACxB,KAAK,CAAC,CAAC,CAAC,KAAK,GAAG;QAChB,IAAA,yBAAc,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CACzB,CAAC;AACJ,CAAC;AAMY,QAAA,SAAS,GAAG;IACvB;;;;;;;;;OASG;IACH,IAAI,CAGF,KAAyB;QACzB,OAAO,IAAA,eAAO,EAAC,IAAA,2BAAe,EAAC,KAAK,CAAC,CAAC,CAAC;IACzC,CAAC;CACF,CAAC"}

package/lib/cjs/commands/expressions/comparisons/not-equals.d.ts

@@ -0,0 +1,20 @@
+import { type Brand, type Phantom } from "@infra-blocks/types";
+import type { AttributeValue } from "../../../types.js";
+import type { ExpressionFormatter } from "../formatter.js";
+import { type Operand, type OperandInput } from "../operands/index.js";
+export type NotEqualsInput<OI extends OperandInput<AttributeValue> = OperandInput<AttributeValue>> = [OI, "<>", OI];
+export declare function isNotEqualsInput<OI extends OperandInput<AttributeValue> = OperandInput<AttributeValue>>(value: unknown): value is NotEqualsInput<OI>;
+export type NotEquals<O extends Operand<AttributeValue> = Operand<AttributeValue>> = ExpressionFormatter & Brand<"NotEquals"> & Phantom<O>;
+export declare const NotEquals: {
+    /**
+     * Returns a condition that uses the `=` operator.
+     *
+     * @param input - The parameters of the `=` comparison. The first element contains the left-hand side operand,
+     * and the third element contains the right-hand side operand.
+     *
+     * @returns An {@link NotEquals} that evaluates to true if this operand is equal to the provided one.
+     *
+     * @see https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Comparators
+     */
+    from<O extends Operand<AttributeValue>, OI extends OperandInput<AttributeValue>>(input: NotEqualsInput<OI>): NotEquals<O>;
+};