@cipherstash/protect-ffi 0.27.0 → 0.29.0

package/lib/bigintWire.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Internal wire encoding for JS `bigint` plaintexts crossing the Neon
+ * boundary.
+ *
+ * The native addon extracts every options object with neon's `Json`
+ * extractor, which runs `JSON.stringify` on the JS side — and
+ * `JSON.stringify` throws a `TypeError` on any `bigint`. So `bigint`
+ * plaintexts are bounds-checked against i64 here (with a clear
+ * `RangeError`) and encoded into the tagged single-key map
+ * `{"__protect_ffi_bigint__": "<decimal string>"}`, which the Rust side
+ * deserializes into `JsPlaintext::BigInt`. The value is a decimal string,
+ * not a number: an i64-magnitude number literal would already have lost
+ * precision beyond 2^53.
+ *
+ * The wasm build performs the equivalent encoding in Rust
+ * (`encode_plaintext` in `crates/protect-ffi/src/wasm.rs`) because
+ * wasm consumers call the wasm-bindgen exports directly, without this
+ * wrapper.
+ *
+ * The decrypt direction needs no decoding: the native addon constructs a
+ * real JS `bigint` (`JsBigInt::from_i64` on Neon, `js_sys::BigInt` on
+ * wasm).
+ */
+/** Must match `BIGINT_WIRE_KEY` in `crates/protect-ffi/src/js_plaintext.rs`. */
+export declare const BIGINT_WIRE_KEY = "__protect_ffi_bigint__";
+/** Smallest value an encrypted bigint column can store (i64::MIN). */
+export declare const BIGINT_MIN: bigint;
+/** Largest value an encrypted bigint column can store (i64::MAX). */
+export declare const BIGINT_MAX: bigint;
+/** The tagged wire form a `bigint` plaintext crosses the boundary in. */
+export type BigIntWire = {
+    [K in typeof BIGINT_WIRE_KEY]: string;
+};
+/**
+ * Encode a `bigint` plaintext into its tagged wire form, throwing a
+ * `RangeError` (naming the i64 bounds and the offending direction) when
+ * the value does not fit a signed 64-bit integer. Non-`bigint` values pass
+ * through untouched. The error deliberately does not echo the value: it is
+ * plaintext being encrypted.
+ */
+export declare function encodeBigIntPlaintext<T>(plaintext: T | bigint): T | BigIntWire;
+/**
+ * Return `opts` with a `bigint` `plaintext` replaced by its tagged wire
+ * form. When the plaintext is not a `bigint`, the original object is
+ * returned unchanged (no clone).
+ */
+export declare function withEncodedPlaintext<T extends {
+    plaintext: unknown;
+}>(opts: T): T;
+/**
+ * Bulk variant of {@link withEncodedPlaintext}: returns the original array
+ * (no clone) when no payload carries a `bigint` plaintext.
+ */
+export declare function withEncodedPlaintexts<T extends {
+    plaintext: unknown;
+}>(payloads: T[]): T[];

