okmodel 0.2.1 → 0.4.0

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

@@ -0,0 +1,18 @@
+/**
+ * `provision(target)` for one configured target (D198).
+ *
+ * Same rules as `okm migrate apply` on an empty target, including
+ * {@link assertTargetPolicy}. A target that is not empty is OKM1851.
+ * Tenant registry creation is M5.
+ */
+/**
+ * Provisions one configured target from the head snapshot.
+ *
+ * The target must be empty. Reference rows are inserted if missing. History
+ * records `provisioned@<migration id>` and no migration step.
+ *
+ * @param target - Configured target name. `default` is the `database` target
+ * @param cwd - Project directory. Defaults to the process working directory
+ * @returns The same text `okm migrate apply` prints for that run
+ */
+export declare function provision(target: string, cwd?: string): Promise<string>;

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

@@ -0,0 +1,40 @@
+/**
+ * Reference rows declared on a table (D198).
+ *
+ * The rows live on the schema, not as a catalog diff. Apply inserts a row
+ * when its key is missing and does not update or delete. The statements are
+ * not migration steps, so OKM1542 does not see them.
+ */
+import type { Catalog } from "../../contracts/catalog/types.js";
+import { type AnyTable } from "../../dialects/pg/table.js";
+/** One value a reference row may store. */
+export type ReferenceValue = string | number | boolean | null;
+/** One table's reference declaration, in SQL names. */
+export type ReferenceTable = {
+    readonly table: string;
+    readonly key: readonly string[];
+    readonly rows: readonly (readonly (readonly [string, ReferenceValue])[])[];
+};
+/**
+ * Reads `reference` from the schema and checks it against the head catalog.
+ *
+ * A key must be a primary key, a unique constraint, or a unique index, in
+ * that column order. The catalog is not given a copy of the rows.
+ *
+ * @param tables - Tables the schema built
+ * @param casing - Schema casing. Absent means names are used as written
+ * @param head - Head snapshot the rows will be inserted into
+ * @returns One entry per table that declares rows
+ */
+export declare function readReference(tables: readonly AnyTable[], casing: "snake" | undefined, head: Catalog): readonly ReferenceTable[];
+/**
+ * Insert-if-missing statements for one schema.
+ *
+ * Each row is its own `INSERT … ON CONFLICT DO NOTHING`. There is no
+ * `UPDATE` and no `DELETE`.
+ *
+ * @param tables - Declarations from {@link readReference}
+ * @param schema - Schema the statements write
+ * @returns SQL in declaration order
+ */
+export declare function referenceInserts(tables: readonly ReferenceTable[], schema: string): readonly string[];

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

