@crvouga/postgres-mem 0.1.0

package/dist/lexer/tokenize.d.ts

@@ -0,0 +1,8 @@
+export type TokenType = "ident" | "quoted_ident" | "string" | "bitstring" | "number" | "param" | "op" | "punct" | "eof";
+export interface Token {
+    readonly type: TokenType;
+    readonly value: string;
+    /** byte offset in the source (for error positions) */
+    readonly pos: number;
+}
+export declare function tokenize(sql: string): Token[];

package/dist/parser/index.d.ts

@@ -0,0 +1 @@
+export { parse, parseSingle } from "./parser.js";

package/dist/parser/parser.d.ts

@@ -0,0 +1,96 @@
+import type { Expr, SelectStmt, Statement, TypeName, WithClause } from "../ast/nodes.js";
+export declare class Parser {
+    private tokens;
+    private pos;
+    constructor(sql: string);
+    private peek;
+    private next;
+    private atKw;
+    private eatKw;
+    private expectKw;
+    private atPunct;
+    private eatPunct;
+    private expectPunct;
+    private atOp;
+    private eatOp;
+    private errorAt;
+    /** identifier (unquoted non-reserved or quoted) */
+    private ident;
+    private qualifiedName;
+    parseStatements(): Statement[];
+    parseStatement(): Statement;
+    private skipToStatementEnd;
+    private parseWithableStatement;
+    private parseWithClause;
+    parseSelectStmt(withClause?: WithClause | null): SelectStmt;
+    private parseSelectBody;
+    private parseSelectTerm;
+    private parseSelectPrimary;
+    private parseSelectCore;
+    private parseGroupItem;
+    private parseSelectTarget;
+    private parseOrderByClause;
+    private parseOrderByItem;
+    private parseLimitOffset;
+    private parseFromItem;
+    private tryParseJoin;
+    private parseFromPrimary;
+    private parseWithOrdinality;
+    private parseAliasClause;
+    private parseInsert;
+    private parseReturning;
+    private parseUpdateSets;
+    private parseSetColumn;
+    private parseUpdate;
+    private parseDelete;
+    private parseCreate;
+    private parseIfNotExists;
+    private parseIfExists;
+    private parseCreateTable;
+    private tryParseTableConstraint;
+    private skipConstraintTail;
+    private parseRefActions;
+    private parseRefAction;
+    private parseColumnDef;
+    private parseIdentityOptions;
+    private parseSequenceOptions;
+    private parseSignedBigInt;
+    private parseCreateIndex;
+    private parseCreateView;
+    private parseCreateFunction;
+    private parseCreateTrigger;
+    private parseAlter;
+    private parseAlterTableAction;
+    private parseDrop;
+    private parseTruncate;
+    private parseSet;
+    private parseExplain;
+    private parseCopy;
+    parseTypeName(): TypeName;
+    parseExpr(): Expr;
+    private parseOr;
+    private parseAnd;
+    private parseNot;
+    private parseIs;
+    private parseComparison;
+    private tryParseAnyAll;
+    private parseLikeBetweenIn;
+    /** all other binary operators: ||, &, |, #, <<, >>, @>, <@, ->, ->>, etc. */
+    private parseGenericOps;
+    private parseAdditive;
+    private parseMultiplicative;
+    private parseExponent;
+    private parseUnary;
+    private parsePostfix;
+    private parsePrimary;
+    private parseCase;
+    private maybePrecision;
+    private parseNestedArrayLiteral;
+    private parseFuncCall;
+    private parseWindowSpec;
+    private parseFrameBound;
+}
+/** Parse SQL text into a list of statements. */
+export declare function parse(sql: string): Statement[];
+/** Parse exactly one statement; throws `misuse`-style errors handled by API layer. */
+export declare function parseSingle(sql: string): Statement;

package/dist/runtime/clock.d.ts

