@jarenjs/db 0.49.2 → 0.66.1

package/dist/types/dialect.d.ts

@@ -1,154 +0,0 @@
-/**
- * @file The dialect seam: the ONLY place SQL text is produced. A
- * dialect is data plus a small emitter — a spelling spec (how to quote
- * an identifier, reference a parameter, extract a JSON member, open a
- * savepoint) composed by {@link createDialect} into the DDL and DML
- * statement builders the store consumes. Nothing outside a dialect
- * concatenates SQL; that costs one indirection now, and without it a
- * second backend is a rewrite.
- *
- * Deliberately NOT in the dialect, because they are behavioural rather
- * than syntactic: whether functions can be registered per connection,
- * whether change capture exists and in what form, and whether tables
- * can be restructured in place. Those are capabilities on the
- * connection.
- */
-export type JsonPathSegment = {
-    name: string;
-} | {
-    index: number;
-};
-/**
- * A typed member path into the JSON document column: name segments for
- * object members, index segments for array positions. Produced by the
- * DDL planner (from analyzed index paths) and the patch translator
- * (from pointers discriminated against the live document).
- * @typedef {{ name: string } | { index: number }} JsonPathSegment
- */
-/**
- * Compose a dialect from its spelling spec. Every statement the store
- * ever runs is built here from the spec's primitives, so a spec with
- * different quoting or parameter style produces correspondingly
- * different SQL from the same model — the property the test-double
- * dialect pins.
- * @param {{
- *   name: string,
- *   capabilities: Record<string, any>,
- *   tableSuffix: string,
- *   docColumnType: string,
- *   packedVectorType: string,
- *   quoteIdentifier: (s: string) => string,
- *   parameterRef: (i: number, name: string) => string,
- *   stringLiteral: (s: string) => string,
- *   booleanLiteral: (b: boolean) => string,
- *   typeFor: (schemaType: string | undefined, hint: string) => string,
- *   limitClause: (limit: number, offset?: number) => string,
- *   jsonPathText: (segments: JsonPathSegment[]) => string | null,
- *   jsonExtract: (columnSql: string, pathText: string) => string,
- *   derivedExpression?: (memberSql: string, column: { derive: string,
- *     precision?: number, component?: string, dims?: number }) => string,
- *   jsonSet: (exprSql: string, pathText: string, valueSql: string) => string,
- *   jsonRemove: (exprSql: string, pathText: string) => string,
- *   jsonAppend: (exprSql: string, arrayPathText: string, valueSql: string) => string,
- *   jsonEncode: (paramSql: string) => string,
- *   jsonText: (columnSql: string) => string,
- *   jsonAgg: (exprSql: string) => string,
- *   jsonTypeOf: (columnSql: string, pathText: string) => string,
- *   valueTypeOf: (paramSql: string) => string,
- *   strStartsWith: (valueSql: string, lowerParamSql: string, upperParamSql: string) => string,
- *   strStartsWithExact: (valueSql: string, patternA: string, patternB: string) => string,
- *   strEndsWith: (valueSql: string, patternA: string, patternB: string, patternC: string) => string,
- *   strContains: (valueSql: string, patternSql: string) => string,
- *   orderNulls: (nullsFirst: boolean) => string,
- *   timeBucket: (instantSql: string, originSql: string, everyA: string,
- *     everyB: string, everyC: string) => string,
- *   groupAggregate: (fn: string, valueSql: string | null) => string,
- *   rowIdentity: () => string,
- *   identityIn: (identitySql: string, paramSqls: string[]) => string,
- *   rtree?: { module: string, columns: readonly string[] },
- *   explainQuery: (sql: string) => string,
- *   excludedRef: (columnSql: string) => string,
- *   tx: { begin: string, beginImmediate: string, commit: string,
- *     rollback: string,
- *     savepoint: (n: string) => string, release: (n: string) => string,
- *     rollbackTo: (n: string) => string },
- *   pragma: { busyTimeout: (ms: number) => string,
- *     journalMode: (mode: string) => string,
- *     foreignKeys: (on: boolean) => string },
- *   introspect: { version: () => string, compileOptions: () => string,
- *     tableExists: () => string, columns: (table: string) => string,
- *     indexes: (table: string) => string,
- *     indexColumns: (index: string) => string,
- *     foreignKeysOn: () => string,
- *     foreignKeyList: (table: string) => string },
- * }} spec
- * @returns {any} the frozen dialect
- */
-export declare function createDialect(spec: {
-    name: string;
-    capabilities: Record<string, any>;
-    tableSuffix: string;
-    docColumnType: string;
-    packedVectorType: string;
-    quoteIdentifier: (s: string) => string;
-    parameterRef: (i: number, name: string) => string;
-    stringLiteral: (s: string) => string;
-    booleanLiteral: (b: boolean) => string;
-    typeFor: (schemaType: string | undefined, hint: string) => string;
-    limitClause: (limit: number, offset?: number) => string;
-    jsonPathText: (segments: JsonPathSegment[]) => string | null;
-    jsonExtract: (columnSql: string, pathText: string) => string;
-    derivedExpression?: (memberSql: string, column: {
-        derive: string;
-        precision?: number;
-        component?: string;
-        dims?: number;
-    }) => string;
-    jsonSet: (exprSql: string, pathText: string, valueSql: string) => string;
-    jsonRemove: (exprSql: string, pathText: string) => string;
-    jsonAppend: (exprSql: string, arrayPathText: string, valueSql: string) => string;
-    jsonEncode: (paramSql: string) => string;
-    jsonText: (columnSql: string) => string;
-    jsonAgg: (exprSql: string) => string;
-    jsonTypeOf: (columnSql: string, pathText: string) => string;
-    valueTypeOf: (paramSql: string) => string;
-    strStartsWith: (valueSql: string, lowerParamSql: string, upperParamSql: string) => string;
-    strStartsWithExact: (valueSql: string, patternA: string, patternB: string) => string;
-    strEndsWith: (valueSql: string, patternA: string, patternB: string, patternC: string) => string;
-    strContains: (valueSql: string, patternSql: string) => string;
-    orderNulls: (nullsFirst: boolean) => string;
-    timeBucket: (instantSql: string, originSql: string, everyA: string, everyB: string, everyC: string) => string;
-    groupAggregate: (fn: string, valueSql: string | null) => string;
-    rowIdentity: () => string;
-    identityIn: (identitySql: string, paramSqls: string[]) => string;
-    rtree?: {
-        module: string;
-        columns: readonly string[];
-    };
-    explainQuery: (sql: string) => string;
-    excludedRef: (columnSql: string) => string;
-    tx: {
-        begin: string;
-        beginImmediate: string;
-        commit: string;
-        rollback: string;
-        savepoint: (n: string) => string;
-        release: (n: string) => string;
-        rollbackTo: (n: string) => string;
-    };
-    pragma: {
-        busyTimeout: (ms: number) => string;
-        journalMode: (mode: string) => string;
-        foreignKeys: (on: boolean) => string;
-    };
-    introspect: {
-        version: () => string;
-        compileOptions: () => string;
-        tableExists: () => string;
-        columns: (table: string) => string;
-        indexes: (table: string) => string;
-        indexColumns: (index: string) => string;
-        foreignKeysOn: () => string;
-        foreignKeyList: (table: string) => string;
-    };
-}): any;

