@jarenjs/db 0.49.2 → 0.56.0

package/dist/types/ddl.d.ts

@@ -1,229 +0,0 @@
-/**
- * @file DDL planning: a normalized collection becomes one physical
- * table — a key column, a JSON document column, a virtual generated
- * column per indexed path, and the declared indexes — with every byte
- * of SQL rendered by the dialect.
- *
- * Index paths are JSONPath expressions analyzed through the engine's
- * PUBLISHED AST (`analyzeQuery`): a path is indexable exactly when the
- * analysis says it is singular and every segment is a plain member or
- * index selection. That reuses the one grammar authority instead of
- * re-parsing, and it fails loudly (`JD0004`) on everything else —
- * wildcards, slices, filters, descendants, functions — rather than
- * silently indexing the wrong thing.
- */
-/** The fixed physical column names of the 0.1 mapping. */
-export declare const KEY_COLUMN = "key";
-export declare const DOC_COLUMN = "doc";
-/**
- * Analyze one index path expression down to typed segments.
- * @param {string} expression - A JSONPath expression (`$.email`)
- * @param {string} docPath - Model-document pointer for diagnostics
- * @returns {{ segments: import('./dialect.js').JsonPathSegment[],
- *   canonical: string }}
- */
-export declare function compileIndexPath(expression: string, docPath: string): {
-    segments: import('./dialect.js').JsonPathSegment[];
-    canonical: string;
-};
-/**
- * The schema subschema at a segment path, walked structurally through
- * `properties` / `items` / `prefixItems`. The collection's schema is
- * the type source — that is why the physical mapping needs no
- * engine-side inference. `undefined` where the walk leaves the schema.
- * @param {any} schema
- * @param {import('./dialect.js').JsonPathSegment[]} segments
- * @returns {any}
- */
-export declare function schemaNodeAt(schema: any, segments: import('./dialect.js').JsonPathSegment[]): any;
-/**
- * The declared schema type at a segment path: the first non-`null`
- * member of a union, which is the type a COLUMN takes its storage
- * from. A caller that must know the whole union (a promotion refusing
- * a member that may also be `null`) reads {@link schemaNodeAt}.
- * @param {any} schema
- * @param {import('./dialect.js').JsonPathSegment[]} segments
- * @returns {string | undefined}
- */
-export declare function schemaTypeAt(schema: any, segments: import('./dialect.js').JsonPathSegment[]): string | undefined;
-/**
- * Plan one collection's physical shape: the DDL statements to create
- * it and the structural facts an existing table must match (the
- * `JD0002` comparison set).
- * A derived index (`derive: 'geohash' | 'bbox'`) maps to the same
- * shape through a registered deterministic function, EXCEPT where the
- * driver cannot index one (`capabilities.deterministicIndexableFunctions`
- * is false): there the columns are ordinary ones the store writes. The
- * two mappings produce different declared text on purpose — a database
- * built under one and opened under the other really does disagree, and
- * `verifyShape` says so rather than papering over it. A
- * `derive: 'vector'` column is the stored shape under BOTH mappings
- * (`derivedMappingFor`), so for it the two agree.
- * @param {string} name - The collection name (also the table name)
- * @param {{ schema: any, keySegments: { name: string }[] | null,
- *   identity: string, indexes: { name: string, paths: string[],
- *   unique: boolean, derive?: string | null, precision?: number,
- *   dims?: number, docPath: string }[] }} collection - normalized
- * @param {any} dialect
- * @param {{ derived?: 'virtual' | 'stored', rtree?: boolean }} [options]
- *   - `derived` is the physical mapping for derived columns:
- *   `'virtual'` (a generated column over a registered function) unless
- *   the driver says it cannot index one. `rtree` is whether the driver
- *   carries the R\*Tree module; when it does not, a column set that
- *   declared `physical: 'rtree'` falls back to the B-tree over its
- *   columns and `explain().prefilters[].via` reports which shape ran
- *   (MODEL-FORMAT §4) — a report, not a silent degradation
- * @returns {{
- *   table: string, keyColumn: string, docColumn: string,
- *   keyType: string,
- *   generated: { name: string, type: string, pathText: string,
- *     canonical: string }[],
- *   derived: { name: string, derive: string, precision?: number,
- *     component?: string, dims?: number, segments: any[] }[],
- *   columnByCanonical: Map<string, string>,
- *   createSql: string[],
- *   virtualTables: { stem: string, name: string, columns: string[],
- *     edges: string[], createSql: string, fillSql: string,
- *     triggers: { name: string, sql: string }[] }[],
- *   expected: { columns: { name: string, type: string,
- *     generated: boolean }[], indexes: { name: string, unique: boolean,
- *     columns: string[] }[] },
- * }}
- */
-export declare function planCollection(name: string, collection: {
-    schema: any;
-    keySegments: {
-        name: string;
-    }[] | null;
-    identity: string;
-    indexes: {
-        name: string;
-        paths: string[];
-        unique: boolean;
-        derive?: string | null;
-        precision?: number;
-        dims?: number;
-        docPath: string;
-    }[];
-}, dialect: any, options?: {
-    derived?: 'virtual' | 'stored';
-    rtree?: boolean;
-}): {
-    table: string;
-    keyColumn: string;
-    docColumn: string;
-    keyType: string;
-    generated: {
-        name: string;
-        type: string;
-        pathText: string;
-        canonical: string;
-    }[];
-    derived: {
-        name: string;
-        derive: string;
-        precision?: number;
-        component?: string;
-        dims?: number;
-        segments: any[];
-    }[];
-    columnByCanonical: Map<string, string>;
-    createSql: string[];
-    virtualTables: {
-        stem: string;
-        name: string;
-        columns: string[];
-        edges: string[];
-        createSql: string;
-        fillSql: string;
-        triggers: {
-            name: string;
-            sql: string;
-        }[];
-    }[];
-    expected: {
-        columns: {
-            name: string;
-            type: string;
-            generated: boolean;
-        }[];
-        indexes: {
-            name: string;
-            unique: boolean;
-            columns: string[];
-        }[];
-    };
-};
-/**
- * Normalize a stored `CREATE` statement for comparison: collapse runs of
- * whitespace, drop whitespace around punctuation, and strip the
- * `IF NOT EXISTS` SQLite does not keep. What survives is every token that
- * carries meaning, so two statements compare equal exactly when they
- * declare the same physical object.
- * @param {string} sql
- * @returns {string}
- */
-export declare function normalizeDeclaredSql(sql: string): string;
-/**
- * A comparable form of one `CREATE` statement.
- *
- * For a TABLE the column definitions compare as a SET, because
- * `ALTER TABLE … ADD COLUMN` can only append — so a migrated table and a
- * freshly built one legitimately differ in column order, and this store
- * never reads a column positionally. Everything else is exact: each
- * column's full definition (type, `PRIMARY KEY`, `NOT NULL`, `DEFAULT`,
- * `CHECK`, `GENERATED … AS`, `REFERENCES … ON DELETE …`), the table
- * constraints, and the trailing table options (`STRICT`,
- * `WITHOUT ROWID`).
- *
- * For an INDEX the text compares whole, because an index IS its order —
- * `(a,b)` and `(b,a)` serve different lookups — as are its partial
- * predicate and each term's collation and direction.
- * @param {string} sql
- * @returns {string}
- */
-export declare function comparableDeclaredSql(sql: string): string;
-/**
- * Verify an existing table against the planned shape; any difference
- * is `JD0002` and nothing is altered. Shared by the store's open path
- * and the migration engine's shadow validation.
- * @param {any} connection
- * @param {any} plan
- * @param {string} collection
- * @param {string} docPath
- * @returns {any} value-or-promise
- */
-export declare function verifyShape(connection: any, plan: any, collection: string, docPath: string): any;
-/**
- * Plan one ENTITY's physical shape from the mapping data
- * `explainMapping` derived: the relational table (typed columns,
- * checks, foreign keys, the JSONB document column), its indexes, and
- * the structural facts an existing table must match. One verify path
- * serves both document kinds.
- * @param {string} name
- * @param {any} entityMapping - `explainMapping(model).entities[name]`
- * @param {any} entities - the full `explainMapping` result (key types
- *   come from the referenced entity's columns)
- * @param {any} dialect
- * @returns {{ table: string, createSql: string[], expected: any,
- *   columnNames: Set<string> }}
- */
-export declare function planEntity(name: string, entityMapping: any, entities: any, dialect: any): {
-    table: string;
-    createSql: string[];
-    expected: any;
-    columnNames: Set<string>;
-};
-/**
- * Plan a many-to-many join table.
- * @param {string} tableName
- * @param {any} join - `explainMapping(model).joinTables[tableName]`
- * @param {any} entities - the full mapping
- * @param {any} dialect
- * @returns {{ table: string, createSql: string[], expected: any }}
- */
-export declare function planJoinTable(tableName: string, join: any, entities: any, dialect: any): {
-    table: string;
-    createSql: string[];
-    expected: any;
-};

