okmodel 0.8.0 → 0.9.0

package/dist/tooling/migrate/ext-surface.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Catalog reads shared by `okm ext scaffold` and `okm ext test`.
+ *
+ * Both are read-only. The queries are `pg_depend`, `pg_type`, `pg_proc`,
+ * `pg_operator`, and `pg_settings`. Nothing is created.
+ */
+import type { DriverPool } from "../../contracts/driver.js";
+import type { Extension, ExtensionFunction, ExtensionIndexMethod, ExtensionOperator, ExtensionProvides, ExtensionType } from "../../dialects/pg/ext/index.js";
+/** One extension as the connected server describes it. */
+export type ServerSurface = {
+    readonly name: string;
+    readonly version: string;
+    readonly schema: string;
+    readonly relocatable: boolean;
+    readonly serverMajor: number;
+    readonly types: readonly ExtensionType[];
+    readonly operators: readonly ExtensionOperator[];
+    readonly functions: readonly ExtensionFunction[];
+    readonly indexMethods: readonly ExtensionIndexMethod[];
+    readonly settings: readonly string[];
+};
+/**
+ * Reads one installed extension.
+ *
+ * A name that is not installed is OKM1811. The connection is not asked to
+ * create it.
+ *
+ * @param pool - Connected server
+ * @param name - Extension name
+ * @returns The catalog surface
+ */
+export declare function readSurface(pool: DriverPool, name: string): Promise<ServerSurface>;
+/**
+ * Prints a starting `extension()` definition.
+ *
+ * The developer owns the file. `requires` and `provides` are the fields
+ * `okm ext test` reads. Settings are a comment, because they are not part
+ * of the definition.
+ *
+ * @param surface - Catalog read
+ * @returns TypeScript source, including the trailing newline
+ */
+export declare function renderScaffold(surface: ServerSurface): string;
+/**
+ * Lists mismatches between a definition and the server.
+ *
+ * An empty list means the definition matches. Version failures and signature
+ * failures are both lines in that list.
+ *
+ * @param declared - The loaded `extension()` value
+ * @param server - The catalog read for `declared.name`
+ * @returns Mismatch lines, stable order
+ */
+export declare function surfaceMismatches(declared: Extension, server: ServerSurface): readonly string[];
+/**
+ * Throws when {@link surfaceMismatches} found any line.
+ *
+ * Version lines are OKM1812. A signature line is `invalid`. Both are listed
+ * in the message.
+ *
+ * @param name - Extension name
+ * @param mismatches - Lines from {@link surfaceMismatches}
+ */
+export declare function refuseMismatches(name: string, mismatches: readonly string[]): void;
+/**
+ * Reports whether a value is an `extension()` result.
+ *
+ * @param value - A module export
+ * @returns `true` when it has a name and `contribute`
+ */
+export declare function isExtension(value: unknown): value is Extension;
+/**
+ * Reads `extension()` values exported by a loaded module.
+ *
+ * @param imported - Module namespace
+ * @returns The definitions, in export order
+ */
+export declare function extensionsFromModule(imported: unknown): readonly Extension[];
+/** Provides kept on the type so a scaffold round-trip can name them. */
+export type { ExtensionProvides };

package/dist/tooling/migrate/ext.d.ts

@@ -1,9 +1,10 @@
 /**
- * `okm ext list` and `okm ext check`.
+ * `okm ext list`, `check`, `scaffold`, and `test`.
  *
- * Both talk to the selected target. List prints every extension the server
- * can install, and the installed version when one is present. Check compares
- * the schema's declarations with what is installed.
+ * All four talk to the selected target and are read-only, including on a
+ * protected target. List prints every extension the server can install.
+ * Check compares the schema's declarations with what is installed. Scaffold
+ * prints a starting definition. Test checks that definition against the server.
  */
 import { type InvokeFlags } from "./policy.js";
 /**
@@ -15,3 +16,29 @@ import { type InvokeFlags } from "./policy.js";
  * @returns Text for stdout, including the trailing newline
  */
 export declare function extProject(cwd: string, command: "list" | "check", flags: InvokeFlags): Promise<string>;