package/dist/types/dialects/sqlite.d.ts

@@ -1,9 +0,0 @@
-/**
- * @file The SQLite dialect — the first spelling of the dialect
- * contract, not the only conceivable one. Documents are stored JSONB
- * in a BLOB column of a STRICT table; indexed paths become virtual
- * generated columns over `jsonb_extract`; reads render back to text
- * through `json()`. Parameters are positional (`?`) because every
- * binding this package ships binds arrays.
- */
-export declare const sqliteDialect: any;

package/dist/types/driver.d.ts

@@ -1,110 +0,0 @@
-/**
- * @file The driver seam: the contract every binding satisfies, the
- * capability probe that runs once at open, and the sync-capable-async
- * helpers the store composes with.
- *
- * A driver is `{ name, dialect, open(path, options) }`; `open` returns
- * a `Connection` or a promise of one. Every connection method may
- * return a value or a promise — the store never assumes either, and
- * composes through {@link chain}, which does not allocate a promise
- * when the driver answered with a value. That is what keeps the public
- * asynchronous surface from paying twice while the synchronous fast
- * path stays exact.
- *
- * The runtime builtin behind a binding is imported LAZILY inside
- * `open()` via {@link lazyOpen} — never at module scope — because the
- * packed-consumer gate imports every export subpath under Node *and*
- * Bun, Bun ships no `node:sqlite`, and Node cannot resolve `bun:`
- * specifiers. `open()` is where "this driver does not exist here"
- * becomes the coded `JD0003` instead of a module-load crash.
- *
- * `capabilities` is read once at open — from the library's version
- * report, its compile options and the binding's declaration — and is
- * the single source of truth for feature gating; never a `typeof`
- * sniff at a call site. Two slots are deliberately EMPTY on every
- * SQLite driver: `statementTimeout` (no interrupt or progress handler
- * exists to build one on) and `rowEstimates` (the query plan is prose,
- * not numbers). They exist so a driver that has the facts can fill
- * them without a contract change; pretending SQLite has them is the
- * silent degradation this suite refuses.
- */
-import { isThenable, chain, toPromise } from '@jarenjs/core/function';
-/** The minimum SQLite the store accepts, asserted at open. */
-export declare const SQLITE_FLOOR = "3.45.0";
-/**
- * How long work may wait for an open transaction to settle before it is
- * rejected with `JD0012`. Matches the store's default busy timeout: the
- * question "has this waited unreasonably long?" has one answer per
- * connection whether the contention is another process (SQLite's own
- * busy timeout) or another transaction on this one.
- */
-export declare const DEFAULT_QUEUE_TIMEOUT = 5000;
-export { isThenable, chain, toPromise };
-/**
- * Compare two dotted version strings numerically.
- * @param {string} a
- * @param {string} b
- * @returns {number} negative when a < b, zero when equal
- */
-export declare function compareVersions(a: string, b: string): number;
-/**
- * Load a runtime builtin lazily and hand it to the binding's adapter.
- * A failed import — the specifier does not exist on this runtime —
- * becomes `JD0003` carrying the loader's error as `cause`.
- * @param {string} specifier - The builtin module specifier
- * @param {string} reason - The `JD0003` reason for this binding
- * @param {(mod: any, ...args: any[]) => any} use - The binding's
- *   module-to-connection adapter (a named export so the suite can
- *   exercise it with a substitute module on any runtime)
- * @param {any[]} args - Extra arguments forwarded to `use`
- * @returns {Promise<any>}
- */
-export declare function lazyOpen(specifier: string, reason: string, use: (mod: any, ...args: any[]) => any, args: any[]): Promise<any>;
-/**
- * Normalize a raw statement to the contract shape. A binding without a
- * native `iterate` gets one composed over `all` — eager, but the same
- * rows in the same order.
- * @param {{ run: Function, get: Function, all: Function,
- *   iterate?: Function }} statement
- * @returns {{ run: Function, get: Function, all: Function,
- *   iterate: Function }}
- */
-export declare function wrapStatement(statement: {
-    run: Function;
-    get: Function;
-    all: Function;
-    iterate?: Function;
-}): {
-    run: Function;
-    get: Function;
-    all: Function;
-    iterate: Function;
-};
-/**
- * Finish a raw binding into the connection contract: probe the library
- * once, assert the version floor, freeze the capability table, and
- * attach the savepoint-nested `transaction`.
- *
- * The raw shape a binding supplies:
- * `{ exec(sql), prepare(sql) -> { run, get, all, iterate? }, close(),
- *   registerFunction?, registerAggregate?, session? }` — every method
- * value-or-promise.
- *
- * @param {any} raw
- * @param {{ dialect: any, synchronous?: boolean, queueTimeout?: number,
- *   declared?: { sessions?: boolean, userFunctions?: boolean,
- *     deterministicIndexableFunctions?: boolean,
- *     aggregateFunctions?: boolean } }} options
- * @returns {any} a Connection, or a promise of one
- */
-export declare function openConnection(raw: any, options: {
-    dialect: any;
-    synchronous?: boolean;
-    queueTimeout?: number;
-    declared?: {
-        sessions?: boolean;
-        userFunctions?: boolean;
-        deterministicIndexableFunctions?: boolean;
-        aggregateFunctions?: boolean;
-    };
-}): any;