@@ -0,0 +1,14 @@
+/** Fixed reference instant used when callers do not supply a clock (`2000-01-01T00:00:00.000Z`). */
+export declare const DEFAULT_NOW: Date;
+/** Function that returns the current instant for `now()` and related builtins. */
+export type Clock = () => Date;
+/**
+ * Clock that always returns a copy of `instant` (default {@link DEFAULT_NOW}).
+ *
+ * @throws {RangeError} If `instant` is an invalid `Date`.
+ */
+export declare function fixedClock(instant?: Date): Clock;
+/** Wall-clock `now()` matching PostgreSQL (`new Date()` each call). */
+export declare function systemClock(): Clock;
+/** Normalize a `Date`, {@link Clock}, `"system"`, or `undefined` into a {@link Clock}. */
+export declare function resolveClock(now?: Date | Clock | "system"): Clock;

package/dist/runtime/index.d.ts

@@ -0,0 +1,3 @@
+export { type Clock, DEFAULT_NOW, fixedClock, resolveClock, systemClock } from "./clock.js";
+export { type DatabaseOptions, DEFAULT_DATABASE_SEED, type RandomMode } from "./options.js";
+export { deriveSeed, OsEntropy, Prng } from "./prng.js";

package/dist/runtime/options.d.ts

@@ -0,0 +1,25 @@
+import type { Clock } from "./clock.js";
+/** Entropy source for `random()` / `gen_random_uuid()`. Default is seeded xorshift64*. */
+export type RandomMode = "deterministic" | "os";
+/** Options for {@link Database} construction. All fields are optional. */
+export interface DatabaseOptions {
+    /**
+     * Seed for deterministic `random()` (and any other PRNG-backed builtins).
+     * Defaults to {@link DEFAULT_DATABASE_SEED} (`1`). Ignored when {@link random} is `"os"`.
+     */
+    seed?: number | bigint;
+    /**
+     * Entropy for `random()` / `gen_random_uuid()`.
+     * `"deterministic"` (default) uses {@link seed}. `"os"` uses CSPRNG like PostgreSQL
+     * (not rolled back with transactions; not restored from snapshots).
+     */
+    random?: RandomMode;
+    /**
+     * Clock for `now()` / `current_timestamp` / etc.
+     * Defaults to a fixed instant (`2000-01-01T00:00:00.000Z`).
+     * Pass a `Date`, `() => Date`, or `"system"` for wall-clock `now()` like PostgreSQL.
+     */
+    now?: Date | Clock | "system";
+}
+/** Default {@link DatabaseOptions.seed} when constructing a {@link Database}. */
+export declare const DEFAULT_DATABASE_SEED = 1;

package/dist/runtime/prng.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Deterministic 64-bit PRNG (xorshift64*).
+ * Used for PostgreSQL `random()` / `gen_random_uuid()` and any other
+ * nondeterministic builtins.
+ */
+export declare class Prng {
+    private state;
+    /**
+     * @param seed - Engine seed. `0` is replaced with a non-zero constant.
+     */
+    constructor(seed?: number | bigint);
+    /** Next unsigned 64-bit value. */
+    nextU64(): bigint;
+    /** Next float in `[0, 1)` from 53 bits of {@link nextU64}. */
+    nextFloat(): number;
+    /**
+     * Next integer in `[min, max]` (inclusive).
+     *
+     * @throws {RangeError} If `max < min`.
+     */
+    nextInt(min: number, max: number): number;
+    /** Next bigint in `[min, max]` (inclusive). */
+    nextBigInt(min: bigint, max: bigint): bigint;
+    /** Random UUIDv4 string from PRNG bits. */
+    nextUuid4(): string;
+    /** Reseed from a float in [-1, 1] (SQL `setseed()`). */
+    setSeedFloat(seed: number): void;
+    /** Current unsigned 64-bit engine state (for snapshot / transaction rollback). */
+    getState(): bigint;
+    /** Restore unsigned 64-bit engine state from {@link getState}. */
+    setState(state: bigint): void;
+    /** Independent copy with the same engine state. */
+    clone(): Prng;
+}
+/**
+ * CSPRNG-backed entropy for `random()` / `gen_random_uuid()` when
+ * {@link DatabaseOptions.random} is `"os"`. `setState` is a no-op so
+ * ROLLBACK / snapshot restore do not rewind draws.
+ */
+export declare class OsEntropy extends Prng {
+    constructor();
+    nextU64(): bigint;
+    getState(): bigint;
+    setState(_state: bigint): void;
+    clone(): Prng;
+}
+/** FNV-1a hash of `parts` as a signed 32-bit seed (for tests and custom PRNGs). */
+export declare function deriveSeed(...parts: Array<number | string | bigint>): number;