+/**
+ * Prints a starting definition for one installed extension.
+ *
+ * `--out` writes the file when that path does not exist. An existing file
+ * is refused and nothing is written. Without `--out`, the text is returned
+ * for stdout.
+ *
+ * @param cwd - Project directory
+ * @param name - Extension name
+ * @param flags - Target and protection flags
+ * @param out - File to write, when the caller passed `--out`
+ * @returns The definition, or a one-line wrote message
+ */
+export declare function extScaffold(cwd: string, name: string, flags: InvokeFlags, out?: string): Promise<string>;
+/**
+ * Checks one definition file against the connected server.
+ *
+ * Every declared type, operator, function, and index method must exist with
+ * the declared signature. `requires` must be met (OKM1812).
+ *
+ * @param cwd - Project directory
+ * @param file - Definition file, relative to `cwd` or absolute
+ * @param flags - Target and protection flags
+ * @returns `ok <name>` for each definition
+ */
+export declare function extTest(cwd: string, file: string, flags: InvokeFlags): Promise<string>;

package/dist/tooling/migrate/import-drizzle.d.ts

@@ -0,0 +1,40 @@
+/**
+ * `okm import drizzle` reads a Drizzle schema and writes table files.
+ *
+ * The schema is imported with the project's own `drizzle-orm`. That import
+ * runs the file. okmodel does not depend on drizzle-orm. The catalog is
+ * written by the same emitter as `okm pull`.
+ */
+import { type PullSkip } from "./pull-emit.js";
+/** What `okm import drizzle` prints, and the objects the files leave out. */
+export type ImportDrizzleResult = {
+    /** Report text, including the trailing newline. */
+    readonly text: string;
+    /** Objects that were not written. */
+    readonly skipped: readonly PullSkip[];
+    /** Postgres schema the tables share. `schema()` still compiles `public`. */
+    readonly namespace: string;
+};
+/**
+ * Imports a Drizzle schema and writes one table file per table, plus the schema file.
+ *
+ * The path is a module in the project. `--out` is the directory that receives
+ * `schema.ts` and `tables/`. Without it, an `okmodel.config.ts` in `cwd`
+ * supplies the layout. A project that has no config yet writes `schema.ts`
+ * and `tables/` in `cwd`.
+ *
+ * @param cwd - Project directory the files are written into
+ * @param argv - Arguments after `import drizzle`
+ * @returns The report and the Postgres schema name
+ */
+export declare function importDrizzle(cwd: string, argv: readonly string[]): Promise<ImportDrizzleResult>;
+/**
+ * Reads the schema path and `--out`.
+ *
+ * @param argv - Arguments after `import drizzle`
+ * @returns The path and the optional output directory
+ */
+export declare function parseImportArgs(argv: readonly string[]): {
+    readonly path: string;
+    readonly out: string | undefined;
+};

package/dist/tooling/migrate/index.d.ts

@@ -2,7 +2,10 @@
  * Public entry for `okmodel/migrate`.
  *
  * `defineConfig`, its types, and `provision` for one configured target.
+ * `describe` and `buildCatalog` are the programmatic schema API.
  * The CLI imports planning and apply helpers from their modules.
  */
 export { defineConfig, type MigrateConfig, type TargetInput } from "./config.js";
+export { type LogicalIdentity } from "./export.js";
+export { buildCatalog, describe, type SchemaDescription } from "./schema-api.js";
 export { provision } from "./provision.js";

package/dist/tooling/migrate/index.js

