@oh-my-pi/omptype 17.2.6 → 17.2.8

package/dist/types/type.d.ts

@@ -1,27 +1,96 @@
-import { OmpErrors } from "./errors.js";
-import type { InferDef, InferObjectLiteral, InferString } from "./infer.js";
-import { type Def, hasMorph, type IR, IR_BRAND } from "./ir.js";
+import { type ErrorConfig, OmpErrors } from "./errors.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;
-}
-/** Options accepted by `Type.toJsonSchema` (ArkType-compatible; emission is always draft 2020-12). */
-export interface ToJsonSchemaOptions {
-    target?: string;
-    dialect?: string;
-    fallback?: (ctx: {
-        base: Record<string, unknown>;
-    }) => unknown;
-}
-interface SchemaInference<out t> {
+    reject(problem: string | NarrowErrorInput): OmpErrors | false;
+}
+/** Schema metadata and validation-message overrides accepted by `.configure()`. */
+export interface SchemaConfig extends ErrorConfig {
+    readonly description?: string;
+}
+/** Options accepted by `Type.toJsonSchema`. */
+export interface ToJsonSchemaOptions extends JsonSchemaOptions {
+}
+declare const brand: unique symbol;
+/** Inference-only nominal brand attached by `.brand(name)`. */
+export type Brand<t, name extends string> = t & {
+    readonly [brand]: name;
+};
+interface SchemaInference<out t, i = t> {
     readonly [IR_BRAND]: true;
     readonly infer: t;
+    readonly inferIn: i;
+}
+/** Property descriptor exposed by object schemas and consumed by `.map()`. */
+export interface TypeProperty {
+    readonly kind: "required" | "optional";
+    readonly key: PropertyKey;
+    readonly value: FluentType<unknown>;
+    readonly default?: unknown;
+    readonly meta: Readonly<Record<string, unknown>>;
+}
+/** Structural node returned by `.select()`. */
+export interface SelectedNode {
+    readonly kind: string;
+    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> {
+export interface Type<out t = unknown, i = t> {
     (data: unknown): t | OmpErrors;
     readonly [IR_BRAND]: true;
     /** Structural IR (base type; runtime steps live in `steps`). */
@@ -31,70 +100,466 @@ export interface Type<out t = unknown> {
     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: t;
+    readonly inferIn: i;
     /** Structural + narrow check without running pipes. */
-    allows(data: unknown): data is t;
+    allows(data: unknown): data is i;
     /** Validate and return output, throwing `TraversalError` on failure. */
     assert(data: unknown): t;
-    /** JSON Schema (draft 2020-12) for this schema's structural base. */
+    /** Validate a statically typed input and return its output. */
+    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>;
 }
-/** Schema returned by omptype builders, with precise object-literal composition inference. */
-export interface FluentType<t = unknown> extends Type<t> {
-    describe(description: string): FluentType<t>;
-    default(value: t | (() => t)): FluentType<t>;
-    or<r>(def: SchemaInference<r>): FluentType<t | r>;
-    or<const def extends string>(def: def): FluentType<t | InferString<def>>;
-    or<const def extends Record<string, unknown>>(def: def): FluentType<t | InferObjectLiteral<def>>;
+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, 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 | InferObjectLiteralIn<def>>;
     or(def: Def): FluentType<unknown>;
-    and<r>(def: SchemaInference<r>): FluentType<t & r>;
-    and<const def extends Record<string, unknown>>(def: def): FluentType<t & InferObjectLiteral<def>>;
+    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 & InferObjectLiteralIn<def>>;
     and(def: Def): FluentType<unknown>;
-    array(): FluentType<t[]>;
-    atLeastLength(bound: number): FluentType<t>;
-    atMostLength(bound: number): FluentType<t>;
-    atLeast(bound: number): FluentType<t>;
-    atMost(bound: number): FluentType<t>;
-    pipe<r>(fn: (data: t, ctx: NarrowContext) => r): FluentType<Exclude<r, OmpErrors>>;
-    narrow<narrowed extends t>(fn: (data: t, ctx: NarrowContext) => data is narrowed): FluentType<narrowed>;
-    narrow(fn: (data: t, ctx: NarrowContext) => boolean): FluentType<t>;
+    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>, reducer?: (branches: readonly SchemaInference<r>[]) => SchemaInference<unknown>): FluentType<r>;
+    select(kind: string): readonly SelectedNode[];
+    array(): FluentType<t[], i[]>;
+    atLeastLength(bound: number): FluentType<t, i>;
+    atMostLength(bound: number): FluentType<t, i>;
+    moreThanLength(bound: number): FluentType<t, i>;
+    lessThanLength(bound: number): FluentType<t, i>;
+    exactlyLength(bound: number): FluentType<t, i>;
+    atLeast(bound: number): FluentType<t, i>;
+    atMost(bound: number): FluentType<t, i>;
+    moreThan(bound: number): FluentType<t, i>;
+    lessThan(bound: number): FluentType<t, i>;
+    divisibleBy(divisor: number): FluentType<t, i>;
+    positive(): FluentType<t, i>;
+    negative(): FluentType<t, i>;
+    nonNegative(): FluentType<t, i>;
+    nonPositive(): FluentType<t, i>;
+    matching(pattern: RegExp): FluentType<t, 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 | 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 | 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>;
+    exclude<r, ri>(def: SchemaInference<r, ri>): FluentType<Exclude<t, r>, Exclude<i, ri>>;
+    exclude<const def extends string>(def: def): FluentType<Exclude<t, InferString<def>>, Exclude<i, InferString<def>>>;
+    exclude(def: Def): FluentType<unknown>;
+    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<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, 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;
-/**
- * The `type()` builder: parses a definition into a callable schema.
- *
- * The `const def` generic drives static inference (`typeof schema.infer`);
- * the runtime is definition-shape-agnostic, hence the cast.
- */
-export declare function type<const def>(def: def): FluentType<InferDef<def>>;
+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>;
+}
+/** Morphing string keyword paired with its non-morphing preformatted validator. */
+export interface PreformattedKeyword extends FluentType<string, string> {
+    readonly preformatted: FluentType<string>;
+}
+/** Base64 keyword with its URL-safe alphabet variant. */
+export interface Base64Keyword extends FluentType<string> {
+    readonly url: FluentType<string>;
+}
+/** Date-string keyword family. */
+export interface DateStringKeyword extends ParsedStringKeyword<Date> {
+    readonly iso: ParsedStringKeyword<Date>;
+    readonly epoch: ParsedStringKeyword<Date>;
+}
+/** IP address keyword family. */
+export interface IpKeyword extends FluentType<string> {
+    readonly v4: FluentType<string>;
+    readonly v6: FluentType<string>;
+}
+/** UUID keyword family. */
+export interface UuidKeyword extends FluentType<string> {
+    readonly v1: FluentType<string>;
+    readonly v2: FluentType<string>;
+    readonly v3: FluentType<string>;
+    readonly v4: FluentType<string>;
+    readonly v5: FluentType<string>;
+    readonly v6: FluentType<string>;
+    readonly v7: FluentType<string>;
+    readonly v8: FluentType<string>;
+}
+/** String normalization keyword family. */
+export interface NormalizeKeyword extends PreformattedKeyword {
+    readonly NFC: PreformattedKeyword;
+    readonly NFD: PreformattedKeyword;
+    readonly NFKC: PreformattedKeyword;
+    readonly NFKD: PreformattedKeyword;
+}
+/** Runtime string parsers exposed under `type.parse`. */
+export interface ParseKeyword {
+    readonly number: FluentType<number, string>;
+    readonly integer: FluentType<number, string>;
+    readonly json: FluentType<unknown, string>;
+    readonly date: FluentType<Date, string>;
+    readonly url: FluentType<URL, string>;
+    readonly boolean: FluentType<boolean, string>;
+    readonly bigint: FluentType<bigint, string>;
+}
+/** Full string keyword module attached to `type.string`. */
+export interface StringKeyword extends FluentType<string> {
+    readonly alpha: FluentType<string>;
+    readonly alphanumeric: FluentType<string>;
+    readonly base64: Base64Keyword;
+    readonly capitalize: PreformattedKeyword;
+    readonly creditCard: FluentType<string>;
+    readonly date: DateStringKeyword;
+    readonly digits: FluentType<string>;
+    readonly email: FluentType<string>;
+    readonly hex: FluentType<string>;
+    readonly integer: ParsedStringKeyword<number>;
+    readonly ip: IpKeyword;
+    readonly json: ParsedStringKeyword<unknown>;
+    readonly lower: PreformattedKeyword;
+    readonly normalize: NormalizeKeyword;
+    readonly numeric: ParsedStringKeyword<number>;
+    readonly regex: FluentType<string>;
+    readonly semver: FluentType<string>;
+    readonly trim: PreformattedKeyword;
+    readonly upper: PreformattedKeyword;
+    readonly url: ParsedStringKeyword<URL>;
+    readonly uuid: UuidKeyword;
+}
+/** Number keyword module attached to `type.number`. */
+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;
-    /** Keyword statics for fluent building, e.g. `type.number.atLeast(5)`. */
-    const string: FluentType<string>;
-    const number: FluentType<number>;
-    const boolean: FluentType<boolean>;
-    const unknown: FluentType<unknown>;
-    /** Union of literal values from a runtime array (`type.enumerated(...list)`). */
-    function enumerated<const values extends readonly unknown[]>(...values: values): FluentType<values[number]>;
-    /** Untyped builder for runtime-assembled definitions (`type.raw({...})`). */
-    function raw(def: unknown): BaseType;
+    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. */
+    export const string: StringKeyword;
+    /** Runtime parser keyword family. */
+    export const parse: ParseKeyword;
+    /** Number validator with integer refinement. */
+    export const number: NumberKeyword;
+    /** Schema-valued key representing any non-negative integer array index. */
+    export const arrayIndex: FluentType<string, string>;
+    /** Boolean validator. */
+    export const boolean: FluentType<boolean, boolean>;
+    /** Bigint validator. */
+    export const bigint: FluentType<bigint, bigint>;
+    /** Symbol validator. */
+    export const symbol: FluentType<symbol, symbol>;
+    /** Non-null object validator. */
+    export const object: FluentType<object, object>;
+    /** Unknown validator. */
+    export const unknown: FluentType<unknown, unknown>;
+    /** Alias of the unknown validator. */
+    export const any: FluentType<unknown, unknown>;
+    /** Validator that rejects every value. */
+    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. */
+    export const Date: FluentType<Date, Date>;
+    /** Validate instances of `ctor`. */
+    export function instanceOf<const ctor extends Constructor>(ctor: ctor): FluentType<Constructed<ctor>>;
+    /** Validate one exact unit value. */
+    export function unit<const value>(value: value): FluentType<value>;
+    /** Union of literal values from a runtime array. */
+    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. */
+    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. */
+    export function scope(aliases: Record<string, unknown>, options?: ScopeOptions): TypeScope;
+    /** Compile a named schema module whose definitions may reference each other. */
+    export function module<const definitions extends Record<string, unknown>>(definitions: definitions, options?: ScopeOptions): {
+        [name in keyof definitions]: Type<InferDef<definitions[name]>, InferDefIn<definitions[name]>>;
+    };
+    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. */
+    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>>) & typeof type;
+/** Named schema scope with scoped parsing, imports, and bound module exports. */
+export interface TypeScope {
+    readonly type: ScopedBuilder;
+    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;
 }
-/** ArkType-compatible scope wrapper; omptype's global builder is already lazy. */
-export declare function scope(_aliases: Record<string, unknown>, _options?: ScopeOptions): {
-    type: typeof type;
-};
 /** A schema whose output type is not statically known (`type.raw` results). */
-export type BaseType = FluentType<unknown>;
+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 };