okmodel 0.0.0 → 0.1.0

package/dist/dialects/pg/column.d.ts

@@ -0,0 +1,386 @@
+/**
+ * Column builder shared by every Postgres type.
+ *
+ * Modifiers allocate a new builder when called. Importing this module does
+ * not build a codec table. `.validate()` stays a slot for P26.
+ */
+import { type ReferentialAction } from "../../contracts/catalog/types.js";
+/** Flags that decide the row, insert, and update shapes of one column. */
+export type ColumnFlags = {
+    readonly nullable: boolean;
+    readonly hasDefault: boolean;
+    readonly generated: boolean;
+    readonly guarded: boolean;
+    readonly hidden: boolean;
+    readonly omitWrite: boolean;
+};
+/** Flags for a required column with no default. */
+export type PlainFlags = {
+    readonly nullable: false;
+    readonly hasDefault: false;
+    readonly generated: false;
+    readonly guarded: false;
+    readonly hidden: false;
+    readonly omitWrite: false;
+};
+/** Flags for {@link id}. Insert and update omit it. */
+export type IdFlags = {
+    readonly nullable: false;
+    readonly hasDefault: true;
+    readonly generated: false;
+    readonly guarded: true;
+    readonly hidden: false;
+    readonly omitWrite: true;
+};
+/** Flags for {@link identity}. The database fills the value. */
+export type IdentityFlags = {
+    readonly nullable: false;
+    readonly hasDefault: true;
+    readonly generated: false;
+    readonly guarded: false;
+    readonly hidden: false;
+    readonly omitWrite: true;
+};
+/**
+ * Turns one flag on.
+ *
+ * @typeParam TFlags - Current flags
+ * @typeParam K - Flag to set
+ */
+export type FlagTrue<TFlags extends ColumnFlags, K extends keyof ColumnFlags> = {
+    readonly [P in keyof TFlags]: P extends K ? true : TFlags[P];
+};
+/**
+ * Marks a column generated, which also counts as having a default.
+ *
+ * @typeParam TFlags - Current flags
+ */
+export type WithGenerated<TFlags extends ColumnFlags> = {
+    readonly [P in keyof TFlags]: P extends "generated" | "hasDefault" ? true : TFlags[P];
+};
+/** How a default expression is spelled in the catalog. */
+export type SqlForm = "raw" | "quote" | "json" | "jsonb" | "cast";
+/**
+ * A foreign key declared on a column.
+ *
+ * `columns` names the target columns. When it is omitted, `schema()` uses
+ * that table's primary key.
+ */
+export type ReferenceModifier = {
+    readonly table: string;
+    readonly onDelete?: ReferentialAction;
+    readonly onUpdate?: ReferentialAction;
+    readonly columns?: readonly string[];
+};
+/**
+ * Options for {@link ColumnBuilder.references}.
+ */
+export type ReferenceOptions = {
+    readonly onDelete?: ReferentialAction;
+    readonly onUpdate?: ReferentialAction;
+    readonly columns?: readonly string[];
+};
+/**
+ * Validation rules, stored when a later prompt adds `.validate()`.
+ */
+export type ValidateModifier = {
+    readonly rules: readonly unknown[];
+};
+/** Nested readonly arrays of rank `D`. Ranks above 3 stay `unknown[]`. */
+export type ArrayOf<T, D extends number> = D extends 0 ? T : D extends 1 ? readonly T[] : D extends 2 ? readonly (readonly T[])[] : D extends 3 ? readonly (readonly (readonly T[])[])[] : readonly unknown[];
+/**
+ * Value stored on a column, including null when the column is nullable.
+ *
+ * Hidden columns are absent from the default row (`never`).
+ *
+ * @typeParam TFlags - Column flags
+ * @typeParam TValue - Scalar or array value
+ */
+export type ColumnRow<TFlags extends ColumnFlags, TValue> = TFlags["hidden"] extends true ? never : TFlags["nullable"] extends true ? TValue | null : TValue;
+/** Whether insert requires the value, allows it to be omitted, or drops it. */
+export type InsertKind<TFlags extends ColumnFlags> = TFlags["omitWrite"] extends true ? "omit" : TFlags["generated"] extends true ? "omit" : TFlags["guarded"] extends true ? "omit" : TFlags["hasDefault"] extends true ? "optional" : TFlags["nullable"] extends true ? "optional" : "required";
+/**
+ * Insert shape of one column.
+ *
+ * `undefined` means the field is omitted. `never` means it is not writable.
+ *
+ * @typeParam TFlags - Column flags
+ * @typeParam TValue - Scalar or array value
+ */
+export type ColumnInsert<TFlags extends ColumnFlags, TValue> = InsertKind<TFlags> extends "omit" ? never : InsertKind<TFlags> extends "optional" ? TFlags["nullable"] extends true ? TValue | null | undefined : TValue | undefined : TValue;
+/**
+ * Update shape of one column. Writable values are optional.
+ *
+ * @typeParam TFlags - Column flags
+ * @typeParam TValue - Scalar or array value
+ */
+export type ColumnUpdate<TFlags extends ColumnFlags, TValue> = InsertKind<TFlags> extends "omit" ? never : TFlags["nullable"] extends true ? TValue | null | undefined : TValue | undefined;
+/**
+ * Row shape of a builder.
+ *
+ * @typeParam TBuilder - Column builder
+ */
+export type ColumnRowOf<TBuilder> = TBuilder extends ColumnBuilder<infer TValue, infer TFlags> ? ColumnRow<TFlags, TValue> : never;
+/**
+ * Insert shape of a builder.
+ *
+ * @typeParam TBuilder - Column builder
+ */
+export type ColumnInsertOf<TBuilder> = TBuilder extends ColumnBuilder<infer TValue, infer TFlags> ? ColumnInsert<TFlags, TValue> : never;
+/**
+ * Update shape of a builder.
+ *
+ * @typeParam TBuilder - Column builder
+ */
+export type ColumnUpdateOf<TBuilder> = TBuilder extends ColumnBuilder<infer TValue, infer TFlags> ? ColumnUpdate<TFlags, TValue> : never;
+/** Runtime definition a modifier updates and compile reads. */
+export type ColumnState<TValue> = {
+    readonly baseType: string;
+    readonly dims: number;
+    readonly nullable: boolean;
+    readonly hasDefault: boolean;
+    readonly defaultSql: string | undefined;
+    readonly defaultValue: unknown;
+    readonly identity: {
+        readonly always: boolean;
+    } | undefined;
+    readonly generated: {
+        readonly stored: boolean;
+        readonly expression: string;
+    } | undefined;
+    readonly unique: {
+        readonly reason: string | undefined;
+        readonly global: boolean | undefined;
+    } | undefined;
+    readonly picklist: {
+        readonly values: readonly string[];
+        readonly check: boolean;
+    } | undefined;
+    readonly guarded: boolean;
+    readonly hidden: boolean;
+    readonly omitWrite: boolean;
+    readonly renamedFrom: string | undefined;
+    readonly sqlName: string | undefined;
+    readonly comment: string | undefined;
+    readonly extension: string | undefined;
+    readonly typeDependency: string | undefined;
+    /** Ordered enum labels. Absent on every column that is not an enum. */
+    readonly enumLabels: readonly string[] | undefined;
+    readonly domain: {
+        readonly base: string;
+        readonly check: string;
+    } | undefined;
+    readonly primaryKey: boolean;
+    readonly typeLabel: string | undefined;
+    readonly references: ReferenceModifier | undefined;
+    readonly validate: ValidateModifier | undefined;
+    readonly sqlForm: SqlForm;
+    readonly encode: (value: TValue) => string;
+    readonly decode: (wire: string) => TValue;
+    readonly elementEncode: (value: unknown) => string;
+    readonly elementDecode: (wire: string) => unknown;
+};
+/** Fields a scalar builder sets. Flags are passed beside the codec. */
+export type OpenColumn<TValue> = {
+    readonly baseType: string;
+    readonly nullable: boolean;
+    readonly hasDefault: boolean;
+    readonly generated: boolean;
+    readonly guarded: boolean;
+    readonly hidden: boolean;
+    readonly omitWrite: boolean;
+    readonly encode: (value: TValue) => string;
+    readonly decode: (wire: string) => TValue;
+    readonly sqlForm: SqlForm;
+    readonly defaultSql?: string;
+    readonly identity?: {
+        readonly always: boolean;
+    };
+    readonly extension?: string;
+    readonly typeDependency?: string;
+    readonly enumLabels?: readonly string[];
+    readonly domain?: {
+        readonly base: string;
+        readonly check: string;
+    };
+    readonly primaryKey?: boolean;
+    readonly typeLabel?: string;
+};
+/**
+ * Chainable column definition.
+ *
+ * Call {@link ColumnBuilder.encode} and {@link ColumnBuilder.decode} for the
+ * codec. Catalog compilation lives in `compileColumn` so a caller that only
+ * encodes does not load it.
+ *
+ * @typeParam TValue - TypeScript value
+ * @typeParam TFlags - Nullability, defaults, generation, and exposure
+ */
+export declare class ColumnBuilder<TValue, TFlags extends ColumnFlags> {
+    /** Phantom value, so the class carries `TValue`. */
+    readonly "~value": TValue;
+    /** Phantom flags. */
+    readonly "~flags": TFlags;
+    /** Definition. Modifiers replace the builder instead of mutating it. */
+    readonly state: ColumnState<TValue>;
+    /**
+     * @param state - Definition
+     */
+    constructor(state: ColumnState<TValue>);
+    /**
+     * Encodes a value to the text the catalog and the driver store.
+     *
+     * @param value - Application value
+     * @returns Wire text
+     */
+    encode(value: TValue): string;
+    /**
+     * Decodes wire text to the application value.
+     *
+     * @param wire - Text from {@link encode}
+     * @returns Application value
+     */
+    decode(wire: string): TValue;
+    /**
+     * Allows SQL NULL.
+     *
+     * @returns The same column, nullable
+     */
+    nullable(): ColumnBuilder<TValue, FlagTrue<TFlags, "nullable">>;
+    /**
+     * Stores a JavaScript default. The catalog receives its SQL spelling.
+     *
+     * @param value - Default value
+     * @returns The same column, with a default
+     */
+    default(value: TFlags["nullable"] extends true ? TValue | null : TValue): ColumnBuilder<TValue, FlagTrue<TFlags, "hasDefault">>;
+    /**
+     * Stores a SQL default expression as written.
+     *
+     * @param expression - SQL expression
+     * @returns The same column, with a default
+     */
+    defaultSql(expression: string): ColumnBuilder<TValue, FlagTrue<TFlags, "hasDefault">>;
+    /**
+     * Records a unique constraint. Tenancy later reads `global`.
+     *
+     * @param options - Exemption reason, and whether the unique ignores the tenant key
+     * @returns The same column
+     */
+    unique(options?: {
+        readonly reason?: string;
+        readonly global?: boolean;
+    }): ColumnBuilder<TValue, TFlags>;
+    /**
+     * Narrows a string column to a literal union.
+     *
+     * `{ check: false }` keeps the list in the type and skips the catalog CHECK.
+     * An empty list or a repeated value is OKM1060.
+     *
+     * @param values - Allowed literals, in stored order
+     * @param options - Whether the catalog gets a CHECK
+     * @returns The column typed as that union
+     */
+    picklist<const TValues extends readonly (TValue & string)[]>(values: TValues, options?: {
+        readonly check?: boolean;
+    }): ColumnBuilder<TValues[number], TFlags>;
+    /**
+     * Stores a generated expression. Insert and update omit the column.
+     *
+     * @param expression - SQL expression
+     * @param options - `stored` defaults to true
+     * @returns The same column, generated
+     */
+    generated(expression: string, options?: {
+        readonly stored?: boolean;
+    }): ColumnBuilder<TValue, WithGenerated<TFlags>>;
+    /**
+     * Omits the column from insert and update input.
+     *
+     * @returns The same column, guarded
+     */
+    guarded(): ColumnBuilder<TValue, FlagTrue<TFlags, "guarded">>;
+    /**
+     * Excludes the column from the default row.
+     *
+     * @returns The same column, hidden
+     */
+    hidden(): ColumnBuilder<TValue, FlagTrue<TFlags, "hidden">>;
+    /**
+     * Points this column at another table.
+     *
+     * `schema()` checks that the table exists (OKM1020). The argument stays a
+     * string so the column type does not cycle through `Register`.
+     *
+     * @param table - Target table name
+     * @param options - Referential actions and target columns
+     * @returns The same column, with the reference stored
+     */
+    references(table: string, options?: ReferenceOptions): ColumnBuilder<TValue, TFlags>;
+    /**
+     * Records the previous SQL name. Migrations read it later.
+     *
+     * @param name - Previous column name
+     * @returns The same column
+     */
+    renamedFrom(name: string): ColumnBuilder<TValue, TFlags>;
+    /**
+     * Sets the catalog column name when it differs from the field name.
+     *
+     * @param name - SQL identifier
+     * @returns The same column
+     */
+    sqlName(name: string): ColumnBuilder<TValue, TFlags>;
+    /**
+     * Stores a comment. The catalog column object has no comment field yet,
+     * so compile returns it beside the column.
+     *
+     * @param text - Comment text
+     * @returns The same column
+     */
+    comment(text: string): ColumnBuilder<TValue, TFlags>;
+    /**
+     * Wraps the value in an array. `dims` defaults to one more rank, starting at 1.
+     *
+     * @param options - Explicit rank from 1 to 6
+     * @returns An array column
+     */
+    array<const D extends number = 1>(options?: {
+        readonly dims?: D;
+    }): ColumnBuilder<ArrayOf<TValue, D>, TFlags>;
+}
+/** Codec and SQL type, without the flag booleans {@link required} fills in. */
+export type RequiredBody<TValue> = Omit<OpenColumn<TValue>, "nullable" | "hasDefault" | "generated" | "guarded" | "hidden" | "omitWrite">;
+/**
+ * Starts a required scalar column.
+ *
+ * @typeParam TValue - TypeScript value
+ * @param body - Type and codec
+ * @returns A builder with {@link PlainFlags}
+ */
+export declare function required<TValue>(body: RequiredBody<TValue>): ColumnBuilder<TValue, PlainFlags>;
+/**
+ * Starts a scalar column.
+ *
+ * @typeParam TValue - TypeScript value
+ * @typeParam TFlags - Flags the caller names
+ * @param input - Type, codec, and flags
+ * @returns A builder
+ */
+export declare function openColumn<TValue, TFlags extends ColumnFlags>(input: OpenColumn<TValue>): ColumnBuilder<TValue, TFlags>;
+/**
+ * SQL type name, with `[]` repeated for each array rank.
+ *
+ * @param baseType - Scalar SQL type
+ * @param dims - Array rank, 0 for a scalar
+ * @returns Catalog `dataType`
+ */
+export declare function formatType(baseType: string, dims: number): string;
+/**
+ * SQL spelling of a default value.
+ *
+ * @param state - Column definition
+ * @param value - Application value
+ * @returns A default expression
+ */
+export declare function sqlOf<TValue>(state: ColumnState<TValue>, value: TValue): string;

