import { type Type } from "./type.js";
interface OptionalSchemaMarker {
    readonly _optional: true;
}
interface RefineOptions {
    message?: string;
    error?: string;
}
export interface SuperRefineIssue {
    code?: string;
    path?: PropertyKey[];
    message: string;
    actual?: unknown;
}
export interface SuperRefineContext {
    addIssue(issue: SuperRefineIssue): void;
}
export interface ZodLikeIssue {
    path: PropertyKey[];
    message: string;
}
export type ZodLikeSafeParseResult<Out> = {
    success: true;
    data: Out;
} | {
    success: false;
    error: {
        message: string;
        issues: ZodLikeIssue[];
    };
};
/** A callable omptype schema carrying the Zod-v4-style fluent surface. */
export interface ZodLikeSchema<out Out> extends Type<Out, unknown> {
    readonly _output: Out;
    /** @internal Used while composing object property IR. */
    readonly isOptional: boolean;
    parse(value: unknown): Out;
    safeParse(value: unknown): ZodLikeSafeParseResult<Out>;
    min(bound: number): ZodLikeSchema<Out>;
    max(bound: number): ZodLikeSchema<Out>;
    int(): ZodLikeSchema<Out>;
    positive(): ZodLikeSchema<Out>;
    nonnegative(): ZodLikeSchema<Out>;
    regex(expression: RegExp, message?: string): ZodLikeSchema<Out>;
    url(): ZodLikeSchema<Out>;
    optional(): ZodLikeSchema<Out | undefined> & OptionalSchemaMarker;
    nullable(): ZodLikeSchema<Out | null>;
    default(value: Exclude<Out, undefined> | (() => Exclude<Out, undefined>)): ZodLikeSchema<Exclude<Out, undefined>>;
    describe(description: string): ZodLikeSchema<Out>;
    refine(predicate: (value: Out) => unknown, messageOrOptions?: string | RefineOptions): ZodLikeSchema<Out>;
    superRefine(refinement: (value: Out, ctx: SuperRefineContext) => void): ZodLikeSchema<Out>;
    trim(): ZodLikeSchema<Out>;
    transform<Next>(transformer: (value: Out) => Next): ZodLikeSchema<Next>;
    catch(fallback: Out | (() => Out)): ZodLikeSchema<Out>;
    strict(): ZodLikeSchema<Out>;
    passthrough(): ZodLikeSchema<Out & Record<string, unknown>>;
    strip(): ZodLikeSchema<Out>;
    partial(): Out extends object ? ZodLikeSchema<Partial<Out>> : ZodLikeSchema<Out>;
}
export type infer<T> = T extends {
    readonly _output: infer Out;
} ? Out : never;
type SchemaOutput<Schema> = Schema extends {
    readonly _output: infer Out;
} ? Out : never;
type Shape = Readonly<Record<string, ZodLikeSchema<unknown>>>;
type ObjectOutput<S extends Shape> = {
    -readonly [K in keyof S as S[K] extends OptionalSchemaMarker ? never : K]: SchemaOutput<S[K]>;
} & {
    -readonly [K in keyof S as S[K] extends OptionalSchemaMarker ? K : never]?: SchemaOutput<S[K]>;
};
type Simplify<T> = {
    [K in keyof T]: T[K];
};
type UnionOutput<Schemas extends readonly ZodLikeSchema<unknown>[]> = SchemaOutput<Schemas[number]>;
export declare const string: () => ZodLikeSchema<string>;
export declare const number: () => ZodLikeSchema<number>;
export declare const boolean: () => ZodLikeSchema<boolean>;
export declare const literal: <const Value>(value: Value) => ZodLikeSchema<Value>;
declare const enumSchema: <const Values extends readonly [string, ...string[]]>(values: Values) => ZodLikeSchema<Values[number]>;
export { enumSchema as enum };
export declare const union: <const Schemas extends readonly [ZodLikeSchema<unknown>, ZodLikeSchema<unknown>, ...ZodLikeSchema<unknown>[]]>(schemas: Schemas) => ZodLikeSchema<UnionOutput<Schemas>>;
export declare const array: <Element>(element: ZodLikeSchema<Element>) => ZodLikeSchema<Element[]>;
export declare const object: <const S extends Shape>(shape: S) => ZodLikeSchema<Simplify<ObjectOutput<S>>>;
export declare function record<Key extends string, Value>(keySchema: ZodLikeSchema<Key>, valueSchema: ZodLikeSchema<Value>): ZodLikeSchema<Record<string, Value>>;
export declare function record<Value>(valueSchema: ZodLikeSchema<Value>): ZodLikeSchema<Record<string, Value>>;
export declare const unknown: () => ZodLikeSchema<unknown>;
export declare const any: () => ZodLikeSchema<unknown>;
declare const nullSchema: () => ZodLikeSchema<null>;
declare const undefinedSchema: () => ZodLikeSchema<undefined>;
export { nullSchema as null, undefinedSchema as undefined };
/** Runtime `z.*` facade, merged with the `z.infer` type namespace below. */
export declare const z: {
    string: typeof string;
    number: typeof number;
    boolean: typeof boolean;
    literal: typeof literal;
    enum: typeof enumSchema;
    union: typeof union;
    array: typeof array;
    object: typeof object;
    record: typeof record;
    unknown: typeof unknown;
    any: typeof any;
    null: typeof nullSchema;
    undefined: typeof undefinedSchema;
};
export declare namespace z {
    type infer<Schema> = Schema extends {
        readonly _output: infer Out;
    } ? Out : never;
}