package/lib/bigintWire.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * Internal wire encoding for JS `bigint` plaintexts crossing the Neon
+ * boundary.
+ *
+ * The native addon extracts every options object with neon's `Json`
+ * extractor, which runs `JSON.stringify` on the JS side — and
+ * `JSON.stringify` throws a `TypeError` on any `bigint`. So `bigint`
+ * plaintexts are bounds-checked against i64 here (with a clear
+ * `RangeError`) and encoded into the tagged single-key map
+ * `{"__protect_ffi_bigint__": "<decimal string>"}`, which the Rust side
+ * deserializes into `JsPlaintext::BigInt`. The value is a decimal string,
+ * not a number: an i64-magnitude number literal would already have lost
+ * precision beyond 2^53.
+ *
+ * The wasm build performs the equivalent encoding in Rust
+ * (`encode_plaintext` in `crates/protect-ffi/src/wasm.rs`) because
+ * wasm consumers call the wasm-bindgen exports directly, without this
+ * wrapper.
+ *
+ * The decrypt direction needs no decoding: the native addon constructs a
+ * real JS `bigint` (`JsBigInt::from_i64` on Neon, `js_sys::BigInt` on
+ * wasm).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BIGINT_MAX = exports.BIGINT_MIN = exports.BIGINT_WIRE_KEY = void 0;
+exports.encodeBigIntPlaintext = encodeBigIntPlaintext;
+exports.withEncodedPlaintext = withEncodedPlaintext;
+exports.withEncodedPlaintexts = withEncodedPlaintexts;
+/** Must match `BIGINT_WIRE_KEY` in `crates/protect-ffi/src/js_plaintext.rs`. */
+exports.BIGINT_WIRE_KEY = '__protect_ffi_bigint__';
+/** Smallest value an encrypted bigint column can store (i64::MIN). */
+exports.BIGINT_MIN = -(2n ** 63n);
+/** Largest value an encrypted bigint column can store (i64::MAX). */
+exports.BIGINT_MAX = 2n ** 63n - 1n;
+const I64_BOUNDS_SUFFIX = 'encrypted bigint values must fit in a signed 64-bit integer ' +
+    '(-9223372036854775808 to 9223372036854775807)';
+/**
+ * Encode a `bigint` plaintext into its tagged wire form, throwing a
+ * `RangeError` (naming the i64 bounds and the offending direction) when
+ * the value does not fit a signed 64-bit integer. Non-`bigint` values pass
+ * through untouched. The error deliberately does not echo the value: it is
+ * plaintext being encrypted.
+ */
+function encodeBigIntPlaintext(plaintext) {
+    if (typeof plaintext !== 'bigint') {
+        return plaintext;
+    }
+    if (plaintext > exports.BIGINT_MAX) {
+        throw new RangeError(`BigInt plaintext is above the maximum supported value: ${I64_BOUNDS_SUFFIX}`);
+    }
+    if (plaintext < exports.BIGINT_MIN) {
+        throw new RangeError(`BigInt plaintext is below the minimum supported value: ${I64_BOUNDS_SUFFIX}`);
+    }
+    return { [exports.BIGINT_WIRE_KEY]: plaintext.toString() };
+}
+/**
+ * Return `opts` with a `bigint` `plaintext` replaced by its tagged wire
+ * form. When the plaintext is not a `bigint`, the original object is
+ * returned unchanged (no clone).
+ */
+function withEncodedPlaintext(opts) {
+    // `opts?.` (matching the detection pass in withEncodedPlaintexts): a
+    // null/undefined element must fall through to native's own validation
+    // error rather than throw a raw property-access TypeError here — the
+    // error a bad element produces must not depend on whether a *sibling*
+    // element happens to carry a bigint.
+    if (typeof opts?.plaintext !== 'bigint') {
+        return opts;
+    }
+    return { ...opts, plaintext: encodeBigIntPlaintext(opts.plaintext) };
+}
+/**
+ * Bulk variant of {@link withEncodedPlaintext}: returns the original array
+ * (no clone) when no payload carries a `bigint` plaintext.
+ */
+function withEncodedPlaintexts(payloads) {
+    if (!Array.isArray(payloads) ||
+        !payloads.some((p) => typeof p?.plaintext === 'bigint')) {
+        return payloads;
+    }
+    return payloads.map(withEncodedPlaintext);
+}

package/lib/eql-v3-types/Bigint.d.ts

@@ -2,7 +2,7 @@ import type { Ciphertext } from "./Ciphertext";
 import type { Identifier } from "./Identifier";
 import type { SchemaVersion } from "./SchemaVersion";
 /**
- * `eql_v3.bigint` — storage-only domain.
+ * `public.eql_v3_bigint` — storage-only domain.
  *
  * Operators: none. Required keys: `v` `i` `c`.
  */

package/lib/eql-v3-types/BigintEq.d.ts

@@ -3,7 +3,7 @@ import type { Hmac256 } from "./Hmac256";
 import type { Identifier } from "./Identifier";
 import type { SchemaVersion } from "./SchemaVersion";
 /**
- * `eql_v3.bigint_eq` — equality domain.
+ * `public.eql_v3_bigint_eq` — equality domain.
  *
  * Operators: `=` `<>`. Required keys: `v` `i` `c` `hm`.
  */

package/lib/eql-v3-types/BigintEqQuery.d.ts