package/dist/dialects/pg/compile.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Compiles one column builder into catalog objects.
+ *
+ * The column factory lives here, not on the builder, so encoding a value
+ * does not load constraint naming.
+ */
+import type { ColumnObject, ConstraintObject, ObjectIdentity, ObjectRef, Owner, Provenance } from "../../contracts/catalog/types.js";
+/** Column fields {@link compileColumn} reads. Builders satisfy this structurally. */
+export type CompilableColumn = {
+    readonly state: {
+        readonly baseType: string;
+        readonly dims: number;
+        readonly nullable: boolean;
+        readonly defaultSql: string | undefined;
+        readonly identity: {
+            readonly always: boolean;
+        } | undefined;
+        readonly generated: {
+            readonly stored: boolean;
+            readonly expression: string;
+        } | undefined;
+        readonly unique: {
+            readonly reason: string | undefined;
+            readonly global: boolean | undefined;
+        } | undefined;
+        readonly picklist: {
+            readonly values: readonly string[];
+            readonly check: boolean;
+        } | undefined;
+        readonly guarded: boolean;
+        readonly hidden: boolean;
+        readonly renamedFrom: string | undefined;
+        readonly sqlName: string | undefined;
+        readonly comment: string | undefined;
+        readonly extension: string | undefined;
+        readonly typeDependency: string | undefined;
+        readonly enumLabels: readonly string[] | undefined;
+        readonly domain: {
+            readonly base: string;
+            readonly check: string;
+        } | undefined;
+    };
+};
+/** Where the column is compiled. */
+export type CompileColumnInput = {
+    readonly parent: ObjectRef;
+    readonly name: string;
+    readonly provenance: Provenance;
+    readonly owner?: Owner;
+    readonly dependencies?: readonly ObjectIdentity[];
+};
+/**
+ * Catalog column plus the constraints and notes the column object cannot store.
+ */
+export type CompiledColumn = {
+    readonly column: ColumnObject;
+    readonly check?: ConstraintObject;
+    readonly unique?: ConstraintObject;
+    readonly guarded: boolean;
+    readonly hidden: boolean;
+    readonly renamedFrom?: string;
+    readonly comment?: string;
+    readonly uniqueReason?: string;
+    readonly uniqueGlobal?: boolean;
+    readonly domain?: {
+        readonly base: string;
+        readonly check: string;
+    };
+};
+/**
+ * Compiles a column into the catalog column definition.
+ *
+ * `citext` and `ltree` record an extension dependency. Enums and domains
+ * record a type dependency. A picklist with `check` adds a CHECK constraint.
+ * `.unique()` adds a unique constraint.
+ *
+ * @param builder - Column definition
+ * @param input - Parent table, field name, and provenance
+ * @returns The column and any constraints
+ */
+export declare function compileColumn(builder: CompilableColumn, input: CompileColumnInput): CompiledColumn;