package/dist/types/drivers/bun.d.ts

@@ -1,47 +0,0 @@
-/**
- * @file The Bun binding: `bun:sqlite` behind the driver contract. The
- * builtin is imported lazily inside `open()` — never at module scope —
- * so this module itself loads under any runtime; on a runtime that
- * cannot resolve `bun:` specifiers the open fails with the coded
- * `JD0003`.
- *
- * Probed reality this binding declares rather than papers over:
- * `bun:sqlite`'s `Database` exposes no `function`, no `aggregate` and
- * no `createSession` — on Bun the UDF hatch does not exist and there
- * is no session-based change capture. The capability table says so.
- *
- * What it DOES expose is a native lazy row iterator, forwarded below.
- * Without it the driver's generic fallback composes a cursor over
- * `all()`, which materialises every row first — so a query that streams
- * on Node would spike memory in a compiled Bun binary, on the same code
- * and the same data. A cursor that is not lazy is not a cursor.
- */
-/**
- * Adapt an already-constructed `bun:sqlite` `Database` (or any object
- * with its shape) into a probed connection. Exported so the adapter is
- * exercisable without the builtin.
- * @param {any} db - A Bun `Database`-shaped database
- * @param {{ queueTimeout?: number }} [options]
- * @returns {any} a Connection, or a promise of one
- */
-export declare function adaptBunDatabase(db: any, options?: {
-    queueTimeout?: number;
-}): any;
-/**
- * Construct and adapt the database from a loaded `bun:sqlite` module.
- * Exported so the whole open path runs under any runtime with a
- * substitute module.
- * @param {any} mod - The `bun:sqlite` module (or a substitute)
- * @param {string} path
- * @param {{ readOnly?: boolean, queueTimeout?: number }} [options]
- * @returns {any}
- */
-export declare function fromBunModule(mod: any, path: string, options?: {
-    readOnly?: boolean;
-    queueTimeout?: number;
-}): any;
-/**
- * The Bun driver: `{ name, dialect, open }` over `bun:sqlite`.
- * @returns {any}
- */
-export declare function bunDriver(): any;

