okmodel 0.1.1 → 0.3.0

package/dist/adapters/capabilities.d.ts

@@ -41,6 +41,40 @@ export declare const PGLITE_CAPABILITIES: {
     readonly prepared: "unnamed";
     readonly describe: true;
 };
+/**
+ * node-postgres execution flags.
+ *
+ * Interactive transactions, cursor streaming, listen, and cancel are set
+ * because the conformance suite passes them. Describe is false: `pg` cannot
+ * describe a statement without running it, and that case is skipped.
+ * Parameterized queries use the unnamed extended protocol.
+ */
+export declare const NODE_POSTGRES_CAPABILITIES: {
+    readonly transactions: "interactive";
+    readonly stream: true;
+    readonly listen: true;
+    readonly cancel: true;
+    readonly prepared: "unnamed";
+    readonly describe: false;
+};
+/**
+ * Bun.sql execution flags.
+ *
+ * Interactive transactions, cursor streaming, and listen pass the conformance
+ * suite. `cancel` is false: `Query.cancel()` does not abort the backend
+ * (Bun 1.4), so the cancel and in-flight timeout cases are skipped.
+ * `describe` is false: Bun.sql has no describe API. RAISE NOTICE is not
+ * surfaced, so the notice case is skipped. `prepare` is off, so a
+ * parameterized query does not leave a named statement.
+ */
+export declare const BUNSQL_CAPABILITIES: {
+    readonly transactions: "interactive";
+    readonly stream: true;
+    readonly listen: true;
+    readonly cancel: false;
+    readonly prepared: "unnamed";
+    readonly describe: false;
+};
 /**
  * Reads one capability flag.
  *

package/dist/adapters/pg/bunsql-extra.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Reserved connections for Bun.sql.
+ *
+ * Loaded on the first reserve, batch, or stream. A read does not use it.
+ */
+import type { DriverConnection } from "../../contracts/driver.js";
+import { type HeldPool } from "./bunsql.js";
+/**
+ * Checks out one connection and clears it on release.
+ *
+ * A connection that is gone is neither reset nor parked: Bun.sql has already
+ * dropped it, and parking it would hand a dead session to the next caller.
+ *
+ * @param held - The pool and its counters
+ * @returns A connection the caller must release
+ */
+export declare function checkout(held: HeldPool): Promise<DriverConnection>;

package/dist/adapters/pg/bunsql.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Bun.sql adapter (`okmodel/pg/bun`).
+ *
+ * Bun's built-in client. There is no package to install. This module is the
+ * only place that imports `bun`. It runs on Bun; another runtime cannot load
+ * that import.
+ *
+ * `idleTimeout` stays 0, which is Bun's default: no idle timer, and a
+ * finished script exits without `close()`. `Query.cancel()` does not abort
+ * the backend, so `cancel` is false. Server notices are not surfaced.
+ */
+import { SQL, type ReservedSQL } from "bun";
+import type { DriverPool, DriverPoolConfig, WireValue } from "../../contracts/driver.js";
+import { noticeBuffer, type WireQuery } from "./session.js";
+export { BUNSQL_CAPABILITIES as capabilities, hasCapability, readCapability, } from "../capabilities.js";
+export { DriverError } from "../error.js";
+/** TLS values Bun.sql accepts that this adapter forwards. */
+export type BunSqlTls = boolean | "disable" | "allow" | "prefer" | "require" | "verify-ca" | "verify-full";
+/** Options for {@link open}. */
+export type BunSqlConfig = DriverPoolConfig & {
+    /** Connection URL for this endpoint. */
+    readonly url: string;
+    /**
+     * Named prepared statements, or the unnamed protocol.
+     *
+     * Unnamed is the default (`prepare: false`). `prepared: "named"` is not
+     * for transaction-mode poolers.
+     */
+    readonly prepared?: "named" | "unnamed";
+    /** Session search path for every connection in the pool. */
+    readonly searchPath?: string;
+    /** TLS mode passed to Bun.sql. */
+    readonly ssl?: BunSqlTls;
+};
+/** What a checkout needs from the pool that opened it. */
+export type HeldPool = {
+    readonly sql: SQL;
+    readonly parked: ReservedSQL[];
+    readonly acquireMs: number | undefined;
+    readonly counters: Counters;
+    readonly notices: ReturnType<typeof noticeBuffer>;
+    readonly isClosed: () => boolean;
+};
+/** Pool occupancy. */
+export type Counters = {
+    reserved: number;
+    busy: number;
+    reservedBusy: number;
+    waiting: number;
+};
+/**
+ * Opens a Bun.sql pool for one endpoint.
+ *
+ * @param config - URL, pool size, and acquire timeout
+ * @returns The pool
+ */
+export declare function open(config: BunSqlConfig): DriverPool;
+export declare function send(sql: SQL, text: string, params: readonly WireValue[] | undefined): WireQuery;
+export declare function reserve(sql: SQL, acquireMs: number | undefined, counters: Counters): Promise<ReservedSQL>;
+export declare function park(parked: ReservedSQL[], reserved: ReservedSQL): Promise<void>;