package/dist/schema/catalog-tables.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/schema/catalog.d.ts

@@ -0,0 +1,12 @@
+import type { Relation } from "../executor/relation.js";
+import type { EngineCtx } from "../expressions/context.js";
+/**
+ * Virtual pg_catalog / information_schema relations, materialized on demand.
+ * Implemented in catalog-tables.ts; this indirection keeps the executor
+ * import graph acyclic.
+ */
+export type CatalogBuilder = (ctx: EngineCtx, schema: string, name: string) => Relation | null;
+export declare function setCatalogBuilder(b: CatalogBuilder): void;
+export declare function catalogRelation(ctx: EngineCtx, schema: string, name: string): Relation | null;
+/** Relations resolvable unqualified via the implicit pg_catalog search-path entry. */
+export declare const PG_CATALOG_RELATIONS: ReadonlySet<string>;

package/dist/serialization/codec.d.ts

@@ -0,0 +1,29 @@
+import type { Clock } from "../runtime/clock.js";
+import type { Prng } from "../runtime/prng.js";
+import { DatabaseState } from "../storage/database-state.js";
+/** PRNG + clock captured alongside catalog/rows in a snapshot. */
+export interface SnapshotRuntime {
+    /** Unsigned 64-bit {@link Prng} state. */
+    prngState: bigint;
+    /** Clock instant as milliseconds since Unix epoch. */
+    nowMs: number;
+}
+/** Result of {@link decodeDatabaseState}. */
+export interface DecodedSnapshot {
+    /** Restored catalog and table data. */
+    state: DatabaseState;
+    runtime: SnapshotRuntime | null;
+}
+/**
+ * Encode catalog, rows, and runtime into a postgres-mem `PGMM` snapshot blob
+ * (not an on-disk PostgreSQL format).
+ *
+ * Prefer {@link Database.snapshot} unless you are serializing engine state directly.
+ */
+export declare function encodeDatabaseState(state: DatabaseState, runtime: SnapshotRuntime): Uint8Array;
+/**
+ * Decode a blob from {@link encodeDatabaseState} / {@link Database.snapshot}.
+ *
+ * @throws {PostgresError} If the magic, version, or payload is invalid.
+ */
+export declare function decodeDatabaseState(snapshot: Uint8Array, prng: Prng, clock: Clock): DecodedSnapshot;

package/dist/serialization/index.d.ts

@@ -0,0 +1 @@
+export { type DecodedSnapshot, decodeDatabaseState, encodeDatabaseState, type SnapshotRuntime, } from "./codec.js";

package/dist/storage/database-state.d.ts