@@ -0,0 +1,13 @@
+import type { Hmac256 } from "./Hmac256";
+import type { Identifier } from "./Identifier";
+import type { SchemaVersion } from "./SchemaVersion";
+/**
+ * `eql_v3.query_bigint_eq` — equality domain query operand.
+ *
+ * Operators: `=` `<>`. Required keys: `v` `i` `hm`.
+ */
+export type BigintEqQuery = {
+    v: SchemaVersion;
+    i: Identifier;
+    hm: Hmac256;
+};

package/lib/eql-v3-types/BigintEqQuery.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/eql-v3-types/BigintOrd.d.ts

@@ -1,15 +1,15 @@
 import type { Ciphertext } from "./Ciphertext";
 import type { Identifier } from "./Identifier";
-import type { OreBlock256 } from "./OreBlock256";
+import type { OpeCllw } from "./OpeCllw";
 import type { SchemaVersion } from "./SchemaVersion";
 /**
- * `eql_v3.bigint_ord` — ordering domain.
+ * `public.eql_v3_bigint_ord` — ordering domain.
  *
- * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `c` `ob`.
+ * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `c` `op`.
  */
 export type BigintOrd = {
     v: SchemaVersion;
     i: Identifier;
     c: Ciphertext;
-    ob: OreBlock256;
+    op: OpeCllw;
 };

package/lib/eql-v3-types/BigintOrdOpe.d.ts

@@ -3,7 +3,7 @@ import type { Identifier } from "./Identifier";
 import type { OpeCllw } from "./OpeCllw";
 import type { SchemaVersion } from "./SchemaVersion";
 /**
- * `eql_v3.bigint_ord_ope` — ordering domain.
+ * `public.eql_v3_bigint_ord_ope` — ordering domain.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `c` `op`.
  */

package/lib/eql-v3-types/BigintOrdOpeQuery.d.ts

@@ -0,0 +1,13 @@
+import type { Identifier } from "./Identifier";
+import type { OpeCllw } from "./OpeCllw";
+import type { SchemaVersion } from "./SchemaVersion";
+/**
+ * `eql_v3.query_bigint_ord_ope` — ordering domain query operand.
+ *
+ * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.
+ */
+export type BigintOrdOpeQuery = {
+    v: SchemaVersion;
+    i: Identifier;
+    op: OpeCllw;
+};

package/lib/eql-v3-types/BigintOrdOpeQuery.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/eql-v3-types/BigintOrdOre.d.ts

@@ -3,7 +3,7 @@ import type { Identifier } from "./Identifier";
 import type { OreBlock256 } from "./OreBlock256";
 import type { SchemaVersion } from "./SchemaVersion";
 /**
- * `eql_v3.bigint_ord_ore` — ordering domain.
+ * `public.eql_v3_bigint_ord_ore` — ordering domain.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `c` `ob`.
  */

package/lib/eql-v3-types/BigintOrdOreQuery.d.ts

@@ -0,0 +1,13 @@
+import type { Identifier } from "./Identifier";
+import type { OreBlock256 } from "./OreBlock256";
+import type { SchemaVersion } from "./SchemaVersion";
+/**
+ * `eql_v3.query_bigint_ord_ore` — ordering domain query operand.
+ *
+ * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
+ */
+export type BigintOrdOreQuery = {
+    v: SchemaVersion;
+    i: Identifier;
+    ob: OreBlock256;
+};

package/lib/eql-v3-types/BigintOrdOreQuery.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/eql-v3-types/BigintOrdQuery.d.ts

@@ -0,0 +1,13 @@
+import type { Identifier } from "./Identifier";
+import type { OpeCllw } from "./OpeCllw";
+import type { SchemaVersion } from "./SchemaVersion";
+/**
+ * `eql_v3.query_bigint_ord` — ordering domain query operand.
+ *
+ * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.
+ */
+export type BigintOrdQuery = {
+    v: SchemaVersion;
+    i: Identifier;
+    op: OpeCllw;
+};

package/lib/eql-v3-types/BigintOrdQuery.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/eql-v3-types/Boolean.d.ts

@@ -2,7 +2,7 @@ import type { Ciphertext } from "./Ciphertext";
 import type { Identifier } from "./Identifier";
 import type { SchemaVersion } from "./SchemaVersion";
 /**
- * `eql_v3.boolean` — storage-only domain.
+ * `public.eql_v3_boolean` — storage-only domain.
  *
  * Operators: none. Required keys: `v` `i` `c`.
  */