package/dist/types/drivers/node.d.ts

@@ -1,37 +0,0 @@
-/**
- * @file The Node binding: `node:sqlite` behind the driver contract.
- * The builtin is imported lazily inside `open()` — never at module
- * scope — so this module itself loads under any runtime; on a runtime
- * without `node:sqlite` the open fails with the coded `JD0003`.
- */
-/**
- * Adapt an already-constructed `node:sqlite` `DatabaseSync` (or any
- * object with its shape) into a probed connection. Exported so the
- * adapter is exercisable without the builtin.
- * @param {any} db - A `DatabaseSync`-shaped database
- * @param {{ queueTimeout?: number }} [options]
- * @returns {any} a Connection, or a promise of one
- */
-export declare function adaptNodeDatabase(db: any, options?: {
-    queueTimeout?: number;
-}): any;
-/**
- * Construct and adapt the database from a loaded `node:sqlite` module.
- * The seam {@link nodeDriver} feeds through `lazyOpen`; exported so the
- * whole open path runs under any runtime with a substitute module.
- * @param {any} mod - The `node:sqlite` module (or a substitute)
- * @param {string} path
- * @param {{ timeout?: number, readOnly?: boolean,
- *   queueTimeout?: number }} [options]
- * @returns {any}
- */
-export declare function fromNodeModule(mod: any, path: string, options?: {
-    timeout?: number;
-    readOnly?: boolean;
-    queueTimeout?: number;
-}): any;
-/**
- * The Node driver: `{ name, dialect, open }` over `node:sqlite`.
- * @returns {any}
- */
-export declare function nodeDriver(): any;

package/dist/types/drivers/wasm.d.ts

