@oh-my-pi/omptype 17.2.7 → 17.2.8

package/dist/types/type.d.ts

@@ -1,13 +1,19 @@
 import { type ErrorConfig, OmpErrors } from "./errors.js";
-import type { InferDef, InferDefIn, InferObjectLiteral, InferString } from "./infer.js";
+import type { InferDef, InferDefIn, InferObjectLiteral, InferObjectLiteralIn, InferString } from "./infer.js";
 import { type Constructor, type Def, hasMorph, type IR, IR_BRAND } from "./ir.js";
 import { type JsonSchemaOptions } from "./json-schema.js";
+export interface NarrowErrorInput {
+    readonly expected: string;
+    readonly actual?: unknown;
+    readonly path?: readonly PropertyKey[];
+    readonly relativePath?: readonly PropertyKey[];
+}
 /** Context passed to `.narrow()` / `.pipe()` callbacks. */
 export interface NarrowContext {
-    /** Record `must be <expectation>` and signal failure. */
+    readonly path: readonly PropertyKey[];
+    error(error: string | NarrowErrorInput): OmpErrors;
     mustBe(expectation: string): false;
-    /** Record a custom problem and signal failure. */
-    reject(problem: string): false;
+    reject(problem: string | NarrowErrorInput): OmpErrors | false;
 }
 /** Schema metadata and validation-message overrides accepted by `.configure()`. */
 export interface SchemaConfig extends ErrorConfig {
@@ -40,6 +46,49 @@ export interface SelectedNode {
     readonly node: IR;
     readonly unit?: unknown;
 }
+/**
+ * Standard Schema V1 (https://standardschema.dev) — the cross-library
+ * validation interface consumed by tools like @t3-oss/env, tRPC, and
+ * Hono validators. Inlined per the spec's recommendation; no dependency.
+ */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardSchemaV1 {
+    interface Props<Input = unknown, Output = Input> {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+        readonly types?: Types<Input, Output> | undefined;
+        readonly jsonSchema: {
+            readonly input: (options: StandardJsonSchemaOptions) => Record<string, unknown>;
+            readonly output: (options: StandardJsonSchemaOptions) => Record<string, unknown>;
+        };
+    }
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    interface SuccessResult<Output> {
+        readonly value: Output;
+        readonly issues?: undefined;
+    }
+    interface FailureResult {
+        readonly issues: readonly Issue[];
+    }
+    interface Issue {
+        readonly message: string;
+        readonly path?: readonly PropertyKey[] | undefined;
+    }
+    interface Types<Input = unknown, Output = Input> {
+        readonly input: Input;
+        readonly output: Output;
+    }
+}
+export interface StandardJsonSchemaOptions {
+    readonly target: "draft-2020-12" | "draft-07" | string;
+    readonly libraryOptions?: {
+        readonly dialect?: string | null;
+        readonly fallback?: JsonSchemaOptions["fallback"];
+    };
+}
 /** A compiled schema: callable validator plus composition methods. */
 export interface Type<out t = unknown, i = t> {
     (data: unknown): t | OmpErrors;
@@ -51,10 +100,26 @@ export interface Type<out t = unknown, i = t> {
     readonly hasDefault: boolean;
     readonly defaultValue?: unknown;
     readonly description?: string;
+    /** Canonical ArkType-compatible expression for diagnostics. */
+    readonly expression: string;
+    /** Canonical structural node representation. */
+    readonly json: unknown;
     /** Full validate+morph pipeline; identical to calling the schema. */
     readonly run: (data: unknown) => unknown;
+    /** ArkType-compatible inference alias (type-only; undefined at runtime). */
+    readonly t: t;
+    /** Scope that parsed this schema (or the ambient Ark-compatible scope). */
+    readonly $: TypeScope | {
+        readonly internal: {
+            readonly name: "ark";
+        };
+    };
     /** Inference-only output type (no runtime value). */
     readonly infer: t;
+    /** Standalone validator for the schema's accepted input. */
+    readonly in: FluentType<i>;
+    /** Standalone validator for its known output, or `unknown` after an opaque morph. */
+    readonly out: FluentType<t>;
     /** Inference-only input type (no runtime value). */
     readonly inferIn: i;
     /** Structural + narrow check without running pipes. */
@@ -65,25 +130,49 @@ export interface Type<out t = unknown, i = t> {
     from(data: i): t;
     /** JSON Schema for this schema's structural base. */
     toJsonSchema(options?: ToJsonSchemaOptions): Record<string, unknown>;
+    /** Standard Schema V1 interop (synchronous validation). */
+    readonly "~standard": StandardSchemaV1.Props<i, t>;
 }
 type MergeTypes<left, right> = left extends object ? right extends object ? Omit<left, keyof right> & right : right : right;
+type SimplifyNary<t> = t extends object ? {
+    [key in keyof t]: t[key];
+} : t;
+type UnionToIntersection<union> = (union extends unknown ? (value: union) => void : never) extends (value: infer intersection) => void ? intersection : never;
+type NaryOrOutput<definitions extends readonly unknown[]> = InferDef<definitions[number]>;
+type NaryOrInput<definitions extends readonly unknown[]> = InferDefIn<definitions[number]>;
+type NaryAndOutput<definitions extends readonly unknown[]> = definitions extends readonly [] ? unknown : SimplifyNary<UnionToIntersection<InferDef<definitions[number]>>>;
+type NaryAndInput<definitions extends readonly unknown[]> = definitions extends readonly [] ? unknown : SimplifyNary<UnionToIntersection<InferDefIn<definitions[number]>>>;
+type ReduceNaryMergeOutput<definitions extends readonly unknown[], result = {}> = definitions extends readonly [
+    infer head,
+    ...infer tail
+] ? ReduceNaryMergeOutput<tail, SimplifyNary<MergeTypes<result, InferDef<head>>>> : definitions extends readonly [] ? result : {};
+type ReduceNaryMergeInput<definitions extends readonly unknown[], result = {}> = definitions extends readonly [
+    infer head,
+    ...infer tail
+] ? ReduceNaryMergeInput<tail, SimplifyNary<MergeTypes<result, InferDefIn<head>>>> : definitions extends readonly [] ? result : {};
+type NaryMergeOutput<definitions extends readonly unknown[]> = definitions extends readonly [] ? object : ReduceNaryMergeOutput<definitions>;
+type NaryMergeInput<definitions extends readonly unknown[]> = definitions extends readonly [] ? object : ReduceNaryMergeInput<definitions>;
+type PipeItemOutput<item> = item extends SchemaInference<infer output, unknown> ? output : item extends (data: never, ...arguments_: never[]) => infer output ? Exclude<output, OmpErrors> : InferDef<item>;
+type NaryPipeOutput<items extends readonly unknown[]> = items extends readonly [...(readonly unknown[]), infer last] ? PipeItemOutput<last> : unknown;
+type NaryPipeInput<items extends readonly unknown[]> = items extends readonly [infer first, ...(readonly unknown[])] ? first extends SchemaInference<unknown, infer input> ? input : first extends (data: infer input, ...arguments_: never[]) => unknown ? input : InferDefIn<first> : unknown;
 interface FluentMethods<t, i> {
     describe(description: string): FluentType<t, i>;
-    configure(config: SchemaConfig): FluentType<t, i>;
-    default(value: t | (() => t)): FluentType<t, i>;
+    configure(config: SchemaConfig, selector?: "self" | ConfigureSelector): FluentType<t, i>;
+    default(value: i | (() => i)): FluentType<t, i | undefined>;
     optional(): readonly [SchemaInference<t, i>, "?"];
     or<r, ri>(def: SchemaInference<r, ri>): FluentType<t | r, i | ri>;
     or<const def extends string>(def: def): FluentType<t | InferString<def>, i | InferString<def>>;
-    or<const def extends Record<string, unknown>>(def: def): FluentType<t | InferObjectLiteral<def>, i | InferObjectLiteral<def>>;
+    or<const def extends Record<string, unknown>>(def: def): FluentType<t | InferObjectLiteral<def>, i | InferObjectLiteralIn<def>>;
     or(def: Def): FluentType<unknown>;
     and<r, ri>(def: SchemaInference<r, ri>): FluentType<t & r, i & ri>;
-    and<const def extends Record<string, unknown>>(def: def): FluentType<t & InferObjectLiteral<def>, i & InferObjectLiteral<def>>;
+    and<const def extends Record<string, unknown>>(def: def): FluentType<t & InferObjectLiteral<def>, i & InferObjectLiteralIn<def>>;
     and(def: Def): FluentType<unknown>;
     equals(def: Def): boolean;
     ifEquals(def: Def): FluentType<t, i> | undefined;
+    ifExtends(def: Def): FluentType<t, i> | undefined;
     extends(def: Def): boolean;
     overlaps(def: Def): boolean;
-    distribute<r>(mapper: (branch: FluentType<unknown>) => SchemaInference<r>): FluentType<r>;
+    distribute<r>(mapper: (branch: FluentType<unknown>) => SchemaInference<r>, reducer?: (branches: readonly SchemaInference<r>[]) => SchemaInference<unknown>): FluentType<r>;
     select(kind: string): readonly SelectedNode[];
     array(): FluentType<t[], i[]>;
     atLeastLength(bound: number): FluentType<t, i>;
@@ -101,18 +190,19 @@ interface FluentMethods<t, i> {
     nonNegative(): FluentType<t, i>;
     nonPositive(): FluentType<t, i>;
     matching(pattern: RegExp): FluentType<t, i>;
-    atOrAfter(bound: Date): FluentType<t, i>;
-    atOrBefore(bound: Date): FluentType<t, i>;
-    laterThan(bound: Date): FluentType<t, i>;
-    earlierThan(bound: Date): FluentType<t, i>;
-    pipe<r>(fn: (data: t, ctx: NarrowContext) => r): FluentType<Exclude<r, OmpErrors>, i>;
+    atOrAfter(bound: Date | number): FluentType<t, i>;
+    atOrBefore(bound: Date | number): FluentType<t, i>;
+    laterThan(bound: Date | number): FluentType<t, i>;
+    earlierThan(bound: Date | number): FluentType<t, i>;
+    readonly pipe: PipeMethod<t, i>;
     to<const def>(def: def): FluentType<InferDef<def>, i>;
     filter<narrowed extends i>(fn: (data: i, ctx: NarrowContext) => data is narrowed): FluentType<t, narrowed>;
-    filter(fn: (data: i, ctx: NarrowContext) => boolean): FluentType<t, i>;
+    filter(fn: (data: i, ctx: NarrowContext) => boolean | OmpErrors): FluentType<t, i>;
     narrow<narrowed extends t>(fn: (data: t, ctx: NarrowContext) => data is narrowed): FluentType<narrowed, i>;
-    narrow(fn: (data: t, ctx: NarrowContext) => boolean): FluentType<t, i>;
+    narrow(fn: (data: t, ctx: NarrowContext) => boolean | OmpErrors): FluentType<t, i>;
     brand<const name extends string>(name: name): FluentType<Brand<t, name>, i>;
     as<castTo>(): FluentType<castTo, i>;
+    readonly(): FluentType<Readonly<t>, i>;
     extract<r, ri>(def: SchemaInference<r, ri>): FluentType<Extract<t, r>, Extract<i, ri>>;
     extract<const def extends string>(def: def): FluentType<Extract<t, InferString<def>>, Extract<i, InferString<def>>>;
     extract(def: Def): FluentType<unknown>;
@@ -122,29 +212,82 @@ interface FluentMethods<t, i> {
     onUndeclaredKey(behavior: "ignore" | "reject" | "delete"): FluentType<t, i>;
     onDeepUndeclaredKey(behavior: "ignore" | "reject" | "delete"): FluentType<t, i>;
 }
+interface PipeMethod<t, i> {
+    <r>(fn: (data: t, ctx: NarrowContext) => r): FluentType<Exclude<r, OmpErrors>, i>;
+    <r, ri>(schema: SchemaInference<r, ri>): FluentType<r, i>;
+    (...steps: readonly unknown[]): FluentType<unknown, i>;
+    readonly try: {
+        <r>(fn: (data: t, ctx: NarrowContext) => r): FluentType<Exclude<r, OmpErrors>, i>;
+        (...steps: readonly unknown[]): FluentType<unknown, i>;
+    };
+}
 type InputObject<i> = i extends object ? i : object;
 interface ObjectMethods<t extends object, i> {
     readonly props: readonly TypeProperty[];
     map(mapper: (property: TypeProperty) => TypeProperty | readonly TypeProperty[]): FluentType<Record<PropertyKey, unknown>>;
     keyof(): FluentType<Extract<keyof t, PropertyKey>, Extract<keyof InputObject<i>, PropertyKey>>;
-    get<key extends keyof t>(key: key): FluentType<t[key], key extends keyof InputObject<i> ? InputObject<i>[key] : unknown>;
+    get<const path extends readonly PropertyKey[]>(...path: path): FluentType<unknown>;
     pick<const keys extends readonly (keyof t)[]>(...keys: keys): FluentType<Pick<t, keys[number]>, Pick<InputObject<i>, Extract<keys[number], keyof InputObject<i>>>>;
     omit<const keys extends readonly (keyof t)[]>(...keys: keys): FluentType<Omit<t, keys[number]>, Omit<InputObject<i>, Extract<keys[number], keyof InputObject<i>>>>;
     partial(): FluentType<Partial<t>, Partial<InputObject<i>>>;
     required(): FluentType<Required<t>, Required<InputObject<i>>>;
     merge<r, ri>(def: SchemaInference<r, ri>): FluentType<MergeTypes<t, r>, MergeTypes<i, ri>>;
-    merge<const def extends Record<string, unknown>>(def: def): FluentType<MergeTypes<t, InferObjectLiteral<def>>, MergeTypes<i, InferObjectLiteral<def>>>;
+    merge<const def extends Record<string, unknown>>(def: def): FluentType<MergeTypes<t, InferObjectLiteral<def>>, MergeTypes<i, InferObjectLiteralIn<def>>>;
     merge(def: Def): FluentType<unknown>;
 }
 type ObjectMethodsFor<t, i> = [t] extends [never] ? unknown : [t] extends [readonly unknown[]] ? unknown : [t] extends [object] ? ObjectMethods<t & object, i> : unknown;
 /** Callable schema with fluent methods specialized to its output and input. */
 export type FluentType<t = unknown, i = t> = Type<t, i> & FluentMethods<t, i> & ObjectMethodsFor<t, i>;
+type FnDefinition = Def | SchemaInference<unknown, unknown>;
+/** Function returned by `type.fn`: arguments and an optional return are validated at every call. */
+export type TypedFunction<parameters extends readonly unknown[] = readonly unknown[], returns = unknown, declaredReturns = returns> = ((...arguments_: parameters) => returns) & {
+    readonly params: FluentType<parameters>;
+    readonly returns: FluentType<declaredReturns>;
+    readonly expression: string;
+    readonly raw: (...arguments_: parameters) => returns;
+};
+type InferFnDefinition<definition> = definition extends SchemaInference<infer output, unknown> ? output : InferDef<definition>;
+type InferFnParameters<definitions extends readonly unknown[], accumulator extends readonly unknown[] = []> = definitions extends readonly [infer head, ...infer tail] ? head extends ":" ? accumulator : InferFnParameters<tail, readonly [...accumulator, InferFnDefinition<head>]> : accumulator;
+type InferFnReturn<definitions extends readonly unknown[], inferred> = definitions extends readonly [
+    ...(readonly unknown[]),
+    ":",
+    infer returns
+] ? InferFnDefinition<returns> : inferred;
+type DeclaredFnReturn<definitions extends readonly unknown[]> = definitions extends readonly [
+    ...(readonly unknown[]),
+    ":",
+    infer returns
+] ? InferFnDefinition<returns> : unknown;
+type FnFactory<definitions extends readonly FnDefinition[]> = <result>(implementation: (...arguments_: InferFnParameters<definitions>) => InferFnReturn<definitions, result>) => TypedFunction<InferFnParameters<definitions>, InferFnReturn<definitions, result>, DeclaredFnReturn<definitions>>;
+/** Parses function parameter schemas and validates calls and declared returns. */
+export interface FnParser {
+    <const definitions extends readonly FnDefinition[]>(...definitions: definitions): FnFactory<definitions>;
+    raw<const definitions extends readonly FnDefinition[]>(...definitions: definitions): FnFactory<definitions>;
+}
 /** Runtime constructor-like value used by ArkType-compatible `instanceof Type` checks. */
 export declare const Type: () => void;
-/**
- * Parse a definition into a callable schema with distinct input/output inference.
- */
+export interface ConfigureSelector {
+    readonly kind?: string;
+    readonly where?: (node: {
+        readonly domain?: string;
+        readonly kind: string;
+    }) => boolean;
+}
+/** Callable runtime generic returned by `type("<t>", def)` and `type.generic(...)`. */
+export type Generic = (...arguments_: readonly unknown[]) => BaseType;
+/** Schema arguments passed to a callback-bodied runtime generic. */
+export interface GenericArguments {
+    readonly [name: string]: BaseType;
+}
+export interface GenericBuilder {
+    (definition: (arguments_: GenericArguments) => unknown, hkt?: unknown): Generic;
+    (definition: unknown, hkt?: unknown): Generic;
+}
+export declare function type<const definition>(parameters: `<${string}>`, definition: definition): Generic;
 export declare function type<const def>(def: def): FluentType<InferDef<def>, InferDefIn<def>>;
+export declare function type<input, output>(def: SchemaInference<input> | string, operator: "=>", morph: (data: input, ctx: NarrowContext) => output): FluentType<Exclude<output, OmpErrors>, input>;
+export declare function type<const input, const output>(def: input, operator: "|>", out: output): FluentType<InferDef<output>, InferDefIn<input>>;
+export declare function type<const expression extends readonly unknown[]>(...definition: expression): FluentType<InferDef<expression>, InferDefIn<expression>>;
 /** String keyword with a parser that morphs validated text to another output. */
 export interface ParsedStringKeyword<parsed> extends FluentType<string> {
     readonly parse: FluentType<parsed, string>;
@@ -224,66 +367,199 @@ export interface NumberKeyword extends FluentType<number> {
     readonly integer: FluentType<number>;
 }
 type Constructed<ctor> = ctor extends abstract new (...args: never[]) => infer instance ? instance : never;
+type MatchDefault<input = unknown, output = unknown> = "assert" | "never" | "reject" | ((input: input, ...args: readonly unknown[]) => output);
+type MatchCaseOutput<cases> = {
+    [key in keyof cases]: cases[key] extends (...args: never[]) => infer output ? output : never;
+}[keyof cases];
+/** A finalized matcher. Like a schema, it returns structured errors unless finalized with `"assert"`. */
+export type Matcher<input = unknown, output = unknown> = FluentType<output, input> & (<const value extends input>(value: value, ...args: readonly unknown[]) => output | OmpErrors);
+/** Fluent first-match parser exposed as `match` and `type.match`. */
+export interface MatchParser<input = unknown, output = never> {
+    <const cases extends Record<PropertyKey, unknown>>(cases: cases): MatchParser<input, output | MatchCaseOutput<cases>> | Matcher<input, output | MatchCaseOutput<cases>>;
+    case<const definition, result>(definition: definition, resolver: (value: InferDef<definition>, ...args: readonly unknown[]) => result): MatchParser<input, output | result>;
+    match<const cases extends Record<PropertyKey, unknown>>(cases: cases): MatchParser<input, output | MatchCaseOutput<cases>> | Matcher<input, output | MatchCaseOutput<cases>>;
+    default<const result>(fallback: MatchDefault<input, result>): Matcher<input, output | result>;
+    at<const key extends PropertyKey>(key: key): MatchParser<input, output>;
+    at<const key extends PropertyKey, cases extends Record<PropertyKey, unknown>>(key: key, cases: cases): MatchParser<input, output | MatchCaseOutput<cases>> | Matcher<input, output | MatchCaseOutput<cases>>;
+    strings<const cases extends Record<PropertyKey, unknown>>(cases: cases): MatchParser<input, output | MatchCaseOutput<cases>> | Matcher<input, output | MatchCaseOutput<cases>>;
+    in<narrowed>(): MatchParser<narrowed, output>;
+    in<const definition>(definition: definition): MatchParser<InferDef<definition>, output>;
+}
+/** Build a fluent first-match dispatcher from schema definitions. */
+declare const matchBuilder: MatchParser;
+export { matchBuilder as match };
+/** Declares a schema output type while preserving its inferred input. */
+export interface DeclaredParser<declared> {
+    type<const definition>(definition: definition): FluentType<declared, InferDefIn<definition>>;
+}
+/** Fix a schema's externally declared static type without changing its runtime validation. */
+export declare function declare<declared, _options = {}>(): DeclaredParser<declared>;
 export declare namespace type {
     /** Error aggregate returned by failed validations (`result instanceof type.errors`). */
-    const errors: typeof OmpErrors;
-    type errors = OmpErrors;
+    export const errors: typeof OmpErrors;
+    export type errors = OmpErrors;
+    /** Build a union from zero or more definitions. */
+    export function or<const definitions extends readonly unknown[]>(...definitions: definitions): FluentType<NaryOrOutput<definitions>, NaryOrInput<definitions>>;
+    /** Build an intersection from zero or more definitions. */
+    export function and<const definitions extends readonly unknown[]>(...definitions: definitions): FluentType<NaryAndOutput<definitions>, NaryAndInput<definitions>>;
+    /** Right-biased object merge over zero or more definitions. */
+    export function merge<const definitions extends readonly unknown[]>(...definitions: definitions): FluentType<NaryMergeOutput<definitions>, NaryMergeInput<definitions>>;
+    /** Compose Types, definitions, and morph callbacks from left to right. */
+    export function pipe<const definitions extends readonly unknown[]>(...definitions: definitions): FluentType<NaryPipeOutput<definitions>, NaryPipeInput<definitions>>;
     /** String validator and its refinement/morph keyword module. */
-    const string: StringKeyword;
+    export const string: StringKeyword;
     /** Runtime parser keyword family. */
-    const parse: ParseKeyword;
+    export const parse: ParseKeyword;
     /** Number validator with integer refinement. */
-    const number: NumberKeyword;
+    export const number: NumberKeyword;
+    /** Schema-valued key representing any non-negative integer array index. */
+    export const arrayIndex: FluentType<string, string>;
     /** Boolean validator. */
-    const boolean: FluentType<boolean, boolean>;
+    export const boolean: FluentType<boolean, boolean>;
     /** Bigint validator. */
-    const bigint: FluentType<bigint, bigint>;
+    export const bigint: FluentType<bigint, bigint>;
     /** Symbol validator. */
-    const symbol: FluentType<symbol, symbol>;
+    export const symbol: FluentType<symbol, symbol>;
     /** Non-null object validator. */
-    const object: FluentType<object, object>;
+    export const object: FluentType<object, object>;
     /** Unknown validator. */
-    const unknown: FluentType<unknown, unknown>;
+    export const unknown: FluentType<unknown, unknown>;
     /** Alias of the unknown validator. */
-    const any: FluentType<unknown, unknown>;
+    export const any: FluentType<unknown, unknown>;
     /** Validator that rejects every value. */
-    const never: FluentType<never, never>;
+    export const never: FluentType<never, never>;
+    /** ArkType's built-in keyword namespace, including invokable utility generics. */
+    export const keywords: {
+        number: {
+            integer: FluentType<number, number>;
+        };
+        Map: FluentType<Map<unknown, unknown>, Map<unknown, unknown>>;
+        Set: FluentType<Set<unknown>, Set<unknown>>;
+        RegExp: FluentType<RegExp, RegExp>;
+        File: FluentType<File, File>;
+        Error: FluentType<Error, Error>;
+        Function: FluentType<Function, Function>;
+        Array: {
+            liftFrom<const definition>(definition: definition): FluentType<InferDef<definition>[], InferDefIn<definition> | InferDefIn<definition>[]>;
+        };
+        Record<const key, const value>(key: key, value: value): FluentType<Record<Extract<InferDef<key>, PropertyKey>, InferDef<value>>, Record<Extract<InferDefIn<key>, PropertyKey>, InferDefIn<value>>>;
+        Partial<const definition>(definition: definition): FluentType<Partial<InferDef<definition>>, Partial<InputObject<InferDefIn<definition>>>>;
+        Required<const definition>(definition: definition): FluentType<Required<InferDef<definition>>, Required<InputObject<InferDefIn<definition>>>>;
+        Pick<const definition, const keys extends readonly PropertyKey[]>(definition: definition, ...keys: keys): FluentType<Pick<InferDef<definition>, Extract<keys[number], keyof InferDef<definition>>>, Pick<InputObject<InferDefIn<definition>>, Extract<keys[number], keyof InputObject<InferDefIn<definition>>>>>;
+        Omit<const definition, const keys extends readonly PropertyKey[]>(definition: definition, ...keys: keys): FluentType<Omit<InferDef<definition>, Extract<keys[number], keyof InferDef<definition>>>, Omit<InputObject<InferDefIn<definition>>, Extract<keys[number], keyof InputObject<InferDefIn<definition>>>>>;
+        Merge<const left, const right>(left: left, right: right): FluentType<MergeTypes<InferDef<left>, InferDef<right>>, MergeTypes<InferDefIn<left>, InferDefIn<right>>>;
+        object: {
+            json: FluentType<unknown, unknown>;
+        };
+        unknown: {
+            any: FluentType<unknown, unknown>;
+        };
+    };
     /** Date instance validator. */
-    const Date: FluentType<Date, Date>;
+    export const Date: FluentType<Date, Date>;
     /** Validate instances of `ctor`. */
-    function instanceOf<const ctor extends Constructor>(ctor: ctor): FluentType<Constructed<ctor>>;
+    export function instanceOf<const ctor extends Constructor>(ctor: ctor): FluentType<Constructed<ctor>>;
     /** Validate one exact unit value. */
-    function unit<const value>(value: value): FluentType<value>;
+    export function unit<const value>(value: value): FluentType<value>;
     /** Union of literal values from a runtime array. */
-    function enumerated<const values extends readonly unknown[]>(...values: values): FluentType<values[number]>;
-    /** Build a first-match dispatcher from schema-expression keys and a `default` case. */
-    function match<const cases extends Record<string, unknown>>(cases: cases): (value: unknown) => unknown;
+    export function enumerated<const values extends readonly unknown[]>(...values: values): FluentType<values[number]>;
+    /** Enumerate an enum-like object's forward values, excluding numeric reverse mappings. */
+    export function valueOf<const values extends Record<PropertyKey, unknown>>(values: values): FluentType<values[keyof values]>;
+    /** Fluent first-match dispatcher, also exported as standalone `match`. */
+    export const match: MatchParser;
     /** Preserve a definition's literal type while authoring reusable modules. */
-    function define<const definition>(definition: definition): definition;
+    export function define<const definition>(definition: definition): definition;
+    /** Build a function whose arguments and optional declared return are validated. */
+    export const fn: FnParser;
+    /** Fix an externally declared static type while retaining runtime validation. */
+    export const declare: <declared, _options = {}>() => DeclaredParser<declared>;
     /** Build a lazy named scope from aliases and recursive definitions. */
-    function scope(aliases: Record<string, unknown>, options?: ScopeOptions): TypeScope;
+    export function scope(aliases: Record<string, unknown>, options?: ScopeOptions): TypeScope;
     /** Compile a named schema module whose definitions may reference each other. */
-    function module<const definitions extends Record<string, unknown>>(definitions: definitions): {
+    export function module<const definitions extends Record<string, unknown>>(definitions: definitions, options?: ScopeOptions): {
         [name in keyof definitions]: Type<InferDef<definitions[name]>, InferDefIn<definitions[name]>>;
     };
-    /** Build a runtime generic whose parameter names are supplied as `"<t, u>"`. */
-    function generic<const definition>(parameters: string, definition: definition): (...arguments_: readonly unknown[]) => BaseType;
+    type GenericParameterSpec = string | readonly [name: string, constraint: unknown];
+    /** Build a generic directly from an angle-bracket declaration. */
+    export function generic<const definition>(parameters: `<${string}>`, definition: definition): Generic;
+    /** Build a curried generic from named, optionally constrained parameters. */
+    export function generic(...parameters: readonly GenericParameterSpec[]): GenericBuilder;
     /** Untyped builder for runtime-assembled definitions. */
-    function raw(def: unknown): BaseType;
+    export function raw(def: unknown): BaseType;
+    export {};
 }
 export interface ScopeOptions {
     jitless?: boolean;
+    clone?: false | ((input: unknown) => unknown);
+    divisor?: SchemaConfig;
 }
 /** Callable builder bound to one alias scope. */
-export type ScopedBuilder = <const definition>(definition: definition) => FluentType<InferDef<definition>, InferDefIn<definition>>;
-/** Named schema scope with a scoped builder and compiled module export. */
+export type ScopedBuilder = (<const definition>(definition: definition) => FluentType<InferDef<definition>, InferDefIn<definition>>) & typeof type;
+/** Named schema scope with scoped parsing, imports, and bound module exports. */
 export interface TypeScope {
     readonly type: ScopedBuilder;
-    export(): Record<string, BaseType>;
+    readonly match: MatchParser;
+    readonly json: Record<string, unknown>;
+    define<const definition>(definition: definition): definition;
+    resolve(name: string): BaseType;
+    import(...names: readonly string[]): Record<string, unknown>;
+    export(...names: readonly string[]): Record<string, BaseType>;
 }
 /** Build a scope whose aliases resolve lazily, including recursive cycles. */
 export declare function scope(aliases: Record<string, unknown>, options?: ScopeOptions): TypeScope;
+export declare namespace scope {
+    /** Preserve a scope definition's literal shape without constructing it. */
+    function define<const aliases>(definitions: aliases): aliases;
+}
 /** A schema whose output type is not statically known (`type.raw` results). */
 export type BaseType = FluentType<unknown, unknown>;
+/**
+ * Minimal structural constraint matching any omptype schema.
+ *
+ * `FluentType`'s recursive fluent surface makes `T extends FluentType<...>`
+ * checks descend until TypeScript's depth limiter reports spurious
+ * incompatibilities, and its invariant input parameter rejects concrete
+ * schemas outright. This interface exposes only the schema marker plus the
+ * members generic helpers commonly need — method syntax keeps parameter
+ * positions bivariant, and returns recurse shallowly through `AnyType`.
+ */
+export interface AnyType {
+    (data: unknown): unknown;
+    readonly [IR_BRAND]: true;
+    readonly ir: IR;
+    readonly infer: unknown;
+    readonly inferIn: unknown;
+    readonly hasDefault: boolean;
+    readonly description?: string;
+    run(data: unknown): unknown;
+    assert(data: unknown): unknown;
+    allows(data: unknown): boolean;
+    toJsonSchema(options?: ToJsonSchemaOptions): Record<string, unknown>;
+    describe(description: string): AnyType;
+    default(value: unknown): AnyType;
+    or(def: Def): AnyType;
+    and(def: Def): AnyType;
+    pipe(fn: (data: never, ctx: NarrowContext) => unknown): AnyType;
+    narrow(fn: (data: never, ctx: NarrowContext) => unknown): AnyType;
+    array(): AnyType;
+}
+declare const submoduleType: unique symbol;
+type BoundAlias<value> = value extends Submodule<infer aliases> ? Submodule<aliases> : FluentType<value>;
+/** Exported aliases from a scope, each bound to that scope's resolver. */
+export type Module<aliases extends Record<string, unknown>> = {
+    readonly [name in keyof aliases]: BoundAlias<aliases[name]>;
+};
+/** A module nested under an alias rather than directly parseable as a schema. */
+export type Submodule<aliases extends Record<string, unknown>> = {
+    readonly [submoduleType]?: aliases;
+} & {
+    readonly [name in keyof aliases]: BoundAlias<aliases[name]>;
+};
+/** A selected module export whose schemas retain access to the full scope. */
+export type BoundModule<exports extends Record<string, unknown>, _allAliases extends Record<string, unknown> = exports> = Module<exports>;
+/** Type-level view of a named scope. */
+export type Scope<aliases extends Record<string, unknown>> = TypeScope & {
+    readonly t: aliases;
+};
 /** `hasMorph` re-export for diagnostics/tooling. */
 export { hasMorph };