@@ -0,0 +1,108 @@
+/**
+ * One-target apply runner (D195).
+ *
+ * `okm migrate apply` calls {@link runTarget} with the units of one target.
+ * Bounded concurrency, several targets, canaries, and class flags are M5.
+ * A backfill step is one transaction per batch, with a checkpoint in
+ * `okm_backfill` after each commit.
+ */
+import type { DriverConnection } from "../../contracts/driver.js";
+import type { PlanStep } from "./plan.js";
+/** One step with its index in the migration file. */
+export type RunnableStep = {
+    readonly index: number;
+    readonly step: PlanStep;
+};
+/** Steps that commit together, or one step that cannot. */
+export type RunnableUnit = {
+    readonly migrationId: string;
+    readonly catalogHash: string;
+    /** True when this unit is the last step of its migration. */
+    readonly finishes: boolean;
+    readonly transactional: boolean;
+    readonly steps: readonly RunnableStep[];
+};
+/** What one committed backfill batch recorded. */
+export type BackfillBatch = {
+    readonly migrationId: string;
+    readonly stepIndex: number;
+    readonly batch: number;
+    readonly rows: number;
+    readonly lastKey: string | null;
+};
+/**
+ * Protection and timeouts the runner reads on every batch.
+ *
+ * `protected` is read again at each batch, so a caller can change it between
+ * batches.
+ */
+export type RunPolicy = {
+    readonly target: string;
+    readonly protected: boolean;
+    readonly allowProtected?: boolean;
+};
+/** One target's units, retries, and checkpoints. */
+export type TargetRun = {
+    readonly policy: RunPolicy;
+    readonly units: readonly RunnableUnit[];
+    readonly retries: number;
+    readonly lockTimeoutMs: number;
+    readonly statementTimeoutMs: number;
+    readonly backfillPauseMs?: number;
+    readonly backfillStatementTimeoutMs?: number;
+    readonly migrationRole?: string;
+    readonly schema?: string;
+    readonly onProgress?: (line: string) => void;
+    readonly afterBatch?: (batch: BackfillBatch) => void | Promise<void>;
+};
+/** What {@link runTarget} finished on this target. */
+export type TargetRunReport = {
+    readonly target: string;
+    readonly applied: readonly string[];
+    readonly setRole?: string;
+};
+/**
+ * Runs one target's units in order.
+ *
+ * A finished step is skipped by the caller before it is placed in `units`.
+ * Lock timeout retries that step. A backfill retries the current batch only
+ * and resumes from `okm_backfill`.
+ *
+ * @param connection - Reserved connection. The caller holds the advisory lock
+ * @param run - Units, retries, and the protection flag
+ * @param session - Role assumed for the rest of the connection
+ * @returns The target and the migration ids that ran at least one unit
+ */
+export declare function runTarget(connection: DriverConnection, run: TargetRun, session: {
+    setRole?: string;
+}): Promise<TargetRunReport>;
+/**
+ * Assumes `role` for the rest of this connection.
+ *
+ * A second call with the same role does nothing.
+ *
+ * @param connection - Reserved connection
+ * @param role - Migration role
+ * @param session - Remembers the role already assumed
+ */
+export declare function assumeRole(connection: DriverConnection, role: string, session: {
+    setRole?: string;
+}): Promise<void>;
+/**
+ * Lets a new migration role create objects in `schema`.
+ *
+ * @param connection - Reserved connection, before `SET ROLE`
+ * @param schema - Schema the migration writes
+ * @param role - Role that was just created
+ */
+export declare function grantSchema(connection: DriverConnection, schema: string, role: string): Promise<void>;
+/**
+ * Reports whether Postgres refuses to run `sql` inside a transaction.
+ *
+ * `VACUUM`, `ALTER TYPE … ADD VALUE`, and concurrent index create or drop
+ * each need their own unit.
+ *
+ * @param sql - One statement
+ * @returns `true` when the statement cannot share a transaction
+ */
+export declare function statementOutsideTransaction(sql: string): boolean;

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