package/dist/dialects/pg/custom.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A column whose SQL type and codec are supplied by the caller.
+ *
+ * The spec writes `tsType` in the options object. The type parameter is that
+ * type; a runtime `tsType` field cannot carry it.
+ */
+import { type ColumnBuilder, type PlainFlags, type SqlForm } from "./column.js";
+/**
+ * Custom column.
+ *
+ * @typeParam TValue - TypeScript value
+ * @param spec - SQL type, codec, and optional extension
+ * @returns A column using that codec
+ */
+export declare function custom<TValue>(spec: {
+    readonly sqlType: string;
+    readonly encode: (value: TValue) => string;
+    readonly decode: (wire: string) => TValue;
+    readonly extension?: string;
+    readonly sqlForm?: SqlForm;
+}): ColumnBuilder<TValue, PlainFlags>;

package/dist/dialects/pg/ddl.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Postgres DDL for a catalog.
+ *
+ * Planning and scratch comparison both render through here, so a statement
+ * has one spelling.
+ */
+import type { Catalog, CatalogObject, ColumnObject, SequenceObject, TableObject } from "../../contracts/catalog/types.js";
+/**
+ * Quotes one identifier.
+ *
+ * @param name - Identifier already checked by the catalog
+ * @returns A double-quoted identifier
+ */
+export declare function quoteIdent(name: string): string;
+/**
+ * Renders a catalog as create statements in dependency order.
+ *
+ * Columns and primary keys are folded into `CREATE TABLE`. An identity
+ * sequence is created by the column, not as its own statement.
+ *
+ * @param source - Catalog to apply
+ * @param schema - Concrete schema name
+ * @returns SQL statements
+ */
+export declare function renderCatalog(source: Catalog, schema: string): readonly string[];
+/**
+ * SQL that drops one object.
+ *
+ * A column or constraint drop is an `ALTER TABLE`. Dropping a table does not
+ * use `CASCADE`.
+ *
+ * @param object - Object to drop
+ * @param schema - Concrete schema name
+ * @returns The statement, or `undefined` when the object is not dropped alone
+ */
+export declare function dropObjectSql(object: CatalogObject, schema: string): string | undefined;
+/**
+ * SQL that creates one object that is not folded into a new table.
+ *
+ * @param object - Object to create
+ * @param schema - Concrete schema name
+ * @returns The statement
+ */
+export declare function createObjectSql(object: CatalogObject, schema: string): string | undefined;
+/**
+ * In-place column changes: type, nullability, and default.
+ *
+ * @param before - Column already applied
+ * @param after - Column the plan must reach
+ * @param schema - Concrete schema name
+ * @returns Statements, empty when the definitions match
+ */
+export declare function alterColumnSql(before: ColumnObject, after: ColumnObject, schema: string): readonly string[];
+/**
+ * Reports whether a sequence is the one an identity column creates.
+ *
+ * @param sequence - Sequence object
+ * @param source - Catalog that may own it
+ * @returns `true` when a column depends on the sequence and declares identity
+ */
+export declare function identitySequence(sequence: SequenceObject, source: Catalog): boolean;
+/**
+ * `CREATE TABLE` for one table, including its columns and primary key.
+ *
+ * @param tableObject - Table to create
+ * @param source - Catalog that holds the columns
+ * @param schema - Concrete schema name
+ * @returns The statement
+ */
+export declare function createTableSql(tableObject: TableObject, source: Catalog, schema: string): string;

