@cipherstash/stack 0.16.0 → 0.19.0

package/dist/table-DihEAlxG.d.cts

@@ -0,0 +1,603 @@
+import { i as ColumnSchema, M as MatchIndexOpts, a as Encrypted, j as EncryptConfig } from './types-public-CpS5KjwX.cjs';
+
+/**
+ * The query capabilities a v3 concrete domain exposes. These are SDK-facing
+ * semantic flags describing what kinds of query terms a column can produce —
+ * NOT the raw EQL index keys. They are metadata only and never emitted by
+ * `build()`.
+ *
+ * - `equality`: exact-match lookups (EQL `hm`, or comparison via `ob`).
+ * - `orderAndRange`: comparison / range lookups (EQL `ob`).
+ * - `freeTextSearch`: tokenised substring match (EQL `bf`).
+ */
+type QueryCapabilities = Readonly<{
+    equality: boolean;
+    orderAndRange: boolean;
+    freeTextSearch: boolean;
+}>;
+/** The plaintext (TypeScript) kind a v3 domain decrypts to. A subset of the
+ * SDK `CastAs` enum, restricted to the scalar kinds v3 domains actually use. */
+type PlaintextKind = 'string' | 'number' | 'boolean' | 'date' | 'timestamp';
+/**
+ * The full, literal definition of a v3 domain. This is the LOAD-BEARING type:
+ * the base column class carries a private field of this type so that every
+ * concrete (otherwise-empty) subclass is discriminated by its literal
+ * `eqlType`/`castAs`/`capabilities` — TypeScript empty subclasses are NOT
+ * nominal, so without this a storage-only `boolean` column would be assignable to
+ * a storage-only `date` column and plaintext inference would collapse.
+ */
+type V3DomainDefinition = Readonly<{
+    eqlType: `eql_v3.${string}`;
+    castAs: PlaintextKind;
+    capabilities: QueryCapabilities;
+}>;
+/** Type-level mirror of {@link isQueryableCapabilities}: `false` for a
+ * storage-only domain (all capability flags `false`), `true` otherwise. */
+type QueryableFlag<D extends V3DomainDefinition> = D['capabilities'] extends {
+    equality: false;
+    orderAndRange: false;
+    freeTextSearch: false;
+} ? false : true;
+/**
+ * The concrete EQL v3 domain name for a full-capability text column.
+ * Recorded as metadata for future DDL / query-dialect increments; it is
+ * intentionally absent from the emitted encrypt config.
+ */
+declare const TEXT_SEARCH_EQL_TYPE = "eql_v3.text_search";
+declare const INTEGER: {
+    readonly eqlType: "eql_v3.integer";
+    readonly castAs: "number";
+    readonly capabilities: {
+        readonly equality: false;
+        readonly orderAndRange: false;
+        readonly freeTextSearch: false;
+    };
+};
+declare const INTEGER_EQ: {
+    readonly eqlType: "eql_v3.integer_eq";
+    readonly castAs: "number";
+    readonly capabilities: {
+        readonly equality: true;
+        readonly orderAndRange: false;
+        readonly freeTextSearch: false;
+    };
+};
+declare const INTEGER_ORD_ORE: {
+    readonly eqlType: "eql_v3.integer_ord_ore";
+    readonly castAs: "number";
+    readonly capabilities: {
+        readonly equality: true;
+        readonly orderAndRange: true;
+        readonly freeTextSearch: false;
+    };
+};
+declare const INTEGER_ORD: {
+    readonly eqlType: "eql_v3.integer_ord";
+    readonly castAs: "number";
+    readonly capabilities: {
+        readonly equality: true;
+        readonly orderAndRange: true;
+        readonly freeTextSearch: false;
+    };
+};
+declare const SMALLINT: {
+    readonly eqlType: "eql_v3.smallint";
+    readonly castAs: "number";
+    readonly capabilities: {
+        readonly equality: false;
+        readonly orderAndRange: false;
+        readonly freeTextSearch: false;
+    };
+};
+declare const SMALLINT_EQ: {
+    readonly eqlType: "eql_v3.smallint_eq";
+    readonly castAs: "number";
+    readonly capabilities: {
+        readonly equality: true;
+        readonly orderAndRange: false;
+        readonly freeTextSearch: false;
+    };
+};
+declare const SMALLINT_ORD_ORE: {
+    readonly eqlType: "eql_v3.smallint_ord_ore";
+    readonly castAs: "number";
+    readonly capabilities: {
+        readonly equality: true;
+        readonly orderAndRange: true;
+        readonly freeTextSearch: false;
+    };
+};
+declare const SMALLINT_ORD: {
+    readonly eqlType: "eql_v3.smallint_ord";
+    readonly castAs: "number";
+    readonly capabilities: {
+        readonly equality: true;
+        readonly orderAndRange: true;
+        readonly freeTextSearch: false;
+    };
+};
+declare const DATE: {
+    readonly eqlType: "eql_v3.date";
+    readonly castAs: "date";
+    readonly capabilities: {
+        readonly equality: false;
+        readonly orderAndRange: false;
+        readonly freeTextSearch: false;
+    };
+};
+declare const DATE_EQ: {
+    readonly eqlType: "eql_v3.date_eq";
+    readonly castAs: "date";
+    readonly capabilities: {
+        readonly equality: true;
+        readonly orderAndRange: false;
+        readonly freeTextSearch: false;
+    };
+};
+declare const DATE_ORD_ORE: {
+    readonly eqlType: "eql_v3.date_ord_ore";
+    readonly castAs: "date";
+    readonly capabilities: {
+        readonly equality: true;
+        readonly orderAndRange: true;
+        readonly freeTextSearch: false;
+    };
+};
+declare const DATE_ORD: {
+    readonly eqlType: "eql_v3.date_ord";
+    readonly castAs: "date";
+    readonly capabilities: {
+        readonly equality: true;
+        readonly orderAndRange: true;
+        readonly freeTextSearch: false;
+    };
+};
+declare const TIMESTAMP: {
+    readonly eqlType: "eql_v3.timestamp";
+    readonly castAs: "timestamp";
+    readonly capabilities: {
+        readonly equality: false;
+        readonly orderAndRange: false;
+        readonly freeTextSearch: false;
+    };
+};
+declare const TIMESTAMP_EQ: {
+    readonly eqlType: "eql_v3.timestamp_eq";
+    readonly castAs: "timestamp";
+    readonly capabilities: {
+        readonly equality: true;
+        readonly orderAndRange: false;
+        readonly freeTextSearch: false;
+    };
+};
+declare const TIMESTAMP_ORD_ORE: {
+    readonly eqlType: "eql_v3.timestamp_ord_ore";
+    readonly castAs: "timestamp";
+    readonly capabilities: {
+        readonly equality: true;
+        readonly orderAndRange: true;
+        readonly freeTextSearch: false;
+    };
+};
+declare const TIMESTAMP_ORD: {
+    readonly eqlType: "eql_v3.timestamp_ord";
+    readonly castAs: "timestamp";
+    readonly capabilities: {
+        readonly equality: true;
+        readonly orderAndRange: true;
+        readonly freeTextSearch: false;
+    };
+};
+declare const NUMERIC: {
+    readonly eqlType: "eql_v3.numeric";
+    readonly castAs: "number";
+    readonly capabilities: {
+        readonly equality: false;
+        readonly orderAndRange: false;
+        readonly freeTextSearch: false;
+    };
+};
+declare const NUMERIC_EQ: {
+    readonly eqlType: "eql_v3.numeric_eq";
+    readonly castAs: "number";
+    readonly capabilities: {
+        readonly equality: true;
+        readonly orderAndRange: false;
+        readonly freeTextSearch: false;
+    };
+};
+declare const NUMERIC_ORD_ORE: {
+    readonly eqlType: "eql_v3.numeric_ord_ore";
+    readonly castAs: "number";
+    readonly capabilities: {
+        readonly equality: true;
+        readonly orderAndRange: true;
+        readonly freeTextSearch: false;
+    };
+};
+declare const NUMERIC_ORD: {
+    readonly eqlType: "eql_v3.numeric_ord";
+    readonly castAs: "number";
+    readonly capabilities: {
+        readonly equality: true;
+        readonly orderAndRange: true;
+        readonly freeTextSearch: false;
+    };
+};
+declare const TEXT: {
+    readonly eqlType: "eql_v3.text";
+    readonly castAs: "string";
+    readonly capabilities: {
+        readonly equality: false;
+        readonly orderAndRange: false;
+        readonly freeTextSearch: false;
+    };
+};
+declare const TEXT_EQ: {
+    readonly eqlType: "eql_v3.text_eq";
+    readonly castAs: "string";
+    readonly capabilities: {
+        readonly equality: true;
+        readonly orderAndRange: false;
+        readonly freeTextSearch: false;
+    };
+};
+declare const TEXT_MATCH: {
+    readonly eqlType: "eql_v3.text_match";
+    readonly castAs: "string";
+    readonly capabilities: {
+        readonly equality: false;
+        readonly orderAndRange: false;
+        readonly freeTextSearch: true;
+    };
+};
+declare const TEXT_ORD_ORE: {
+    readonly eqlType: "eql_v3.text_ord_ore";
+    readonly castAs: "string";
+    readonly capabilities: {
+        readonly equality: true;
+        readonly orderAndRange: true;
+        readonly freeTextSearch: false;
+    };
+};
+declare const TEXT_ORD: {
+    readonly eqlType: "eql_v3.text_ord";
+    readonly castAs: "string";
+    readonly capabilities: {
+        readonly equality: true;
+        readonly orderAndRange: true;
+        readonly freeTextSearch: false;
+    };
+};
+declare const BOOLEAN: {
+    readonly eqlType: "eql_v3.boolean";
+    readonly castAs: "boolean";
+    readonly capabilities: {
+        readonly equality: false;
+        readonly orderAndRange: false;
+        readonly freeTextSearch: false;
+    };
+};
+declare const REAL: {
+    readonly eqlType: "eql_v3.real";
+    readonly castAs: "number";
+    readonly capabilities: {
+        readonly equality: false;
+        readonly orderAndRange: false;
+        readonly freeTextSearch: false;
+    };
+};
+declare const REAL_EQ: {
+    readonly eqlType: "eql_v3.real_eq";
+    readonly castAs: "number";
+    readonly capabilities: {
+        readonly equality: true;
+        readonly orderAndRange: false;
+        readonly freeTextSearch: false;
+    };
+};
+declare const REAL_ORD_ORE: {
+    readonly eqlType: "eql_v3.real_ord_ore";
+    readonly castAs: "number";
+    readonly capabilities: {
+        readonly equality: true;
+        readonly orderAndRange: true;
+        readonly freeTextSearch: false;
+    };
+};
+declare const REAL_ORD: {
+    readonly eqlType: "eql_v3.real_ord";
+    readonly castAs: "number";
+    readonly capabilities: {
+        readonly equality: true;
+        readonly orderAndRange: true;
+        readonly freeTextSearch: false;
+    };
+};
+declare const DOUBLE: {
+    readonly eqlType: "eql_v3.double";
+    readonly castAs: "number";
+    readonly capabilities: {
+        readonly equality: false;
+        readonly orderAndRange: false;
+        readonly freeTextSearch: false;
+    };
+};
+declare const DOUBLE_EQ: {
+    readonly eqlType: "eql_v3.double_eq";
+    readonly castAs: "number";
+    readonly capabilities: {
+        readonly equality: true;
+        readonly orderAndRange: false;
+        readonly freeTextSearch: false;
+    };
+};
+declare const DOUBLE_ORD_ORE: {
+    readonly eqlType: "eql_v3.double_ord_ore";
+    readonly castAs: "number";
+    readonly capabilities: {
+        readonly equality: true;
+        readonly orderAndRange: true;
+        readonly freeTextSearch: false;
+    };
+};
+declare const DOUBLE_ORD: {
+    readonly eqlType: "eql_v3.double_ord";
+    readonly castAs: "number";
+    readonly capabilities: {
+        readonly equality: true;
+        readonly orderAndRange: true;
+        readonly freeTextSearch: false;
+    };
+};
+/**
+ * Shared base for every v3 concrete domain column. Parameterised by the FULL
+ * literal {@link V3DomainDefinition} (not by capabilities alone): the private
+ * `definition` field carries the literal `eqlType`/`castAs`/`capabilities`, so
+ * two otherwise-empty subclasses (e.g. `EncryptedBooleanColumn` and
+ * `EncryptedDateColumn`, both storage-only) are NOT mutually assignable. This
+ * nominality is what keeps plaintext inference precise.
+ */
+declare class EncryptedV3Column<D extends V3DomainDefinition> {
+    private readonly columnName;
+    private readonly definition;
+    constructor(columnName: string, definition: D);
+    getName(): string;
+    /** The concrete EQL v3 domain name. Metadata only; not emitted by `build()`. */
+    getEqlType(): D['eqlType'];
+    /** The semantic query capabilities this domain exposes. Metadata only. */
+    getQueryCapabilities(): D['capabilities'];
+    /** `true` when this domain can produce at least one kind of query term. */
+    isQueryable(): QueryableFlag<D>;
+    /** Emit the encrypt-config column: `cast_as` plus capability-derived indexes. */
+    build(): ColumnSchema;
+}
+declare const TEXT_SEARCH_DOMAIN: {
+    readonly eqlType: "eql_v3.text_search";
+    readonly castAs: "string";
+    readonly capabilities: {
+        readonly equality: true;
+        readonly orderAndRange: true;
+        readonly freeTextSearch: true;
+    };
+};
+/**
+ * Builder for an `eql_v3.text_search` column.
+ *
+ * The concrete type inherently enables equality + order/range + free-text
+ * match — there are no capability-enabling methods. `.freeTextSearch(opts?)`
+ * tunes the match index only.
+ *
+ * NOTE — querying: a `text_search` column emits all three indexes (`unique`,
+ * `ore`, `match`), and the shared index-inference picks them by fixed priority
+ * `unique > match > ore`. So `encryptQuery(value, { column, table })` with NO
+ * explicit `queryType` builds an EQUALITY term (via `unique`), NOT a free-text
+ * match — a substring like `'joh'` then matches nothing. To run a free-text
+ * match query you MUST pass `queryType: 'freeTextSearch'`:
+ *
+ * ```typescript
+ * // equality (default): exact value only
+ * client.encryptQuery('john@example.com', { column: users.email, table: users })
+ * // free-text match: substring/token search
+ * client.encryptQuery('joh', { column: users.email, table: users, queryType: 'freeTextSearch' })
+ * ```
+ */
+declare class EncryptedTextSearchColumn extends EncryptedV3Column<typeof TEXT_SEARCH_DOMAIN> {
+    private matchOpts;
+    constructor(columnName: string);
+    /**
+     * Tune the match index. Each provided key replaces its default; omitted
+     * keys keep the default. This NEVER enables a capability — match is always
+     * on for this type. Merge semantics mirror v2's `opts?.x ?? default`.
+     */
+    freeTextSearch(opts?: MatchIndexOpts): this;
+    /** Emit the encrypt-config column. Byte-identical to a v2 equality+order+match column. */
+    build(): ColumnSchema;
+}
+declare class EncryptedIntegerColumn extends EncryptedV3Column<typeof INTEGER> {
+}
+declare class EncryptedIntegerEqColumn extends EncryptedV3Column<typeof INTEGER_EQ> {
+}
+declare class EncryptedIntegerOrdOreColumn extends EncryptedV3Column<typeof INTEGER_ORD_ORE> {
+}
+declare class EncryptedIntegerOrdColumn extends EncryptedV3Column<typeof INTEGER_ORD> {
+}
+declare class EncryptedSmallintColumn extends EncryptedV3Column<typeof SMALLINT> {
+}
+declare class EncryptedSmallintEqColumn extends EncryptedV3Column<typeof SMALLINT_EQ> {
+}
+declare class EncryptedSmallintOrdOreColumn extends EncryptedV3Column<typeof SMALLINT_ORD_ORE> {
+}
+declare class EncryptedSmallintOrdColumn extends EncryptedV3Column<typeof SMALLINT_ORD> {
+}
+declare class EncryptedDateColumn extends EncryptedV3Column<typeof DATE> {
+}
+declare class EncryptedDateEqColumn extends EncryptedV3Column<typeof DATE_EQ> {
+}
+declare class EncryptedDateOrdOreColumn extends EncryptedV3Column<typeof DATE_ORD_ORE> {
+}
+declare class EncryptedDateOrdColumn extends EncryptedV3Column<typeof DATE_ORD> {
+}
+declare class EncryptedTimestampColumn extends EncryptedV3Column<typeof TIMESTAMP> {
+}
+declare class EncryptedTimestampEqColumn extends EncryptedV3Column<typeof TIMESTAMP_EQ> {
+}
+declare class EncryptedTimestampOrdOreColumn extends EncryptedV3Column<typeof TIMESTAMP_ORD_ORE> {
+}
+declare class EncryptedTimestampOrdColumn extends EncryptedV3Column<typeof TIMESTAMP_ORD> {
+}
+declare class EncryptedNumericColumn extends EncryptedV3Column<typeof NUMERIC> {
+}
+declare class EncryptedNumericEqColumn extends EncryptedV3Column<typeof NUMERIC_EQ> {
+}
+declare class EncryptedNumericOrdOreColumn extends EncryptedV3Column<typeof NUMERIC_ORD_ORE> {
+}
+declare class EncryptedNumericOrdColumn extends EncryptedV3Column<typeof NUMERIC_ORD> {
+}
+declare class EncryptedTextColumn extends EncryptedV3Column<typeof TEXT> {
+}
+declare class EncryptedTextEqColumn extends EncryptedV3Column<typeof TEXT_EQ> {
+}
+declare class EncryptedTextMatchColumn extends EncryptedV3Column<typeof TEXT_MATCH> {
+}
+declare class EncryptedTextOrdOreColumn extends EncryptedV3Column<typeof TEXT_ORD_ORE> {
+}
+declare class EncryptedTextOrdColumn extends EncryptedV3Column<typeof TEXT_ORD> {
+}
+declare class EncryptedBooleanColumn extends EncryptedV3Column<typeof BOOLEAN> {
+}
+declare class EncryptedRealColumn extends EncryptedV3Column<typeof REAL> {
+}
+declare class EncryptedRealEqColumn extends EncryptedV3Column<typeof REAL_EQ> {
+}
+declare class EncryptedRealOrdOreColumn extends EncryptedV3Column<typeof REAL_ORD_ORE> {
+}
+declare class EncryptedRealOrdColumn extends EncryptedV3Column<typeof REAL_ORD> {
+}
+declare class EncryptedDoubleColumn extends EncryptedV3Column<typeof DOUBLE> {
+}
+declare class EncryptedDoubleEqColumn extends EncryptedV3Column<typeof DOUBLE_EQ> {
+}
+declare class EncryptedDoubleOrdOreColumn extends EncryptedV3Column<typeof DOUBLE_ORD_ORE> {
+}
+declare class EncryptedDoubleOrdColumn extends EncryptedV3Column<typeof DOUBLE_ORD> {
+}
+/**
+ * Union of every v3 concrete column type. Used as the value type for v3 table
+ * columns so a table may mix any generated domains.
+ */
+type AnyEncryptedV3Column = EncryptedIntegerColumn | EncryptedIntegerEqColumn | EncryptedIntegerOrdOreColumn | EncryptedIntegerOrdColumn | EncryptedSmallintColumn | EncryptedSmallintEqColumn | EncryptedSmallintOrdOreColumn | EncryptedSmallintOrdColumn | EncryptedDateColumn | EncryptedDateEqColumn | EncryptedDateOrdOreColumn | EncryptedDateOrdColumn | EncryptedTimestampColumn | EncryptedTimestampEqColumn | EncryptedTimestampOrdOreColumn | EncryptedTimestampOrdColumn | EncryptedNumericColumn | EncryptedNumericEqColumn | EncryptedNumericOrdOreColumn | EncryptedNumericOrdColumn | EncryptedTextColumn | EncryptedTextEqColumn | EncryptedTextMatchColumn | EncryptedTextOrdOreColumn | EncryptedTextOrdColumn | EncryptedTextSearchColumn | EncryptedBooleanColumn | EncryptedRealColumn | EncryptedRealEqColumn | EncryptedRealOrdOreColumn | EncryptedRealOrdColumn | EncryptedDoubleColumn | EncryptedDoubleEqColumn | EncryptedDoubleOrdOreColumn | EncryptedDoubleOrdColumn;
+/**
+ * Shape of v3 table columns: every value is a v3 concrete column builder.
+ * (Nested fields are deferred to later increments.)
+ */
+type EncryptedV3TableColumn = {
+    [key: string]: AnyEncryptedV3Column;
+};
+/** Map a domain's {@link PlaintextKind} to its TypeScript plaintext type. */
+type PlaintextFromKind<K extends PlaintextKind> = K extends 'string' ? string : K extends 'number' ? number : K extends 'boolean' ? boolean : K extends 'date' | 'timestamp' ? Date : never;
+/**
+ * The plaintext type for a single v3 column, read from the literal domain
+ * definition carried on the base class's private field. This is stable across
+ * empty subclasses that share the same base generic — a subclass-name
+ * conditional would collapse because those subclasses are structurally
+ * assignable to one another.
+ */
+type PlaintextForColumn<C> = C extends EncryptedV3Column<infer D> ? PlaintextFromKind<D['castAs']> : never;
+/**
+ * The user-facing `queryType` names a v3 column supports, derived 1:1 from its
+ * capability flags. Resolves to `never` for a storage-only column (all flags
+ * `false`) and for any non-v3 value. The names mirror the {@link QueryCapabilities}
+ * keys and the first three {@link import('@/types').QueryTypeName} members.
+ */
+type QueryTypesForColumn<C> = C extends EncryptedV3Column<infer D> ? (D['capabilities']['equality'] extends true ? 'equality' : never) | (D['capabilities']['orderAndRange'] extends true ? 'orderAndRange' : never) | (D['capabilities']['freeTextSearch'] extends true ? 'freeTextSearch' : never) : never;
+/**
+ * The concrete EQL v3 type string for a single column, read from the literal
+ * domain definition carried on the base class's private field (mirrors
+ * {@link PlaintextForColumn}). Distributes over a union of columns, so
+ * `EqlTypeForColumn<AnyEncryptedV3Column>` yields the union of every domain's
+ * `eqlType` — the canonical, source-of-truth key set for a type-driven test
+ * matrix keyed by domain.
+ */
+type EqlTypeForColumn<C> = C extends EncryptedV3Column<infer D> ? D['eqlType'] : never;
+
+interface TableDefinition {
+    tableName: string;
+    columns: Record<string, ColumnSchema>;
+}
+/**
+ * A v3 encrypted table. Mirrors the v2 `EncryptedTable` but only accepts v3
+ * column builders. Emits the same `{ tableName, columns }` definition shape.
+ */
+declare class EncryptedTable<T extends EncryptedV3TableColumn> {
+    readonly tableName: string;
+    readonly columnBuilders: T;
+    /** @internal Type-level brand so TypeScript can infer `T` from `EncryptedTable<T>`. */
+    readonly _columnType: T;
+    constructor(tableName: string, columnBuilders: T);
+    build(): TableDefinition;
+    /**
+     * Map each column's JS property name to its DB column name (`getName()`).
+     * The model path matches user models by property name but must address the
+     * encrypt config and FFI by DB name — `build()` keys columns by DB name, so
+     * the two only agree when property == name. This recovers the mapping that
+     * `build()` discards.
+     */
+    buildColumnKeyMap(): Record<string, string>;
+}
+/**
+ * Define a v3 encrypted table. Intentionally shadows the v2 `encryptedTable`
+ * name but lives on the `/eql/v3` subpath — the importer picks the model by
+ * import path. The returned object is also a column accessor (`users.email`).
+ */
+declare function encryptedTable<T extends EncryptedV3TableColumn>(tableName: string, columns: T): EncryptedTable<T> & T;
+/**
+ * Build an `EncryptConfig` (`v: 1`) from one or more v3 tables. Emits the same
+ * shape as v2's `buildEncryptConfig`.
+ */
+declare function buildEncryptConfig(...tables: Array<EncryptedTable<EncryptedV3TableColumn>>): EncryptConfig;
+/**
+ * Infer the plaintext (decrypted) shape from a v3 table schema. Each column maps
+ * to the TypeScript type of its domain's `castAs` kind.
+ */
+type InferPlaintext<T extends EncryptedTable<EncryptedV3TableColumn>> = T extends EncryptedTable<infer C> ? {
+    [K in keyof C]: PlaintextForColumn<C[K]>;
+} : never;
+/**
+ * Infer the encrypted shape from a v3 table schema. See {@link InferPlaintext}
+ * for why no key-remap filter is needed in the flat single-type model.
+ */
+type InferEncrypted<T extends EncryptedTable<EncryptedV3TableColumn>> = T extends EncryptedTable<infer C> ? {
+    [K in keyof C]: Encrypted;
+} : never;
+/** Any v3 table, regardless of its column map. */
+type AnyV3Table = EncryptedTable<EncryptedV3TableColumn>;
+/** Union of the concrete column builders declared on a v3 table. */
+type ColumnsOf<T extends AnyV3Table> = T extends EncryptedTable<infer C> ? C[keyof C] : never;
+/**
+ * Union of the *queryable* column builders on a v3 table. Storage-only columns
+ * (whose {@link QueryTypesForColumn} is `never`) are filtered out, so they can't
+ * be passed to a query method.
+ */
+type QueryableColumnsOf<T extends AnyV3Table> = T extends EncryptedTable<infer C> ? {
+    [K in keyof C]: [QueryTypesForColumn<C[K]>] extends [never] ? never : C[K];
+}[keyof C] : never;
+/**
+ * The accepted input model for {@link import('@/encryption/v3').TypedEncryptionClient.encryptModel}.
+ * `T` is inferred from the argument: keys that name a schema column are pinned to
+ * the column's plaintext type (nullable if the field is nullable), so a wrong-typed
+ * field fails assignability; all other keys pass through unchanged.
+ */
+type V3ModelInput<Table extends AnyV3Table, T> = {
+    [K in keyof T]: K extends keyof InferPlaintext<Table> ? null extends T[K] ? InferPlaintext<Table>[K] | null : InferPlaintext<Table>[K] : T[K];
+};
+/** The encrypted result model: schema columns become `Encrypted`, others pass through. */
+type V3EncryptedModel<Table extends AnyV3Table, T> = {
+    [K in keyof T]: K extends keyof InferPlaintext<Table> ? null extends T[K] ? Encrypted | null : Encrypted : T[K];
+};
+/** The decrypted result model: schema columns become their plaintext type, others pass through. */
+type V3DecryptedModel<Table extends AnyV3Table, T> = {
+    [K in keyof T]: K extends keyof InferPlaintext<Table> ? null extends T[K] ? InferPlaintext<Table>[K] | null : InferPlaintext<Table>[K] : T[K];
+};
+
+export { type AnyV3Table as A, EncryptedSmallintOrdColumn as B, type ColumnsOf as C, EncryptedSmallintOrdOreColumn as D, EncryptedBooleanColumn as E, EncryptedTable as F, EncryptedTextColumn as G, EncryptedTextEqColumn as H, EncryptedTextMatchColumn as I, EncryptedTextOrdColumn as J, EncryptedTextOrdOreColumn as K, EncryptedTextSearchColumn as L, EncryptedTimestampColumn as M, EncryptedTimestampEqColumn as N, EncryptedTimestampOrdColumn as O, type PlaintextForColumn as P, type QueryableColumnsOf as Q, EncryptedTimestampOrdOreColumn as R, type EncryptedV3TableColumn as S, type EqlTypeForColumn as T, type InferEncrypted as U, type V3ModelInput as V, type InferPlaintext as W, type QueryCapabilities as X, TEXT_SEARCH_EQL_TYPE as Y, buildEncryptConfig as Z, encryptedTable as _, type QueryTypesForColumn as a, type V3EncryptedModel as b, type V3DecryptedModel as c, type AnyEncryptedV3Column as d, EncryptedDateColumn as e, EncryptedDateEqColumn as f, EncryptedDateOrdColumn as g, EncryptedDateOrdOreColumn as h, EncryptedDoubleColumn as i, EncryptedDoubleEqColumn as j, EncryptedDoubleOrdColumn as k, EncryptedDoubleOrdOreColumn as l, EncryptedIntegerColumn as m, EncryptedIntegerEqColumn as n, EncryptedIntegerOrdColumn as o, EncryptedIntegerOrdOreColumn as p, EncryptedNumericColumn as q, EncryptedNumericEqColumn as r, EncryptedNumericOrdColumn as s, EncryptedNumericOrdOreColumn as t, EncryptedRealColumn as u, EncryptedRealEqColumn as v, EncryptedRealOrdColumn as w, EncryptedRealOrdOreColumn as x, EncryptedSmallintColumn as y, EncryptedSmallintEqColumn as z };