package/lib/eql-v3-types/Date.d.ts

@@ -2,7 +2,7 @@ import type { Ciphertext } from "./Ciphertext";
 import type { Identifier } from "./Identifier";
 import type { SchemaVersion } from "./SchemaVersion";
 /**
- * `eql_v3.date` — storage-only domain.
+ * `public.eql_v3_date` — storage-only domain.
  *
  * Operators: none. Required keys: `v` `i` `c`.
  */

package/lib/eql-v3-types/DateEq.d.ts

@@ -3,7 +3,7 @@ import type { Hmac256 } from "./Hmac256";
 import type { Identifier } from "./Identifier";
 import type { SchemaVersion } from "./SchemaVersion";
 /**
- * `eql_v3.date_eq` — equality domain.
+ * `public.eql_v3_date_eq` — equality domain.
  *
  * Operators: `=` `<>`. Required keys: `v` `i` `c` `hm`.
  */

package/lib/eql-v3-types/DateEqQuery.d.ts

@@ -0,0 +1,13 @@
+import type { Hmac256 } from "./Hmac256";
+import type { Identifier } from "./Identifier";
+import type { SchemaVersion } from "./SchemaVersion";
+/**
+ * `eql_v3.query_date_eq` — equality domain query operand.
+ *
+ * Operators: `=` `<>`. Required keys: `v` `i` `hm`.
+ */
+export type DateEqQuery = {
+    v: SchemaVersion;
+    i: Identifier;
+    hm: Hmac256;
+};

package/lib/eql-v3-types/DateEqQuery.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/eql-v3-types/DateOrd.d.ts

@@ -1,15 +1,15 @@
 import type { Ciphertext } from "./Ciphertext";
 import type { Identifier } from "./Identifier";
-import type { OreBlock256 } from "./OreBlock256";
+import type { OpeCllw } from "./OpeCllw";
 import type { SchemaVersion } from "./SchemaVersion";
 /**
- * `eql_v3.date_ord` — ordering domain.
+ * `public.eql_v3_date_ord` — ordering domain.
  *
- * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `c` `ob`.
+ * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `c` `op`.
  */
 export type DateOrd = {
     v: SchemaVersion;
     i: Identifier;
     c: Ciphertext;
-    ob: OreBlock256;
+    op: OpeCllw;
 };

package/lib/eql-v3-types/DateOrdOpe.d.ts

@@ -3,7 +3,7 @@ import type { Identifier } from "./Identifier";
 import type { OpeCllw } from "./OpeCllw";
 import type { SchemaVersion } from "./SchemaVersion";
 /**
- * `eql_v3.date_ord_ope` — ordering domain.
+ * `public.eql_v3_date_ord_ope` — ordering domain.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `c` `op`.
  */

package/lib/eql-v3-types/DateOrdOpeQuery.d.ts

@@ -0,0 +1,13 @@
+import type { Identifier } from "./Identifier";
+import type { OpeCllw } from "./OpeCllw";
+import type { SchemaVersion } from "./SchemaVersion";
+/**
+ * `eql_v3.query_date_ord_ope` — ordering domain query operand.
+ *
+ * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.
+ */
+export type DateOrdOpeQuery = {
+    v: SchemaVersion;
+    i: Identifier;
+    op: OpeCllw;
+};

package/lib/eql-v3-types/DateOrdOpeQuery.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/eql-v3-types/DateOrdOre.d.ts

@@ -3,7 +3,7 @@ import type { Identifier } from "./Identifier";
 import type { OreBlock256 } from "./OreBlock256";
 import type { SchemaVersion } from "./SchemaVersion";
 /**
- * `eql_v3.date_ord_ore` — ordering domain.
+ * `public.eql_v3_date_ord_ore` — ordering domain.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `c` `ob`.
  */

package/lib/eql-v3-types/DateOrdOreQuery.d.ts

@@ -0,0 +1,13 @@
+import type { Identifier } from "./Identifier";
+import type { OreBlock256 } from "./OreBlock256";
+import type { SchemaVersion } from "./SchemaVersion";
+/**
+ * `eql_v3.query_date_ord_ore` — ordering domain query operand.
+ *
+ * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
+ */
+export type DateOrdOreQuery = {
+    v: SchemaVersion;
+    i: Identifier;
+    ob: OreBlock256;
+};