package/dist/adapters/pg/call.d.ts

@@ -28,24 +28,14 @@ export declare function needsWatch(options: ExecuteOptions | undefined): boolean
 /**
  * Next transaction depth after one statement.
  *
- * Only a whole command matches, so `ROLLBACK TO SAVEPOINT` stays inside the
- * transaction. Kept here so a read does not load the batch runner.
+ * `BEGIN` may carry modes (`begin isolation level serializable`). `ROLLBACK TO
+ * SAVEPOINT` stays inside the transaction. Kept here so a read does not load the batch runner.
  *
  * @param depth - Depth before the statement
  * @param text - Statement text
  * @returns Depth after a successful statement
  */
 export declare function nextTransactionDepth(depth: number, text: string): number;
-/**
- * Opens a watch for one call.
- *
- * The caller has already rejected a pre-aborted signal and a non-positive
- * timeout.
- *
- * @param options - Options that include a signal or a timeout
- * @returns The watch. The caller must {@link Watch.finish} it
- */
-export declare function openWatch(options: ExecuteOptions): Watch;
 /**
  * Runs `fn` with a watch when the caller set a signal or a timeout.
  *

package/dist/adapters/pg/nodepostgres-extra.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Reserved connections for node-postgres.
+ *
+ * Loaded on the first reserve, batch, or stream. A read does not use it.
+ */
+import type { DriverConnection } from "../../contracts/driver.js";
+import { type HeldPool } from "./nodepostgres.js";
+/**
+ * Checks out one client and clears it on release.
+ *
+ * A client whose connection is gone is destroyed on release, and nothing more is
+ * sent to it. A checked-out client has no pool error listener, so one is set here:
+ * without it a dropped socket is an uncaught `error` event.
+ *
+ * @param held - The pool and its counters
+ * @returns A connection the caller must release
+ */
+export declare function checkout(held: HeldPool): Promise<DriverConnection>;

package/dist/adapters/pg/nodepostgres.d.ts

@@ -0,0 +1,57 @@
+/**
+ * node-postgres adapter (`okmodel/pg/pg`).
+ *
+ * One pool per `open` call. `pg` is an optional peer of this entry.
+ * Idle clients are unref'd (`allowExitOnIdle`) and are not closed on a timer
+ * (`idleTimeoutMillis: 0`), so a finished script exits and a live process
+ * keeps its connection. Cancel sends a Postgres CancelRequest on a side
+ * socket. That socket is unref'd.
+ */
+import pg, { type PoolClient, type QueryConfig, type QueryResult } from "pg";
+import type { DriverPool, DriverPoolConfig, WireValue } from "../../contracts/driver.js";
+import { noticeBuffer, type WireQuery } from "./session.js";
+export { hasCapability, NODE_POSTGRES_CAPABILITIES as capabilities, readCapability, } from "../capabilities.js";
+export { DriverError } from "../error.js";
+/** Options for {@link open}. */
+export type NodePostgresConfig = DriverPoolConfig & {
+    /** Connection URL for this endpoint. */
+    readonly url: string;
+    /**
+     * Named prepared statements, or the unnamed protocol.
+     *
+     * Unnamed is the default. It stays valid behind a pooler in transaction mode.
+     * `prepared: "named"` is not for transaction-mode poolers.
+     */
+    readonly prepared?: "named" | "unnamed";
+    /** Session search path for every connection in the pool. */
+    readonly searchPath?: string;
+    /** TLS mode passed to node-postgres. */
+    readonly ssl?: boolean | "require" | "allow" | "prefer" | "verify-full" | object;
+};
+/** What a checkout needs from the pool that opened it. */
+export type HeldPool = {
+    readonly pool: InstanceType<typeof pg.Pool>;
+    readonly acquireMs: number | undefined;
+    readonly counters: Counters;
+    readonly notices: ReturnType<typeof noticeBuffer>;
+    readonly named: boolean;
+    readonly isClosed: () => boolean;
+};
+/** Pool occupancy. */
+export type Counters = {
+    reserved: number;
+    busy: number;
+    reservedBusy: number;
+    waiting: number;
+};
+/**
+ * Opens a node-postgres pool for one endpoint.
+ *
+ * @param config - URL, pool size, and acquire timeout
+ * @returns The pool
+ */
+export declare function open(config: NodePostgresConfig): DriverPool;
+export declare function send(runner: {
+    query(config: QueryConfig): Promise<QueryResult>;
+}, text: string, params: readonly WireValue[] | undefined, named: boolean, client: PoolClient | undefined): WireQuery;
+export declare function connectClient(pool: InstanceType<typeof pg.Pool>, acquireMs: number | undefined, counters: Counters): Promise<PoolClient>;