@@ -1,35 +1,78 @@
-import"../../shared/35q0n9tz.js";
-import"../../shared/12z7aznj.js";
+import {
+  serializeCatalog2,
+  parseCatalog2
+} from "../../shared/12z7aznj.js";
+import"../../shared/fk9vef30.js";
+import"../../shared/dd5pmnky.js";
 import"../../shared/n442h54c.js";
 import {
   applyTarget2,
   backfillTiming2
-} from "../../shared/pan0370z.js";
+} from "../../shared/ccsmhv9r.js";
 import {
   readReference
-} from "../../shared/mnvjvqyp.js";
-import"../../shared/kj9d8maq.js";
-import"../../shared/p3xbdcvt.js";
+} from "../../shared/3456242y.js";
+import"../../shared/jpybhf98.js";
+import"../../shared/myk8fswx.js";
 import {
   projectPath,
+  LOGICAL_FORMAT,
   loadMigrations,
   loadHeadSnapshot,
   loadBuiltSchema,
   loadConfig
-} from "../../shared/f4jy1j7x.js";
+} from "../../shared/2zdxkt7b.js";
 import {
   assertTargetPolicy,
   selectTarget
-} from "../../shared/dpc2r7rb.js";
-import"../../shared/sjk86yrx.js";
+} from "../../shared/6nae0spm.js";
+import {
+  canonicalJson
+} from "../../shared/358zsv4r.js";
 import {
-  OkmError2
+  OkmError2,
+  catalogError2
 } from "../../shared/52szzakm.js";
 
 // src/tooling/migrate/config.ts
 function defineConfig(config) {
   return config;
 }