package/dist/types/derive.d.ts

@@ -1,250 +0,0 @@
-/**
- * @file Derived index columns: the one place a declared
- * `indexes[].derive` becomes a value. A spatial member is an array of
- * numbers or an object, and a generated column must be a scalar, so a
- * geohash cell or a bounding-box edge is what actually gets indexed;
- * an embedding is an array of hundreds of numbers, and what gets
- * stored is its packed, l2-normalized Float32 form.
- *
- * Every cell and every box comes from `@jarenjs/core/geo`, and every
- * normalization and packing from `@jarenjs/core/vector`; nothing here
- * computes arithmetic of its own. The spatial functions serve BOTH
- * physical mappings — registered as deterministic SQL functions inside
- * a virtual generated column's expression where the driver can index
- * them, and called directly on the write path where it cannot — so
- * the two branches cannot drift into different answers. The vector
- * kind has ONE mapping, stored everywhere (`DERIVE_MAPPING`), and
- * registers no function at all: a whole array re-derived per row as a
- * host call is the cost the spatial work measured at 150×, a stored
- * column is readable without any registration, and bun has no
- * function API — one mapping is the only way every driver agrees.
- *
- * It is also this package's ONLY seam onto `@jarenjs/core/geo` (D1 —
- * one home for spatial arithmetic, grep-proven by test) and onto
- * `@jarenjs/core/vector` (the same rule, one home for vector
- * arithmetic): the planner's probe geometry — the box of a literal or
- * bound region, the box of a bounded-distance circle, a cell's
- * neighbourhood — and the k-nearest plan's probe vector and column
- * score are computed by the helpers below rather than by an import of
- * their own.
- *
- * The switches over the kind are EXHAUSTIVE: a kind with no rule
- * throws, here and in the dialect, so that adding a kind without
- * teaching both is a failure at the first call rather than a bbox
- * edge of the first two floats and `jaren_bbox_undefined(...)` SQL.
- *
- * Determinism is the contract, not a convenience: a value here is a
- * pure function of the document bytes. Nothing reads the clock, a
- * random source or store state, because an INDEX over a function that
- * did would make the database unreadable from a connection whose
- * function answered differently — and unreadable, not merely wrong:
- * a connection that has not registered the function at all cannot even
- * SELECT the table (probed). That hazard is why the mapping is
- * capability-gated rather than always-on.
- */
-/** The closed set of derive kinds. */
-export declare const DERIVE_KINDS: Set<string>;
-/**
- * The per-kind PHYSICAL MAPPING override. A spatial kind takes the
- * mapping the driver's capability selects (`null` here); the vector
- * kind is `'stored'` on every driver, for the three reasons in the
- * file header, and never joins `registerDeriveFunctions`.
- * @type {Readonly<Record<string, 'stored' | null>>}
- */
-export declare const DERIVE_MAPPING: Readonly<Record<string, 'stored' | null>>;
-/**
- * The physical mapping one derived column takes: the kind's override
- * where it has one, the driver's mapping otherwise.
- * @param {string} kind
- * @param {'virtual' | 'stored'} driverMapping
- * @returns {'virtual' | 'stored'}
- */
-export declare function derivedMappingFor(kind: string, driverMapping: 'virtual' | 'stored'): 'virtual' | 'stored';
-/**
- * The closed set of PHYSICAL realizations a `derive: 'bbox'` index may
- * ask for. `'columns'` is the default and what an absent member means:
- * four generated columns under one B-tree. `'rtree'` is the same four
- * columns (they stay the box's one definition) beside a SQLite R\*Tree
- * virtual table kept in sync by declared triggers, with no B-tree over
- * them. The LOGICAL meaning of `derive: 'bbox'` is identical either
- * way — same rows, same answers — which is the whole point of naming
- * the shape separately from the derivation.
- */
-export declare const PHYSICAL_KINDS: Set<string>;
-/** A bbox index's four columns, in the order they are declared —
- * `[west, south, east, north]`, the order the kernel's boxes carry. */
-export declare const BBOX_COMPONENTS: readonly string[];
-/**
- * The order a bbox index COVERS its four columns, which is not the
- * order they are declared in: an intersection test reads
- * `w <= ? AND e >= ? AND s <= ? AND n >= ?`, so the two longitude
- * bounds sit together at the front of the index where a leading-column
- * range can use them. `(a,b)` and `(b,a)` are different indexes.
- */
-export declare const BBOX_INDEX_ORDER: readonly string[];
-/** The declared geohash precision range (characters). */
-export declare const PRECISION_MIN = 1;
-export declare const PRECISION_MAX = 12;
-/** The declared vector width range (components). */
-export declare const DIMS_MIN = 1;
-export declare const DIMS_MAX = 8192;
-/**
- * The geohash cell of a value at a precision, or null when the value
- * carries no bounded position.
- * @param {any} value
- * @param {number} precision
- * @returns {string | null}
- */
-export declare function deriveGeohash(value: any, precision: number): string | null;
-/**
- * One edge of a value's bounding box, or null when it has none —
- * including the D6 case where a non-finite coordinate refuses the box
- * rather than producing one that does not bound its input.
- * @param {any} value
- * @param {string} component - `'w'`, `'s'`, `'e'` or `'n'`
- * @returns {number | null}
- */
-export declare function deriveBboxEdge(value: any, component: string): number | null;
-/**
- * The value of a `derive: 'vector'` column for a document member — the
- * ONE seam from this package onto `@jarenjs/core/vector`. The member
- * round-trips through its stored form first, exactly as the spatial
- * kinds do: a `Float32Array` in the document is held as an object and
- * a `NaN` as `null`, and the column must be a function of what is
- * held, so that a write, a migration backfill and a second open can
- * never disagree about one row.
- * @param {any} member - the value at the index path, or `undefined`
- * @param {number} dims - the declared width
- * @returns {Uint8Array | null} `4·dims` bytes, or `null` when the
- *   member is not a vector of that width
- */
-export declare function deriveVector(member: any, dims: number): Uint8Array | null;
-/**
- * A member as the database will hold it. A derived value must be a
- * function of the STORED document, not of the object handed to the
- * write: JSON has no `NaN` and no `Infinity`, so a non-finite
- * coordinate becomes `null` on the way in and is no longer a position
- * at all. Computing from the in-memory value would make the two
- * physical mappings answer differently for the same document, which is
- * the one thing they may never do.
- *
- * Only the indexed MEMBER round-trips, not the whole document — it is
- * the only part a derived column reads.
- * @param {any} member
- * @returns {any} the member as stored, or `undefined` when there is none
- */
-export declare function storedMemberForm(member: any): any;
-/**
- * The value of one derived column for a document member, which the
- * caller hands over in its STORED form (`storedMemberForm`): the write
- * path round-trips it, and a migration backfill reads it from the row.
- * Exhaustive over the kind — see the file header.
- * @param {{ derive: string, precision?: number, component?: string,
- *   dims?: number }} column
- * @param {any} member - the stored value at the index path, or `undefined`
- * @returns {string | number | Uint8Array | null}
- */
-export declare function derivedValue(column: {
-    derive: string;
-    precision?: number;
-    component?: string;
-    dims?: number;
-}, member: any): string | number | Uint8Array | null;
-/**
- * Read the member one derived column is computed from, walking the
- * same typed segments the physical mapping was planned over.
- * @param {any} doc
- * @param {import('./dialect.js').JsonPathSegment[]} segments
- * @returns {any} the member, or `undefined`
- */
-export declare function memberAt(doc: any, segments: import('./dialect.js').JsonPathSegment[]): any;
-/**
- * Register the deterministic functions the virtual generated columns
- * call. Idempotent per connection by SQLite's own semantics (a second
- * registration replaces the first with the identical implementation),
- * and a no-op where the driver cannot index a registered function —
- * that branch stores the columns instead.
- *
- * The four bbox edges share a one-entry memo of the last text they
- * were asked about, because they are called back to back with the same
- * argument for one row and the box costs a full walk of the geometry.
- * The memo is keyed on the argument itself, so it changes no answer.
- * @param {any} connection
- * @returns {any} value-or-promise
- */
-export declare function registerDeriveFunctions(connection: any): any;
-/**
- * The bounding box of a probe value, or `null` when it has none — the
- * D6 refusal included, which is what makes an unbounded probe divert to
- * the full scan instead of narrowing with a box that does not bound it.
- * @param {any} value - a GeoJSON value or a `[lon, lat]` position
- * @returns {number[] | null} `[west, south, east, north]`
- */
-export declare function probeBox(value: any): number[] | null;
-/**
- * The representative position §8.14 measures a probe value by — the
- * same rule the derived columns use, so the pushed filter and the
- * engine cannot disagree about where a value IS. `null` when it has no
- * bounded position.
- * @param {any} value
- * @returns {number[] | null}
- */
-export declare function probePosition(value: any): number[] | null;
-/**
- * The bounding box of the circle of `metres` around a position — the
- * box a `$distance <= r` predicate narrows with, on the same sphere and
- * the same radius constant the engine measures with. `null` when the
- * radius is not a finite non-negative number, or when the circle
- * reaches a pole, where there is no longitude bound to give.
- * @param {number[]} position
- * @param {number} metres
- * @returns {number[] | null} `[west, south, east, north]`, NOT wrapped
- *   into `[-180, 180]`: a circle spanning the antimeridian answers a
- *   west below -180, which is how the planner detects it
- */
-export declare function probeCircleBox(position: number[], metres: number): number[] | null;
-/**
- * A cell and its neighbours, the nine-cell probe D7 requires — a single
- * prefix is bucketing, never proximity.
- * @param {string} cell
- * @returns {string[]} up to nine cells (fewer past a pole)
- */
-export declare function cellNeighbourhood(cell: string): string[];
-/**
- * The value one DERIVED parameter slot binds: an axis of a bound
- * external's bounding box, computed at bind time because a GeoJSON
- * object is not a value any database can bind. `null` when the value
- * has no box, which is what tells the caller to divert.
- * @param {{ kind: string, external: string, axis: string }} derived
- * @param {any} value - the bound external
- * @returns {number | null}
- */
-export declare function derivedSlotValue(derived: {
-    kind: string;
-    external: string;
-    axis: string;
-}, value: any): number | null;
-/**
- * The probe a k-nearest plan scores the column against: a literal or
- * bound vector, l2-normalized once, so that its dot product with the
- * column's normalized form IS the cosine of the raw vectors. `null`
- * when the value is not a vector of exactly `dims` finite numbers —
- * the binder's signal to divert the call to the residual, where the
- * engine answers what it answers everywhere for such a probe (empty
- * keys for another width, its own refusal for a non-array).
- * @param {unknown} value
- * @param {number} dims - the column's declared width
- * @returns {Float32Array | null}
- */
-export declare function probeVector(value: unknown, dims: number): Float32Array | null;
-/**
- * One row's column score against a prepared probe: the packed column
- * unpacked at the declared width and dotted with the probe. `null` for
- * a row whose column holds no vector — SQL `NULL`, or bytes of another
- * length — because such a row is unrankable and 0 is a real score.
- * @param {unknown} bytes - the column value as the driver returns it
- * @param {number} dims
- * @param {Float32Array} probe - from {@link probeVector}
- * @returns {number | null}
- */
-export declare function columnScore(bytes: unknown, dims: number, probe: Float32Array): number | null;

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;