@@ -0,0 +1,216 @@
+import type { CreateTriggerStmt, Expr, SelectStmt, Statement } from "../ast/nodes.js";
+import type { Clock } from "../runtime/clock.js";
+import type { Prng } from "../runtime/prng.js";
+import { type ColumnType, type Datum, type TypeId } from "../types/value.js";
+export interface ColumnMeta {
+    name: string;
+    type: ColumnType;
+    notNull: boolean;
+    defaultExpr: Expr | null;
+    identity: {
+        always: boolean;
+        sequence: string;
+    } | null;
+    generated: Expr | null;
+    collate: string | null;
+    /** resolved domain name when column type came from a domain */
+    domain: string | null;
+}
+export type ConstraintMeta = {
+    kind: "primary_key";
+    name: string;
+    columns: string[];
+} | {
+    kind: "unique";
+    name: string;
+    columns: string[];
+    nullsNotDistinct: boolean;
+} | {
+    kind: "check";
+    name: string;
+    expr: Expr;
+} | {
+    kind: "foreign_key";
+    name: string;
+    columns: string[];
+    refSchema: string;
+    refTable: string;
+    refColumns: string[];
+    onDelete: string | null;
+    onUpdate: string | null;
+    match: "full" | "simple";
+};
+export interface IndexMeta {
+    name: string;
+    schema: string;
+    table: string;
+    unique: boolean;
+    /** simple column indexes store names; expression indexes store the AST */
+    columns: Array<{
+        column: string | null;
+        expr: Expr | null;
+        dir: "asc" | "desc";
+        nulls: "first" | "last";
+    }>;
+    where: Expr | null;
+    nullsNotDistinct: boolean;
+    /** true when this index backs a constraint (pkey / unique constraint) */
+    isConstraint: boolean;
+}
+export interface TriggerMeta {
+    name: string;
+    timing: "before" | "after" | "instead_of";
+    events: CreateTriggerStmt["events"];
+    forEachRow: boolean;
+    when: Expr | null;
+    funcSchema: string;
+    funcName: string;
+    funcArgs: string[];
+}
+export declare class TableData {
+    name: string;
+    schema: string;
+    columns: ColumnMeta[];
+    rows: Datum[][];
+    constraints: ConstraintMeta[];
+    triggers: TriggerMeta[];
+    temp: boolean;
+    /** monotonically increasing oid-like id for catalog output */
+    readonly oid: number;
+    constructor(schema: string, name: string, columns: ColumnMeta[], oid: number, temp?: boolean);
+    columnIndex(name: string): number;
+    clone(): TableData;
+}
+export interface ViewData {
+    name: string;
+    schema: string;
+    query: SelectStmt;
+    columns: string[] | null;
+    materialized: boolean;
+    /** materialized contents; null = WITH NO DATA (not populated) */
+    matRows: Datum[][] | null;
+    matColumns: Array<{
+        name: string;
+        type: TypeId;
+    }> | null;
+    temp: boolean;
+    oid: number;
+}
+export interface SequenceData {
+    name: string;
+    schema: string;
+    increment: bigint;
+    minValue: bigint;
+    maxValue: bigint;
+    startValue: bigint;
+    cache: bigint;
+    cycle: boolean;
+    lastValue: bigint;
+    isCalled: boolean;
+    ownedBy: {
+        table: string;
+        column: string;
+    } | null;
+    dataType: TypeId;
+    temp: boolean;
+    oid: number;
+}
+export interface EnumData {
+    name: string;
+    schema: string;
+    labels: string[];
+    oid: number;
+}
+export interface DomainData {
+    name: string;
+    schema: string;
+    baseType: ColumnType;
+    notNull: boolean;
+    defaultExpr: Expr | null;
+    checks: Array<{
+        name: string;
+        expr: Expr;
+    }>;
+    oid: number;
+}
+export interface FunctionData {
+    name: string;
+    schema: string;
+    argNames: (string | null)[];
+    argTypes: TypeId[];
+    argDefaults: (Expr | null)[];
+    returns: TypeId | null;
+    returnsSet: boolean;
+    returnsTable: Array<{
+        name: string;
+        type: TypeId;
+    }> | null;
+    language: string;
+    body: Statement[] | null;
+    rawBody: string | null;
+    strict: boolean;
+    oid: number;
+}
+export declare class SchemaData {
+    name: string;
+    tables: Map<string, TableData>;
+    views: Map<string, ViewData>;
+    sequences: Map<string, SequenceData>;
+    enums: Map<string, EnumData>;
+    domains: Map<string, DomainData>;
+    functions: Map<string, FunctionData[]>;
+    indexes: Map<string, IndexMeta>;
+    oid: number;
+    constructor(name: string, oid: number);
+    /** all relation names (tables, views, sequences, indexes share pg_class namespace) */
+    hasRelation(name: string): boolean;
+    clone(): SchemaData;
+}
+export interface PreparedStatement {
+    name: string;
+    argTypes: TypeId[] | null;
+    stmt: Statement;
+}
+export declare class DatabaseState {
+    schemas: Map<string, SchemaData>;
+    settings: Map<string, string>;
+    /** SET LOCAL values, cleared on COMMIT/ROLLBACK */
+    localSettings: Map<string, string>;
+    prepared: Map<string, PreparedStatement>;
+    prng: Prng;
+    clock: Clock;
+    changes: number;
+    private oidCounter;
+    inTransaction: boolean;
+    /** most recent sequence touched by nextval/setval, for lastval() */
+    lastSequence: {
+        schema: string;
+        name: string;
+    } | null;
+    constructor(prng: Prng, clock: Clock);
+    nextOid(): number;
+    getSetting(name: string): string | undefined;
+    /** effective search path: existing schemas from search_path setting */
+    effectiveSearchPath(): string[];
+    currentSchema(): string;
+    getSchema(name: string): SchemaData;
+    /** Resolve a possibly-qualified relation name to its schema. */
+    resolveRelationSchema(parts: string[]): {
+        schema: string;
+        name: string;
+    } | null;
+    findTable(parts: string[]): TableData | null;
+    requireTable(parts: string[]): TableData;
+    findView(parts: string[]): ViewData | null;
+    findSequence(parts: string[]): SequenceData | null;
+    findEnum(parts: string[]): EnumData | null;
+    findDomain(parts: string[]): DomainData | null;
+    findFunctions(parts: string[]): FunctionData[];
+    findEnumByKey(key: string): EnumData | null;
+    /** format_type()-style display name for a type OID (builtin or enum). */
+    typeNameForOid(oid: number): string | null;
+    /** deep clone for transaction snapshots (datums are immutable; rows copied) */
+    clone(): DatabaseState;
+    /** copy the contents of `other` into this state (rollback restore) */
+    restoreFrom(other: DatabaseState): void;
+}