@@ -0,0 +1,77 @@
+/**
+ * Safe DDL for a table that already exists (D193).
+ *
+ * A new table keeps the plain statements from `ddl.ts`. These shapes are only
+ * for a table in the before-catalog: concurrent indexes, `NOT VALID` plus
+ * `VALIDATE`, `SET NOT NULL` through a validated check, a volatile default
+ * split from column creation, and a unique or primary key built from a
+ * concurrent unique index.
+ *
+ * The volatile-default fill is a backfill: one idempotent `UPDATE` per batch,
+ * limited to rows where the new column is still null (D195).
+ */
+import type { Catalog, CatalogObject, ColumnObject } from "../../contracts/catalog/types.js";
+import { type BackfillSpec } from "./backfill.js";
+import type { StepKind } from "./classify.js";
+/** One statement the planner emits instead of the plain form. */
+export type SafeStep = {
+    readonly sql: string;
+    readonly kind: StepKind;
+    readonly action: "ddl" | "backfill";
+    readonly lock: string;
+    readonly transactional: boolean;
+    /** Set on the volatile-default fill. The statement is one batch. */
+    readonly backfill?: BackfillSpec;
+};
+/**
+ * Safe steps for one object on a table that already exists.
+ *
+ * Returns `undefined` when the plain statement is already safe: a stable or
+ * constant column default, or an object this rewrite does not cover.
+ *
+ * @param object - Object the plan is creating
+ * @param schema - Concrete schema name
+ * @param catalogs - Before and after catalogs, for volatility and name clashes
+ * @param batchSize - Rows per batch written on a volatile-default fill
+ * @returns The replacement steps, or `undefined` to keep the plain statement
+ */
+export declare function stepsForExistingTable(object: CatalogObject, schema: string, catalogs: readonly Catalog[], batchSize: number): readonly SafeStep[] | undefined;
+/**
+ * `SET NOT NULL` through a validated check (Postgres 12+, always on the floor of 15).
+ *
+ * Postgres skips the table scan when a validated `CHECK (col IS NOT NULL)`
+ * already exists. The temporary check is dropped after `SET NOT NULL`.
+ *
+ * @param column - Column that must become `NOT NULL`
+ * @param schema - Concrete schema name
+ * @param setKind - `set-not-null` when the column already existed; `add-column` when this finishes a new column and the plan stays expand
+ * @param catalogs - Catalogs whose constraint names the temporary check must not reuse
+ * @returns Add `NOT VALID`, validate, set not null, drop the check
+ */
+export declare function notNullSteps(column: ColumnObject, schema: string, setKind: "set-not-null" | "add-column", catalogs: readonly Catalog[]): readonly SafeStep[];
+/**
+ * Inserts `CONCURRENTLY` into a `CREATE INDEX` statement.
+ *
+ * @param sql - Plain `create index` or `create unique index` from `ddl.ts`
+ * @returns The same statement, concurrent
+ */
+export declare function concurrentIndexSql(sql: string): string;
+/**
+ * Inserts `CONCURRENTLY` into a `DROP INDEX` statement.
+ *
+ * @param sql - Plain `drop index` from `ddl.ts`
+ * @returns The same statement, concurrent
+ */
+export declare function concurrentDropIndexSql(sql: string): string;
+/**
+ * Reports whether a default expression is volatile.
+ *
+ * A constant has no call. `now()` and the other stable builtins stay plain.
+ * `gen_random_uuid()`, `uuidv7()`, and any other call the catalog marks
+ * volatile are split. A call the catalog does not know is left plain.
+ *
+ * @param expression - Column `defaultExpression`, when the column has one
+ * @param catalogs - Catalogs that may hold the called function
+ * @returns `true` when adding the column with this default would rewrite existing rows
+ */
+export declare function volatileDefault(expression: string | undefined, catalogs: readonly Catalog[]): boolean;

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

@@ -0,0 +1,20 @@
+/**
+ * `okm seed <file>` (spec §20, D199).
+ *
+ * The file's default export receives the testing harness for the selected
+ * target. Protection is `assertTargetPolicy`, the same gate as every other
+ * command. The target is already migrated: this command does not apply DDL.
+ */
+import { type InvokeFlags } from "./policy.js";
+/**
+ * Runs a seed file against the selected target.
+ *
+ * Policy and target selection run before the pool opens, so a protected
+ * target is refused without a connection.
+ *
+ * @param cwd - Project directory
+ * @param file - Seed module, relative to `cwd`
+ * @param flags - `--target`, `--allow-protected`, and `--allow-pooler`
+ * @returns Text for stdout
+ */
+export declare function seedProject(cwd: string, file: string, flags: InvokeFlags): Promise<string>;

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