package/dist/dialects/pg/decimal.d.ts

@@ -0,0 +1,62 @@
+/**
+ * numeric, real, and double precision.
+ */
+import { type ColumnBuilder, type PlainFlags } from "./column.js";
+/** How a numeric value is represented in TypeScript. */
+export type NumericAs = "string" | "number";
+/** TypeScript value for a numeric codec mode. */
+export type NumericValue<TAs extends NumericAs> = TAs extends "number" ? number : string;
+/**
+ * Exact numeric. The default codec is a decimal string.
+ *
+ * @typeParam TAs - `string` or `number`
+ * @param precision - Total digits, with `scale`
+ * @param scale - Digits after the decimal point
+ * @param options - Codec selection
+ * @returns A numeric column
+ */
+export declare function numeric<const TAs extends NumericAs = "string">(precision?: number, scale?: number, options?: {
+    readonly as?: TAs;
+}): ColumnBuilder<NumericValue<TAs>, PlainFlags>;
+/**
+ * Single-precision float.
+ *
+ * @returns A real column
+ */
+export declare function real(): ColumnBuilder<number, PlainFlags>;
+/**
+ * Double-precision float.
+ *
+ * @returns A double precision column
+ */
+export declare function double(): ColumnBuilder<number, PlainFlags>;
+/**
+ * Encodes a canonical numeric literal.
+ *
+ * @param value - Decimal text
+ * @returns The same spelling when it is a numeric literal
+ */
+export declare function encodeNumericString(value: string): string;
+/**
+ * Decodes a numeric literal to the same string.
+ *
+ * @param wire - Decimal text
+ * @returns The same spelling
+ */
+export declare function decodeNumericString(wire: string): string;
+/**
+ * Encodes a finite number as a numeric literal.
+ *
+ * @param value - Finite number
+ * @returns Decimal text
+ */
+export declare function encodeNumericNumber(value: number): string;
+/**
+ * Decodes a numeric literal to a number.
+ *
+ * Precision past a JavaScript number is lost. The string codec is the default.
+ *
+ * @param wire - Decimal text
+ * @returns A number
+ */
+export declare function decodeNumericNumber(wire: string): number;