package/dist/transactions/manager.d.ts

@@ -0,0 +1,25 @@
+import type { DatabaseState } from "../storage/database-state.js";
+/**
+ * Single-session transaction manager: BEGIN clones the whole state (datums are
+ * immutable; rows are copied), ROLLBACK restores it. Savepoints stack inner
+ * snapshots. The PRNG state participates so `random()` draws rewind on
+ * rollback (determinism invariant, mirrors sqlite-mem).
+ */
+export declare class TransactionManager {
+    private readonly state;
+    private base;
+    private savepoints;
+    constructor(state: DatabaseState);
+    get inTransaction(): boolean;
+    private takeSnapshot;
+    private restore;
+    begin(): void;
+    commit(): void;
+    rollback(): void;
+    savepoint(name: string): void;
+    releaseSavepoint(name: string): void;
+    rollbackToSavepoint(name: string): void;
+    private findSavepoint;
+    /** abort any open transaction without restoring (used by Database.close) */
+    reset(): void;
+}

package/dist/tsearch/stem.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Porter2 (Snowball English) stemmer — the algorithm behind PostgreSQL's
+ * `english` text search dictionary.
+ */
+export declare function stemEnglish(input: string): string;

package/dist/tsearch/tsearch.d.ts

@@ -0,0 +1,59 @@
+export interface Lexeme {
+    word: string;
+    positions: Array<{
+        pos: number;
+        weight: string;
+    }>;
+}
+/** Build canonical tsvector text: lexemes sorted, with positions. */
+export declare function toTsvector(config: string, text: string): string;
+/** Parse tsvector text (typinput): `'a':1,2 'b':3A b` */
+export declare function parseTsvector(text: string): string;
+/** tsvector || tsvector: shift right-side positions by the left's max position, merge lexemes. */
+export declare function tsvectorConcat(a: string, b: string): string;
+export declare function tsvectorLexemes(vec: string): Lexeme[];
+export type TsQueryNode = {
+    kind: "lexeme";
+    word: string;
+    prefix: boolean;
+    weights: string | null;
+} | {
+    kind: "and";
+    left: TsQueryNode;
+    right: TsQueryNode;
+} | {
+    kind: "or";
+    left: TsQueryNode;
+    right: TsQueryNode;
+} | {
+    kind: "not";
+    operand: TsQueryNode;
+} | {
+    kind: "phrase";
+    left: TsQueryNode;
+    right: TsQueryNode;
+    distance: number;
+};
+export declare function toTsquery(config: string, text: string): string;
+export declare function plaintoTsquery(config: string, text: string): string;
+export declare function phrasetoTsquery(config: string, text: string): string;
+export declare function websearchToTsquery(_config: string, _text: string): string;
+export declare function tsqueryText(node: TsQueryNode | null): string;
+export declare function parseTsqueryText(text: string): TsQueryNode | null;
+/** tsquery || tsquery / tsquery && tsquery */
+export declare function tsqueryCombine(op: "and" | "or", a: string, b: string): string;
+/**
+ * ts_headline (minimal): wraps query-matching words of the document in
+ * StartSel/StopSel. Fragment selection (MaxWords/MinWords windows) is not
+ * implemented — short documents match PG output exactly.
+ */
+export declare function tsHeadline(config: string, document: string, query: string, options?: string): string;
+/** !! tsquery */
+export declare function tsqueryNegate(a: string): string;
+export declare function tsvectorMatches(vec: string, query: string): boolean;
+export declare const DEFAULT_RANK_WEIGHTS: number[];
+/** calc_rank + normalization flags (RANK_NORM_*). */
+export declare function tsRank(vec: string, query: string, weights?: number[], method?: number): number;
+export declare function tsvectorLength(vec: string): number;
+export declare function tsvectorStrip(vec: string): string;
+export declare function tsvectorSetweight(vec: string, weight: string): string;