@@ -1,65 +0,0 @@
-/**
- * @file The wasm binding: an INJECTED handle behind the driver
- * contract. This module imports no runtime builtin at all — the host
- * (a browser, a worker) supplies the SQLite build, and this driver
- * only adapts it. Every handle method may return a value or a promise;
- * a main-thread OPFS-backed build is asynchronous and that is exactly
- * why the public store surface is.
- *
- * The injected contract:
- *
- *   handle = {
- *     open(path, options) -> raw | Promise<raw>,
- *     synchronous?: boolean,           // default false
- *     declares?: { userFunctions?, deterministicIndexableFunctions?,
- *                  sessions? }         // default all false
- *   }
- *   raw = { exec(sql), prepare(sql) -> { run, get, all, iterate? },
- *           close(), registerFunction?, registerAggregate?, session? }
- *
- * Capability truth still comes from the probe: whatever the handle
- * declares is intersected with what the loaded library actually
- * compiled in.
- */
-/**
- * Adapt an already-constructed `sqlite3.oo1` database (the official
- * SQLite wasm build's object API) into the raw contract. The oo1 API
- * is SYNCHRONOUS — wasm SQLite computes in place and the SAH-pool
- * OPFS VFS does synchronous I/O inside a dedicated worker — which is
- * exactly what keeps journal capture, live queries and the job queue
- * working unchanged in a browser.
- *
- * Statements are REUSED by the store's prepared caches: every
- * operation ends in `reset()`, never `finalize()`. oo1 user functions
- * receive a context pointer first — stripped here — and register
- * variadic (`arity: -1`), matching the engine's fragment shapes.
- * @param {any} sqlite3 - the loaded sqlite3 module (for `capi`)
- * @param {any} db - an `sqlite3.oo1.DB`-shaped database
- * @returns {any} the raw binding for {@link openConnection}
- */
-export declare function adaptOo1Database(sqlite3: any, db: any): any;
-/**
- * Build the injected HANDLE from a loaded sqlite3 module — the D6
- * recipe: the host loads the wasm build and picks the database class
- * (`sqlite3.oo1.DB` for `:memory:`, the SAH-pool util's `OpfsSAHPoolDb`
- * for OPFS persistence), and this package only adapts it.
- *
- * `sessions` is deliberately NOT declared even though the canonical
- * wasm build compiles `ENABLE_SESSION`: this adapter does not yet map
- * the session C API, so capture runs in the journal mode — stated in
- * the capability matrix, adapting it is a roadmap item.
- * @param {any} sqlite3 - the loaded sqlite3 module
- * @param {{ DbClass?: any }} [handleOptions] - the database class to
- *   construct (default `sqlite3.oo1.DB`)
- * @returns {any} a handle for {@link wasmDriver}
- */
-export declare function sqlite3Handle(sqlite3: any, handleOptions?: {
-    DbClass?: any;
-}): any;
-/**
- * The wasm driver over an injected handle.
- * @param {any} handle - The host-supplied SQLite handle (see the file
- *   header for the contract)
- * @returns {any}
- */
-export declare function wasmDriver(handle: any): any;

package/dist/types/emit-model.d.ts

@@ -1,44 +0,0 @@
-/**
- * @file Entity types from models (D17): build an EMIT MODEL DOCUMENT
- * — the published contract from EMIT-FORMAT.md — that renders entity
- * interfaces, input variants and the typed-store metadata from the
- * same model document the runtime validates against.
- *
- * The seam (EMIT-FORMAT §4.1, recorded here as the order demanded):
- * the schema compiler is INJECTED (`options.compile` is
- * `compileEmitModel` from `@jarenjs/emit`), called with
- * `extensions: ['x-entity']` so the vocabulary rides the member nodes
- * verbatim; this module then post-processes the MODEL DOCUMENT —
- * replacing relation member types with references, flipping
- * optionality, adding declarations — and never renders a character of
- * TypeScript itself. Emit stays database-free, db stays
- * renderer-free, and the injection keeps `@jarenjs/emit` out of db's
- * dependency graph (the generator script wires the two).
- *
- * What the artifact says, deliberately:
- * - entity interfaces are CLOSED objects (excess-property checking is
- *   the point of generated types; the runtime validator stays
- *   authoritative for what a database accepts);
- * - relation members are optional references — present only when a
- *   graph load included them; `date-time`/`date` strings carry the
- *   `DateTime` brand so the linq date operators light up;
- * - the `<Name>Input` variant makes defaulted and generated members
- *   optional, drops to-one/to-many relation members (`create`/`add`
- *   refuse them), and types many-to-many members as key-or-document
- *   arrays (what `add()` accepts);
- * - `EntityMetaMap` carries doc/input/key/relations per entity — the
- *   generic typed-store surface (`@jarenjs/db/typed`) binds to it.
- */
-/**
- * Build the emit-model document for a model's entities.
- * @param {any} model - a jaren-model document with `entities`
- * @param {{ compile: (schema: any, options?: any) => any,
- *   source?: string, reserved?: string[] }} options - `compile` is
- *   `compileEmitModel` (injected; see the header)
- * @returns {any} an EMIT-FORMAT `0.1` model document
- */
-export declare function entityEmitModel(model: any, options: {
-    compile: (schema: any, options?: any) => any;
-    source?: string;
-    reserved?: string[];
-}): any;

package/dist/types/emit.d.ts