@@ -0,0 +1,78 @@
+/**
+ * Head snapshot install and the comparison with a replayed history (D198).
+ *
+ * Provision plans the head catalog from an empty catalog and runs that SQL.
+ * It does not replay migration files. OKM1521 is the difference between that
+ * result and a full replay, after {@link canonicalTypeName} (D191).
+ */
+import type { Catalog } from "../../contracts/catalog/types.js";
+import type { DriverConnection } from "../../contracts/driver.js";
+import type { ReferenceTable } from "./reference.js";
+/** History id prefix for a target installed from the head snapshot. */
+export declare const PROVISION_PREFIX = "provisioned@";
+/**
+ * History id written when a target is provisioned at `migrationId`.
+ *
+ * @param migrationId - Head migration id
+ * @returns `provisioned@` plus that id
+ */
+export declare function provisionMark(migrationId: string): string;
+/**
+ * Migration id stored inside a provision mark.
+ *
+ * @param migrationId - A history migration id
+ * @returns The id after the prefix, or `undefined` when it is not a mark
+ */
+export declare function provisionedMigrationId(migrationId: string): string | undefined;
+/**
+ * Marks every step up through a provisioned migration as done.
+ *
+ * A later file stays pending. A mark whose id is not in `migrations` is left
+ * for the caller to treat as history this project does not contain.
+ *
+ * @param migrations - Files in apply order
+ * @param done - Keys `${id}:${step}` already in history
+ * @param historyIds - `migration_id` values in history
+ * @returns A set the applier can skip
+ */
+export declare function expandProvisioned(migrations: readonly {
+    readonly id: string;
+    readonly steps: readonly unknown[];
+}[], done: ReadonlySet<string>, historyIds: readonly string[]): Set<string>;
+/**
+ * Reports whether a history id belongs to this project's files.
+ *
+ * A `provisioned@` mark belongs when the id after the prefix is a file.
+ *
+ * @param migrationId - History migration id
+ * @param known - File ids
+ * @returns `true` when status should not call the row ahead
+ */
+export declare function provisionHistoryIsKnown(migrationId: string, known: ReadonlySet<string>): boolean;
+/**
+ * Installs `head` into an empty schema and inserts reference rows.
+ *
+ * The plan is from an empty catalog, so no expand, backfill, or contract
+ * file is replayed. An existing role is left in place. The caller records
+ * history.
+ *
+ * @param connection - Reserved connection, after the advisory lock
+ * @param head - Head snapshot
+ * @param schema - Schema that receives the objects
+ * @param reference - Rows to insert if missing
+ * @param migrationRole - Role assumed after this run creates it
+ */
+export declare function installSnapshot(connection: DriverConnection, head: Catalog, schema: string, reference: readonly ReferenceTable[], session: {
+    setRole?: string;
+}, migrationRole?: string): Promise<void>;
+/**
+ * Names the first object that differs between two introspected catalogs.
+ *
+ * Type names are compared with {@link canonicalTypeName}. Managed history
+ * tables are omitted. `undefined` means the catalogs match.
+ *
+ * @param left - One introspection
+ * @param right - The other introspection
+ * @returns The object, and the statement that would change it, when they differ
+ */
+export declare function snapshotDifference(left: Catalog, right: Catalog): string | undefined;

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

@@ -2,8 +2,10 @@
  * `okm migrate status`.
  *
  * One row per target: version, catalog hash, state, and a separate protected
- * column. The state is current, behind by expand, behind by contract, ahead,
- * or failed at a step.
+ * column. The state is current, behind by expand, behind by contract, ahead
+ * by expand, ahead by contract, or failed at a step with a resume hint. An
+ * unfinished backfill is a later section: migration, step, rows so far, last
+ * key, and state.
  */
 import type { MigrationClass } from "./plan.js";
 import type { StoredMigration } from "./files.js";