+// src/tooling/migrate/schema-api.ts
+var LOGICAL_NAMESPACE = "public";
+function describe(schema) {
+  const source = schemaCatalog(schema);
+  const document = JSON.parse(serializeCatalog2(source));
+  const text = canonicalJson({
+    catalog: document,
+    logical: {
+      format: LOGICAL_FORMAT,
+      name: LOGICAL_NAMESPACE,
+      namespace: LOGICAL_NAMESPACE
+    }
+  });
+  return JSON.parse(text);
+}
+function buildCatalog(description) {
+  if (description === null || typeof description !== "object" || !("catalog" in description)) {
+    catalogError2("OKM1027", "Catalog document is not an object.");
+  }
+  const body = description.catalog;
+  if (body === null || typeof body !== "object") {
+    catalogError2("OKM1027", "Catalog document is not an object.");
+  }
+  return parseCatalog2(JSON.stringify(body));
+}
+function schemaCatalog(schema) {
+  if (schema === null || typeof schema !== "object") {
+    catalogError2("OKM1020", "describe() needs the schema() result.");
+  }
+  const catalog = schema.catalog;
+  if (typeof catalog !== "object" || catalog === null || !("objects" in catalog)) {
+    catalogError2("OKM1020", "describe() needs the schema() result.");
+  }
+  return catalog;
+}
 // src/tooling/migrate/provision.ts
 async function provision(target, cwd = process.cwd()) {
   const config = await loadConfig(cwd);
@@ -71,6 +114,8 @@ ${report.applied.map((id) => `applied ${id}`).join(`
 `;
 }
 export {
+  buildCatalog,
   defineConfig,
+  describe,
   provision
 };

package/dist/tooling/migrate/lint-rules.d.ts

@@ -42,10 +42,27 @@ export type ColumnRule = {
  * Step rules, lowest free code in each category.
  *
  * OKM1534 to OKM1537 are errors when the statement is not the safe form.
- * OKM1538 stays a warning: a rewriting type change has no safe form here.
+ * OKM1538 stays a warning, and only when the type change rewrites the table.
  */
 export declare const STEP_RULES: readonly StepRule[];
 /**
  * Type preferences. Warnings, read from the schema catalog by `okm check`.
  */
 export declare const COLUMN_RULES: readonly ColumnRule[];
+/**
+ * Collapses whitespace and lowercases SQL outside quoted identifiers.
+ *
+ * @param sql - One statement
+ * @returns The comparison form
+ */
+export declare function normalizedSql(sql: string): string;
+/**
+ * A create or alter of a domain, or a `LANGUAGE sql` function.
+ *
+ * Offline lint cannot see the reprint. The allow is still for that statement.
+ * `okm migrate check` decides whether the text actually differs.
+ *
+ * @param sql - One statement
+ * @returns `true` when OKM1552 can fire for this statement
+ */
+export declare function statementMayReprint(sql: string): boolean;

package/dist/tooling/migrate/lint.d.ts

@@ -8,7 +8,7 @@
 import type { Catalog } from "../../contracts/catalog/types.js";
 import { OkmError } from "../../contracts/error.js";
 import { type LintSeverity } from "./lint-rules.js";
-import type { MigrationPlan } from "./plan.js";
+import type { MigrationPlan, PlanStep } from "./plan.js";
 /** One finding. `place` is `step N`, `step N statement M`, or `table.column`. */
 export type Finding = {
     readonly severity: LintSeverity;
@@ -26,6 +26,19 @@ export type Finding = {
  * @returns Findings in step order, then code order
  */
 export declare function lintPlan(plan: MigrationPlan, before: Catalog, after: Catalog): readonly Finding[];
+/**
+ * Warns when a replayed domain check or `LANGUAGE sql` body reprints.
+ *
+ * Called from `okm migrate check` after introspection. A warning does not
+ * fail the command. An allow with an empty reason, or a code the replay did
+ * not trigger, is OKM1510.
+ *
+ * @param declared - Catalog stored with the migration
+ * @param stored - Catalog read back from the scratch schema
+ * @param steps - Statements of that migration, including `-- okm-allow`
+ * @returns Findings in catalog order
+ */
+export declare function lintReprints(declared: Catalog, stored: Catalog, steps: readonly PlanStep[]): readonly Finding[];
 /**
  * Lints type preferences on the author catalog.
  *

package/dist/tooling/migrate/place.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Places a `schema()` catalog into the namespace from `defineConfig`.
+ *
+ * `schema()` compiles `public`. Planning reads this copy, so two catalogs
+ * on one database do not share table identities. An `external` table keeps
+ * the namespace from its snapshot. A catalog that is already `public` and
+ * has no external namespace is returned as itself, so its hash does not change.
+ */
+import type { Catalog } from "../../contracts/catalog/types.js";
+/**
+ * Rewrites managed objects into `namespace` and external tables into `externalNamespaces`.
+ *
+ * @param source - Catalog from `schema()`, after ownership is stamped
+ * @param namespace - Postgres schema this catalog owns. `public` is the default
+ * @param externalNamespaces - SQL table name to the owning catalog's namespace
+ * @returns `source` when nothing moves, otherwise a new catalog
+ */
+export declare function placeCatalog(source: Catalog, namespace: string, externalNamespaces: ReadonlyMap<string, string>): Catalog;

package/dist/tooling/migrate/plan-json.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Machine-readable `okm migrate plan --json` (D279).
+ *
+ * The document is the plan the comment renderer reads. It is not parsed
+ * back out of the human SQL text.
+ */
+import type { MigrationClass } from "./classify.js";
+import type { Finding } from "./lint.js";
+import type { MigrationPlan, PlanStep } from "./plan.js";
+/** One step in a plan document. `lock` matches the human `-- lock:` line. */
+export type PlanStepJson = {
+    readonly class: MigrationClass;
+    readonly lock: string;
+    readonly sql: string;
+};
+/** One lint finding in a plan document. */
+export type PlanFindingJson = {
+    readonly severity: "error" | "warning";
+    readonly code: string;
+    readonly place: string;
+    readonly reason: string;
+    readonly fix: string;
+};
+/**
+ * What `okm migrate plan --json` prints.
+ *
+ * `class` is the strictest class, the same value as the human header.
+ */
+export type PlanDocument = {
+    readonly name: string;
+    readonly class: MigrationClass;
+    readonly steps: readonly PlanStepJson[];
+    readonly findings: readonly PlanFindingJson[];
+};
+/**
+ * Builds the document `okm migrate plan --json` prints.
+ *
+ * `lockText` is the same callback {@link formatPlan} uses, so a lock line
+ * that includes a row estimate is the same string in both outputs.
+ *
+ * @param plan - Plan the command already computed
+ * @param findings - Lint findings for that plan
+ * @param lockText - Annotated lock, when a target answered
+ * @returns The document
+ */
+export declare function planDocument(plan: MigrationPlan, findings: readonly Finding[], lockText?: (step: PlanStep) => string): PlanDocument;
+/**
+ * Serialises a plan document.
+ *
+ * @param plan - Plan the command already computed
+ * @param findings - Lint findings for that plan
+ * @param lockText - Annotated lock, when a target answered
+ * @returns JSON text ending in a newline
+ */
+export declare function formatPlanJson(plan: MigrationPlan, findings: readonly Finding[], lockText?: (step: PlanStep) => string): string;
+/**
+ * Reads a plan document.
+ *
+ * Extra fields are ignored. A missing field, or a class that is not
+ * `expand`, `contract`, or `unclassified`, is refused.
+ *
+ * @param text - JSON from `okm migrate plan --json`
+ * @returns The document
+ */
+export declare function parsePlanJson(text: string): PlanDocument;

package/dist/tooling/migrate/project.d.ts

@@ -46,12 +46,13 @@ export declare function generateProject(cwd: string, name: string, flags: readon
  * @param name - Plan name
  * @param flags - `--replace` values
  * @param invoke - Target and protection flags, when the command passed them
- * @returns The plan, its lint findings, and the text to print
+ * @returns The plan, its lint findings, the human text, and the `--json` document. Both forms use the same lock lines
  */
 export declare function planProject(cwd: string, name: string, flags: readonly string[], invoke?: InvokeFlags): Promise<{
     readonly plan: MigrationPlan;
     readonly findings: readonly Finding[];
     readonly text: string;
+    readonly json: string;
 }>;
 /**
  * Validates the schema, then reports stale renames and unlisted table files.
@@ -113,6 +114,14 @@ export declare function openProject(cwd: string): Promise<{
  * @returns The built schema, with roles attached when the config declares them
  */
 export declare function loadBuiltSchema(cwd: string, config: MigrateConfig): Promise<Built>;
+/**
+ * Prints or writes the catalog snapshot.
+ *
+ * @param cwd - Project directory
+ * @param args - Arguments after `export`
+ * @returns Stdout
+ */
+export declare function exportProject(cwd: string, args: readonly string[]): Promise<string>;
 /**
  * Loads `okmodel.config.ts`.
  *

package/dist/tooling/migrate/pull-emit.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Turns an introspected catalog into table files and a schema file.
+ *
+ * `schema()` is the only writer. Functions, triggers, and views are written
+ * beside the tables. A kind it cannot store is returned, with the SQL the
+ * catalog already holds, and is not guessed.
+ */
+import type { Catalog } from "../../contracts/catalog/types.js";
+import { type RoutinePlan, type RoutineVerdict } from "./pull-routines.js";
+/** One file `okm pull` writes. */
+export type PullFile = {
+    /** Absolute path. */
+    readonly path: string;
+    /** Source text, before the project formatter runs. */
+    readonly text: string;
+};
+/** One object the schema file does not declare. */
+export type PullSkip = {
+    /** {@link identityKey} of the catalog object. */
+    readonly key: string;
+    /** Catalog kind, or `column` for a type `table()` cannot build. */
+    readonly kind: string;
+    /** `table.column`, or the object name. */
+    readonly label: string;
+    /** Why this step left it out. */
+    readonly reason: string;
+    /** SQL from the catalog. Empty when the kind has no statement of its own. */
+    readonly sql: string;
+};
+/** Where the schema file and the table files go. */
+export type PullLayout = {
+    /** Absolute path of the schema module. */
+    readonly schemaFile: string;
+    /** Absolute directory of one file per table. */
+    readonly tablesDir: string;
+};
+/** Files to write, and the objects those files leave out. */
+export type PullEmission = {
+    readonly files: readonly PullFile[];
+    readonly skipped: readonly PullSkip[];
+    /** Scratch results for the routines the files declare. */
+    readonly verdicts: readonly RoutineVerdict[];
+    readonly counts: {
+        readonly tables: number;
+        readonly functions: number;
+        readonly triggers: number;
+        readonly views: number;
+        readonly materializedViews: number;
+    };
+};
+/** A kind the catalog cannot store, counted for the report. */
+export type PullCount = {
+    readonly kind: string;
+    readonly count: number;
+    readonly reason: string;
+};
+/** Scratch verdicts and the kinds the catalog has no object for. */
+export type PullReview = {
+    readonly plan: RoutinePlan;
+    readonly verdicts: readonly RoutineVerdict[];
+    readonly unexpressed: readonly PullCount[];
+};
+/**
+ * Writes one table module per table and the schema module that imports them.
+ *
+ * Column order, import order, and option keys are sorted, so the same catalog
+ * produces the same text.
+ *
+ * @param source - Catalog from introspection, logical namespace `public`
+ * @param layout - Schema file and tables directory
+ * @param review - Scratch verdicts. Omitted marks every function candidate-only
+ * @returns The files and the objects they do not declare
+ */
+export declare function emitPull(source: Catalog, layout: PullLayout, review?: PullReview): PullEmission;
+/**
+ * Text `okm pull` prints.
+ *
+ * Deferred kinds and kinds the catalog cannot store are always listed,
+ * including a count of zero, so a kind is not dropped without a line.
+ * Each pulled function is `verified`, `candidate-only`, or `unverified`.
+ *
+ * @param counts - Objects the files declare
+ * @param skipped - Objects the files leave out
+ * @param verdicts - Scratch results. Empty when no routine was pulled
+ * @param unexpressed - Aggregates, procedures, event triggers, and rules
+ * @param verb - `imported` for `okm import drizzle`. `pulled` is `okm pull`
+ * @returns The report, with a trailing newline
+ */
+export declare function formatPullReport(counts: PullEmission["counts"], skipped: readonly PullSkip[], verdicts?: readonly RoutineVerdict[], unexpressed?: readonly PullCount[], verb?: "pulled" | "imported"): string;
+/**
+ * SQL table name to the binding `table()` writes.
+ *
+ * A partitioned table is omitted. The binding matches the table file.
+ *
+ * @param source - Introspected catalog
+ * @returns Bindings for tables this step writes
+ */
+export declare function tableExportNames(source: Catalog): ReadonlyMap<string, string>;

package/dist/tooling/migrate/pull-routines.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Plans `fn()`, `trigger()`, `view()`, and `materializedView()` for `okm pull`.
+ *
+ * Views and `BEGIN ATOMIC` bodies take edges the catalog already read from
+ * `pg_depend`. A plpgsql or SQL-string body gets table candidates from
+ * {@link sqlIdentifiers}. A view or a function named in that body is an
+ * ordering edge only: `dependsOn` accepts tables and columns. A view query
+ * is matched the same way, so a view over a view waits for the view it names
+ * when `pg_depend` recorded no column edge.
+ */
+import type { Catalog, FunctionObject, IndexObject, MaterializedViewObject, ObjectIdentity, TriggerObject, ViewObject } from "../../contracts/catalog/types.js";
+/** Why a pulled routine is marked the way it is. */
+export type RoutineStatus = "verified" | "candidate-only" | "unverified";
+/** One function, trigger, or view after the scratch replay. */
+export type RoutineVerdict = {
+    /** {@link identityKey} of the catalog object. */
+    readonly key: string;
+    /** Catalog kind. */
+    readonly kind: "function" | "trigger" | "view" | "materializedView";
+    /** Report label. */
+    readonly label: string;
+    /** What the scratch run proved. */
+    readonly status: RoutineStatus;
+    /** Postgres error, or why the scratch schema did not run. Empty when proved or candidate-only. */
+    readonly detail: string;
+};
+/** One object the schema file does not declare. Shape matches the pull skip. */
+export type RoutineSkip = {
+    readonly key: string;
+    readonly kind: string;
+    readonly label: string;
+    readonly reason: string;
+    readonly sql: string;
+};
+/** A function the schema file will declare. */
+export type PlannedFunction = {
+    readonly object: FunctionObject;
+    /** Binding in the schema file. */
+    readonly binding: string;
+    /** Source fragments inside `dependsOn: [...]`. */
+    readonly dependsOn: readonly string[];
+};
+/** A trigger the schema file will declare. */
+export type PlannedTrigger = {
+    readonly object: TriggerObject;
+    readonly binding: string;
+    /** Table binding passed to `on`. */
+    readonly on: string;
+    /** Function binding passed to `calls`. */
+    readonly calls: string;
+};
+/** A view or materialized view the schema file will declare. */
+export type PlannedView = {
+    readonly object: ViewObject | MaterializedViewObject;
+    readonly binding: string;
+    /** Indexes `materializedView()` can store. Expression indexes are skipped. */
+    readonly indexes: readonly IndexObject[];
+};
+/**
+ * Routines to write, and the extra edges the scratch replay orders by.
+ *
+ * `orderEdges` are not written. `dependsOn` cannot name a view or a function.
+ */
+export type RoutinePlan = {
+    readonly functions: readonly PlannedFunction[];
+    readonly triggers: readonly PlannedTrigger[];
+    readonly views: readonly PlannedView[];
+    readonly skipped: readonly RoutineSkip[];
+    /** Identity key to edges added for the scratch order only. */
+    readonly orderEdges: ReadonlyMap<string, readonly ObjectIdentity[]>;
+};
+/** Bindings and declarations inserted into the schema file. */
+export type RenderedRoutines = {
+    readonly imports: readonly string[];
+    readonly body: string;
+    readonly functions: readonly string[];
+    readonly triggers: readonly string[];
+    readonly views: readonly string[];
+};
+/**
+ * Chooses which routines to write and which names `dependsOn` can cite.
+ *
+ * @param source - Introspected catalog
+ * @param tableExports - SQL table name to the binding `table()` writes
+ * @returns The plan. Comments are applied later, from the scratch verdicts
+ */
+export declare function planRoutines(source: Catalog, tableExports: ReadonlyMap<string, string>): RoutinePlan;
+/**
+ * Renders the schema-file text for a plan.
+ *
+ * A missing verdict is candidate-only for a function and unverified for a
+ * view or a trigger. That is what a scratch run that did not happen can say.
+ *
+ * @param plan - Routines to write
+ * @param verdicts - Scratch results, keyed by {@link identityKey}
+ * @returns Imports, bindings, and the `schema()` lists
+ */
+export declare function renderRoutines(plan: RoutinePlan, verdicts: ReadonlyMap<string, RoutineVerdict>): RenderedRoutines;
+/**
+ * Verdicts for a plan when the scratch schema was not created.
+ *
+ * Nothing is verified. A plpgsql function stays candidate-only. A SQL
+ * function, a view, and a trigger are unverified.
+ *
+ * @param plan - Routines that would have been replayed
+ * @param detail - Why the scratch schema was not created
+ * @returns One verdict per planned routine
+ */
+export declare function verdictsWithoutScratch(plan: RoutinePlan, detail: string): readonly RoutineVerdict[];
+/**
+ * Tables, views, and functions named in `body`.
+ *
+ * Unquoted names fold to lower case. A quoted name matches the stored spelling.
+ * The function's own name is included; the caller drops a self-edge.
+ *
+ * @param body - Function body or view query
+ * @param tables - Pulled tables
+ * @param views - Pulled views and materialized views
+ * @param functions - Functions grouped by name
+ * @returns Matches, tables by SQL name and the other two as identities
+ */
+export declare function matchNames(body: string, tables: ReadonlyMap<string, ObjectIdentity>, views: ReadonlyMap<string, ViewObject | MaterializedViewObject>, functions: ReadonlyMap<string, readonly FunctionObject[]>): {
+    readonly tables: readonly string[];
+    readonly views: readonly ObjectIdentity[];
+    readonly functions: readonly ObjectIdentity[];
+};