okmodel 0.1.1 → 0.3.0

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

@@ -14,7 +14,7 @@ export type Owner = (typeof OWNERS)[number];
  * Object kinds from spec section 5.7.
  *
  * Built in this layer: table, column, index, constraint, sequence, and type.
- * A type object is an enum: ordered labels, and no other form.
+ * A type object is an enum (ordered labels) or a domain (base type and check).
  */
 export declare const OBJECT_KINDS: readonly ["table", "column", "index", "constraint", "sequence", "view", "materializedView", "type", "function", "trigger", "policy", "extension", "role", "grant", "defaultPrivilege"];
 /** A catalog object kind. */
@@ -100,9 +100,15 @@ export type GrantIdentity = {
     readonly object: GrantObjectRef;
     readonly privilege: string;
 };
-/** What a grant attaches to. `namespace` is the schema itself. */
+/**
+ * What a grant attaches to.
+ *
+ * `namespace` is the schema itself. A function's `name` is `name(argTypes)`
+ * so overloads stay distinct without a second field. The key is not a stored
+ * identifier (D119).
+ */
 export type GrantObjectRef = {
-    readonly kind: "table" | "sequence" | "namespace";
+    readonly kind: "table" | "view" | "materializedView" | "sequence" | "function" | "namespace";
     readonly namespace: Namespace;
     readonly name: string;
 };
@@ -130,18 +136,31 @@ export type ExtensionIdentity = {
     readonly kind: "extension";
     readonly name: string;
 };
+/**
+ * Canonical extension record.
+ *
+ * `version` is an exact pin (`1.6`) or a floor (`>=0.7`). Absent means
+ * unpinned: the installed version is information and drift ignores it.
+ */
+export type ExtensionDefinition = {
+    /** Schema the extension is installed in. */
+    readonly schema: string;
+    /** Whether `ALTER EXTENSION … SET SCHEMA` is allowed. */
+    readonly relocatable: boolean;
+    readonly version?: string;
+};
 /** Stable identity. The variant depends on the kind. */
 export type ObjectIdentity = NamespaceIdentity | AnchoredIdentity | FunctionIdentity | GrantIdentity | DefaultPrivilegeIdentity | RoleIdentity | ExtensionIdentity;
-/** Where an object came from. */
+/**
+ * Where an object, a query, or a rule came from.
+ *
+ * `source` is the authoring location (`schema.ts:12`). It is recorded when
+ * the object is defined and is not part of the catalog hash.
+ */
 export type Provenance = {
-    readonly origin: "file";
-    readonly name: string;
-} | {
-    readonly origin: "trait";
-    readonly name: string;
-} | {
-    readonly origin: "extension";
+    readonly origin: "file" | "trait" | "extension";
     readonly name: string;
+    readonly source?: string;
 };
 /**
  * An edge to another object.
@@ -179,6 +198,13 @@ export type ColumnDefinition = {
         readonly stored: boolean;
         readonly expression: string;
     };
+    /**
+     * Collation name, such as `C`.
+     *
+     * Absent when the column uses the type's default collation. A client
+     * generator is not stored here.
+     */
+    readonly collation?: string;
 };
 /**
  * Index definition.
@@ -230,11 +256,22 @@ export type ConstraintDefinition = {
  * Enum definition.
  *
  * `labels` is the stored order. That order is part of the catalog hash.
- * Domains are not represented here.
  */