package/lib/eql-v3-types/DateOrdOreQuery.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/eql-v3-types/DateOrdQuery.d.ts

@@ -0,0 +1,13 @@
+import type { Identifier } from "./Identifier";
+import type { OpeCllw } from "./OpeCllw";
+import type { SchemaVersion } from "./SchemaVersion";
+/**
+ * `eql_v3.query_date_ord` — ordering domain query operand.
+ *
+ * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.
+ */
+export type DateOrdQuery = {
+    v: SchemaVersion;
+    i: Identifier;
+    op: OpeCllw;
+};

package/lib/eql-v3-types/DateOrdQuery.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/eql-v3-types/Double.d.ts

@@ -2,7 +2,7 @@ import type { Ciphertext } from "./Ciphertext";
 import type { Identifier } from "./Identifier";
 import type { SchemaVersion } from "./SchemaVersion";
 /**
- * `eql_v3.double` — storage-only domain.
+ * `public.eql_v3_double` — storage-only domain.
  *
  * Operators: none. Required keys: `v` `i` `c`.
  */

package/lib/eql-v3-types/DoubleEq.d.ts

@@ -3,7 +3,7 @@ import type { Hmac256 } from "./Hmac256";
 import type { Identifier } from "./Identifier";
 import type { SchemaVersion } from "./SchemaVersion";
 /**
- * `eql_v3.double_eq` — equality domain.
+ * `public.eql_v3_double_eq` — equality domain.
  *
  * Operators: `=` `<>`. Required keys: `v` `i` `c` `hm`.
  */

package/lib/eql-v3-types/DoubleEqQuery.d.ts

@@ -0,0 +1,13 @@
+import type { Hmac256 } from "./Hmac256";
+import type { Identifier } from "./Identifier";
+import type { SchemaVersion } from "./SchemaVersion";
+/**
+ * `eql_v3.query_double_eq` — equality domain query operand.
+ *
+ * Operators: `=` `<>`. Required keys: `v` `i` `hm`.
+ */
+export type DoubleEqQuery = {
+    v: SchemaVersion;
+    i: Identifier;
+    hm: Hmac256;
+};

package/lib/eql-v3-types/DoubleEqQuery.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/eql-v3-types/DoubleOrd.d.ts

@@ -1,15 +1,15 @@
 import type { Ciphertext } from "./Ciphertext";
 import type { Identifier } from "./Identifier";
-import type { OreBlock256 } from "./OreBlock256";
+import type { OpeCllw } from "./OpeCllw";
 import type { SchemaVersion } from "./SchemaVersion";
 /**
- * `eql_v3.double_ord` — ordering domain.
+ * `public.eql_v3_double_ord` — ordering domain.
  *
- * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `c` `ob`.
+ * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `c` `op`.
  */
 export type DoubleOrd = {
     v: SchemaVersion;
     i: Identifier;
     c: Ciphertext;
-    ob: OreBlock256;
+    op: OpeCllw;
 };

package/lib/eql-v3-types/DoubleOrdOpe.d.ts

@@ -3,7 +3,7 @@ import type { Identifier } from "./Identifier";
 import type { OpeCllw } from "./OpeCllw";
 import type { SchemaVersion } from "./SchemaVersion";
 /**
- * `eql_v3.double_ord_ope` — ordering domain.
+ * `public.eql_v3_double_ord_ope` — ordering domain.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `c` `op`.
  */

package/lib/eql-v3-types/DoubleOrdOpeQuery.d.ts

@@ -0,0 +1,13 @@
+import type { Identifier } from "./Identifier";
+import type { OpeCllw } from "./OpeCllw";
+import type { SchemaVersion } from "./SchemaVersion";
+/**
+ * `eql_v3.query_double_ord_ope` — ordering domain query operand.
+ *
+ * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.
+ */
+export type DoubleOrdOpeQuery = {
+    v: SchemaVersion;
+    i: Identifier;
+    op: OpeCllw;
+};

package/lib/eql-v3-types/DoubleOrdOpeQuery.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/eql-v3-types/DoubleOrdOre.d.ts

