import { z, ZodEnum, ZodNumber, ZodObject, ZodType } from "zod/v4";
export type { ZodArray, ZodType, ZodIntersection, ZodObject, ZodEnum } from "zod/v4";
export type ZodAnyUnionType = z.ZodUnion<any> | z.ZodDiscriminatedUnion<any>;
type ZodNumberConstraints = {
    min?: number;
    max?: number;
    isInt: boolean;
};
export declare enum ZodFirstPartyTypeKind {
    ZodAny = "any",
    ZodString = "string",
    ZodNumber = "number",
    ZodBigInt = "bigint",
    ZodLiteral = "literal",
    ZodBoolean = "boolean",
    ZodDate = "date",
    ZodEnum = "enum",
    ZodUnion = "union",
    ZodIntersection = "intersection",
    ZodObject = "object",
    ZodLazy = "lazy",
    ZodRecord = "record",
    ZodMap = "map",
    ZodSet = "set",
    ZodArray = "array",
    ZodTuple = "tuple",
    ZodOptional = "optional",
    ZodNullable = "nullable",
    ZodDefault = "default"
}
/**
 * Zod's type is checked insted of instanceof to resolve Bun incomatibilities.
 */
export declare class ZodHelpers {
    static isZodType(i: ZodType): boolean;
    static isZodAny(i: ZodType): i is z.ZodAny;
    static isZodString(i: ZodType): i is z.ZodString;
    static isZodNumber(i: ZodType): i is z.ZodNumber;
    static isZodBigInt(i: ZodType): i is z.ZodBigInt;
    static isZodLiteral(i: ZodType): i is z.ZodLiteral<any>;
    static isZodBoolean(i: ZodType): i is z.ZodBoolean;
    static isZodDate(i: ZodType): i is z.ZodDate;
    static isZodEnum(i: ZodType): i is ZodEnum<any>;
    static isZodUnion(i: ZodType): i is z.ZodUnion<any>;
    static isZodDiscriminatedUnion(i: ZodType): i is z.ZodDiscriminatedUnion;
    static isZodIntersection(i: ZodType): i is z.ZodIntersection<any, any>;
    static isZodObject(i: ZodType): i is z.ZodObject<any>;
    static isZodLazy(i: ZodType): i is z.ZodLazy<any>;
    static isZodRecord(i: ZodType): i is z.ZodRecord<any, any>;
    static isZodMap(i: ZodType): i is z.ZodMap<any, any>;
    static isZodArray(i: ZodType): i is z.ZodArray<any>;
    static isZodSet(i: ZodType): i is z.ZodSet<any>;
    static isZodTuple(i: ZodType): i is z.ZodTuple<any>;
    static isZodOptional(i: ZodType): i is z.ZodOptional<any>;
    static isZodNullable(i: ZodType): i is z.ZodNullable<any>;
    static isZodDefault(i: ZodType): i is z.ZodDefault<any>;
    static isZodAnyUnionType(i: ZodType): i is z.ZodUnion<any> | z.ZodDiscriminatedUnion<readonly z.core.$ZodType<unknown, unknown>[]>;
    static isZodAnyNumberType(i: ZodType): i is z.ZodNumber | z.ZodBigInt;
    static isZodAnyMapType(i: ZodType): i is z.ZodRecord<any, any> | z.ZodMap<any, any>;
    /**
     * Complex types that shall always be transpiled, which output would be a type, or alias if
     * redefined using layered modeling.
     * @param zodType
     * @returns
     */
    static isTranspilerableZodType(zodType: string | ZodType): boolean;
    /**
     * Primitive types that can only be transpiled if defined using layered modeling, which output
     * would be a type alias.
     * @param zodType
     * @param onlyArray Array types are always transpiled as alias in layered modeling.
     * @returns
     */
    static isTranspilerableAliasedZodType(zodType: string | ZodType, onlyArray?: boolean): boolean;
    static cloneZod(i: ZodType): z.ZodType<unknown, unknown>;
    static createZodObject(properties: Map<string, ZodType>): ZodObject<any>;
    static getZodNumberConstraints(i: ZodNumber | z.ZodBigInt): ZodNumberConstraints;
}