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 {
    readonly path: readonly PropertyKey[];
    error(error: string | NarrowErrorInput): OmpErrors;
    mustBe(expectation: string): false;
    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, i = t> {
    (data: unknown): t | OmpErrors;
    readonly [IR_BRAND]: true;
    /** Structural IR (base type; runtime steps live in `steps`). */
    readonly ir: IR;
    /** `.pipe()` / `.narrow()` steps applied after structural validation. */
    readonly hasSteps: boolean;
    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. */
    allows(data: unknown): data is i;
    /** Validate and return output, throwing `TraversalError` on failure. */
    assert(data: unknown): t;
    /** 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>;
}
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, 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>;
    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;
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`). */
    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 array schema from an element definition. */
    export function array<const definition>(definition: definition): FluentType<InferDef<definition>[], InferDefIn<definition>[]>;
    /** Build a union from a runtime array of definitions. */
    export function union<const definitions extends readonly unknown[]>(definitions: definitions): FluentType<NaryOrOutput<definitions>, NaryOrInput<definitions>>;
    /** Build a tuple schema from a runtime array of definitions. */
    export function tuple<const definitions extends readonly unknown[]>(definitions: definitions): FluentType<InferDef<definitions>, InferDefIn<definitions>>;
    /** Build an open record schema from key and value definitions. */
    export function record<const key, const value>(key: key, value: value): FluentType<Record<Extract<InferDef<key>, PropertyKey>, InferDef<value>>, Record<Extract<InferDefIn<key>, PropertyKey>, InferDefIn<value>>>;
    /** 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]>;
    /** Build a literal union from a runtime array. */
    export function enumeration<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;
    /**
     * Return a validation-only schema that emits `json` verbatim — even when
     * embedded in an object, array, or union.
     *
     * A `.toJsonSchema()` method override cannot survive nesting: a parent schema
     * emits each child's IR directly and never calls the child's method, so the
     * override silently disappears from the wire schema. This stores the override
     * on the IR instead.
     *
     * # Errors
     *
     * Throws when `schema` has a default or output-changing morph/pipe. A refine
     * can preserve validation and the input value, but silently discarding a
     * transformed output would violate the returned {@link Type}.
     */
    export function withJsonSchema<t, i = t>(schema: Type<t, i>, json: Record<string, unknown>): Type<t, i>;
    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;
}
/** 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 };