import type { EmbeddableSchema } from "./ir.js";
import { type NarrowContext, type Type as OmpType, type ToJsonSchemaOptions } from "./type.js";
export interface Meta {
    title?: string;
    description?: string;
    default?: unknown;
    examples?: unknown[];
    [key: string]: unknown;
}
export interface StringOpts extends Meta {
    minLength?: number;
    maxLength?: number;
    pattern?: string;
    format?: string;
}
export interface NumberOpts extends Meta {
    minimum?: number;
    maximum?: number;
    exclusiveMinimum?: number;
    exclusiveMaximum?: number;
    multipleOf?: number;
}
export interface ArrayOpts extends Meta {
    minItems?: number;
    maxItems?: number;
    uniqueItems?: boolean;
}
export interface ObjectOpts extends Meta {
    additionalProperties?: boolean | AnySchema;
}
declare const OPTIONAL_INNER: unique symbol;
declare const OBJECT_INFO: unique symbol;
export interface TypeBoxValidationFailure {
    message: string;
}
export type TypeBoxSafeParseResult<T> = {
    success: true;
    data: T;
} | {
    success: false;
    error: TypeBoxValidationFailure;
};
interface LegacyTypeBoxCompat<T> {
    /** TypeBox compatibility validator used by legacy extension loaders. */
    __validator(data: unknown): T | TypeBoxValidationFailure;
    /** Zod-style compatibility parser used by legacy extensions. */
    safeParse(input: unknown): TypeBoxSafeParseResult<T>;
}
/**
 * Erased schema surface accepted anywhere this facade takes a schema, native
 * omptype schemas included (those carry no legacy compat members).
 *
 * Members use method syntax so parameter positions stay bivariant: the typed
 * {@link TTyped} form is invariant in its static type (its `in`/`out`
 * validators are), so a concrete `TString` is not assignable to
 * `TTyped<unknown>`. Erasing here is what keeps `TString`, `TObject<…>` and
 * friends assignable to a plain schema annotation.
 */
export interface AnySchema extends EmbeddableSchema {
    (data: unknown): unknown;
    readonly infer: unknown;
    readonly hasSteps: boolean;
    toJsonSchema(options?: ToJsonSchemaOptions): Record<string, unknown>;
}
/**
 * Every schema this facade returns: the TypeBox `TSchema` analog. Erased like
 * {@link AnySchema}, plus the legacy compat members builder results carry.
 */