@@ -15,6 +17,18 @@ export type TargetStatus = {
     readonly catalogHash: string;
     readonly state: string;
     readonly protected: boolean;
+    /** Unfinished `okm_backfill` rows for this target. A finished step is absent. */
+    readonly backfills: readonly BackfillProgress[];
+};
+/** One backfill that has committed at least one batch and is not done. */
+export type BackfillProgress = {
+    readonly migrationId: string;
+    readonly stepIndex: number;
+    /** Rows the committed batches changed. */
+    readonly rows: string;
+    /** Last committed boundary, or `-` when the first batch is still open. */
+    readonly lastKey: string;
+    readonly state: string;
 };
 /** A checkpoint row the state function reads. */
 export type StatusHistory = {
@@ -25,9 +39,11 @@ export type StatusHistory = {
 /**
  * Decides the status state from files and history.
  *
- * A partial migration is `failed at step`. History the files do not contain
- * is `ahead`. Pending files are behind by expand, or by contract when any
- * pending step is not expand.
+ * A partial migration is `failed at step` plus the resume hint. History the
+ * files do not contain is ahead by expand, or ahead by contract when a stored
+ * class is not expand. Pending files are behind by expand, or by contract
+ * when any pending step is not expand. The class is the one stored on the
+ * file or in `okm_history`.
  *
  * @param migrations - Files in apply order
  * @param history - Checkpoint rows
@@ -68,7 +84,10 @@ export declare function statusProject(cwd: string, flags: InvokeFlags): Promise<
 /**
  * Prints status rows.
  *
+ * The target columns stay `target`, `version`, `catalog`, `state`, and
+ * `protected`. Unfinished backfills follow as their own section.
+ *
  * @param rows - One per target
- * @returns Header plus one line per target
+ * @returns Header plus one line per target, then unfinished backfills
  */
 export declare function formatStatus(rows: readonly TargetStatus[]): string;

package/dist/tooling/migrate/type-name.d.ts

@@ -0,0 +1,19 @@
+/**
+ * One spelling for a SQL type name in a diff (D191).
+ *
+ * The catalog keeps the spelling the schema wrote. Introspection keeps
+ * `format_type`. Both sides of a comparison pass through here, so
+ * `timestamptz` and `timestamp with time zone` are one type. A different
+ * length, precision, or type stays different. An unknown name is returned
+ * as written.
+ */
+/**
+ * Maps a schema spelling or a `format_type` spelling to the long form.
+ *
+ * Modifiers and array ranks stay. `varchar(20)[]` becomes
+ * `character varying(20)[]`.
+ *
+ * @param typeName - Type name from a catalog definition
+ * @returns The Postgres long spelling
+ */
+export declare function canonicalTypeName(typeName: string): string;

package/dist/tooling/testing/factories.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Factories: `create`, `createMany`, `with({ child: n })`, and `x.ref`.
+ *
+ * A required column the definition leaves out is filled from its type (D199).
+ * `x.ref` reuses the latest row of that table in the same tenant, or creates one.
+ */
+import type { Connected } from "../../runtime/types.js";
+import { type TableFacts, type TestingSchema } from "./facts.js";
+import type { Rng } from "./random.js";
+declare const REF: unique symbol;
+/** A `x.ref("table")` marker. Resolved when the row is inserted. */
+type FactoryRef = {
+    readonly [REF]: string;
+};
+/** Values a factory definition may return. */
+export type FactoryContext = {
+    /** `userN@example.com`. N increases for each call. */
+    email(): string;
+    /** A first and last name from a fixed list. */
+    name(): string;
+    /** `count` words from a fixed list. */
+    words(count: number): string;
+    /** An integer in `[0, bound)`. `bound` defaults to 10_000. */
+    int(bound?: number): number;
+    /** A number in `[0, 1)`. */
+    float(): number;
+    /** A boolean. */
+    boolean(): boolean;
+    /** An ISO date `YYYY-MM-DD` in January 2020. */
+    date(): string;
+    /** A UUID from the seed. */
+    uuid(): string;
+    /** One entry of `list`. */
+    pick<T>(list: readonly T[]): T;
+    /**
+     * The primary key of `table`.
+     *
+     * The first call creates the row. A later call in the same tenant reuses it.
+     * A `create` of that table replaces the reused row.
+     */
+    ref(table: string): FactoryRef;
+};
+/** One table's factory. */
+export type TableFactory = {
+    /**
+     * Inserts one row.
+     *
+     * @param overrides - Column values. A tenant key here is the scope, not a column.
+     * @returns The inserted row
+     */
+    create(overrides?: Readonly<Record<string, unknown>>): Promise<Record<string, unknown>>;
+    /**
+     * Inserts `count` rows. Each row draws new generated values.
+     *
+     * @param count - How many rows
+     * @param overrides - Column values applied to every row
+     * @returns The inserted rows
+     */
+    createMany(count: number, overrides?: Readonly<Record<string, unknown>>): Promise<readonly Record<string, unknown>[]>;
+    /**
+     * Creates `count` rows of `child` after the parent, linked by the foreign key.
+     *
+     * @param children - Child table name to how many rows
+     * @returns A factory that still inserts this table
+     */
+    with(children: Readonly<Record<string, number>>): TableFactory;
+};
+/**
+ * Remembers `host` for the harness object `okm seed` prints from.
+ *
+ * @param harness - The object returned by `testing()`
+ * @param host - Its factory state
+ */
+export declare function attachHost(harness: object, host: FactoryHost): void;
+/**
+ * Rows inserted through factories, summed by table name.
+ *
+ * @param harness - The object returned by `testing()`
+ * @returns Counts in table-name order
+ */
+export declare function createdOf(harness: object): readonly {
+    readonly table: string;
+    readonly count: number;
+}[];
+/** Shared state for one harness. */
+export type FactoryHost = {
+    readonly schema: TestingSchema;
+    readonly db: Connected<TestingSchema>;
+    readonly facts: ReadonlyMap<string, TableFacts>;
+    readonly rng: Rng;
+    /** Latest row of a table in one tenant. Isolation uses its own map. */
+    cache: Map<string, Record<string, unknown>>;
+    /** Tables currently being inserted. A repeat is a factory cycle. */
+    readonly creating: Set<string>;
+    readonly created: Map<string, number>;
+    readonly definitions: Map<string, (context: FactoryContext) => Readonly<Record<string, unknown>>>;
+};
+/**
+ * Builds the factory object for `definitions`.
+ *
+ * @param host - Schema, client, and seed
+ * @param definitions - One function per table
+ * @returns A factory per definition
+ */
+export declare function bindFactories(host: FactoryHost, definitions: Readonly<Record<string, (context: FactoryContext) => Readonly<Record<string, unknown>>>>): Record<string, TableFactory>;
+/**
+ * Inserts one row, filling required columns. Used by factories and by isolation.
+ *
+ * @param host - Schema, client, and seed
+ * @param table - Table name
+ * @param overrides - Column values and the tenant key
+ * @param children - Child counts from `with`
+ * @param inherited - Tenant from the parent row, when this row is a child
+ * @returns The inserted row
+ */
+export declare function insertRow(host: FactoryHost, table: string, overrides: Readonly<Record<string, unknown>> | undefined, children: Readonly<Record<string, number>> | undefined, inherited: string | undefined): Promise<Record<string, unknown>>;
+export {};

package/dist/tooling/testing/facts.d.ts

@@ -0,0 +1,72 @@
+/**
+ * What a factory needs from a compiled schema: required columns, foreign keys,
+ * and which tables are tenant or global.
+ *
+ * Column tenancy is the only strategy in this version. A table is tenant when
+ * its predicate binds a scope, and global when `global("reason")` opted it out.
+ * `schemaPerTenant` and `databasePerTenant` are not in 0.4.
+ */
+import type { Catalog } from "../../contracts/catalog/types.js";
+import type { QuerySchema, RelationModel } from "../../dialects/pg/model.js";
+/** A schema `testing()` can open. `schema()` returns this shape. */
+export type TestingSchema = QuerySchema & {
+    readonly catalog: Catalog;
+};
+/** One foreign key, SQL names, child columns aligned with the target columns. */
+export type ForeignKey = {
+    readonly columns: readonly string[];
+    readonly target: string;
+    readonly targetColumns: readonly string[];
+};
+/** One column, with the catalog facts the factory uses to fill a default. */
+export type ColumnFacts = {
+    readonly field: string;
+    readonly sql: string;
+    readonly dataType: string;
+    readonly nullable: boolean;
+    readonly databaseDefault: boolean;
+    readonly identity: boolean;
+    readonly generated: boolean;
+    readonly guarded: boolean;
+    readonly writable: boolean;
+    readonly fill: boolean;
+    readonly accepts: readonly string[] | undefined;
+    readonly encode: (value: unknown) => string;
+};
+/** One table. */
+export type TableFacts = {
+    readonly name: string;
+    readonly sql: string;
+    readonly primary: readonly string[];
+    readonly columns: readonly ColumnFacts[];
+    readonly relations: readonly RelationModel[];
+    readonly foreignKeys: readonly ForeignKey[];
+    /** Column tenancy applies a predicate. */
+    readonly tenant: boolean;
+    /** `global("reason")`. Absent on a tenant table and on a schema with no tenancy. */
+    readonly globalReason: string | undefined;
+};
+/**
+ * Scope value used to ask a tenancy object whether a table is tenant.
+ *
+ * A test tenancy can recognise this probe and still omit the predicate on a
+ * real query. That is how the isolation check is shown to fail.
+ */
+export declare const tenantProbe = "00000000-0000-4000-8000-000000000001";
+/**
+ * Reads every table in declaration order.
+ *
+ * @param schema - Compiled schema
+ * @returns One facts object per table
+ */
+export declare function readFacts(schema: TestingSchema): readonly TableFacts[];
+/**
+ * A column the factory must set when the definition and the overrides omit it.
+ *
+ * Nullable, a database default, identity, a generated expression, a client
+ * fill, and a guarded column are left to the database or the scope (D199).
+ *
+ * @param column - Column facts
+ * @returns Whether the factory fills it
+ */
+export declare function isRequired(column: ColumnFacts): boolean;