package/dist/dialects/pg/declarations.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Renames read off a built schema.
+ *
+ * Enum labels are a catalog type, not a side file. `renamedFrom` stays on the
+ * schema because a rename is an author declaration, not a stored object.
+ */
+import type { AnyTable } from "./table.js";
+/** A rename the author declared on a table or a column. */
+export type DeclaredRename = {
+    readonly kind: "table";
+    readonly from: string;
+    readonly to: string;
+} | {
+    readonly kind: "column";
+    readonly table: string;
+    readonly from: string;
+    readonly to: string;
+};
+/** Renames collected from one schema. */
+export type SchemaDeclarations = {
+    readonly renames: readonly DeclaredRename[];
+};
+/**
+ * Reads declared renames.
+ *
+ * SQL names follow `sqlName`, then snake_case when the schema asked for it.
+ *
+ * @param source - Built schema
+ * @returns Rename declarations, in table order
+ */
+export declare function schemaDeclarations(source: {
+    readonly tables: readonly AnyTable[];
+    readonly casing: "snake" | undefined;
+}): SchemaDeclarations;

package/dist/dialects/pg/emit.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Writes `.okm/types.d.ts` text from a schema.
+ *
+ * The CLI that writes the file arrives later. This function is the text.
+ * Field shapes match the inferred `~row`, `~insert`, and `~update` types.
+ */
+import { type BuiltSchema } from "./schema.js";
+import { type AnyTable } from "./table.js";
+/**
+ * Emits row, insert, and update interfaces for every table.
+ *
+ * Names come from the table name: `tasks` becomes `Tasks`, `TasksInsert`,
+ * and `TasksUpdate`.
+ *
+ * @param source - Schema from {@link schema}
+ * @returns Declaration text
+ */
+export declare function emitRowTypes(source: BuiltSchema<readonly AnyTable[]>): string;