package/dist/types/cast.d.ts

@@ -0,0 +1,26 @@
+import { unsupported } from "../errors/error.js";
+import { type Datum, type InputCtx, type OutputCtx, type TypedValue, type TypeId, type TypeMod } from "./value.js";
+export interface CastEnv extends OutputCtx, InputCtx {
+    enumLabels(enumType: TypeId): string[] | null;
+}
+export declare const UTC_CAST_ENV: CastEnv;
+export declare function isTextType(t: TypeId): boolean;
+export declare function isNumericType(t: TypeId): boolean;
+export declare function isDatetimeType(t: TypeId): boolean;
+/** implicit-cast reachability (subset of pg_cast castcontext = 'i') */
+export declare function canImplicitCast(from: TypeId, to: TypeId): boolean;
+export declare function canAssignCast(from: TypeId, to: TypeId): boolean;
+export interface CastOptions {
+    explicit?: boolean;
+    mod?: TypeMod | null;
+    /** true for INSERT/UPDATE assignment (allows assignment casts + typmod coercion with truncation errors) */
+    assignment?: boolean;
+}
+/** Cast a typed value to `target`. */
+export declare function castTo(env: CastEnv, value: TypedValue, target: TypeId, opts?: CastOptions): TypedValue;
+export declare function numericFamilyCast(from: TypeId, to: TypeId, v: Datum): Datum;
+/** Apply typmod (varchar(n) truncation checks, numeric(p,s), bpchar padding, time precision). */
+export declare function applyTypmod(_env: CastEnv, t: TypeId, v: Datum, opts: CastOptions): Datum;
+/** unify two types for comparison/set operations (simplified union type resolution) */
+export declare function unifyTypes(a: TypeId, b: TypeId): TypeId | null;
+export { unsupported };

package/dist/types/compare.d.ts

@@ -0,0 +1,18 @@
+import { type Datum, type TypeId } from "./value.js";
+/**
+ * Total order for non-null datums of the same type. Text uses C-locale
+ * (code point) ordering — the engine's pinned collation.
+ *
+ * Enum ordering needs label positions; callers pass `enumOrder`.
+ */
+export interface CompareCtx {
+    enumOrder?(enumType: TypeId, label: string): number;
+}
+export declare const DEFAULT_COMPARE_CTX: CompareCtx;
+export declare function datumCompare(t: TypeId, a: Datum, b: Datum, ctx?: CompareCtx): number;
+export declare function datumEquals(t: TypeId, a: Datum, b: Datum, ctx?: CompareCtx): boolean;
+/**
+ * Canonical grouping/uniqueness key. Equal values (2.50 = 2.5, +0 = -0)
+ * must map to the same key.
+ */
+export declare function datumKey(t: TypeId, v: Datum): string;