export interface TSchema extends AnySchema {
    /** TypeBox compatibility validator used by legacy extension loaders. */
    __validator(data: unknown): unknown;
    /** Zod-style compatibility parser used by legacy extensions. */
    safeParse(input: unknown): TypeBoxSafeParseResult<unknown>;
}
/** Schema carrying a statically known type; every `TXxx` alias resolves here. */
export type TTyped<T> = OmpType<T> & LegacyTypeBoxCompat<T>;
export type Static<T extends AnySchema> = T["infer"];
export type TAny = TTyped<unknown>;
export type TUnknown = TTyped<unknown>;
export type TNever = TTyped<never>;
export type TNull = TTyped<null>;
export type TString = TTyped<string>;
export type TNumber = TTyped<number>;
export type TInteger = TTyped<number>;
export type TBoolean = TTyped<boolean>;
export type TLiteral<V extends string | number | boolean | null> = TTyped<V>;
export type TArray<E extends AnySchema> = TTyped<Static<E>[]>;
export type TTuple<E extends readonly AnySchema[] = readonly AnySchema[]> = TTyped<{
    -readonly [K in keyof E]: Static<E[K]>;
}>;
export type TOptional<E extends AnySchema> = TTyped<Static<E> | undefined> & {
    readonly [OPTIONAL_INNER]: E;
};
export type TUnion<E extends readonly AnySchema[] = readonly AnySchema[]> = TTyped<Static<E[number]>>;
export type TIntersect<E extends readonly AnySchema[] = readonly AnySchema[]> = TTyped<UnionToIntersection<Static<E[number]>>>;
export type TEnum<E extends readonly (string | number)[] = readonly (string | number)[]> = TTyped<E[number]>;
export type TRecord<K extends AnySchema, V extends AnySchema> = TTyped<Record<Extract<Static<K>, PropertyKey>, Static<V>>>;
export type TNullable<E extends AnySchema> = TTyped<Static<E> | null>;
export type TReadonly<E extends AnySchema> = TTyped<Readonly<Static<E>>>;
export type TUnsafe<T = unknown> = TTyped<T>;
type OptionalKeys<P extends Record<string, AnySchema>> = {
    [K in keyof P]-?: P[K] extends {
        readonly [OPTIONAL_INNER]: AnySchema;
    } ? K : never;
}[keyof P];
type RequiredKeys<P extends Record<string, AnySchema>> = Exclude<keyof P, OptionalKeys<P>>;
type ObjectStatic<P extends Record<string, AnySchema>> = {
    [K in RequiredKeys<P>]: Static<P[K]>;
} & {
    [K in OptionalKeys<P>]?: Exclude<Static<P[K]>, undefined>;
};
export type TObject<P extends Record<string, AnySchema> = Record<string, AnySchema>> = TTyped<ObjectStatic<P>>;
type RequiredProps<P extends Record<string, AnySchema>> = {
    [K in keyof P]: P[K] extends TOptional<infer E> ? E : P[K];
};
interface RuntimeType<T> extends OmpType<T> {
    [OPTIONAL_INNER]?: AnySchema;
    [OBJECT_INFO]?: ObjectInfo;
    describe(description: string): RuntimeType<T>;
    default(value: T | (() => T)): RuntimeType<T>;
    or<schema extends AnySchema>(schema: schema): RuntimeType<T | Static<schema>>;
    and<schema extends AnySchema>(schema: schema): RuntimeType<T & Static<schema>>;
    array(): RuntimeType<T[]>;
    atLeastLength(bound: number): RuntimeType<T>;
    atMostLength(bound: number): RuntimeType<T>;
    atLeast(bound: number): RuntimeType<T>;
    atMost(bound: number): RuntimeType<T>;
    narrow<N extends T>(predicate: (value: T, ctx: NarrowContext) => value is N): RuntimeType<N>;
    narrow(predicate: (value: T, ctx: NarrowContext) => boolean): RuntimeType<T>;
}
type CompatRuntime<T> = RuntimeType<T> & LegacyTypeBoxCompat<T>;
type ObjectInfo = {
    props: Record<string, AnySchema>;
    additionalProperties?: boolean | AnySchema;
};
declare function tString(opts?: StringOpts): TString;
declare function tLiteral<const V extends string | number | boolean | null>(value: V, opts?: Meta): TLiteral<V>;
declare function tNever(opts?: Meta): TNever;
declare function tUnion<const E extends readonly AnySchema[]>(schemas: E, opts?: Meta): TUnion<E>;
declare function tIntersect<const E extends readonly AnySchema[]>(schemas: E, opts?: Meta): TTyped<UnionToIntersection<Static<E[number]>>>;
type UnionToIntersection<U> = (U extends unknown ? (value: U) => void : never) extends (value: infer I) => void ? I : never;
declare function tEnum<const E extends Record<string, string | number> | readonly (string | number)[]>(values: E, opts?: Meta): TTyped<E extends readonly (infer V)[] ? V : E[keyof E]>;
declare function tArray<E extends AnySchema>(item: E, opts?: ArrayOpts): TArray<E>;
declare function tTuple<const E extends readonly AnySchema[]>(items: E, opts?: Meta): TTuple<E>;
declare function tObject<const P extends Record<string, AnySchema>>(properties: P, opts?: ObjectOpts): TObject<P>;
declare function tRecord<K extends AnySchema, V extends AnySchema>(key: K, value: V, opts?: Meta): TRecord<K, V>;
declare function tOptional<E extends AnySchema>(schema: E, opts?: Meta): TOptional<E>;
declare function tNullable<E extends AnySchema>(schema: E, opts?: Meta): TTyped<Static<E> | null>;
declare function tPartial<P extends Record<string, AnySchema>>(schema: TObject<P>): TTyped<Partial<ObjectStatic<P>>>;
declare function tRequired<P extends Record<string, AnySchema>>(schema: TObject<P>): TObject<RequiredProps<P>>;
declare function tPick<P extends Record<string, AnySchema>, const K extends readonly (keyof P)[]>(schema: TObject<P>, keys: K): TObject<Pick<P, K[number]>>;
declare function tOmit<P extends Record<string, AnySchema>, const K extends readonly (keyof P)[]>(schema: TObject<P>, keys: K): TObject<Omit<P, K[number]>>;
declare function tComposite<const E extends readonly TObject<Record<string, AnySchema>>[]>(schemas: E, opts?: ObjectOpts): TTyped<UnionToIntersection<Static<E[number]>>>;
declare function tUnsafe<T = unknown>(_jsonSchema?: Record<string, unknown>): TUnsafe<T>;
export declare const Type: {
    readonly String: typeof tString;
    readonly Number: (opts?: NumberOpts) => TNumber;
    readonly Integer: (opts?: NumberOpts) => TNumber;
    readonly Boolean: (opts?: Meta) => CompatRuntime<boolean>;
    readonly Null: (opts?: Meta) => CompatRuntime<null>;
    readonly Any: (opts?: Meta) => CompatRuntime<unknown>;
    readonly Unknown: (opts?: Meta) => CompatRuntime<unknown>;
    readonly Never: typeof tNever;
    readonly Literal: typeof tLiteral;
    readonly Union: typeof tUnion;
    readonly Intersect: typeof tIntersect;
    readonly Enum: typeof tEnum;
    readonly Array: typeof tArray;
    readonly Tuple: typeof tTuple;
    readonly Object: typeof tObject;
    readonly Record: typeof tRecord;
    readonly Optional: typeof tOptional;
    readonly Nullable: typeof tNullable;
    readonly Readonly: <E extends AnySchema>(schema: E) => TReadonly<E>;
    readonly Partial: typeof tPartial;
    readonly Required: typeof tRequired;
    readonly Pick: typeof tPick;
    readonly Omit: typeof tOmit;
    readonly Composite: typeof tComposite;
    readonly Unsafe: typeof tUnsafe;
};
export type TypeBuilder = typeof Type;
declare const _default: {
    Type: {
        readonly String: typeof tString;
        readonly Number: (opts?: NumberOpts) => TNumber;
        readonly Integer: (opts?: NumberOpts) => TNumber;
        readonly Boolean: (opts?: Meta) => CompatRuntime<boolean>;
        readonly Null: (opts?: Meta) => CompatRuntime<null>;
        readonly Any: (opts?: Meta) => CompatRuntime<unknown>;
        readonly Unknown: (opts?: Meta) => CompatRuntime<unknown>;
        readonly Never: typeof tNever;
        readonly Literal: typeof tLiteral;
        readonly Union: typeof tUnion;
        readonly Intersect: typeof tIntersect;
        readonly Enum: typeof tEnum;
        readonly Array: typeof tArray;
        readonly Tuple: typeof tTuple;
        readonly Object: typeof tObject;
        readonly Record: typeof tRecord;
        readonly Optional: typeof tOptional;
        readonly Nullable: typeof tNullable;
        readonly Readonly: <E extends AnySchema>(schema: E) => TReadonly<E>;
        readonly Partial: typeof tPartial;
        readonly Required: typeof tRequired;
        readonly Pick: typeof tPick;
        readonly Omit: typeof tOmit;
        readonly Composite: typeof tComposite;
        readonly Unsafe: typeof tUnsafe;
    };
};
export default _default;