@@ -1,75 +0,0 @@
-/**
- * @file Plan → SQL through a dialect. This is the query layer's shared
- * emitter, the same division of labour as `createDialect`'s DDL/DML
- * builders: structural SQL composition lives here, every
- * dialect-varying spelling (identifiers, parameters, string literals,
- * JSON access, `json_type`, `typeof`, string-operator forms, NULLS
- * placement, EXPLAIN phrasing) comes from the dialect. Values are
- * NEVER interpolated into the text: every literal and every external
- * becomes an ordered parameter slot, which is what makes injection
- * structurally impossible.
- *
- * Every emitted predicate is TOTAL (two-valued) by construction — the
- * `json_type` guards from the truth table in ARCHITECTURE.md — so
- * `NOT`/`AND`/`OR` compose classically and SQL's three-valued NULL
- * logic never decides a row.
- */
-export type ParamSlot = {
-    external: string;
-} | {
-    literal: unknown;
-} | {
-    derived: {
-        kind: 'bboxAxis';
-        external: string;
-        axis: 'w' | 's' | 'e' | 'n';
-    };
-};
-/**
- * Emit one plan as SQL plus its ordered parameter slots.
- * @param {import('./algebra.js').Plan} plan
- * @param {any} dialect
- * @param {{ table: string, keyColumn: string, docColumn: string }} physical
- * @returns {{ sql: string, slots: ParamSlot[] }}
- */
-export declare function emitPlan(plan: import('./algebra.js').Plan, dialect: any, physical: {
-    table: string;
-    keyColumn: string;
-    docColumn: string;
-}): {
-    sql: string;
-    slots: ParamSlot[];
-};
-/**
- * The entity predicate emitters, shared by the entity plan emitter
- * and the graph-load builder: given an alias and its document column,
- * emit one predicate with the flavor-correct forms.
- * @param {any} dialect
- * @param {(slot: ParamSlot) => string} param
- * @returns {{ emitPred: (aliasSql: string, docSql: string, pred: any) => string }}
- */
-export declare function createEntityPredicateEmitters(dialect: any, param: (slot: ParamSlot) => string): {
-    emitPred: (aliasSql: string, docSql: string, pred: any) => string;
-};
-/**
- * Emit an entity plan (`entity-select` or `entity-join`) as SQL plus
- * ordered parameter slots. Entity-COLUMN refs compare real typed
- * columns with TOTAL forms and no `json_type` guard — a column-mapped
- * property has no present-`null` (§9.3), so presence IS `IS NOT
- * NULL`; entity-EPOCH refs compare the derived integer column against
- * a plan-time epoch translation; entity-DOC refs ride the phase-A
- * guarded truth table over the entity's JSONB column. Join emission
- * appends BOTH bindings' row identities in binding order, which is
- * exactly the engine's nested-loop order — determinism the oracle
- * depends on.
- * @param {any} plan - from `planEntityQuery`
- * @param {any} dialect
- * @param {(entity: string) => { table: string }} physicalOf
- * @returns {{ sql: string, slots: ParamSlot[] }}
- */
-export declare function emitEntityPlan(plan: any, dialect: any, physicalOf: (entity: string) => {
-    table: string;
-}): {
-    sql: string;
-    slots: ParamSlot[];
-};

package/dist/types/entity.d.ts

@@ -1,23 +0,0 @@
-/**
- * @file Entity sets: create / read by key / update / delete over the
- * hybrid mapping. The physical row is the mapped scalar columns, the
- * foreign-key columns, and one JSONB `doc` column for everything
- * else; a write SPLITS the completed document along the mapping and a
- * read MERGES it back. Defaults apply in JavaScript before validation
- * — the value the application sees and the value stored are the same
- * — and identity follows the declared strategy (caller, uuid, auto).
- *
- * Epoch date columns are DERIVED: the document keeps the RFC 3339
- * string, the column carries `getEpochOf…RFC3339(value)` so range
- * predicates are index-friendly; reads take the string from the
- * document and skip the derived column.
- */
-/**
- * The write/read machinery for one entity, prepared once.
- * @param {any} connection
- * @param {any} entity - the normalized entity (model.js)
- * @param {any} entityMapping - `explainMapping(...).entities[name]`
- * @param {((doc: any) => any) | null} validate
- * @returns {any}
- */
-export declare function entityCore(connection: any, entity: any, entityMapping: any, validate: ((doc: any) => any) | null): any;