-export type TypeDefinition = {
+export type EnumDefinition = {
     readonly labels: readonly string[];
 };
+/**
+ * Domain definition.
+ *
+ * `base` is the Postgres type the domain is created over. `check` is the
+ * domain check, stored as written. A later base type is refused (OKM1020).
+ */
+export type DomainDefinition = {
+    readonly base: string;
+    readonly check: string;
+};
+/** A catalog type: an enum or a domain. */
+export type TypeDefinition = EnumDefinition | DomainDefinition;
 /** Sequence definition. Start and increment are decimal integers. */
 export type SequenceDefinition = {
     readonly dataType: "smallint" | "integer" | "bigint";
@@ -276,13 +313,137 @@ export type TypeObject = CatalogEnvelope<"type", NamespaceIdentity & {
     readonly kind: "type";
 }, TypeDefinition>;
 /**
- * One built catalog object.
+ * An extension.
+ *
+ * The record is identity, schema, relocatable, and version. Core stores it
+ * and does not interpret it. The extension object produces it.
+ */
+export type ExtensionObject = CatalogEnvelope<"extension", ExtensionIdentity, ExtensionDefinition>;
+/** One function language. */
+export type FunctionLanguage = "sql" | "plpgsql";
+/** One volatility. */
+export type FunctionVolatility = "volatile" | "stable" | "immutable";
+/** `SECURITY INVOKER` or `SECURITY DEFINER`. */
+export type FunctionSecurity = "invoker" | "definer";
+/** One argument. The name is not part of the identity. */
+export type FunctionArgument = {
+    readonly name: string;
+    readonly type: string;
+};
+/**
+ * Function definition.
  *
- * Views, functions, triggers, extensions, roles, grants, and default
- * privileges use {@link CatalogEnvelope} when they are built. They are not
- * part of this union yet.
+ * The body of a plpgsql or plain SQL function is the source Postgres stores
+ * (`prosrc`). A `LANGUAGE sql` body that starts with `BEGIN ATOMIC` is marked
+ * `atomic`: Postgres reprints that body and leaves `prosrc` empty.
+ */
+export type FunctionDefinition = {
+    readonly arguments: readonly FunctionArgument[];
+    readonly returns: string;
+    readonly language: FunctionLanguage;
+    readonly volatility: FunctionVolatility;
+    readonly security: FunctionSecurity;
+    readonly body: string;
+    readonly searchPath?: string;
+    readonly atomic?: true;
+};
+/** One trigger timing. */
+export type TriggerTiming = "before" | "after" | "instead";
+/** One trigger event. Stored order is insert, update, delete, truncate. */
+export type TriggerEvent = "insert" | "update" | "delete" | "truncate";
+/** One trigger level. */
+export type TriggerLevel = "row" | "statement";
+/** The function a trigger calls. Argument types keep an overload distinct. */
+export type TriggerCall = {
+    readonly namespace: Namespace;
+    readonly name: string;
+    readonly argTypes: readonly string[];
+};
+/**
+ * Trigger definition.
+ *
+ * `updateOf` lists SQL column names for `UPDATE OF`. `when` is the predicate
+ * text. The table and the function are dependency edges.
+ */
+export type TriggerDefinition = {
+    readonly timing: TriggerTiming;
+    readonly events: readonly TriggerEvent[];
+    readonly level: TriggerLevel;
+    readonly calls: TriggerCall;
+    readonly updateOf?: readonly string[];
+    readonly when?: string;
+};
+/** A function. Identity is `(schema, name, argTypes[])`. */
+export type FunctionObject = CatalogEnvelope<"function", FunctionIdentity, FunctionDefinition>;
+/** A trigger. Identity is `(table, name)`. */
+export type TriggerObject = CatalogEnvelope<"trigger", AnchoredIdentity & {
+    readonly kind: "trigger";
+}, TriggerDefinition>;
+/** One output column of a view or materialized view. */
+export type ViewColumn = {
+    readonly name: string;
+    readonly dataType: string;
+};
+/**
+ * View definition.
+ *
+ * `query` is the server reprint when one has been read (`pg_get_viewdef`),
+ * and the author's SQL until then. Column dependencies are separate edges.
+ */
+export type ViewDefinition = {
+    readonly columns: readonly ViewColumn[];
+    readonly query: string;
+};
+/**
+ * Materialized view definition.
+ *
+ * There is no replace. `refresh` is the populate mode. Postgres does not
+ * store it; introspection leaves it unset.
+ */
+export type MaterializedViewDefinition = {
+    readonly columns: readonly ViewColumn[];
+    readonly query: string;
+    readonly refresh?: "concurrently";
+};
+/** A view. Identity is `(namespace, name)`. */
+export type ViewObject = CatalogEnvelope<"view", NamespaceIdentity & {
+    readonly kind: "view";
+}, ViewDefinition>;
+/** A materialized view. Identity is `(namespace, name)`. */
+export type MaterializedViewObject = CatalogEnvelope<"materializedView", NamespaceIdentity & {
+    readonly kind: "materializedView";
+}, MaterializedViewDefinition>;
+/**
+ * Role definition.
+ *
+ * Only `login` and `inherit` are altered in place. A password is not stored.
+ */
+export type RoleDefinition = {
+    readonly login: boolean;
+    readonly inherit: boolean;
+};
+/**
+ * Grant definition.
+ *
+ * The privilege is the identity. `GRANT OPTION` is not in this version.
+ */
+export type GrantDefinition = Record<string, never>;
+/**
+ * Default-privilege definition.
+ *
+ * The key is the identity. The statement is `ALTER DEFAULT PRIVILEGES`.
+ */
+export type DefaultPrivilegeDefinition = Record<string, never>;
+/** A role. Identity is the name. Roles are never dropped (D119). */
+export type RoleObject = CatalogEnvelope<"role", RoleIdentity, RoleDefinition>;
+/** A grant. Identity is `(role, object, privilege)`. */
+export type GrantObject = CatalogEnvelope<"grant", GrantIdentity, GrantDefinition>;
+/** A default privilege. Identity is `(forRole, namespace, objectKind, grantee, privilege)`. */
+export type DefaultPrivilegeObject = CatalogEnvelope<"defaultPrivilege", DefaultPrivilegeIdentity, DefaultPrivilegeDefinition>;
+/**
+ * One built catalog object.
  */
-export type CatalogObject = TableObject | ColumnObject | IndexObject | ConstraintObject | SequenceObject | TypeObject;
+export type CatalogObject = TableObject | ColumnObject | IndexObject | ConstraintObject | SequenceObject | TypeObject | ExtensionObject | FunctionObject | TriggerObject | ViewObject | MaterializedViewObject | RoleObject | GrantObject | DefaultPrivilegeObject;
 /** Format version stored in the serialized catalog. */
 export declare const CATALOG_VERSION = 1;
 /** A catalog document. Object order is identity-key order. */

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

@@ -0,0 +1,73 @@
+/**
+ * View and materialized view catalog objects.
+ *
+ * The factories store the record. They do not plan SQL. DDL stays in the
+ * dialect, and `view()` / `materializedView()` stay on `okmodel/view`.
+ */
+import type { IndexObject, MaterializedViewObject, Namespace, ObjectIdentity, ObjectRef, Owner, Provenance, ViewColumn, ViewObject } from "./types.js";
+/** Input for {@link viewObject}. */
+export type ViewInput = {
+    readonly namespace?: Namespace;
+    readonly name: string;
+    readonly columns: readonly ViewColumn[];
+    readonly query: string;
+    readonly owner?: Owner;
+    readonly provenance: Provenance;
+    readonly dependencies?: readonly ObjectIdentity[];
+};
+/** Input for {@link materializedViewObject}. */
+export type MaterializedViewInput = ViewInput & {
+    readonly refresh?: "concurrently";
+};
+/** Input for {@link materializedViewIndex}. */
+export type MaterializedViewIndexInput = {
+    readonly parent: ObjectRef;
+    readonly name?: string;
+    readonly columns: readonly string[];
+    readonly unique?: boolean;
+    readonly nameKey?: string;
+    readonly expression?: string;
+    readonly predicate?: string;
+    readonly owner?: Owner;
+    readonly provenance: Provenance;
+    /** Retargeted edges. Omitted edges depend on the materialized view. */
+    readonly dependencies?: readonly ObjectIdentity[];
+};
+/**
+ * Trims a view query and drops one trailing semicolon.
+ *
+ * `pg_get_viewdef` and the author's SQL both go through this before they are
+ * stored, so two reads of the same reprint compare equal.
+ *
+ * @param query - Author SQL or a server reprint
+ * @returns The stored query text
+ */
+export declare function normaliseViewQuery(query: string): string;
+/**
+ * Builds a view record.
+ *
+ * Identity is `(namespace, name)`. Columns stay in declaration order.
+ *
+ * @param input - Columns, query, and dependency edges
+ * @returns The catalog object
+ */
+export declare function viewObject(input: ViewInput): ViewObject;
+/**
+ * Builds a materialized view record.
+ *
+ * `refresh` is stored only for `"concurrently"`. The object has no replace.
+ *
+ * @param input - Columns, query, populate mode, and dependency edges
+ * @returns The catalog object
+ */
+export declare function materializedViewObject(input: MaterializedViewInput): MaterializedViewObject;
+/**
+ * Builds an index owned by a materialized view.
+ *
+ * The edge points at the view, not at a table. View output columns are not
+ * catalog objects, so the index does not depend on column identities.
+ *
+ * @param input - Parent view, columns, and uniqueness
+ * @returns An index envelope
+ */
+export declare function materializedViewIndex(input: MaterializedViewIndexInput): IndexObject;

package/dist/contracts/connection.d.ts

@@ -31,3 +31,16 @@ export declare function isConnectionErrno(code: string): boolean;
  * @returns `true` when no session remains
  */
 export declare function isConnectionFailure(error: unknown): boolean;
+/**
+ * Reports whether the connection is gone after `error`, or the outcome of a
+ * statement on it is unknown (`outcome_unknown`).
+ *
+ * It reads what {@link isConnectionFailure} reads, plus the messages node-postgres
+ * ("Connection terminated unexpectedly") and Bun.sql (`ERR_POSTGRES_CONNECTION_CLOSED`)
+ * give, and the error's `cause`. Nothing more should be sent to such a connection:
+ * not a rollback, not a reset. Loaded with the code that reserves a connection.
+ *
+ * @param error - Caught value
+ * @returns `true` when the session cannot be used again
+ */
+export declare function isConnectionLost(error: unknown): boolean;

package/dist/contracts/driver.d.ts

@@ -154,10 +154,23 @@ export type DriverPoolConfig = {
     /** Connections in the pool. PGlite is always one. */
     readonly max?: number;
     /**
-     * Wait for a connection up to `acquire` milliseconds, then fail with
-     * OKM1846. Omitted means wait without that deadline.
+     * Ceilings in milliseconds. An adapter reads `acquire`: it waits for a
+     * connection up to that long, then fails with OKM1846. Omitted means wait
+     * without a deadline. The other keys belong to the runtime.
      */
-    readonly timeouts?: {
-        readonly acquire?: number;
-    };
+    readonly timeouts?: DriverTimeouts;
+};
+/**
+ * Ceilings from `connect({ timeouts })`, in milliseconds (spec §15).
+ *
+ * `acquire` bounds the wait for a connection (OKM1846). `statement` is the
+ * default `timeout` of a call that sets none. `transaction` bounds a whole
+ * `tx()`. `idleInTransaction` bounds the time a `tx()` waits between
+ * statements. Every one but `acquire` fails as kind `timeout`.
+ */
+export type DriverTimeouts = {
+    readonly acquire?: number;
+    readonly statement?: number;
+    readonly transaction?: number;
+    readonly idleInTransaction?: number;
 };

package/dist/contracts/error.d.ts

@@ -31,7 +31,7 @@ export type ColumnCode = (typeof COLUMN_CODES)[number];
  * These are spec §21 codes. They are a type only, so the runtime entry does
  * not gain a second registry.
  */
-export type QueryCode = "OKM1101" | "OKM1102" | "OKM1104" | "OKM1105" | "OKM1111" | "OKM1120" | "OKM1121" | "OKM1190" | "OKM1801" | "OKM1802" | "OKM1843";
+export type QueryCode = "OKM1101" | "OKM1102" | "OKM1104" | "OKM1105" | "OKM1111" | "OKM1120" | "OKM1121" | "OKM1124" | "OKM1130" | "OKM1190" | "OKM1701" | "OKM1704" | "OKM1801" | "OKM1802" | "OKM1803" | "OKM1843";
 /** Kinds from spec §14, in category order. */
 export declare const ERROR_KINDS: readonly ["invalid", "not_null", "check", "foreign_key", "unique", "exclusion", "conflict", "not_found", "not_unique", "forbidden", "serialization", "deadlock", "lock_timeout", "timeout", "cancelled", "unavailable", "schema_drift", "driver", "read_only", "outcome_unknown"];
 /** One spec §14 kind. */
@@ -51,6 +51,16 @@ export type ErrorFix = {
     /** Accepted name to use instead, when one is close. */
     readonly suggestion?: string;
 };
+/**
+ * One failed validation check.
+ *
+ * `message` is a key, never prose and never a row value. `path` walks the
+ * value: a field name, or a row index then a field name.
+ */
+export type ValidationIssue = {
+    readonly path: readonly (string | number)[];
+    readonly message: string;
+};
 /** Column name to constraint reason. Row values are not included. */
 export type ErrorFields = Readonly<Record<string, string>>;
 /** Body of {@link OkmError.toHttp}. */
@@ -80,6 +90,8 @@ export type ErrorLog = {
     readonly batchIndex: number | null;
     readonly fix: ErrorFix;
     readonly fields: ErrorFields;
+    /** Validation checks, when the failure is OKM1200. */
+    readonly issues?: readonly ValidationIssue[];
     readonly table?: string;
     readonly columns?: readonly string[];
     readonly constraint?: string;
@@ -105,6 +117,8 @@ export type OkmErrorOptions = {
      */
     readonly includeValues?: boolean;
     readonly values?: Readonly<Record<string, string>>;
+    /** Checks from a failed validation. Omitted on every other error. */
+    readonly issues?: readonly ValidationIssue[];
     /**
      * Category overrides from `connect({ errors })`.
      *
@@ -164,6 +178,8 @@ export declare class OkmError extends Error {
     readonly batchIndex: number | null;
     /** Constraint reason used by {@link fields}. */
     readonly fieldReason: string;
+    /** Validation checks. Absent when this error is not a failed check. */
+    readonly issues?: readonly ValidationIssue[];
     /**
      * Same text as `message`.
      *

package/dist/contracts/generator.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Client generators.
+ *
+ * A generator fills a column on insert. It is not a database default, so it
+ * stays off the catalog and its hash. Built-ins are marked by name so
+ * `connect({ generators })` can replace them.
+ */
+/** Property that marks a function as a client generator. */
+export declare const CLIENT_DEFAULT: unique symbol;
+/** Built-in generator names, plus a caller-supplied function. */
+export type GeneratorName = "uuidv4" | "uuidv7" | "okid" | "function";
+/** Scalar options stored with a named generator. OKID uses these. */
+export type GeneratorOptions = Readonly<Record<string, string | number | boolean>>;
+/**
+ * What insert calls when a column was omitted.
+ *
+ * `label` is the catalog-output word for a client default. The catalog
+ * document itself does not store it.
+ */
+export type ClientFill = {
+    readonly label: "client";
+    readonly name: GeneratorName;
+    readonly options?: GeneratorOptions;
+    readonly call: () => unknown;
+};
+/** A function `.default()` and `schema({ defaults: { id } })` accept. */
+export type ClientGenerator<T = string> = (() => T) & {
+    readonly [CLIENT_DEFAULT]: {
+        readonly label: "client";
+        readonly name: Exclude<GeneratorName, "function">;
+        readonly options?: GeneratorOptions;
+    };
+};
+/**
+ * Replacements for the built-in generators, keyed by name.
+ *
+ * A test passes fixed functions here. A custom function with no name is left
+ * alone.
+ */
+export type IdGenerators = {
+    readonly uuidv4?: () => string;
+    readonly uuidv7?: () => string;
+    readonly okid?: () => string;
+};
+/**
+ * Marks `call` as a named client generator.
+ *
+ * @typeParam T - Value the generator returns
+ * @param call - Function that produces one value
+ * @param name - Built-in name `connect({ generators })` can replace
+ * @param options - Scalar options stored beside the name
+ * @returns The same function, marked
+ */
+export declare function clientGenerator<T>(call: () => T, name: Exclude<GeneratorName, "function">, options?: GeneratorOptions): ClientGenerator<T>;
+/**
+ * Reads a client generator from a `.default()` argument.
+ *
+ * A marked built-in keeps its name. Any other function is a custom generator.
+ *
+ * @param value - Argument passed to `.default()` or `defaults.id`
+ * @returns The fill insert should call, or `undefined` when `value` is a literal
+ */
+export declare function readClientGenerator(value: unknown): ClientFill | undefined;

package/dist/contracts/index.d.ts

@@ -6,6 +6,6 @@
  * live on `okmodel/internal`, so `table` and `index` on this entry are not a
  * second schema API.
  */
-export { CATALOG_CODES, COLUMN_CODES, ERROR_CATEGORIES, ERROR_KINDS, OkmError, safe, type CatalogCode, type ColumnCode, type QueryCode, type ErrorCategory, type ErrorColumns, type ErrorFields, type ErrorFix, type ErrorKind, type ErrorLog, type ErrorStatuses, type HttpError, type HttpErrorBody, type OkmErrorOptions, type SafeResult, } from "./error.js";
-export type { AnySchema, AnyTableShape, Insert, Register, Row, SchemaOf, TableName, Update, } from "./rows.js";
+export { CATALOG_CODES, COLUMN_CODES, ERROR_CATEGORIES, ERROR_KINDS, OkmError, safe, type CatalogCode, type ColumnCode, type QueryCode, type ErrorCategory, type ErrorColumns, type ErrorFields, type ErrorFix, type ErrorKind, type ErrorLog, type ErrorStatuses, type HttpError, type HttpErrorBody, type OkmErrorOptions, type SafeResult, type ValidationIssue, } from "./error.js";
+export type { AnySchema, AnyTableShape, Input, Insert, Register, Row, SchemaOf, TableName, Update, } from "./rows.js";
 export type { DescribeResult, DriverCapabilities, DriverConnection, DriverErrorFields, DriverFailureKind, DriverPool, DriverPoolConfig, DriverStats, ExecuteOptions, ExecuteResult, Notice, PreparedMode, Statement, TransactionMode, WireValue, } from "./driver.js";

package/dist/contracts/index.js

@@ -5,7 +5,7 @@ import {
   ERROR_CATEGORIES2,
   OkmError2,
   safe2
-} from "../shared/ycwz42az.js";
+} from "../shared/52szzakm.js";
 export {
   CATALOG_CODES2 as CATALOG_CODES,
   COLUMN_CODES2 as COLUMN_CODES,

package/dist/contracts/internal.js

@@ -1,10 +1,4 @@
 import {
-  OWNERS2,
-  OBJECT_KINDS2,
-  BUILT_KINDS2,
-  OBJECT_OPERATIONS2,
-  KIND_OPERATIONS2,
-  CATALOG_VERSION2,
   staticNamespace2,
   templateNamespace2,
   assertNamespace2,
@@ -19,7 +13,15 @@ import {
   index3,
   constraint2,
   sequence2
-} from "../shared/j5cn2963.js";
+} from "../shared/t4tbsy9h.js";
+import {
+  OWNERS2,
+  OBJECT_KINDS2,
+  BUILT_KINDS2,
+  OBJECT_OPERATIONS2,
+  KIND_OPERATIONS2,
+  CATALOG_VERSION2
+} from "../shared/4e4c6vq2.js";
 import {
   utf8ByteLength2,
   sha2562,
@@ -28,12 +30,12 @@ import {
   assertIdentifier2,
   fitIdentifier2,
   deterministicName2
-} from "../shared/mkjmqjv4.js";
+} from "../shared/nfzc5z0w.js";
 import {
   nearestName2,
   catalogError2,
   throwNamed2
-} from "../shared/ycwz42az.js";
+} from "../shared/52szzakm.js";
 export {
   BUILT_KINDS2 as BUILT_KINDS,
   CATALOG_VERSION2 as CATALOG_VERSION,

package/dist/contracts/location.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Authoring location for provenance.
+ *
+ * `source` is recorded when a table or a rule is defined. The catalog hash
+ * does not include it.
+ */
+/**
+ * File and line of the caller `skip` frames above this function.
+ *
+ * Frames in this file are ignored. `skip` 1 is the direct caller, so a
+ * `table()` call records the schema line, not `table` itself.
+ *
+ * @param skip - Callers to pass before the frame that is recorded
+ * @returns `file.ts:line`, or `undefined` when the runtime has no stack
+ */
+export declare function callerLocation(skip: number): string | undefined;
+/**
+ * Appends a source location to an error message.
+ *
+ * @param message - What failed
+ * @param source - `file.ts:line`, when one was recorded
+ * @returns The message `okm` prints
+ */
+export declare function withLocation(message: string, source: string | undefined): string;

package/dist/contracts/rows.d.ts

@@ -70,6 +70,21 @@ export type Insert<N extends TableName<S>, S extends AnySchema | undefined = und
  * @typeParam S - Explicit schema. Omit it to use {@link Register}
  */
 export type Update<N extends TableName<S>, S extends AnySchema | undefined = undefined> = ShapeOf<S, N, "~update">;
+/**
+ * Insert shape used when validation is on.
+ *
+ * The fields match {@link Insert}. The optional mark makes the two types
+ * distinct, so a checked call can require this shape only while validation
+ * is enabled. Guarded fields and the tenant key are already absent.
+ *
+ * @typeParam N - Table name
+ * @typeParam S - Explicit schema. Omit it to use {@link Register}
+ */
+export type Input<N extends TableName<S>, S extends AnySchema | undefined = undefined> = Insert<N, S> & InputMark;
+/** Optional mark that distinguishes {@link Input} from {@link Insert}. */
+export type InputMark = {
+    readonly "~input"?: true;
+};
 /**
  * One phantom on the table named `N`.
  *

package/dist/dialects/pg/archive-bind.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Cascade checks and partial uniques for `archivable()`.
+ *
+ * The trait calls this from the schema rewrite, after tenancy widens uniques.
+ * `schema()` does not import it.
+ */
+import { type AnyTable } from "./table.js";
+/**
+ * Makes an archivable table's uniques partial and checks its cascade.
+ *
+ * Tenancy has already widened uniques. This pass turns those lists into
+ * unique indexes filtered on `archived_at is null`, and stores the cascade
+ * links the planner reads.
+ *
+ * @param self - The trait object on the table or the schema
+ * @param tables - Tables after the tenancy rewrite
+ * @param casing - Schema casing
+ * @param schemaTraits - Traits from `schema()`, when any were passed
+ * @param cascade - Child tables named on this trait
+ * @returns Tables with partial uniques and an archive model where this trait applies
+ */
+export declare function rewriteArchivable(self: object, tables: readonly AnyTable[], casing: "snake" | undefined, schemaTraits: readonly object[] | undefined, cascade: readonly string[]): readonly AnyTable[];