@@ -3,7 +3,7 @@ import type { Identifier } from "./Identifier";
 import type { OreBlock256 } from "./OreBlock256";
 import type { SchemaVersion } from "./SchemaVersion";
 /**
- * `eql_v3.double_ord_ore` — ordering domain.
+ * `public.eql_v3_double_ord_ore` — ordering domain.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `c` `ob`.
  */

package/lib/eql-v3-types/DoubleOrdOreQuery.d.ts

@@ -0,0 +1,13 @@
+import type { Identifier } from "./Identifier";
+import type { OreBlock256 } from "./OreBlock256";
+import type { SchemaVersion } from "./SchemaVersion";
+/**
+ * `eql_v3.query_double_ord_ore` — ordering domain query operand.
+ *
+ * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
+ */
+export type DoubleOrdOreQuery = {
+    v: SchemaVersion;
+    i: Identifier;
+    ob: OreBlock256;
+};

package/lib/eql-v3-types/DoubleOrdOreQuery.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/eql-v3-types/DoubleOrdQuery.d.ts

@@ -0,0 +1,13 @@
+import type { Identifier } from "./Identifier";
+import type { OpeCllw } from "./OpeCllw";
+import type { SchemaVersion } from "./SchemaVersion";
+/**
+ * `eql_v3.query_double_ord` — ordering domain query operand.
+ *
+ * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.
+ */
+export type DoubleOrdQuery = {
+    v: SchemaVersion;
+    i: Identifier;
+    op: OpeCllw;
+};

package/lib/eql-v3-types/DoubleOrdQuery.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/eql-v3-types/Integer.d.ts

@@ -2,7 +2,7 @@ import type { Ciphertext } from "./Ciphertext";
 import type { Identifier } from "./Identifier";
 import type { SchemaVersion } from "./SchemaVersion";
 /**
- * `eql_v3.integer` — storage-only domain.
+ * `public.eql_v3_integer` — storage-only domain.
  *
  * Operators: none. Required keys: `v` `i` `c`.
  */

package/lib/eql-v3-types/IntegerEq.d.ts

@@ -3,7 +3,7 @@ import type { Hmac256 } from "./Hmac256";
 import type { Identifier } from "./Identifier";
 import type { SchemaVersion } from "./SchemaVersion";
 /**
- * `eql_v3.integer_eq` — equality domain.
+ * `public.eql_v3_integer_eq` — equality domain.
  *
  * Operators: `=` `<>`. Required keys: `v` `i` `c` `hm`.
  */

package/lib/eql-v3-types/IntegerEqQuery.d.ts

@@ -0,0 +1,13 @@
+import type { Hmac256 } from "./Hmac256";
+import type { Identifier } from "./Identifier";
+import type { SchemaVersion } from "./SchemaVersion";
+/**
+ * `eql_v3.query_integer_eq` — equality domain query operand.
+ *
+ * Operators: `=` `<>`. Required keys: `v` `i` `hm`.
+ */
+export type IntegerEqQuery = {
+    v: SchemaVersion;
+    i: Identifier;
+    hm: Hmac256;
+};

package/lib/eql-v3-types/IntegerEqQuery.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/eql-v3-types/IntegerOrd.d.ts

@@ -1,15 +1,15 @@
 import type { Ciphertext } from "./Ciphertext";
 import type { Identifier } from "./Identifier";
-import type { OreBlock256 } from "./OreBlock256";
+import type { OpeCllw } from "./OpeCllw";
 import type { SchemaVersion } from "./SchemaVersion";
 /**
- * `eql_v3.integer_ord` — ordering domain.
+ * `public.eql_v3_integer_ord` — ordering domain.
  *
- * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `c` `ob`.
+ * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `c` `op`.
  */
 export type IntegerOrd = {
     v: SchemaVersion;
     i: Identifier;
     c: Ciphertext;
-    ob: OreBlock256;
+    op: OpeCllw;
 };

package/lib/eql-v3-types/IntegerOrdOpe.d.ts

@@ -3,7 +3,7 @@ import type { Identifier } from "./Identifier";
 import type { OpeCllw } from "./OpeCllw";
 import type { SchemaVersion } from "./SchemaVersion";
 /**
- * `eql_v3.integer_ord_ope` — ordering domain.
+ * `public.eql_v3_integer_ord_ope` — ordering domain.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `c` `op`.
  */