package/dist/types/datetime.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Internal representations (mirroring PostgreSQL):
+ * - date: integer days since 2000-01-01 (PG epoch); ±Infinity as special
+ * - time: bigint microseconds since midnight (0 .. 86_400_000_000 inclusive)
+ * - timestamp / timestamptz: bigint microseconds since 2000-01-01 00:00:00 (UTC for tz)
+ * - interval: { months, days, micros }
+ */
+export declare const PG_EPOCH_JDATE = 2451545;
+export declare const UNIX_EPOCH_MICROS_FROM_PG = -946684800000000n;
+export declare const DATE_POS_INF = 2147483647;
+export declare const DATE_NEG_INF = -2147483648;
+export declare const TS_POS_INF = 9223372036854775807n;
+export declare const TS_NEG_INF = -9223372036854775808n;
+export interface Interval {
+    readonly kind: "interval";
+    readonly months: number;
+    readonly days: number;
+    readonly micros: bigint;
+}
+export declare function makeInterval(months: number, days: number, micros: bigint): Interval;
+export declare function isInterval(v: unknown): v is Interval;
+export declare const USECS_PER_DAY = 86400000000n;
+export declare const USECS_PER_HOUR = 3600000000n;
+export declare const USECS_PER_MIN = 60000000n;
+export declare const USECS_PER_SEC = 1000000n;
+export declare function civilToDays(y: number, m: number, d: number): number;
+export declare function daysToCivil(days: number): {
+    y: number;
+    m: number;
+    d: number;
+};
+export declare function isLeapYear(y: number): boolean;
+export declare function daysInMonth(y: number, m: number): number;
+export declare function isValidCivil(y: number, m: number, d: number): boolean;
+/** day of week, 0=Sunday (2000-01-01 was a Saturday = 6) */
+export declare function dayOfWeek(days: number): number;
+/** Parse a date string -> days since 2000-01-01. DateStyle ISO, MDY. */
+export declare function parseDate(text: string): number;
+/** Parse time -> micros since midnight. */
+export declare function parseTime(text: string): bigint;
+/** Parse timestamp (no tz interpretation) -> PG micros. */
+export declare function parseTimestamp(text: string): bigint;
+/**
+ * Parse timestamptz -> UTC micros. `sessionOffsetSec` applies when the input
+ * has no explicit zone (session TimeZone; we default to UTC).
+ */
+export declare function parseTimestampTz(text: string, zoneOffsetForNaive: (naiveMicros: bigint) => number): bigint;
+export declare function formatDate(days: number): string;
+export declare function formatTimeOfDay(micros: bigint): string;
+/** floor-divide micros into (days, timeOfDay) */
+export declare function splitTs(micros: bigint): {
+    days: number;
+    tod: bigint;
+};
+export declare function formatTimestamp(micros: bigint): string;
+/** Format a UTC timestamptz in a fixed zone offset (seconds east of UTC). */
+export declare function formatTimestampTz(micros: bigint, offsetSec: number): string;
+export declare function parseInterval(text: string): Interval;
+/** Render interval in DateStyle 'postgres' (the default). */
+export declare function formatInterval(v: Interval): string;
+export declare function intervalCmp(a: Interval, b: Interval): number;
+export declare function intervalTotalMicros(v: Interval): bigint;
+export declare function intervalAdd(a: Interval, b: Interval): Interval;
+export declare function intervalNeg(a: Interval): Interval;
+export declare function intervalJustifyHours(v: Interval): Interval;
+export declare function intervalJustifyDays(v: Interval): Interval;
+/** date + interval => timestamp micros arithmetic (add months honoring month-end clamping) */
+export declare function timestampAddInterval(ts: bigint, iv: Interval): bigint;