package/dist/adapters/pg/postgres-extra.d.ts

@@ -4,7 +4,8 @@
  * Loaded on the first reserve, batch, describe, or stream.
  */
 import type { Sql } from "postgres";
-import type { DescribeResult, DriverConnection, WireValue } from "../../contracts/driver.js";
+import type { DescribeResult, DriverConnection, ExecuteResult, WireValue } from "../../contracts/driver.js";
+import { type Watch } from "./call.js";
 import { type Canceller, type Counters, type NoticeBuffer } from "./postgresjs.js";
 /** State `open` shares with a checkout. */
 export type HeldPool = {
@@ -41,3 +42,51 @@ export declare function describe(sql: Sql, text: string, params?: readonly WireV
  * @returns Chunks of wire rows
  */
 export declare function stream(sql: Sql, text: string, params?: readonly WireValue[]): AsyncIterable<readonly (readonly WireValue[])[]>;
+/** Refcount a checkout or a listener borrows from the pool. */
+type Gate = {
+    enter(): void;
+    leave(): void;
+};
+/**
+ * Keeps sockets referenced until `release` finishes.
+ *
+ * The caller has already entered `gate`. A second `release` does not change
+ * the count. Checkout failure leaves the gate.
+ *
+ * @param gate - Refcount already entered for this checkout
+ * @param checkout - Reserves the connection
+ * @returns The connection, with release counted once
+ */
+export declare function holdCheckout<T extends {
+    release(): Promise<void>;
+}>(gate: Gate, checkout: () => Promise<T>): Promise<T>;
+/**
+ * Keeps sockets referenced for as long as the listener is active.
+ *
+ * The caller has already entered `gate`.
+ *
+ * @param gate - Listener refcount already entered
+ * @param start - Subscribes and returns the stop function
+ * @returns A stop function that can be called again
+ */
+export declare function holdListener(gate: Gate, start: () => Promise<() => Promise<void>>): Promise<() => Promise<void>>;
+/**
+ * Finishes a query that can be aborted by a signal or a timeout.
+ *
+ * The caller has already tracked `pending` and attached `onAbort`.
+ *
+ * @param pending - The in-flight statement
+ * @param watch - Abort signal and the reason it fired
+ * @param onAbort - Listener the caller attached
+ * @param ctx - Notice slice and the session counters the plain path also uses
+ * @returns The wire result, or a rejected driver error
+ */
+export declare function watchQuery(pending: Canceller & Promise<unknown>, watch: Watch, onAbort: () => void, ctx: {
+    readonly start: number;
+    readonly text: string;
+    readonly notices: NoticeBuffer;
+    leave(): void;
+    note(text: string): void;
+    untrack(pending: Canceller): void;
+}): Promise<ExecuteResult>;
+export {};

package/dist/adapters/pg/postgresjs.d.ts

@@ -88,8 +88,4 @@ export declare class PgSession implements BatchSession {
     private note;
     private enter;
     private leave;
-    private track;
-    private untrack;
-    private watched;
-    private finishWatched;
 }

package/dist/adapters/pg/session.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Shared interactive session for drivers that speak wire text.
+ *
+ * The postgres.js adapter keeps its own session. node-postgres and Bun.sql
+ * share this one: transaction depth, notices, and a watched cancel.
+ */
+import type { ExecuteResult, Notice, WireValue } from "../../contracts/driver.js";
+import type { BatchSession } from "./batch.js";
+import type { Watch } from "./call.js";
+/** A query the session can abort when the driver supports it. */
+export type WireQuery = Promise<unknown> & {
+    cancel?(): void;
+};
+/** Sends one statement and returns the driver's own result. */
+export type WireSender = (text: string, params: readonly WireValue[] | undefined) => WireQuery;
+/** Notice slice shared by a pool. */
+export type NoticeBuffer = {
+    start(): number;
+    since(start: number): readonly Notice[];
+    push(notice: {
+        readonly severity?: string | undefined;
+        readonly message?: string | undefined;
+        readonly code?: string | undefined;
+    }): void;
+};
+/**
+ * Quotes one identifier.
+ *
+ * @param name - Channel or cursor name
+ * @returns A double-quoted identifier
+ */
+export declare function quoteIdent(name: string): string;
+/**
+ * An empty notice buffer the pool fills as the server sends notices.
+ *
+ * @returns The buffer
+ */
+export declare function noticeBuffer(): NoticeBuffer;
+/**
+ * One connection's statement runner.
+ *
+ * `send` is the driver. This class owns depth, notices, and cancel tracking.
+ */
+export declare class WireSession implements BatchSession {
+    readonly canCancel: boolean;
+    private transactionDepth;
+    private readonly local;
+    private readonly send;
+    private readonly notices;
+    private readonly isClosed;
+    private readonly onEnter;
+    private readonly onLeave;
+    private readonly shared;
+    /**
+     * @param send - Runs one statement on this connection
+     * @param notices - Pool notice buffer
+     * @param isClosed - Pool closed flag
+     * @param canCancel - The driver aborts an in-flight statement
+     * @param onEnter - Marks one statement in flight
+     * @param onLeave - Marks that statement finished
+     * @param shared - Pool-wide in-flight set, when this connection is reserved
+     */
+    constructor(send: WireSender, notices: NoticeBuffer, isClosed: () => boolean, canCancel: boolean, onEnter: () => void, onLeave: () => void, shared?: Set<WireQuery>);
+    /** @inheritdoc */
+    query(text: string, params: readonly WireValue[] | undefined, watch: Watch | undefined): Promise<ExecuteResult>;
+    /** @inheritdoc */
+    inTransaction(): boolean;
+    /** @inheritdoc */
+    abandon(): void;
+    /**
+     * Open transaction depth.
+     *
+     * @returns The depth. Zero means no transaction
+     */
+    depth(): number;
+    /** Aborts in-flight statements on this connection. */
+    cancel(): void;
+    private note;
+    private track;
+    private untrack;
+    private watched;
+    private finishWatched;
+}
+/**
+ * Yields cursor chunks from one connection that is already checked out.
+ *
+ * The cursor is session-local. `ROLLBACK` in the end drops it.
+ *
+ * @param run - Executes on the checked-out connection
+ * @param text - Query to stream
+ * @param params - Wire parameters
+ * @returns Chunks of wire rows
+ */
+export declare function cursorStream(run: (text: string, params?: readonly WireValue[]) => Promise<ExecuteResult>, text: string, params: readonly WireValue[] | undefined): AsyncIterable<readonly (readonly WireValue[])[]>;

package/dist/adapters/pg/watch.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Deadline and abort signal for one call.
+ *
+ * Loaded the first time a call passes `signal` or `timeout`. A plain execute
+ * does not load it.
+ */
+import type { ExecuteOptions } from "../../contracts/driver.js";
+import type { Watch } from "./call.js";
+/**
+ * Opens a watch for one call.
+ *
+ * The caller has already rejected a pre-aborted signal and a non-positive
+ * timeout.
+ *
+ * @param options - Options that include a signal or a timeout
+ * @returns The watch. The caller must {@link Watch.finish} it
+ */
+export declare function openWatch(options: ExecuteOptions): Watch;

package/dist/contracts/catalog/enum.d.ts

@@ -1,10 +1,10 @@
 /**
- * Enum catalog objects.
+ * Enum and domain catalog objects.
  *
- * Kind `type`, identity `(namespace, name)`. The definition is the ordered
- * label list and nothing else: domains are not catalog objects.
+ * Kind `type`, identity `(namespace, name)`. An enum definition is the ordered
+ * label list. A domain definition is the base type and the check.
  */
-import type { Namespace, ObjectIdentity, Owner, Provenance, TypeObject } from "./types.js";
+import type { DomainDefinition, Namespace, ObjectIdentity, Owner, Provenance, TypeDefinition, TypeObject } from "./types.js";
 /** Input for {@link enumType}. */
 export type EnumTypeInput = {
     readonly namespace: Namespace;
@@ -25,6 +25,33 @@ export type EnumTypeInput = {
  * @returns A type envelope
  */
 export declare function enumType(input: EnumTypeInput): TypeObject;
+/** Input for {@link domainType}. */
+export type DomainTypeInput = {
+    readonly namespace: Namespace;
+    readonly name: string;
+    readonly base: string;
+    readonly check: string;
+    readonly owner?: Owner;
+    readonly provenance: Provenance;
+    readonly dependencies?: readonly ObjectIdentity[];
+};
+/**
+ * Builds a domain type object.
+ *
+ * The definition is the base type and the check. An empty base or an empty
+ * check is OKM1020.
+ *
+ * @param input - Namespace, name, base type, and check
+ * @returns A type envelope
+ */
+export declare function domainType(input: DomainTypeInput): TypeObject;
+/**
+ * Reports whether a type definition is a domain.
+ *
+ * @param definition - Enum labels or a domain base and check
+ * @returns `true` when the definition has a base type
+ */
+export declare function isDomain(definition: TypeDefinition): definition is DomainDefinition;
 /**
  * Reports whether two label lists are the same text in the same order.
  *

package/dist/contracts/catalog/extension.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Extension catalog objects.
+ *
+ * The factory stores the record. It does not parse a document and it does
+ * not plan SQL. Those stay in the document chunk and in tooling.
+ */
+import type { Catalog, ExtensionObject, ObjectIdentity, Owner, Provenance } from "./types.js";
+/** Input for {@link extensionObject}. */
+export type ExtensionInput = {
+    readonly name: string;
+    readonly schema: string;
+    readonly relocatable?: boolean;
+    readonly version?: string;
+    readonly owner?: Owner;
+    readonly provenance: Provenance;
+    readonly dependencies?: readonly ObjectIdentity[];
+};
+/**
+ * Builds an extension record.
+ *
+ * @param input - Name, install schema, and optional version pin
+ * @returns The catalog object
+ */
+export declare function extensionObject(input: ExtensionInput): ExtensionObject;
+/**
+ * Reports whether a version is an exact pin (`1.6`), not a floor or an omission.
+ *
+ * @param version - Declared or installed version
+ * @returns `true` when every component is a decimal integer
+ */
+export declare function isExactVersion(version: string | undefined): version is string;
+/**
+ * Compares two exact versions. A shorter tail is zero.
+ *
+ * @param left - Exact version
+ * @param right - Exact version
+ * @returns Negative when `left` is older, positive when it is newer
+ */
+export declare function compareExtensionVersions(left: string, right: string): number;
+/**
+ * Reports whether two extension records are the same migration.
+ *
+ * An unpinned or floor declaration matches any installed version. Schema and
+ * `relocatable` still have to match.
+ *
+ * @param before - Previous record
+ * @param after - Declared record
+ * @returns `true` when no `ALTER EXTENSION` is required
+ */
+export declare function sameExtensionDefinition(before: ExtensionObject, after: ExtensionObject): boolean;
+/**
+ * Drops a version when the other side of a diff does not pin an exact one.
+ *
+ * Serialization then compares the rest of the record. Exact pins on both
+ * sides are left as written.
+ *
+ * @param source - Catalog being compared
+ * @param other - The other catalog
+ * @returns `source`, or a copy with those versions removed
+ */
+export declare function alignExtensionVersions(source: Catalog, other: Catalog): Catalog;

package/dist/contracts/catalog/object.d.ts

@@ -25,6 +25,7 @@ export type ColumnInput = CommonInput & {
     readonly dataType: string;
     readonly nullable: boolean;
     readonly defaultExpression?: string;
+    readonly collation?: string;
     readonly identity?: {
         readonly always: boolean;
     };

package/dist/contracts/catalog/privilege.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Role, grant, and default-privilege records.
+ *
+ * The factories store the envelope. SQL, introspection, and the doctor
+ * checks live in the dialect and in tooling.
+ */
+import type { DefaultPrivilegeObject, GrantObject, GrantObjectRef, Namespace, ObjectIdentity, Owner, Provenance, RoleObject } from "./types.js";
+/** Input for {@link roleObject}. */
+export type RoleInput = {
+    readonly name: string;
+    readonly login?: boolean;
+    readonly inherit?: boolean;
+    readonly owner?: Owner;
+    readonly provenance: Provenance;
+    readonly dependencies?: readonly ObjectIdentity[];
+};
+/** Input for {@link grantObject}. */
+export type GrantInput = {
+    readonly role: string;
+    readonly object: GrantObjectRef;
+    readonly privilege: string;
+    readonly owner?: Owner;
+    readonly provenance: Provenance;
+    readonly dependencies?: readonly ObjectIdentity[];
+};
+/** Input for {@link defaultPrivilegeObject}. */
+export type DefaultPrivilegeInput = {
+    readonly forRole: string;
+    readonly namespace: Namespace;
+    readonly objectKind: string;
+    readonly grantee: string;
+    readonly privilege: string;
+    readonly owner?: Owner;
+    readonly provenance: Provenance;
+    readonly dependencies?: readonly ObjectIdentity[];
+};
+/**
+ * Builds a role record.
+ *
+ * The name is an identifier. The grant key is not.
+ *
+ * @param input - Name, login, and inherit
+ * @returns The catalog object
+ */
+export declare function roleObject(input: RoleInput): RoleObject;
+/**
+ * Builds a grant record.
+ *
+ * Identity is `(role, object, privilege)`. It is not checked against the
+ * 63-byte identifier limit (D119).
+ *
+ * @param input - Grantee, object, and one privilege
+ * @returns The catalog object
+ */
+export declare function grantObject(input: GrantInput): GrantObject;
+/**
+ * Builds a default-privilege record.
+ *
+ * Identity is `(forRole, namespace, objectKind, grantee, privilege)`.
+ *
+ * @param input - Creating role, schema, object kind, grantee, and privilege
+ * @returns The catalog object
+ */
+export declare function defaultPrivilegeObject(input: DefaultPrivilegeInput): DefaultPrivilegeObject;

package/dist/contracts/catalog/routine.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Function and trigger catalog objects.
+ *
+ * The factories store the record. They do not plan SQL. DDL stays in the
+ * dialect, and `fn()` / `trigger()` stay on `okmodel/fn`.
+ */
+import type { FunctionArgument, FunctionLanguage, FunctionObject, FunctionSecurity, FunctionVolatility, Namespace, ObjectIdentity, ObjectRef, Owner, Provenance, TriggerCall, TriggerEvent, TriggerLevel, TriggerObject, TriggerTiming } from "./types.js";
+/** Input for {@link functionObject}. */
+export type FunctionInput = {
+    readonly namespace?: Namespace;
+    readonly name: string;
+    readonly arguments?: readonly FunctionArgument[];
+    readonly returns: string;
+    readonly language: FunctionLanguage;
+    readonly volatility?: FunctionVolatility;
+    readonly security?: FunctionSecurity;
+    readonly searchPath?: string;
+    readonly body: string;
+    readonly atomic?: boolean;
+    readonly owner?: Owner;
+    readonly provenance: Provenance;
+    readonly dependencies?: readonly ObjectIdentity[];
+};
+/** Input for {@link triggerObject}. */
+export type TriggerInput = {
+    readonly parent: ObjectRef;
+    readonly name: string;
+    readonly timing: TriggerTiming;
+    readonly events: readonly TriggerEvent[];
+    readonly level: TriggerLevel;
+    readonly calls: TriggerCall;
+    readonly updateOf?: readonly string[];
+    readonly when?: string;
+    readonly owner?: Owner;
+    readonly provenance: Provenance;
+    readonly dependencies?: readonly ObjectIdentity[];
+};
+/**
+ * Builds a function record.
+ *
+ * Argument types are the identity. Names live only in the definition.
+ *
+ * @param input - Signature, language, and body
+ * @returns The catalog object
+ */
+export declare function functionObject(input: FunctionInput): FunctionObject;
+/**
+ * Builds a trigger record.
+ *
+ * Dependencies are the table, the function, and each `UPDATE OF` column.
+ * Events are stored in a fixed order.
+ *
+ * @param input - Timing, events, and the function it calls
+ * @returns The catalog object
+ */
+export declare function triggerObject(input: TriggerInput): TriggerObject;