import { JSONSchema7 } from 'json-schema';
export { JSONSchema7 } from 'json-schema';

declare const zuiKey$1: "x-zui";

type NoUndefined<T> = T extends undefined ? never : T;
type Satisfies<X extends Y, Y> = X;
type Cast<A, B> = A extends B ? A : B;
type Writeable<T> = {
    -readonly [P in keyof T]: T[P];
};
type _UnionToIntersectionFn<T> = (T extends unknown ? (k: () => T) => void : never) extends (k: infer Intersection) => void ? Intersection : never;
type _GetUnionLast<T> = _UnionToIntersectionFn<T> extends () => infer Last ? Last : never;
type UnionToTuple<T, Tuple extends unknown[] = []> = [T] extends [never] ? Tuple : UnionToTuple<Exclude<T, _GetUnionLast<T>>, [_GetUnionLast<T>, ...Tuple]>;
type _OptionalKeys<T extends object> = {
    [k in keyof T]: undefined extends T[k] ? k : never;
}[keyof T];
type _RequiredKeys<T extends object> = {
    [k in keyof T]: undefined extends T[k] ? never : k;
}[keyof T];
type AddQuestionMarks<T extends object, R extends keyof T = _RequiredKeys<T>, O extends keyof T = _OptionalKeys<T>> = Pick<T, R> & Partial<Pick<T, O>> & {
    [k in keyof T]?: unknown;
};
type Identity<T> = T;
type Flatten<T> = Identity<{
    [k in keyof T]: T[k];
}>;
type _NoNeverKeys<T> = {
    [k in keyof T]: [T[k]] extends [never] ? never : k;
}[keyof T];
type NoNever<T> = Identity<{
    [k in _NoNeverKeys<T>]: k extends keyof T ? T[k] : never;
}>;
type ExtendShape<A, B> = Flatten<Omit<A, keyof B> & B>;

type ZuiMetadata = string | number | boolean | null | undefined | ZuiMetadata[] | {
    [key: string]: ZuiMetadata;
};
type ZuiExtensionObject = {
    tooltip?: boolean;
    displayAs?: [string, ZuiMetadata];
    title?: string;
    disabled?: boolean | string;
    hidden?: boolean | string;
    placeholder?: string;
    secret?: boolean;
    coerce?: boolean;
    [key: string]: ZuiMetadata;
};
type BaseDisplayAsType = 'number' | 'string' | 'boolean' | 'object' | 'array' | 'discriminatedUnion';
type UIComponentDefinitions = {
    [T in BaseDisplayAsType]: {
        [K: string]: {
            id: string;
            params: IZodObject;
        };
    };
};
type ZodKindToBaseType<U extends ZodTypeDef> = U extends ZodStringDef ? 'string' : U extends ZodNumberDef ? 'number' : U extends ZodBooleanDef ? 'boolean' : U extends ZodArrayDef ? 'array' : U extends ZodObjectDef ? 'object' : U extends ZodTupleDef ? never : U extends ZodEnumDef ? 'string' : U extends ZodDefaultDef ? ZodKindToBaseType<U['innerType']['_def']> : U extends ZodOptionalDef ? ZodKindToBaseType<U['innerType']['_def']> : U extends ZodNullableDef ? ZodKindToBaseType<U['innerType']['_def']> : U extends ZodDiscriminatedUnionDef ? 'discriminatedUnion' : never;
type DisplayAsOptions<U> = U extends {
    id: string;
    params: IZodObject;
} ? {
    id: U['id'];
    params: TypeOf<U['params']>;
} : object;
type ErrMessage = string | {
    message?: string;
};
type ZodInvalidTypeIssue = {
    code: 'invalid_type';
    expected: ZodParsedType;
    received: ZodParsedType;
};
type ZodInvalidLiteralIssue = {
    code: 'invalid_literal';
    expected: unknown;
    received: unknown;
};
type ZodUnrecognizedKeysIssue = {
    code: 'unrecognized_keys';
    keys: string[];
};
type ZodInvalidUnionIssue = {
    code: 'invalid_union';
    unionErrors: IZodError[];
};
type ZodInvalidUnionDiscriminatorIssue = {
    code: 'invalid_union_discriminator';
    options: Primitive[];
};
type ZodInvalidEnumValueIssue = {
    received: string | number;
    code: 'invalid_enum_value';
    options: (string | number)[];
};
type ZodInvalidArgumentsIssue = {
    code: 'invalid_arguments';
    argumentsError: IZodError;
};
type ZodInvalidReturnTypeIssue = {
    code: 'invalid_return_type';
    returnTypeError: IZodError;
};
type ZodInvalidDateIssue = {
    code: 'invalid_date';
};
type ZodInvalidStringIssue = {
    code: 'invalid_string';
    validation: 'email' | 'url' | 'emoji' | 'uuid' | 'regex' | 'cuid' | 'cuid2' | 'ulid' | 'datetime' | 'ip' | {
        includes: string;
        position?: number;
    } | {
        startsWith: string;
    } | {
        endsWith: string;
    };
};
type ZodTooSmallIssue = {
    code: 'too_small';
    minimum: number | bigint;
    inclusive: boolean;
    exact?: boolean;
    type: 'array' | 'string' | 'number' | 'set' | 'date' | 'bigint';
};
type ZodTooBigIssue = {
    code: 'too_big';
    maximum: number | bigint;
    inclusive: boolean;
    exact?: boolean;
    type: 'array' | 'string' | 'number' | 'set' | 'date' | 'bigint';
};
type ZodInvalidIntersectionTypesIssue = {
    code: 'invalid_intersection_types';
};
type ZodNotMultipleOfIssue = {
    code: 'not_multiple_of';
    multipleOf: number | bigint;
};
type ZodNotFiniteIssue = {
    code: 'not_finite';
};
type ZodUnresolvedReferenceIssue = {
    code: 'unresolved_reference';
};
type ZodCustomIssue = {
    code: 'custom';
    params?: {
        [k: string]: unknown;
    };
};
type ZodIssueBody = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodUnresolvedReferenceIssue | ZodCustomIssue;
type ZodIssue = ZodIssueBody & {
    path: (string | number)[];
    fatal?: boolean;
    message: string;
};
type CustomErrorParams = Partial<{
    path: (string | number)[];
    message: string;
    params: {
        [k: string]: unknown;
    };
}>;
type _RecursiveZodFormattedError<T> = T extends [any, ...any[]] ? {
    [K in keyof T]?: ZodFormattedError<T[K]>;
} : T extends any[] ? {
    [k: number]: ZodFormattedError<T[number]>;
} : T extends object ? {
    [K in keyof T]?: ZodFormattedError<T[K]>;
} : unknown;
type ZodFormattedError<T, U = string> = {
    _errors: U[];
} & _RecursiveZodFormattedError<NonNullable<T>>;
interface IZodError<T = unknown> extends Error {
    readonly __type__: 'ZuiError';
    issues: ZodIssue[];
    errors: ZodIssue[];
    format(): ZodFormattedError<T>;
    format<U>(mapper: (issue: ZodIssue) => U): ZodFormattedError<T, U>;
    toString(): string;
    message: string;
    isEmpty: boolean;
    addIssue: (sub: ZodIssue) => void;
    addIssues: (subs?: ZodIssue[]) => void;
}
type IssueData = EffectIssue & {
    path?: (string | number)[];
    fatal?: boolean;
    message?: string;
};
type ZodErrorMap = (issue: ZodIssueBody & {
    path: (string | number)[];
    message?: string;
}, ctx: {
    defaultError: string;
    data: any;
}) => {
    message: string;
};
type ZodParsedType = 'string' | 'nan' | 'number' | 'integer' | 'float' | 'boolean' | 'date' | 'bigint' | 'symbol' | 'function' | 'undefined' | 'null' | 'array' | 'object' | 'unknown' | 'promise' | 'void' | 'never' | 'map' | 'set';
type ParseContext = {
    common: {
        issues: ZodIssue[];
        contextualErrorMap?: ZodErrorMap;
        async: boolean;
    };
    schemaErrorMap?: ZodErrorMap;
    parsedType: ZodParsedType;
    data: any;
    path: (string | number)[];
    parent: ParseContext | null;
};
type ParseInput = {
    data: any;
    path: (string | number)[];
    parent: ParseContext;
};
type InvalidParseReturnType = {
    status: 'aborted';
};
type DirtyParseReturnType<T = any> = {
    status: 'dirty';
    value: T;
};
type ValidParseReturnType<T = any> = {
    status: 'valid';
    value: T;
};
type SyncParseReturnType<T = any> = ValidParseReturnType<T> | DirtyParseReturnType<T> | InvalidParseReturnType;
type AsyncParseReturnType<T = any> = Promise<SyncParseReturnType<T>>;
type ParseReturnType<T = any> = SyncParseReturnType<T> | AsyncParseReturnType<T>;
type SafeParseSuccess<Output> = {
    success: true;
    data: Output;
    error?: never;
};
type SafeParseError<Input> = {
    success: false;
    error: IZodError<Input>;
    data?: never;
};
type SafeParseReturnType<Input, Output> = SafeParseSuccess<Output> | SafeParseError<Input>;
type ParseParams = {
    path: (string | number)[];
    errorMap: ZodErrorMap;
    async: boolean;
};
/**
 * @deprecated use upstream and downstream instead which handle issues with a better semantic
 */
type RefinementCtx = {
    /**
     * @deprecated use upstream and downstream instead which handle issues with a better semantic
     */
    addIssue: (arg: IssueData) => void;
    path: (string | number)[];
};
type ZodCreateParams = {
    errorMap?: ZodErrorMap;
    invalid_type_error?: string;
    required_error?: string;
    description?: string;
    ['x-zui']?: ZuiExtensionObject;
} | undefined;
type TypeOf<T extends IZodType> = T['_output'];

type input<T extends IZodType> = T['_input'];
type output<T extends IZodType> = T['_output'];
type DeepPartialBoolean<T> = {
    [K in keyof T]?: T[K] extends object ? DeepPartialBoolean<T[K]> | boolean : boolean;
};
type ZodTypeDef = {
    typeName: string;
    errorMap?: ZodErrorMap;
    description?: string;
    ['x-zui']?: ZuiExtensionObject;
};
type ZodTypeAny = IZodType<any, any, any>;
/**
 * @deprecated use ZodType instead
 */
type ZodSchema<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> = IZodType<Output, Def, Input>;
/**
 * @deprecated use ZodType instead
 */
type Schema$1<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> = IZodType<Output, Def, Input>;
interface IZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {
    readonly __type__: 'ZuiType';
    _type: Output;
    _output: Output;
    _input: Input;
    _def: Def;
    _parse(input: ParseInput): ParseReturnType<Output>;
    _parseAsync(input: ParseInput): AsyncParseReturnType<Output>;
    _parseSync(input: ParseInput): SyncParseReturnType<Output>;
    description: string | undefined;
    typeName: Def['typeName'];
    /** deeply replace all references in the schema */
    dereference(_defs: Record<string, IZodType>): IZodType;
    /** deeply scans the schema to check if it contains references */
    getReferences(): string[];
    clone(): IZodType<Output, Def, Input>;
    parse(data: unknown, params?: Partial<ParseParams>): Output;
    safeParse(data: unknown, params?: Partial<ParseParams>): SafeParseReturnType<Input, Output>;
    parseAsync(data: unknown, params?: Partial<ParseParams>): Promise<Output>;
    safeParseAsync(data: unknown, params?: Partial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
    /** Alias of safeParseAsync */
    spa: (data: unknown, params?: Partial<ParseParams>) => Promise<SafeParseReturnType<Input, Output>>;
    refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): IZodEffects<this, RefinedOutput, Input>;
    refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): IZodEffects<this, Output, Input>;
    /**
     * @deprecated use downstream instead which handle issues with a better semantic
     */
    superRefine<RefinedOutput extends Output>(refinement: (arg: Output, ctx: RefinementCtx) => arg is RefinedOutput): IZodEffects<this, RefinedOutput, Input>;
    /**
     * @deprecated use downstream instead which handle issues with a better semantic
     */
    superRefine(refinement: (arg: Output, ctx: RefinementCtx) => void): IZodEffects<this, Output, Input>;
    /**
     * @deprecated use downstream instead which handle issues with a better semantic
     */
    superRefine(refinement: (arg: Output, ctx: RefinementCtx) => Promise<void>): IZodEffects<this, Output, Input>;
    optional(): IZodOptional<this>;
    nullable(): IZodNullable<this>;
    nullish(): IZodOptional<IZodNullable<this>>;
    array(): IZodArray<this>;
    promise(): IZodPromise<this>;
    /**
     * # \#\#\# Experimental \#\#\#
     *
     * @experimental This function is experimental and is subject to breaking changes in the future.
     *
     * Would have been named `required` but a method with that name already exists in ZodObject.
     * Makes the schema required; i.e. not optional or undefined. If the schema is already required than it returns itself.
     * Null is not considered optional and remains unchanged.
     *
     * @example z.string().optional().mandatory() // z.string()
     * @example z.string().nullable().mandatory() // z.string().nullable()
     * @example z.string().or(z.undefined()).mandatory() // z.string()
     * @example z.union([z.string(), z.number(), z.undefined()]).mandatory() // z.union([z.string(), z.number()])
     */
    mandatory(): IZodType;
    or<T extends IZodType>(option: T): IZodUnion<[this, T]>;
    and<T extends IZodType>(incoming: T): IZodIntersection<this, T>;
    transform<NewOut>(transform: (arg: Output, ctx: RefinementCtx) => NewOut | Promise<NewOut>): IZodEffects<this, NewOut>;
    downstream<NewOut>(fn: (output: Output, ctx: EffectContext) => EffectReturnType<NewOut> | Promise<EffectReturnType<NewOut> | undefined> | undefined, params?: {
        failFast?: boolean;
    }): IZodEffects<this, NewOut>;
    default(def: NoUndefined<Input>): IZodDefault<this>;
    default(def: () => NoUndefined<Input>): IZodDefault<this>;
    brand<B extends string | number | symbol>(brand?: B): IZodBranded<this, B>;
    catch(def: Output | CatchFn<Output>): IZodCatch<this>;
    describe(description: string): this;
    pipe<T extends IZodType>(target: T): IZodPipeline<this, T>;
    readonly(): IZodReadonly<this>;
    isOptional(): boolean;
    isNullable(): boolean;
    /** append metadata to the schema */
    metadata(data: Record<string, ZuiMetadata>): this;
    /** metadataf the schema */
    getMetadata(): Record<string, ZuiMetadata>;
    /** set metadata of the schema */
    setMetadata(data: Record<string, ZuiMetadata>): void;
    /**
     * metadataf the schema
     * @deprecated use `getMetadata()` instead
     */
    ui: Record<string, ZuiMetadata>;
    /**
     * The title of the field. Defaults to the field name.
     */
    title(title: string): this;
    /**
     * Whether the field is hidden in the UI. Useful for internal fields.
     * @default false
     */
    hidden<T = this['_output']>(value?: boolean | ((shape: T | null) => DeepPartialBoolean<T> | boolean)): this;
    /**
     * Whether the field is disabled
     * @default false
     */
    disabled<T = this['_output']>(value?: boolean | ((shape: T | null) => DeepPartialBoolean<T> | boolean)): this;
    /**
     * Placeholder text for the field
     */
    placeholder(placeholder: string): this;
    /**
     * Some Schemas aren't meant to contain metadata, like ZodDefault.
     * In a zui construction like `z.string().default('hello').title('Hello')`, the user's intention is usually to set a title on the string, not on the default value.
     * Also, in JSON-Schema, default is not a data-type like it is in Zui, but an annotation added on the schema itself. Therefore, only one metadata can apply to both the schema and the default value.
     * This property is used to theoot schema that should contain the metadata.
     *
     * TLDR: Allows removing all wrappers around the schema
     * @returns either this or the closest children schema that represents the actual data
     */
    naked(): IZodType;
    /** checks if a schema is equal to another */
    isEqual(schema: IZodType): boolean;
    /**
     * The type of component to use to display the field and its options
     */
    displayAs<UI extends UIComponentDefinitions = UIComponentDefinitions, Type extends BaseDisplayAsType = ZodKindToBaseType<this['_def']>>(options: DisplayAsOptions<UI[Type][keyof UI[Type]]>): this;
    /**
     *
     * @returns a JSON Schema equivalent to the Zui schema
     */
    toJSONSchema(opts?: Partial<JSONSchemaGenerationOptions>): Schema;
    /**
     * @param options generation options
     * @returns a string of the TypeScript type representing the schema
     */
    toTypescriptType(opts?: Partial<TypescriptGenerationOptions>): string;
    /**
     *
     * @param options generation options
     * @returns a typescript program (a string) that would construct the given schema if executed
     */
    toTypescriptSchema(): string;
}
type ZodAnyDef = {
    typeName: 'ZodAny';
} & ZodTypeDef;
interface IZodAny extends IZodType<any, ZodAnyDef> {
}
type ZodArrayDef<T extends IZodType = IZodType> = {
    type: T;
    typeName: 'ZodArray';
    exactLength: {
        value: number;
        message?: string;
    } | null;
    minLength: {
        value: number;
        message?: string;
    } | null;
    maxLength: {
        value: number;
        message?: string;
    } | null;
} & ZodTypeDef;
type ArrayCardinality = 'many' | 'atleastone';
type ArrayOutputType<T extends IZodType, Cardinality extends ArrayCardinality = 'many'> = Cardinality extends 'atleastone' ? [T['_output'], ...T['_output'][]] : T['_output'][];
interface IZodArray<T extends IZodType = IZodType, Cardinality extends ArrayCardinality = 'many'> extends IZodType<ArrayOutputType<T, Cardinality>, ZodArrayDef<T>, Cardinality extends 'atleastone' ? [T['_input'], ...T['_input'][]] : T['_input'][]> {
    element: T;
    min(minLength: number, message?: ErrMessage): this;
    max(maxLength: number, message?: ErrMessage): this;
    length(len: number, message?: ErrMessage): this;
    nonempty(message?: ErrMessage): IZodArray<T, 'atleastone'>;
}
type ZodBigIntCheck = {
    kind: 'min';
    value: bigint;
    inclusive: boolean;
    message?: string;
} | {
    kind: 'max';
    value: bigint;
    inclusive: boolean;
    message?: string;
} | {
    kind: 'multipleOf';
    value: bigint;
    message?: string;
};
type ZodBigIntDef = {
    checks: ZodBigIntCheck[];
    typeName: 'ZodBigInt';
    coerce: boolean;
} & ZodTypeDef;
interface IZodBigInt extends IZodType<bigint, ZodBigIntDef> {
    gte(value: bigint, message?: ErrMessage): IZodBigInt;
    min: (value: bigint, message?: ErrMessage) => IZodBigInt;
    gt(value: bigint, message?: ErrMessage): IZodBigInt;
    lte(value: bigint, message?: ErrMessage): IZodBigInt;
    max: (value: bigint, message?: ErrMessage) => IZodBigInt;
    lt(value: bigint, message?: ErrMessage): IZodBigInt;
    positive(message?: ErrMessage): IZodBigInt;
    negative(message?: ErrMessage): IZodBigInt;
    nonpositive(message?: ErrMessage): IZodBigInt;
    nonnegative(message?: ErrMessage): IZodBigInt;
    multipleOf(value: bigint, message?: ErrMessage): IZodBigInt;
    minValue: bigint | null;
    maxValue: bigint | null;
}
type ZodBooleanDef = {
    typeName: 'ZodBoolean';
    coerce: boolean;
} & ZodTypeDef;
interface IZodBoolean extends IZodType<boolean, ZodBooleanDef> {
}
type _Key = string | number | symbol;
type ZodBrandedDef<T extends IZodType = IZodType> = {
    type: T;
    typeName: 'ZodBranded';
} & ZodTypeDef;
declare const BRAND: unique symbol;
type BRAND<T extends _Key = _Key> = {
    [BRAND]: {
        [k in T]: true;
    };
};
interface IZodBranded<T extends IZodType = IZodType, B extends _Key = _Key> extends IZodType<T['_output'] & BRAND<B>, ZodBrandedDef<T>, T['_input']> {
    unwrap(): T;
}
type CatchFn<Y> = (ctx: {
    error: IZodError;
    input: unknown;
}) => Y;
type ZodCatchDef<T extends IZodType = IZodType> = {
    innerType: T;
    catchValue: CatchFn<T['_output']>;
    typeName: 'ZodCatch';
} & ZodTypeDef;
interface IZodCatch<T extends IZodType = IZodType> extends IZodType<T['_output'], ZodCatchDef<T>, unknown> {
    removeCatch(): T;
}
type ZodDateCheck = {
    kind: 'min';
    value: number;
    message?: string;
} | {
    kind: 'max';
    value: number;
    message?: string;
};
type ZodDateDef = {
    checks: ZodDateCheck[];
    coerce: boolean;
    typeName: 'ZodDate';
} & ZodTypeDef;
interface IZodDate extends IZodType<Date, ZodDateDef> {
    min(minDate: Date, message?: ErrMessage): IZodDate;
    max(maxDate: Date, message?: ErrMessage): IZodDate;
    minDate: Date | null;
    maxDate: Date | null;
}
type ZodDefaultDef<T extends IZodType = IZodType> = {
    innerType: T;
    defaultValue: () => NoUndefined<T['_input']>;
    typeName: 'ZodDefault';
} & ZodTypeDef;
interface IZodDefault<T extends IZodType = IZodType> extends IZodType<NoUndefined<T['_output']>, ZodDefaultDef<T>, T['_input'] | undefined> {
    removeDefault(): T;
    unwrap(): T;
}
type EnumValues = [string, ...string[]];
type EnumValuesMap<T extends EnumValues> = {
    [k in T[number]]: k;
};
type ZodEnumDef<T extends EnumValues = EnumValues> = {
    values: T;
    typeName: 'ZodEnum';
} & ZodTypeDef;
type FilterEnum<Values, ToExclude> = Values extends [] ? [] : Values extends [infer Head, ...infer Rest] ? Head extends ToExclude ? FilterEnum<Rest, ToExclude> : [Head, ...FilterEnum<Rest, ToExclude>] : never;
type NeverCast<A, T> = A extends T ? A : never;
interface IZodEnum<T extends [string, ...string[]] = [string, ...string[]]> extends IZodType<T[number], ZodEnumDef<T>> {
    options: T;
    enum: EnumValuesMap<T>;
    /** @deprecated use .enum instead */
    Values: EnumValuesMap<T>;
    /** @deprecated use .enum instead */
    Enum: EnumValuesMap<T>;
    extract<ToExtract extends readonly [T[number], ...T[number][]]>(values: ToExtract, newDef?: ZodCreateParams): IZodEnum<Writeable<ToExtract>>;
    exclude<ToExclude extends readonly [T[number], ...T[number][]]>(values: ToExclude, newDef?: ZodCreateParams): IZodEnum<NeverCast<Writeable<FilterEnum<T, ToExclude[number]>>, [string, ...string[]]>>;
}
type ZodNeverDef = {
    typeName: 'ZodNever';
} & ZodTypeDef;
interface IZodNever extends IZodType<never, ZodNeverDef> {
}
type ZodNullableDef<T extends IZodType = IZodType> = {
    innerType: T;
    typeName: 'ZodNullable';
} & ZodTypeDef;
interface IZodNullable<T extends IZodType = IZodType> extends IZodType<T['_output'] | null, ZodNullableDef<T>, T['_input'] | null> {
    unwrap(): T;
}
type ZodOptionalDef<T extends IZodType = IZodType> = {
    innerType: T;
    typeName: 'ZodOptional';
} & ZodTypeDef;
interface IZodOptional<T extends IZodType = IZodType> extends IZodType<T['_output'] | undefined, ZodOptionalDef<T>, T['_input'] | undefined> {
    unwrap(): T;
}
type ZodTupleItems = [IZodType, ...IZodType[]];
type AssertArray<T> = T extends any[] ? T : never;
type OutputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
    [k in keyof T]: T[k] extends ZodTypeAny ? T[k]['_output'] : never;
}>;
type OutputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends IZodType | null = null> = Rest extends IZodType ? [...OutputTypeOfTuple<T>, ...Rest['_output'][]] : OutputTypeOfTuple<T>;
type InputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
    [k in keyof T]: T[k] extends ZodTypeAny ? T[k]['_input'] : never;
}>;
type InputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends IZodType | null = null> = Rest extends IZodType ? [...InputTypeOfTuple<T>, ...Rest['_input'][]] : InputTypeOfTuple<T>;
type ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends IZodType | null = null> = {
    items: T;
    rest: Rest;
    typeName: 'ZodTuple';
} & ZodTypeDef;
type AnyZodTuple = IZodTuple<[IZodType, ...IZodType[]] | [], IZodType | null>;
interface IZodTuple<T extends [IZodType, ...IZodType[]] | [] = [IZodType, ...IZodType[]] | [], Rest extends IZodType | null = IZodType | null> extends IZodType<OutputTypeOfTupleWithRest<T, Rest>, ZodTupleDef<T, Rest>, InputTypeOfTupleWithRest<T, Rest>> {
    items: T;
    rest<Rest extends IZodType>(rest: Rest): IZodTuple<T, Rest>;
}
type ZodRawShape = {
    [k: string]: IZodType;
};
type UnknownKeysParam = 'passthrough' | 'strict' | 'strip' | IZodType;
type ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = {
    typeName: 'ZodObject';
    shape: () => T;
    unknownKeys: UnknownKeys;
} & ZodTypeDef;
type ObjectOutputType<Shape extends ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = UnknownKeysOutputType<UnknownKeys> & Flatten<AddQuestionMarks<BaseObjectOutputType<Shape>>>;
type BaseObjectOutputType<Shape extends ZodRawShape> = {
    [k in keyof Shape]: Shape[k]['_output'];
};
type ObjectInputType<Shape extends ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = Flatten<BaseObjectInputType<Shape>> & UnknownKeysInputType<UnknownKeys>;
type BaseObjectInputType<Shape extends ZodRawShape> = AddQuestionMarks<{
    [k in keyof Shape]: Shape[k]['_input'];
}>;
type UnknownKeysInputType<T extends UnknownKeysParam> = T extends IZodType ? {
    [k: string]: T['_input'] | unknown;
} : T extends 'passthrough' ? {
    [k: string]: unknown;
} : {};
type UnknownKeysOutputType<T extends UnknownKeysParam> = T extends IZodType ? {
    [k: string]: T['_output'] | unknown;
} : T extends 'passthrough' ? {
    [k: string]: unknown;
} : {};
type AdditionalProperties<T extends UnknownKeysParam> = T extends IZodType ? T : T extends 'passthrough' ? IZodAny : T extends 'strict' ? IZodNever : undefined;
type Deoptional<T extends IZodType> = T extends IZodOptional<infer U> ? Deoptional<U> : T extends IZodNullable<infer U> ? IZodNullable<Deoptional<U>> : T;
type KeyOfObject<T extends ZodRawShape> = Cast<UnionToTuple<keyof T>, [string, ...string[]]>;
/**
 * @deprecated use ZodObject instead
 */
type SomeZodObject = IZodObject<ZodRawShape, UnknownKeysParam>;
type AnyZodObject = IZodObject<any, any>;
interface IZodObject<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Output = ObjectOutputType<T, UnknownKeys>, Input = ObjectInputType<T, UnknownKeys>> extends IZodType<Output, ZodObjectDef<T, UnknownKeys>, Input> {
    shape: T;
    strict(message?: ErrMessage): IZodObject<T, 'strict'>;
    strip(): IZodObject<T, 'strip'>;
    passthrough(): IZodObject<T, 'passthrough'>;
    /**
     * @returns The ZodType that is used to validate additional properties or undefined if extra keys are stripped.
     */
    additionalProperties(): AdditionalProperties<UnknownKeys>;
    /**
     * @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped.
     * If you want to pass through unknown properties, use `.passthrough()` instead.
     */
    nonstrict: () => IZodObject<T, 'passthrough'>;
    extend<Augmentation extends ZodRawShape>(augmentation: Augmentation): IZodObject<ExtendShape<T, Augmentation>, UnknownKeys>;
    /**
     * @deprecated Use `.extend` instead
     *  */
    augment: <Augmentation extends ZodRawShape>(augmentation: Augmentation) => IZodObject<ExtendShape<T, Augmentation>, UnknownKeys>;
    /**
     * Prior to zod@1.0.12 there was a bug in the
     * inferred type of merged objects. Please
     * upgrade if you are experiencing issues.
     */
    merge<Incoming extends AnyZodObject, Augmentation extends Incoming['shape']>(merging: Incoming): IZodObject<ExtendShape<T, Augmentation>, Incoming['_def']['unknownKeys']>;
    setKey<Key extends string, Schema extends IZodType>(key: Key, schema: Schema): IZodObject<T & {
        [k in Key]: Schema;
    }, UnknownKeys>;
    catchall<Index extends IZodType>(index: Index): IZodObject<T, Index>;
    pick<Mask extends {
        [k in keyof T]?: true;
    }>(mask: Mask): IZodObject<Pick<T, Extract<keyof T, keyof Mask>>, UnknownKeys>;
    omit<Mask extends {
        [k in keyof T]?: true;
    }>(mask: Mask): IZodObject<Omit<T, keyof Mask>, UnknownKeys>;
    partial(): IZodObject<{
        [k in keyof T]: IZodOptional<T[k]>;
    }, UnknownKeys>;
    partial<Mask extends {
        [k in keyof T]?: true;
    }>(mask: Mask): IZodObject<NoNever<{
        [k in keyof T]: k extends keyof Mask ? IZodOptional<T[k]> : T[k];
    }>, UnknownKeys>;
    required(): IZodObject<{
        [k in keyof T]: Deoptional<T[k]>;
    }, UnknownKeys>;
    required<Mask extends {
        [k in keyof T]?: true;
    }>(mask: Mask): IZodObject<NoNever<{
        [k in keyof T]: k extends keyof Mask ? Deoptional<T[k]> : T[k];
    }>, UnknownKeys>;
    keyof(): IZodEnum<KeyOfObject<T>>;
}
type ZodDiscriminatedUnionOption<Discriminator extends string> = IZodObject<{
    [key in Discriminator]: IZodType;
} & ZodRawShape, UnknownKeysParam>;
type ZodDiscriminatedUnionDef<Discriminator extends string = string, Options extends ZodDiscriminatedUnionOption<string>[] = ZodDiscriminatedUnionOption<string>[]> = {
    discriminator: Discriminator;
    options: Options;
    optionsMap: Map<Primitive, ZodDiscriminatedUnionOption<Discriminator>>;
    typeName: 'ZodDiscriminatedUnion';
} & ZodTypeDef;
interface IZodDiscriminatedUnion<Discriminator extends string = string, Options extends ZodDiscriminatedUnionOption<Discriminator>[] = ZodDiscriminatedUnionOption<Discriminator>[]> extends IZodType<output<Options[number]>, ZodDiscriminatedUnionDef<Discriminator, Options>, input<Options[number]>> {
    discriminator: Discriminator;
    options: Options;
    optionsMap: Map<Primitive, ZodDiscriminatedUnionOption<Discriminator>>;
}
type ZodUnknownDef = {
    typeName: 'ZodUnknown';
} & ZodTypeDef;
interface IZodUnknown extends IZodType<unknown, ZodUnknownDef> {
}
type ZodFunctionDef<Args extends AnyZodTuple = IZodTuple, Returns extends IZodType = IZodType> = {
    args: Args;
    returns: Returns;
    typeName: 'ZodFunction';
} & ZodTypeDef;
type OuterTypeOfFunction<Args extends AnyZodTuple, Returns extends IZodType> = Args['_input'] extends any[] ? (...args: Args['_input']) => Returns['_output'] : never;
type InnerTypeOfFunction<Args extends AnyZodTuple, Returns extends IZodType> = Args['_output'] extends any[] ? (...args: Args['_output']) => Returns['_input'] : never;
interface IZodFunction<Args extends AnyZodTuple = AnyZodTuple, Returns extends IZodType = IZodType> extends IZodType<OuterTypeOfFunction<Args, Returns>, ZodFunctionDef<Args, Returns>, InnerTypeOfFunction<Args, Returns>> {
    parameters(): Args;
    returnType(): Returns;
    args<Items extends [IZodType, ...IZodType[]] | []>(...items: Items): IZodFunction<IZodTuple<Items, IZodUnknown>, Returns>;
    returns<NewReturnType extends ZodTypeAny>(returnType: NewReturnType): IZodFunction<Args, NewReturnType>;
    implement<F extends InnerTypeOfFunction<Args, Returns>>(func: F): ReturnType<F> extends Returns['_output'] ? (...args: Args['_input']) => ReturnType<F> : OuterTypeOfFunction<Args, Returns>;
    strictImplement(func: InnerTypeOfFunction<Args, Returns>): InnerTypeOfFunction<Args, Returns>;
    validate: <F extends InnerTypeOfFunction<Args, Returns>>(func: F) => ReturnType<F> extends Returns['_output'] ? (...args: Args['_input']) => ReturnType<F> : OuterTypeOfFunction<Args, Returns>;
}
type ZodIntersectionDef<T extends IZodType = IZodType, U extends IZodType = IZodType> = {
    left: T;
    right: U;
    typeName: 'ZodIntersection';
} & ZodTypeDef;
interface IZodIntersection<T extends IZodType = IZodType, U extends IZodType = IZodType> extends IZodType<T['_output'] & U['_output'], ZodIntersectionDef<T, U>, T['_input'] & U['_input']> {
}
type ZodLazyDef<T extends IZodType = IZodType> = {
    getter: () => T;
    typeName: 'ZodLazy';
} & ZodTypeDef;
interface IZodLazy<T extends IZodType = IZodType> extends IZodType<output<T>, ZodLazyDef<T>, input<T>> {
    schema: T;
}
type Primitive = string | number | bigint | boolean | symbol | null | undefined;
type ZodLiteralDef<T extends Primitive = Primitive> = {
    value: T;
    typeName: 'ZodLiteral';
} & ZodTypeDef;
interface IZodLiteral<T extends Primitive = Primitive> extends IZodType<T, ZodLiteralDef<T>> {
    value: T;
}
type ZodMapDef<Key extends IZodType = IZodType, Value extends IZodType = IZodType> = {
    valueType: Value;
    keyType: Key;
    typeName: 'ZodMap';
} & ZodTypeDef;
interface IZodMap<Key extends IZodType = IZodType, Value extends IZodType = IZodType> extends IZodType<Map<Key['_output'], Value['_output']>, ZodMapDef<Key, Value>, Map<Key['_input'], Value['_input']>> {
    keySchema: Key;
    valueSchema: Value;
}
type ZodNaNDef = {
    typeName: 'ZodNaN';
} & ZodTypeDef;
interface IZodNaN extends IZodType<number, ZodNaNDef> {
}
type EnumLike = {
    [k: string]: string | number;
    [nu: number]: string;
};
type ZodNativeEnumDef<T extends EnumLike = EnumLike> = {
    values: T;
    typeName: 'ZodNativeEnum';
} & ZodTypeDef;
interface IZodNativeEnum<T extends EnumLike = EnumLike> extends IZodType<T[keyof T], ZodNativeEnumDef<T>> {
    enum: T;
}
type ZodNullDef = {
    typeName: 'ZodNull';
} & ZodTypeDef;
interface IZodNull extends IZodType<null, ZodNullDef> {
}
type ZodNumberCheck = {
    kind: 'min';
    value: number;
    inclusive: boolean;
    message?: string;
} | {
    kind: 'max';
    value: number;
    inclusive: boolean;
    message?: string;
} | {
    kind: 'int';
    message?: string;
} | {
    kind: 'multipleOf';
    value: number;
    message?: string;
} | {
    kind: 'finite';
    message?: string;
};
type ZodNumberDef = {
    checks: ZodNumberCheck[];
    typeName: 'ZodNumber';
    coerce: boolean;
} & ZodTypeDef;
interface IZodNumber extends IZodType<number, ZodNumberDef> {
    gte(value: number, message?: ErrMessage): IZodNumber;
    min: (value: number, message?: ErrMessage) => IZodNumber;
    gt(value: number, message?: ErrMessage): IZodNumber;
    lte(value: number, message?: ErrMessage): IZodNumber;
    max: (value: number, message?: ErrMessage) => IZodNumber;
    lt(value: number, message?: ErrMessage): IZodNumber;
    int(message?: ErrMessage): IZodNumber;
    positive(message?: ErrMessage): IZodNumber;
    negative(message?: ErrMessage): IZodNumber;
    nonpositive(message?: ErrMessage): IZodNumber;
    nonnegative(message?: ErrMessage): IZodNumber;
    multipleOf(value: number, message?: ErrMessage): IZodNumber;
    step: (value: number, message?: ErrMessage) => IZodNumber;
    finite(message?: ErrMessage): IZodNumber;
    safe(message?: ErrMessage): IZodNumber;
    minValue: number | null;
    maxValue: number | null;
    isInt: boolean;
    isFinite: boolean;
}
type ZodPipelineDef<A extends IZodType = IZodType, B extends IZodType = IZodType> = {
    in: A;
    out: B;
    typeName: 'ZodPipeline';
} & ZodTypeDef;
interface IZodPipeline<A extends IZodType = IZodType, B extends IZodType = IZodType> extends IZodType<B['_output'], ZodPipelineDef<A, B>, A['_input']> {
}
type ZodPromiseDef<T extends IZodType = IZodType> = {
    type: T;
    typeName: 'ZodPromise';
} & ZodTypeDef;
interface IZodPromise<T extends IZodType = IZodType> extends IZodType<Promise<T['_output']>, ZodPromiseDef<T>, Promise<T['_input']>> {
    unwrap(): T;
}
type _BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
    readonly [Symbol.toStringTag]: string;
} | Date | Error | Generator | Promise<unknown> | RegExp;
type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends _BuiltIn ? T : Readonly<T>;
type ZodReadonlyDef<T extends IZodType = IZodType> = {
    innerType: T;
    typeName: 'ZodReadonly';
} & ZodTypeDef;
interface IZodReadonly<T extends IZodType = IZodType> extends IZodType<MakeReadonly<T['_output']>, ZodReadonlyDef<T>, MakeReadonly<T['_input']>> {
    unwrap(): T;
}
type ZodStringCheck = {
    kind: 'min';
    value: number;
    message?: string;
} | {
    kind: 'max';
    value: number;
    message?: string;
} | {
    kind: 'length';
    value: number;
    message?: string;
} | {
    kind: 'email';
    message?: string;
} | {
    kind: 'url';
    message?: string;
} | {
    kind: 'emoji';
    message?: string;
} | {
    kind: 'uuid';
    message?: string;
} | {
    kind: 'cuid';
    message?: string;
} | {
    kind: 'includes';
    value: string;
    position?: number;
    message?: string;
} | {
    kind: 'cuid2';
    message?: string;
} | {
    kind: 'ulid';
    message?: string;
} | {
    kind: 'startsWith';
    value: string;
    message?: string;
} | {
    kind: 'endsWith';
    value: string;
    message?: string;
} | {
    kind: 'regex';
    regex: RegExp;
    message?: string;
} | {
    kind: 'trim';
    message?: string;
} | {
    kind: 'toLowerCase';
    message?: string;
} | {
    kind: 'toUpperCase';
    message?: string;
} | {
    kind: 'datetime';
    offset: boolean;
    precision: number | null;
    message?: string;
} | {
    kind: 'ip';
    version?: 'v4' | 'v6';
    message?: string;
};
type ZodStringDef = {
    checks: ZodStringCheck[];
    typeName: 'ZodString';
    coerce: boolean;
} & ZodTypeDef;
interface IZodString extends IZodType<string, ZodStringDef> {
    email(message?: ErrMessage): IZodString;
    url(message?: ErrMessage): IZodString;
    emoji(message?: ErrMessage): IZodString;
    uuid(message?: ErrMessage): IZodString;
    cuid(message?: ErrMessage): IZodString;
    cuid2(message?: ErrMessage): IZodString;
    ulid(message?: ErrMessage): IZodString;
    ip(options?: string | {
        version?: 'v4' | 'v6';
        message?: string;
    }): IZodString;
    datetime(options?: string | {
        message?: string | undefined;
        precision?: number | null;
        offset?: boolean;
    }): IZodString;
    regex(regex: RegExp, message?: ErrMessage): IZodString;
    includes(value: string, options?: {
        message?: string;
        position?: number;
    }): IZodString;
    startsWith(value: string, message?: ErrMessage): IZodString;
    endsWith(value: string, message?: ErrMessage): IZodString;
    min(minLength: number, message?: ErrMessage): IZodString;
    max(maxLength: number, message?: ErrMessage): IZodString;
    length(len: number, message?: ErrMessage): IZodString;
    /**
     * @deprecated Use z.string().min(1) instead.
     * @see {@link IZodString.min}
     */
    nonempty(message?: ErrMessage): IZodString;
    trim(): IZodString;
    secret(): this;
    toLowerCase(): IZodString;
    toUpperCase(): IZodString;
    isDatetime: boolean;
    isEmail: boolean;
    isURL: boolean;
    isEmoji: boolean;
    isUUID: boolean;
    isCUID: boolean;
    isCUID2: boolean;
    isULID: boolean;
    isIP: boolean;
    minLength: number | null;
    maxLength: number | null;
}
type ZodRecordDef<Key extends KeySchema = KeySchema, Value extends IZodType = IZodType> = {
    valueType: Value;
    keyType: Key;
    typeName: 'ZodRecord';
} & ZodTypeDef;
type KeySchema = IZodType<string | number | symbol, ZodTypeDef>;
type RecordType<K extends string | number | symbol, V> = [string] extends [K] ? Record<K, V> : [number] extends [K] ? Record<K, V> : [symbol] extends [K] ? Record<K, V> : [BRAND<string | number | symbol>] extends [K] ? Record<K, V> : Partial<Record<K, V>>;
interface IZodRecord<Key extends KeySchema = KeySchema, Value extends IZodType = IZodType> extends IZodType<RecordType<Key['_output'], Value['_output']>, ZodRecordDef<Key, Value>, RecordType<Key['_input'], Value['_input']>> {
    keySchema: Key;
    valueSchema: Value;
    element: Value;
}
type ZodRefDef = {
    typeName: 'ZodRef';
    uri: string;
} & ZodTypeDef;
interface IZodRef extends IZodType<NonNullable<unknown>, ZodRefDef> {
}
type ZodSetDef<Value extends IZodType = IZodType> = {
    valueType: Value;
    typeName: 'ZodSet';
    minSize: {
        value: number;
        message?: string;
    } | null;
    maxSize: {
        value: number;
        message?: string;
    } | null;
} & ZodTypeDef;
interface IZodSet<Value extends IZodType = IZodType> extends IZodType<Set<Value['_output']>, ZodSetDef<Value>, Set<Value['_input']>> {
    min(minSize: number, message?: ErrMessage): this;
    max(maxSize: number, message?: ErrMessage): this;
    size(size: number, message?: ErrMessage): this;
    nonempty(message?: ErrMessage): IZodSet<Value>;
}
type ZodSymbolDef = {
    typeName: 'ZodSymbol';
} & ZodTypeDef;
interface IZodSymbol extends IZodType<symbol, ZodSymbolDef> {
}
type EffectIssue = ZodIssueBody & {
    path?: (string | number)[];
    message?: string;
};
type InvalidEffectReturnType = {
    status: 'aborted';
    issues: EffectIssue[];
};
type DirtyEffectReturnType<T> = {
    status: 'dirty';
    value: T;
    issues: EffectIssue[];
};
type ValidEffectReturnType<T> = {
    status: 'valid';
    value: T;
};
type EffectReturnType<T> = InvalidEffectReturnType | DirtyEffectReturnType<T> | ValidEffectReturnType<T>;
type EffectContext = {
    path: (string | number)[];
};
type UpstreamEffect<I = unknown, O = unknown> = {
    type: 'upstream';
    effect: (arg: I, ctx: EffectContext) => EffectReturnType<O> | Promise<EffectReturnType<O> | undefined> | undefined;
};
type DownstreamEffect<I = unknown, O = unknown> = {
    type: 'downstream';
    failFast?: boolean;
    effect: (arg: I, ctx: EffectContext) => EffectReturnType<O> | Promise<EffectReturnType<O> | undefined> | undefined;
};
type Effect<I = unknown, O = unknown> = UpstreamEffect<I, O> | DownstreamEffect<I, O>;
type ZodEffectsDef<T extends IZodType = IZodType> = {
    schema: T;
    typeName: 'ZodEffects';
    effect: Effect;
} & ZodTypeDef;
interface IZodEffects<T extends IZodType = IZodType, Output = output<T>, Input = input<T>> extends IZodType<Output, ZodEffectsDef<T>, Input> {
    innerType(): T;
    /**
     * @deprecated use naked instead
     */
    sourceType(): T;
}
type ZodUndefinedDef = {
    typeName: 'ZodUndefined';
} & ZodTypeDef;
interface IZodUndefined extends IZodType<undefined, ZodUndefinedDef> {
}
type DefaultZodUnionOptions = Readonly<[IZodType, IZodType, ...IZodType[]]>;
type ZodUnionOptions = Readonly<[IZodType, ...IZodType[]]>;
type ZodUnionDef<T extends ZodUnionOptions = DefaultZodUnionOptions> = {
    options: T;
    typeName: 'ZodUnion';
} & ZodTypeDef;
interface IZodUnion<T extends ZodUnionOptions = DefaultZodUnionOptions> extends IZodType<T[number]['_output'], ZodUnionDef<T>, T[number]['_input']> {
    options: T;
}
type ZodVoidDef = {
    typeName: 'ZodVoid';
} & ZodTypeDef;
interface IZodVoid extends IZodType<void, ZodVoidDef> {
}
/**
 * @deprecated - use ZodNativeType instead
 */
type ZodFirstPartySchemaTypes = ZodNativeType;
type ZodNativeType = IZodAny | IZodArray | IZodBigInt | IZodBoolean | IZodBranded | IZodCatch | IZodDate | IZodDefault | IZodDiscriminatedUnion | IZodEnum | IZodFunction | IZodIntersection | IZodLazy | IZodLiteral | IZodMap | IZodNaN | IZodNativeEnum | IZodNever | IZodNull | IZodNullable | IZodNumber | IZodObject | IZodOptional | IZodPipeline | IZodPromise | IZodReadonly | IZodRecord | IZodRef | IZodSet | IZodString | IZodSymbol | IZodEffects | IZodTuple | IZodUndefined | IZodUnion | IZodUnknown | IZodVoid;
type ZodNativeTypeDef = ZodNativeType['_def'];
type ZodNativeTypeName = ZodNativeTypeDef['typeName'];
type CustomParams = CustomErrorParams & {
    fatal?: boolean;
};
declare function createCustom<T>(check?: (data: unknown) => unknown, params?: string | CustomParams | ((input: unknown) => CustomParams), fatal?: boolean): IZodType<T>;
declare function createInstanceOf<T extends abstract new (...args: any[]) => any>(cls: T, params?: CustomParams): IZodType<InstanceType<T>>;
declare function createAny(params?: ZodCreateParams): IZodAny;
declare function createUnknown(params?: ZodCreateParams): IZodUnknown;
declare function createNever(params?: ZodCreateParams): IZodNever;
declare function createVoid(params?: ZodCreateParams): IZodVoid;
declare function createNull(params?: ZodCreateParams): IZodNull;
declare function createUndefined(params?: ZodCreateParams): IZodUndefined;
declare function createSymbol(params?: ZodCreateParams): IZodSymbol;
declare function createNan(params?: ZodCreateParams): IZodNaN;
declare function createString(params?: ZodCreateParams & {
    coerce?: true;
}): IZodString;
declare function createNumber(params?: ZodCreateParams & {
    coerce?: boolean;
}): IZodNumber;
declare function createBoolean(params?: ZodCreateParams & {
    coerce?: boolean;
}): IZodBoolean;
declare function createBigInt(params?: ZodCreateParams & {
    coerce?: boolean;
}): IZodBigInt;
declare function createDate(params?: ZodCreateParams & {
    coerce?: boolean;
}): IZodDate;
declare function createRef(uri: string): IZodRef;
declare function createLiteral<T extends Primitive>(value: T, params?: ZodCreateParams): IZodLiteral<T>;
declare function createEnum<U extends string, T extends Readonly<[U, ...U[]]>>(values: T, params?: ZodCreateParams): IZodEnum<Writeable<T>>;
declare function createEnum<U extends string, T extends [U, ...U[]]>(values: T, params?: ZodCreateParams): IZodEnum<T>;
declare function createEnum(values: [string, ...string[]], params?: ZodCreateParams): IZodEnum<[string, ...string[]]>;
declare function createNativeEnum<T extends EnumLike>(values: T, params?: ZodCreateParams): IZodNativeEnum<T>;
declare function createArray<T extends IZodType>(schema: T, params?: ZodCreateParams): IZodArray<T>;
declare function createObject<T extends ZodRawShape>(shape: T, params?: ZodCreateParams): IZodObject<T, 'strip'>;
declare function createStrictObject<T extends ZodRawShape>(shape: T, params?: ZodCreateParams): IZodObject<T, 'strict'>;
declare function createUnion<T extends Readonly<[IZodType, IZodType, ...IZodType[]]>>(types: T, params?: ZodCreateParams): IZodUnion<T>;
declare function createDiscriminatedUnion<Discriminator extends string, Types extends [ZodDiscriminatedUnionOption<Discriminator>, ...ZodDiscriminatedUnionOption<Discriminator>[]]>(discriminator: Discriminator, options: Types, params?: ZodCreateParams): IZodDiscriminatedUnion<Discriminator, Types>;
declare function createIntersection<T extends IZodType, U extends IZodType>(left: T, right: U, params?: ZodCreateParams): IZodIntersection<T, U>;
declare function createTuple<T extends [IZodType, ...IZodType[]] | []>(schemas: T, params?: ZodCreateParams): IZodTuple<T, null>;
declare function createRecord<Value extends IZodType>(valueType: Value, params?: ZodCreateParams): IZodRecord<IZodString, Value>;
declare function createRecord<Keys extends KeySchema, Value extends IZodType>(keySchema: Keys, valueType: Value, params?: ZodCreateParams): IZodRecord<Keys, Value>;
declare function createRecord(first: KeySchema | IZodType, second?: ZodCreateParams | IZodType, third?: ZodCreateParams): IZodRecord;
declare function createMap<Key extends IZodType, Value extends IZodType>(keyType: Key, valueType: Value, params?: ZodCreateParams): IZodMap<Key, Value>;
declare function createSet<Value extends IZodType>(valueType: Value, params?: ZodCreateParams): IZodSet<Value>;
declare function createLazy<T extends IZodType>(getter: () => T, params?: ZodCreateParams): IZodLazy<T>;
declare function createPromise<T extends IZodType>(schema: T, params?: ZodCreateParams): IZodPromise<T>;
declare function createFunction(): IZodFunction<IZodTuple<[], IZodUnknown>, IZodUnknown>;
declare function createFunction<T extends IZodTuple<[IZodType, ...IZodType[]] | [], IZodType | null>>(args: T): IZodFunction<T, IZodUnknown>;
declare function createFunction<T extends IZodTuple<[IZodType, ...IZodType[]] | []>, U extends IZodType>(args: T, returns: U): IZodFunction<T, U>;
declare function createFunction<T extends IZodTuple<[IZodType, ...IZodType[]] | [], IZodType | null>, U extends IZodType>(args: T, returns: U, params: ZodCreateParams): IZodFunction<T, U>;
declare function createFunction(args?: AnyZodTuple, returns?: IZodType, params?: ZodCreateParams): IZodFunction;
declare function createPreprocess<T extends IZodType<O>, O>(preprocess: (arg: unknown, ctx: EffectContext) => O | Promise<O>, schema: T, params?: ZodCreateParams): IZodEffects<T, output<T>, unknown>;
declare function createUpstream<T extends IZodType<O>, O>(upstream: (arg: unknown, ctx: EffectContext) => EffectReturnType<O> | Promise<EffectReturnType<O> | undefined> | undefined, schema: T, params?: ZodCreateParams): IZodEffects<T, output<T>, unknown>;
declare function createDownstream<T extends IZodType, O>(schema: T, downstream: (arg: output<T>, ctx: EffectContext) => EffectReturnType<O> | Promise<EffectReturnType<O> | undefined> | undefined, params?: ZodCreateParams & {
    failFast?: boolean;
}): IZodEffects<T, O>;
declare function createOptional<T extends IZodType>(type: T, params?: ZodCreateParams): IZodOptional<T>;
declare function createNullable<T extends IZodType>(type: T, params?: ZodCreateParams): IZodNullable<T>;
declare function createReadonly<T extends IZodType>(type: T, params?: ZodCreateParams): IZodReadonly<T>;
declare function createDefault<T extends IZodType>(type: T, value: T['_input'] | (() => NoUndefined<T['_input']>), params?: ZodCreateParams): IZodDefault<T>;
declare function createCatch<T extends IZodType>(type: T, catcher: T['_output'] | CatchFn<T['_output']>, params?: ZodCreateParams): IZodCatch<T>;
declare function createPipeline<A extends IZodType, B extends IZodType>(a: A, b: B): IZodPipeline<A, B>;
declare function createBranded<T extends IZodType>(type: T): IZodBranded<T>;
type ZodBuilders = {
    any: typeof createAny;
    array: typeof createArray;
    bigint: typeof createBigInt;
    boolean: typeof createBoolean;
    branded: typeof createBranded;
    catch: typeof createCatch;
    custom: typeof createCustom;
    date: typeof createDate;
    default: typeof createDefault;
    discriminatedUnion: typeof createDiscriminatedUnion;
    enum: typeof createEnum;
    function: typeof createFunction;
    instanceof: typeof createInstanceOf;
    intersection: typeof createIntersection;
    lazy: typeof createLazy;
    literal: typeof createLiteral;
    map: typeof createMap;
    nan: typeof createNan;
    nativeEnum: typeof createNativeEnum;
    never: typeof createNever;
    null: typeof createNull;
    nullable: typeof createNullable;
    number: typeof createNumber;
    object: typeof createObject;
    optional: typeof createOptional;
    pipeline: typeof createPipeline;
    preprocess: typeof createPreprocess;
    upstream: typeof createUpstream;
    downstream: typeof createDownstream;
    promise: typeof createPromise;
    record: typeof createRecord;
    ref: typeof createRef;
    readonly: typeof createReadonly;
    set: typeof createSet;
    strictObject: typeof createStrictObject;
    string: typeof createString;
    symbol: typeof createSymbol;
    tuple: typeof createTuple;
    undefined: typeof createUndefined;
    union: typeof createUnion;
    unknown: typeof createUnknown;
    void: typeof createVoid;
};

type _GuardName<S extends ZodNativeTypeName> = S extends `Zod${infer R}` ? `zui${R}` : never;
type _Guards = {
    [G in ZodNativeTypeName as _GuardName<G>]: (value: IZodType) => value is Extract<ZodNativeType, {
        typeName: G;
    }>;
} & {
    zuiError: (thrown: unknown) => thrown is IZodError;
    zuiType: (value: unknown) => value is ZodNativeType;
};
declare const is: _Guards;

declare const customType: ZodBuilders['custom'];
declare const instanceOfType: ZodBuilders['instanceof'];
declare const anyType: ZodBuilders['any'];
declare const unknownType: ZodBuilders['unknown'];
declare const neverType: ZodBuilders['never'];
declare const voidType: ZodBuilders['void'];
declare const nullType: ZodBuilders['null'];
declare const undefinedType: ZodBuilders['undefined'];
declare const symbolType: ZodBuilders['symbol'];
declare const nanType: ZodBuilders['nan'];
declare const stringType: ZodBuilders['string'];
declare const numberType: ZodBuilders['number'];
declare const booleanType: ZodBuilders['boolean'];
declare const bigIntType: ZodBuilders['bigint'];
declare const dateType: ZodBuilders['date'];
declare const refType: ZodBuilders['ref'];
declare const literalType: ZodBuilders['literal'];
declare const enumType: ZodBuilders['enum'];
declare const nativeEnumType: ZodBuilders['nativeEnum'];
declare const arrayType: ZodBuilders['array'];
declare const objectType: ZodBuilders['object'];
declare const strictObjectType: ZodBuilders['strictObject'];
declare const unionType: ZodBuilders['union'];
declare const discriminatedUnionType: ZodBuilders['discriminatedUnion'];
declare const intersectionType: ZodBuilders['intersection'];
declare const tupleType: ZodBuilders['tuple'];
declare const recordType: ZodBuilders['record'];
declare const mapType: ZodBuilders['map'];
declare const setType: ZodBuilders['set'];
declare const lazyType: ZodBuilders['lazy'];
declare const promiseType: ZodBuilders['promise'];
declare const functionType: ZodBuilders['function'];
declare const preprocessType: ZodBuilders['preprocess'];
declare const upstreamType: ZodBuilders['upstream'];
declare const downstreamType: ZodBuilders['downstream'];
declare const optionalType: ZodBuilders['optional'];
declare const nullableType: ZodBuilders['nullable'];
declare const readonlyType: ZodBuilders['readonly'];
declare const defaultType: ZodBuilders['default'];
declare const catchType: ZodBuilders['catch'];
declare const pipelineType: ZodBuilders['pipeline'];
declare const brandedType: ZodBuilders['branded'];
declare const coerce: {
    string(arg?: ZodCreateParams & {
        coerce?: true;
    }): ReturnType<ZodBuilders["string"]>;
    number(arg?: ZodCreateParams & {
        coerce?: boolean;
    }): ReturnType<ZodBuilders["number"]>;
    boolean(arg?: ZodCreateParams & {
        coerce?: boolean;
    }): ReturnType<ZodBuilders["boolean"]>;
    bigint(arg?: ZodCreateParams & {
        coerce?: boolean;
    }): ReturnType<ZodBuilders["bigint"]>;
    date(arg?: ZodCreateParams & {
        coerce?: boolean;
    }): ReturnType<ZodBuilders["date"]>;
};
declare const OK: <T>(value: T) => ValidEffectReturnType<T>;
declare const ERR: (issue: EffectIssue, ...issues: EffectIssue[]) => InvalidEffectReturnType;
declare const DIRTY: <T>(value: T, issue: EffectIssue, ...issues: EffectIssue[]) => DirtyEffectReturnType<T>;

type JsonSchema7AnyType = {
    [zuiKey$1]?: ZuiExtensionObject;
};

type Targets = 'jsonSchema7' | 'jsonSchema2019-09' | 'openApi3';
type Options<Target extends Targets = 'jsonSchema7'> = {
    name: string | undefined;
    $refStrategy: 'root' | 'relative' | 'none' | 'seen';
    basePath: string[];
    effectStrategy: 'input' | 'any';
    pipeStrategy: 'input' | 'output' | 'all';
    dateStrategy: 'string' | 'integer';
    mapStrategy: 'entries' | 'record';
    target: Target;
    strictUnions: boolean;
    definitionPath: string;
    definitions: Record<string, IZodType>;
    errorMessages: boolean;
    markdownDescription: boolean;
    patternStrategy: 'escape' | 'preserve';
    emailStrategy: 'format:email' | 'format:idn-email' | 'pattern:zod';
    discriminator: boolean;
    unionStrategy: 'anyOf' | 'oneOf';
};

type ErrorMessages<T extends JsonSchema7TypeUnion, OmitProperties extends string = ''> = Partial<Omit<{
    [key in keyof T]: string;
}, OmitProperties | 'type' | 'errorMessages'>>;

type JsonSchema7ArrayType = {
    type: 'array';
    items?: JsonSchema7Type;
    minItems?: number;
    maxItems?: number;
    errorMessages?: ErrorMessages<JsonSchema7ArrayType, 'items'>;
    [zuiKey$1]?: ZuiExtensionObject;
};

type JsonSchema7BigintType = {
    type: 'integer';
    format: 'int64';
    minimum?: BigInt;
    exclusiveMinimum?: BigInt;
    maximum?: BigInt;
    exclusiveMaximum?: BigInt;
    multipleOf?: BigInt;
    errorMessage?: ErrorMessages<JsonSchema7BigintType>;
    [zuiKey$1]?: ZuiExtensionObject;
};

type JsonSchema7BooleanType = {
    type: 'boolean';
    [zuiKey$1]?: ZuiExtensionObject;
};

type JsonSchema7NumberType = {
    type: 'number' | 'integer';
    minimum?: number;
    exclusiveMinimum?: number;
    maximum?: number;
    exclusiveMaximum?: number;
    multipleOf?: number;
    errorMessage?: ErrorMessages<JsonSchema7NumberType>;
    [zuiKey$1]?: ZuiExtensionObject;
};

type JsonSchema7DateType = {
    type: 'integer' | 'string';
    format: 'unix-time' | 'date-time';
    minimum?: number;
    maximum?: number;
    errorMessage?: ErrorMessages<JsonSchema7NumberType>;
    [zuiKey$1]?: ZuiExtensionObject;
};

type JsonSchema7EnumType = {
    type: 'string';
    enum: string[];
    [zuiKey$1]?: ZuiExtensionObject;
};

type JsonSchema7AllOfType = {
    allOf: JsonSchema7Type[];
    unevaluatedProperties?: boolean;
    [zuiKey$1]?: ZuiExtensionObject;
};

type JsonSchema7LiteralType = {
    type: 'string' | 'number' | 'integer' | 'boolean';
    const: string | number | boolean;
    [zuiKey$1]?: ZuiExtensionObject;
} | {
    type: 'object' | 'array';
    [zuiKey$1]?: ZuiExtensionObject;
};

type JsonSchema7StringType = {
    type: 'string';
    minLength?: number;
    maxLength?: number;
    format?: 'email' | 'idn-email' | 'uri' | 'uuid' | 'date-time' | 'ipv4' | 'ipv6';
    pattern?: string;
    allOf?: {
        pattern: string;
        errorMessage?: ErrorMessages<{
            type: 'string';
            pattern: string;
        }>;
    }[];
    anyOf?: {
        format: string;
        errorMessage?: ErrorMessages<{
            type: 'string';
            format: string;
        }>;
    }[];
    errorMessage?: ErrorMessages<JsonSchema7StringType>;
    [zuiKey$1]?: ZuiExtensionObject;
};

type JsonSchema7RecordPropertyNamesType = Omit<JsonSchema7StringType, 'type'> | Omit<JsonSchema7EnumType, 'type'>;
type JsonSchema7RecordType = {
    type: 'object';
    additionalProperties: JsonSchema7Type;
    propertyNames?: JsonSchema7RecordPropertyNamesType;
    [zuiKey$1]?: ZuiExtensionObject;
};

type JsonSchema7MapType = {
    type: 'array';
    maxItems: 125;
    items: {
        type: 'array';
        items: [JsonSchema7Type, JsonSchema7Type];
        minItems: 2;
        maxItems: 2;
    };
    [zuiKey$1]?: ZuiExtensionObject;
};

type JsonSchema7NativeEnumType = {
    type: 'string' | 'number' | ['string', 'number'];
    enum: (string | number)[];
    [zuiKey$1]?: ZuiExtensionObject;
};

type JsonSchema7NeverType = {
    not: {};
    [zuiKey$1]?: ZuiExtensionObject;
};

type JsonSchema7NullType = {
    type: 'null';
    [zuiKey$1]?: ZuiExtensionObject;
};

type JsonSchema7NullableType = {
    anyOf: [JsonSchema7Type, JsonSchema7NullType];
    [zuiKey$1]?: ZuiExtensionObject;
} | {
    type: [string, 'null'];
    [zuiKey$1]?: ZuiExtensionObject;
};

declare const zuiKey: "x-zui";
type JsonSchema7ObjectType = {
    type: 'object';
    properties: Record<string, JsonSchema7Type>;
    additionalProperties: boolean | JsonSchema7Type;
    required?: string[];
    [zuiKey]?: ZuiExtensionObject;
};

type JsonSchema7RefType = {
    $ref: string;
    [zuiKey$1]?: ZuiExtensionObject;
};

type JsonSchema7SetType = {
    type: 'array';
    uniqueItems: true;
    items?: JsonSchema7Type;
    minItems?: number;
    maxItems?: number;
    errorMessage?: ErrorMessages<JsonSchema7SetType>;
    [zuiKey$1]?: ZuiExtensionObject;
};

type JsonSchema7TupleType = {
    type: 'array';
    minItems: number;
    items: JsonSchema7Type[];
    [zuiKey$1]?: ZuiExtensionObject;
} & ({
    maxItems: number;
} | {
    additionalItems?: JsonSchema7Type;
});

type JsonSchema7UndefinedType = {
    not: {};
    [zuiKey$1]?: ZuiExtensionObject;
};

declare const primitiveMappings: {
    readonly ZodString: "string";
    readonly ZodNumber: "number";
    readonly ZodBigInt: "integer";
    readonly ZodBoolean: "boolean";
    readonly ZodNull: "null";
};
type JsonSchema7Primitive = (typeof primitiveMappings)[keyof typeof primitiveMappings];
type JsonSchema7UnionType = JsonSchema7PrimitiveUnionType | JsonSchema7AnyOfType | JsonSchema7OneOfType;
type JsonSchema7PrimitiveUnionType = {
    type: JsonSchema7Primitive | JsonSchema7Primitive[];
    [zuiKey$1]?: ZuiExtensionObject;
} | {
    type: JsonSchema7Primitive | JsonSchema7Primitive[];
    enum: (string | number | bigint | boolean | null)[];
    [zuiKey$1]?: ZuiExtensionObject;
};
type JsonSchema7AnyOfType = {
    anyOf: JsonSchema7Type[];
    discriminator?: {
        propertyName: string;
    };
};
type JsonSchema7OneOfType = {
    oneOf: JsonSchema7Type[];
    discriminator?: {
        propertyName: string;
    };
};

type JsonSchema7UnknownType = {
    [zuiKey$1]?: ZuiExtensionObject;
};

type JsonSchema7Meta = {
    default?: any;
    description?: string;
    markdownDescription?: string;
};
type JsonSchema7TypeUnion = JsonSchema7StringType | JsonSchema7ArrayType | JsonSchema7NumberType | JsonSchema7BigintType | JsonSchema7BooleanType | JsonSchema7DateType | JsonSchema7EnumType | JsonSchema7LiteralType | JsonSchema7NativeEnumType | JsonSchema7NullType | JsonSchema7NumberType | JsonSchema7ObjectType | JsonSchema7RecordType | JsonSchema7TupleType | JsonSchema7UnionType | JsonSchema7UndefinedType | JsonSchema7RefType | JsonSchema7NeverType | JsonSchema7MapType | JsonSchema7AnyType | JsonSchema7NullableType | JsonSchema7AllOfType | JsonSchema7UnknownType | JsonSchema7SetType;
type JsonSchema7Type = JsonSchema7TypeUnion & JsonSchema7Meta;

/**
 * Converts a JSONSchema to a Zui schema.
 *
 * @deprecated Use the new fromJSONSchema function instead.
 */
declare const fromJSONSchemaLegacy: (schema: JsonSchema7Type) => ZodTypeAny;

/**
 * Converts a JSON Schema to a ZUI Schema.
 * @param schema json schema
 * @returns ZUI Schema
 */
declare function fromJSONSchema(schema: JSONSchema7): IZodType;

type ObjectToZuiOptions = {
    optional?: boolean;
    nullable?: boolean;
    passtrough?: boolean;
};
/**
 * Converts a plain object to a Zod schema, by inferring the types of its properties.
 *
 * @param obj - The object to convert.
 * @param opts - Options to customize the Zod schema:
 * @returns A Zod schema representing the object.
 */
declare const fromObject: (obj: object, opts?: ObjectToZuiOptions, isRoot?: boolean) => IZodType;

/**
 * @description Options for JSON schema generation.
 */
type JSONSchemaLegacyGenerationOptions = {
    /**
     * The scope is the full path to the property defined in the JSON schema, the root node being represented by #
     * Objects doesn't have any scope, only  its child does
     * @default "#/properties/"
     * */
    rootScope?: string;
    /**
     * Sets the $schema path. If set to false, it will remove the $schema property from the schema
     */
    $schemaUrl?: string | false;
    target?: 'jsonSchema7' | 'openApi3';
} & Partial<Pick<Options, 'unionStrategy' | 'discriminator'>>;
/**
 * Converts a Zod schema to a JSON Schema.
 *
 * @deprecated Use the new toJSONSchema function instead.
 */
declare const toJSONSchemaLegacy: (zuiType: IZodType, opts?: JSONSchemaLegacyGenerationOptions) => JSONSchema7;

/**
 * Definitions:
 *
 * Mutiple zui schemas map to the same JSON schema; undefined/never, any/unknown, union/discriminated-union
 * Adding some ZodDef to the ZuiExtension allows us to differentiate between them
 */
type NullableDef = Satisfies<{
    typeName: 'ZodNullable';
}, Partial<ZodNullableDef>>;
type OptionalDef = Satisfies<{
    typeName: 'ZodOptional';
}, Partial<ZodOptionalDef>>;
type UndefinedDef = Satisfies<{
    typeName: 'ZodUndefined';
}, Partial<ZodUndefinedDef>>;
type UnknownDef = Satisfies<{
    typeName: 'ZodUnknown';
}, Partial<ZodUnknownDef>>;
type DiscriminatedUnionDef = Satisfies<{
    typeName: 'ZodDiscriminatedUnion';
    discriminator?: string;
}, Partial<ZodDiscriminatedUnionDef>>;
/**
 * ZuiJSONSchema:
 *
 * A ZUI flavored subset of JSONSchema7
 */
type ZuiExtension<Def extends Partial<ZodTypeDef> = {}> = {
    def?: Def;
} & ZuiExtensionObject;
type JsonData = string | number | boolean | null | JsonData[] | {
    [key: string]: JsonData;
};
type BaseZuiJSONSchema<Def extends Partial<ZodTypeDef> = {}> = Satisfies<{
    description?: string;
    readOnly?: boolean;
    default?: JsonData;
    ['x-zui']?: ZuiExtension<Def>;
}, JSONSchema7>;
type _ZodSpecificStringFormat = 'cuid' | 'cuid2' | 'emoji' | 'ulid';
type _JSONSchemaStringFormat = 'date-time' | 'email' | 'ipv4' | 'ipv6' | 'uri' | 'uuid';
type _StringSchema = Satisfies<{
    type: 'string';
    pattern?: string;
    format?: _JSONSchemaStringFormat | _ZodSpecificStringFormat;
    minLength?: number;
    maxLength?: number;
}, JSONSchema7>;
type _ZodSpecificNumberFormat = 'finite';
type _NumberSchema = Satisfies<{
    type: 'number' | 'integer';
    minimum?: number;
    exclusiveMinimum?: number;
    maximum?: number;
    exclusiveMaximum?: number;
    multipleOf?: number;
    format?: _ZodSpecificNumberFormat;
}, JSONSchema7>;
type _BooleanSchema = Satisfies<{
    type: 'boolean';
}, JSONSchema7>;
type _NullSchema = Satisfies<{
    type: 'null';
}, JSONSchema7>;
type _UndefinedSchema = Satisfies<{
    not: true;
}, JSONSchema7>;
type _NeverSchema = Satisfies<{
    not: true;
}, JSONSchema7>;
type _ArraySchema = Satisfies<{
    type: 'array';
    items: Schema;
    minItems?: number;
    maxItems?: number;
}, JSONSchema7>;
type _UnionSchema = Satisfies<{
    anyOf: Schema[];
} | {
    oneOf: Schema[];
}, JSONSchema7>;
type _DiscriminatedUnionSchema = Satisfies<{
    anyOf: Schema[];
} | {
    oneOf: Schema[];
    discriminator?: {
        propertyName: string;
    };
}, JSONSchema7>;
type _IntersectionSchema = Satisfies<{
    allOf: Schema[];
}, JSONSchema7>;
type _SetSchema = Satisfies<{
    type: 'array';
    items: Schema;
    uniqueItems: true;
    minItems?: number;
    maxItems?: number;
}, JSONSchema7>;
type _EnumSchema = Satisfies<{
    type: 'string';
    enum: string[];
}, JSONSchema7>;
type _RefSchema = Satisfies<{
    $ref: string;
}, JSONSchema7>;
type _ObjectSchema = Satisfies<{
    type: 'object';
    properties: {
        [key: string]: Schema;
    };
    additionalProperties?: Schema | boolean;
    required?: string[];
}, JSONSchema7>;
type _TupleSchema = Satisfies<{
    type: 'array';
    items: Schema[];
    additionalItems?: Schema;
}, JSONSchema7>;
type _RecordSchema = Satisfies<{
    type: 'object';
    additionalProperties: Schema;
}, JSONSchema7>;
type _LiteralStringSchema = Satisfies<{
    type: 'string';
    const: string;
}, JSONSchema7>;
type _LiteralNumberSchema = Satisfies<{
    type: 'number';
    const: number;
}, JSONSchema7>;
type _LiteralBooleanSchema = Satisfies<{
    type: 'boolean';
    const: boolean;
}, JSONSchema7>;
type _OptionalSchema = Satisfies<{
    anyOf: [Schema, UndefinedSchema];
}, JSONSchema7>;
type _NullableSchema = Satisfies<{
    anyOf: [Schema, NullSchema];
}, JSONSchema7>;
type StringSchema = _StringSchema & BaseZuiJSONSchema;
type NumberSchema = _NumberSchema & BaseZuiJSONSchema;
type BooleanSchema = _BooleanSchema & BaseZuiJSONSchema;
type NullSchema = _NullSchema & BaseZuiJSONSchema;
type UndefinedSchema = _UndefinedSchema & BaseZuiJSONSchema<UndefinedDef>;
type NeverSchema = _NeverSchema & BaseZuiJSONSchema;
type AnySchema = BaseZuiJSONSchema;
type UnknownSchema = BaseZuiJSONSchema<UnknownDef>;
type ArraySchema = _ArraySchema & BaseZuiJSONSchema;
type UnionSchema = _UnionSchema & BaseZuiJSONSchema;
type DiscriminatedUnionSchema = _DiscriminatedUnionSchema & BaseZuiJSONSchema<DiscriminatedUnionDef>;
type IntersectionSchema = _IntersectionSchema & BaseZuiJSONSchema;
type SetSchema = _SetSchema & BaseZuiJSONSchema;
type EnumSchema = _EnumSchema & BaseZuiJSONSchema;
type RefSchema = _RefSchema & BaseZuiJSONSchema;
type ObjectSchema = _ObjectSchema & BaseZuiJSONSchema;
type TupleSchema = _TupleSchema & BaseZuiJSONSchema;
type RecordSchema = _RecordSchema & BaseZuiJSONSchema;
type LiteralStringSchema = _LiteralStringSchema & BaseZuiJSONSchema;
type LiteralNumberSchema = _LiteralNumberSchema & BaseZuiJSONSchema;
type LiteralBooleanSchema = _LiteralBooleanSchema & BaseZuiJSONSchema;
type OptionalSchema = _OptionalSchema & BaseZuiJSONSchema<OptionalDef>;
type NullableSchema = _NullableSchema & BaseZuiJSONSchema<NullableDef>;
type LiteralSchema = LiteralStringSchema | LiteralNumberSchema | LiteralBooleanSchema;
/**
 * Zui flavored JSON Schema; a subset of JSONSchema7 that includes Zui extensions
 */
type Schema = StringSchema | NumberSchema | BooleanSchema | UndefinedSchema | NullSchema | AnySchema | UnknownSchema | NeverSchema | ArraySchema | ObjectSchema | UnionSchema | DiscriminatedUnionSchema | IntersectionSchema | TupleSchema | RecordSchema | SetSchema | LiteralSchema | EnumSchema | RefSchema | OptionalSchema | NullableSchema;

type jsonSchema_AnySchema = AnySchema;
type jsonSchema_ArraySchema = ArraySchema;
type jsonSchema_BooleanSchema = BooleanSchema;
type jsonSchema_DiscriminatedUnionSchema = DiscriminatedUnionSchema;
type jsonSchema_EnumSchema = EnumSchema;
type jsonSchema_IntersectionSchema = IntersectionSchema;
type jsonSchema_LiteralBooleanSchema = LiteralBooleanSchema;
type jsonSchema_LiteralNumberSchema = LiteralNumberSchema;
type jsonSchema_LiteralSchema = LiteralSchema;
type jsonSchema_LiteralStringSchema = LiteralStringSchema;
type jsonSchema_NeverSchema = NeverSchema;
type jsonSchema_NullSchema = NullSchema;
type jsonSchema_NullableSchema = NullableSchema;
type jsonSchema_NumberSchema = NumberSchema;
type jsonSchema_ObjectSchema = ObjectSchema;
type jsonSchema_OptionalSchema = OptionalSchema;
type jsonSchema_RecordSchema = RecordSchema;
type jsonSchema_RefSchema = RefSchema;
type jsonSchema_Schema = Schema;
type jsonSchema_SetSchema = SetSchema;
type jsonSchema_StringSchema = StringSchema;
type jsonSchema_TupleSchema = TupleSchema;
type jsonSchema_UndefinedSchema = UndefinedSchema;
type jsonSchema_UnionSchema = UnionSchema;
type jsonSchema_UnknownSchema = UnknownSchema;
declare namespace jsonSchema {
  export type { jsonSchema_AnySchema as AnySchema, jsonSchema_ArraySchema as ArraySchema, jsonSchema_BooleanSchema as BooleanSchema, jsonSchema_DiscriminatedUnionSchema as DiscriminatedUnionSchema, jsonSchema_EnumSchema as EnumSchema, jsonSchema_IntersectionSchema as IntersectionSchema, jsonSchema_LiteralBooleanSchema as LiteralBooleanSchema, jsonSchema_LiteralNumberSchema as LiteralNumberSchema, jsonSchema_LiteralSchema as LiteralSchema, jsonSchema_LiteralStringSchema as LiteralStringSchema, jsonSchema_NeverSchema as NeverSchema, jsonSchema_NullSchema as NullSchema, jsonSchema_NullableSchema as NullableSchema, jsonSchema_NumberSchema as NumberSchema, jsonSchema_ObjectSchema as ObjectSchema, jsonSchema_OptionalSchema as OptionalSchema, jsonSchema_RecordSchema as RecordSchema, jsonSchema_RefSchema as RefSchema, jsonSchema_Schema as Schema, jsonSchema_SetSchema as SetSchema, jsonSchema_StringSchema as StringSchema, jsonSchema_TupleSchema as TupleSchema, jsonSchema_UndefinedSchema as UndefinedSchema, jsonSchema_UnionSchema as UnionSchema, jsonSchema_UnknownSchema as UnknownSchema };
}

type JSONSchemaUnionStrategy = 'oneOf' | 'anyOf';
/**
 * @description Options for JSON schema generation.
 */
type JSONSchemaGenerationOptions = {
    /**
     * @default 'anyOf'
     */
    unionStrategy: JSONSchemaUnionStrategy;
    /**
     * @default 'oneOf'
     */
    discriminatedUnionStrategy: JSONSchemaUnionStrategy;
    /**
     * @default true
     * @description
     *  Whether to include the discriminator property in the generated JSON schema for discriminated unions.
     *  This property is not part of the JSON schema specification but is used by some tools to optimize validation and code generation for discriminated unions.
     *  If set to false, the discriminator property will be omitted from the generated JSON schema.
     *  Only affects the generated JSON schema when `discriminatedUnionStrategy` is set to 'oneOf'.
     *  For more details, see: https://ajv.js.org/guide/modifying-data.html#removing-additional-properties
     */
    discriminator: boolean;
};
/**
 * Converts a Zui schema to a ZUI flavored JSON schema.
 * @param schema zui schema
 * @returns ZUI flavored JSON schema
 */
declare function toJSONSchema(schema: IZodType, options?: Partial<JSONSchemaGenerationOptions>): Schema;

type DeclarationProps = {
    type: 'variable';
    schema: IZodType;
    identifier: string;
} | {
    type: 'type';
    schema: IZodType;
    identifier: string;
    args: string[];
} | {
    type: 'none';
    schema: IZodType;
};
type TypescriptDeclarationType = DeclarationProps['type'];
/**
 * @description Options for Typescript type generation.
 */
type TypescriptGenerationOptions = {
    formatter?: (typing: string) => string;
    declaration?: boolean | TypescriptDeclarationType;
    /**
     * Whether to include closing tags in the generated TypeScript declarations when they exceed 5 lines.
     * This improves readability for large type declarations by adding comments like "// end of TypeName".
     */
    includeClosingTags?: boolean;
    treatDefaultAsOptional?: boolean;
};
/**
 *
 * @param schema zui schema
 * @param options generation options
 * @returns a string of the TypeScript **type** representing the schema
 */
declare function toTypescriptType(schema: IZodType, options?: TypescriptGenerationOptions): string;

/**
 *
 * @param schema zui schema
 * @param options generation options
 * @returns a typescript program that would construct the given schema if executed
 */
declare function toTypescriptSchema(schema: IZodType): string;

type Transform = 'json-schema-to-zui' | 'object-to-zui' | 'zui-to-json-schema' | 'zui-to-typescript-schema' | 'zui-to-typescript-type';
declare abstract class ZuiTransformError extends Error {
    readonly transform: Transform;
    constructor(transform: Transform, message?: string);
}
declare class JSONSchemaToZuiError extends ZuiTransformError {
    constructor(message?: string);
}
declare class ObjectToZuiError extends ZuiTransformError {
    constructor(message?: string);
}
declare class ZuiToJSONSchemaError extends ZuiTransformError {
    constructor(message?: string);
}
declare class UnsupportedZuiToJSONSchemaError extends ZuiToJSONSchemaError {
    constructor(type: ZodNativeTypeName, { suggestedAlternative }?: {
        suggestedAlternative?: string;
    });
}
declare class UnsupportedZuiCheckToJSONSchemaError extends ZuiToJSONSchemaError {
    constructor({ zodType, checkKind }: {
        zodType: ZodNativeTypeName;
        checkKind: string;
    });
}
declare class UnsupportedJSONSchemaToZuiError extends JSONSchemaToZuiError {
    constructor(schema: JSONSchema7);
}
declare class ZuiToTypescriptSchemaError extends ZuiTransformError {
    constructor(message?: string);
}
declare class UnsupportedZuiToTypescriptSchemaError extends ZuiToTypescriptSchemaError {
    constructor(type: ZodNativeTypeName);
}
declare class ZuiToTypescriptTypeError extends ZuiTransformError {
    constructor(message?: string);
}
declare class UnsupportedZuiToTypescriptTypeError extends ZuiToTypescriptTypeError {
    constructor(type: ZodNativeTypeName);
}
declare class UntitledDeclarationError extends ZuiToTypescriptTypeError {
    constructor();
}
declare class UnrepresentableGenericError extends ZuiToTypescriptTypeError {
    constructor();
}

type errors_JSONSchemaToZuiError = JSONSchemaToZuiError;
declare const errors_JSONSchemaToZuiError: typeof JSONSchemaToZuiError;
type errors_ObjectToZuiError = ObjectToZuiError;
declare const errors_ObjectToZuiError: typeof ObjectToZuiError;
type errors_UnrepresentableGenericError = UnrepresentableGenericError;
declare const errors_UnrepresentableGenericError: typeof UnrepresentableGenericError;
type errors_UnsupportedJSONSchemaToZuiError = UnsupportedJSONSchemaToZuiError;
declare const errors_UnsupportedJSONSchemaToZuiError: typeof UnsupportedJSONSchemaToZuiError;
type errors_UnsupportedZuiCheckToJSONSchemaError = UnsupportedZuiCheckToJSONSchemaError;
declare const errors_UnsupportedZuiCheckToJSONSchemaError: typeof UnsupportedZuiCheckToJSONSchemaError;
type errors_UnsupportedZuiToJSONSchemaError = UnsupportedZuiToJSONSchemaError;
declare const errors_UnsupportedZuiToJSONSchemaError: typeof UnsupportedZuiToJSONSchemaError;
type errors_UnsupportedZuiToTypescriptSchemaError = UnsupportedZuiToTypescriptSchemaError;
declare const errors_UnsupportedZuiToTypescriptSchemaError: typeof UnsupportedZuiToTypescriptSchemaError;
type errors_UnsupportedZuiToTypescriptTypeError = UnsupportedZuiToTypescriptTypeError;
declare const errors_UnsupportedZuiToTypescriptTypeError: typeof UnsupportedZuiToTypescriptTypeError;
type errors_UntitledDeclarationError = UntitledDeclarationError;
declare const errors_UntitledDeclarationError: typeof UntitledDeclarationError;
type errors_ZuiToJSONSchemaError = ZuiToJSONSchemaError;
declare const errors_ZuiToJSONSchemaError: typeof ZuiToJSONSchemaError;
type errors_ZuiToTypescriptSchemaError = ZuiToTypescriptSchemaError;
declare const errors_ZuiToTypescriptSchemaError: typeof ZuiToTypescriptSchemaError;
type errors_ZuiToTypescriptTypeError = ZuiToTypescriptTypeError;
declare const errors_ZuiToTypescriptTypeError: typeof ZuiToTypescriptTypeError;
type errors_ZuiTransformError = ZuiTransformError;
declare const errors_ZuiTransformError: typeof ZuiTransformError;
declare namespace errors {
  export { errors_JSONSchemaToZuiError as JSONSchemaToZuiError, errors_ObjectToZuiError as ObjectToZuiError, errors_UnrepresentableGenericError as UnrepresentableGenericError, errors_UnsupportedJSONSchemaToZuiError as UnsupportedJSONSchemaToZuiError, errors_UnsupportedZuiCheckToJSONSchemaError as UnsupportedZuiCheckToJSONSchemaError, errors_UnsupportedZuiToJSONSchemaError as UnsupportedZuiToJSONSchemaError, errors_UnsupportedZuiToTypescriptSchemaError as UnsupportedZuiToTypescriptSchemaError, errors_UnsupportedZuiToTypescriptTypeError as UnsupportedZuiToTypescriptTypeError, errors_UntitledDeclarationError as UntitledDeclarationError, errors_ZuiToJSONSchemaError as ZuiToJSONSchemaError, errors_ZuiToTypescriptSchemaError as ZuiToTypescriptSchemaError, errors_ZuiToTypescriptTypeError as ZuiToTypescriptTypeError, errors_ZuiTransformError as ZuiTransformError };
}

type index_JSONSchemaGenerationOptions = JSONSchemaGenerationOptions;
type index_TypescriptGenerationOptions = TypescriptGenerationOptions;
declare const index_errors: typeof errors;
declare const index_fromJSONSchema: typeof fromJSONSchema;
declare const index_fromJSONSchemaLegacy: typeof fromJSONSchemaLegacy;
declare const index_fromObject: typeof fromObject;
declare const index_toJSONSchema: typeof toJSONSchema;
declare const index_toJSONSchemaLegacy: typeof toJSONSchemaLegacy;
declare const index_toTypescriptSchema: typeof toTypescriptSchema;
declare const index_toTypescriptType: typeof toTypescriptType;
declare namespace index {
  export { type index_JSONSchemaGenerationOptions as JSONSchemaGenerationOptions, type index_TypescriptGenerationOptions as TypescriptGenerationOptions, index_errors as errors, index_fromJSONSchema as fromJSONSchema, index_fromJSONSchemaLegacy as fromJSONSchemaLegacy, index_fromObject as fromObject, jsonSchema as json, index_toJSONSchema as toJSONSchema, index_toJSONSchemaLegacy as toJSONSchemaLegacy, index_toTypescriptSchema as toTypescriptSchema, index_toTypescriptType as toTypescriptType };
}

type z_AnyZodObject = AnyZodObject;
type z_AnyZodTuple = AnyZodTuple;
declare const z_DIRTY: typeof DIRTY;
type z_DirtyEffectReturnType<T> = DirtyEffectReturnType<T>;
declare const z_ERR: typeof ERR;
type z_EffectContext = EffectContext;
type z_EffectIssue = EffectIssue;
type z_EffectReturnType<T> = EffectReturnType<T>;
type z_EnumValues = EnumValues;
type z_EnumValuesMap<T extends EnumValues> = EnumValuesMap<T>;
type z_InvalidEffectReturnType = InvalidEffectReturnType;
declare const z_OK: typeof OK;
type z_SafeParseError<Input> = SafeParseError<Input>;
type z_SafeParseReturnType<Input, Output> = SafeParseReturnType<Input, Output>;
type z_SafeParseSuccess<Output> = SafeParseSuccess<Output>;
type z_SomeZodObject = SomeZodObject;
type z_TypeOf<T extends IZodType> = TypeOf<T>;
type z_UIComponentDefinitions = UIComponentDefinitions;
type z_UnknownKeysParam = UnknownKeysParam;
type z_ValidEffectReturnType<T> = ValidEffectReturnType<T>;
type z_ZodAnyDef = ZodAnyDef;
type z_ZodArrayDef<T extends IZodType = IZodType> = ZodArrayDef<T>;
type z_ZodBigIntCheck = ZodBigIntCheck;
type z_ZodBigIntDef = ZodBigIntDef;
type z_ZodBooleanDef = ZodBooleanDef;
type z_ZodBrandedDef<T extends IZodType = IZodType> = ZodBrandedDef<T>;
type z_ZodCatchDef<T extends IZodType = IZodType> = ZodCatchDef<T>;
type z_ZodDateCheck = ZodDateCheck;
type z_ZodDateDef = ZodDateDef;
type z_ZodDefaultDef<T extends IZodType = IZodType> = ZodDefaultDef<T>;
type z_ZodDiscriminatedUnionDef<Discriminator extends string = string, Options extends ZodDiscriminatedUnionOption<string>[] = ZodDiscriminatedUnionOption<string>[]> = ZodDiscriminatedUnionDef<Discriminator, Options>;
type z_ZodDiscriminatedUnionOption<Discriminator extends string> = ZodDiscriminatedUnionOption<Discriminator>;
type z_ZodEffectsDef<T extends IZodType = IZodType> = ZodEffectsDef<T>;
type z_ZodEnumDef<T extends EnumValues = EnumValues> = ZodEnumDef<T>;
type z_ZodFirstPartySchemaTypes = ZodFirstPartySchemaTypes;
type z_ZodFunctionDef<Args extends AnyZodTuple = IZodTuple, Returns extends IZodType = IZodType> = ZodFunctionDef<Args, Returns>;
type z_ZodIntersectionDef<T extends IZodType = IZodType, U extends IZodType = IZodType> = ZodIntersectionDef<T, U>;
type z_ZodIssue = ZodIssue;
type z_ZodLazyDef<T extends IZodType = IZodType> = ZodLazyDef<T>;
type z_ZodLiteralDef<T extends Primitive = Primitive> = ZodLiteralDef<T>;
type z_ZodMapDef<Key extends IZodType = IZodType, Value extends IZodType = IZodType> = ZodMapDef<Key, Value>;
type z_ZodNaNDef = ZodNaNDef;
type z_ZodNativeEnumDef<T extends EnumLike = EnumLike> = ZodNativeEnumDef<T>;
type z_ZodNativeType = ZodNativeType;
type z_ZodNativeTypeDef = ZodNativeTypeDef;
type z_ZodNativeTypeName = ZodNativeTypeName;
type z_ZodNeverDef = ZodNeverDef;
type z_ZodNullDef = ZodNullDef;
type z_ZodNullableDef<T extends IZodType = IZodType> = ZodNullableDef<T>;
type z_ZodNumberCheck = ZodNumberCheck;
type z_ZodNumberDef = ZodNumberDef;
type z_ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = ZodObjectDef<T, UnknownKeys>;
type z_ZodOptionalDef<T extends IZodType = IZodType> = ZodOptionalDef<T>;
type z_ZodPipelineDef<A extends IZodType = IZodType, B extends IZodType = IZodType> = ZodPipelineDef<A, B>;
type z_ZodPromiseDef<T extends IZodType = IZodType> = ZodPromiseDef<T>;
type z_ZodRawShape = ZodRawShape;
type z_ZodReadonlyDef<T extends IZodType = IZodType> = ZodReadonlyDef<T>;
type z_ZodRecordDef<Key extends KeySchema = KeySchema, Value extends IZodType = IZodType> = ZodRecordDef<Key, Value>;
type z_ZodRefDef = ZodRefDef;
type z_ZodSchema<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> = ZodSchema<Output, Def, Input>;
type z_ZodSetDef<Value extends IZodType = IZodType> = ZodSetDef<Value>;
type z_ZodStringCheck = ZodStringCheck;
type z_ZodStringDef = ZodStringDef;
type z_ZodSymbolDef = ZodSymbolDef;
type z_ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends IZodType | null = null> = ZodTupleDef<T, Rest>;
type z_ZodTupleItems = ZodTupleItems;
type z_ZodTypeAny = ZodTypeAny;
type z_ZodTypeDef = ZodTypeDef;
type z_ZodUndefinedDef = ZodUndefinedDef;
type z_ZodUnionDef<T extends ZodUnionOptions = DefaultZodUnionOptions> = ZodUnionDef<T>;
type z_ZodUnknownDef = ZodUnknownDef;
type z_ZodVoidDef = ZodVoidDef;
type z_ZuiExtensionObject = ZuiExtensionObject;
type z_ZuiMetadata = ZuiMetadata;
declare const z_coerce: typeof coerce;
type z_input<T extends IZodType> = input<T>;
declare const z_is: typeof is;
type z_output<T extends IZodType> = output<T>;
declare namespace z {
  export { type z_AnyZodObject as AnyZodObject, type z_AnyZodTuple as AnyZodTuple, z_DIRTY as DIRTY, type z_DirtyEffectReturnType as DirtyEffectReturnType, z_ERR as ERR, type z_EffectContext as EffectContext, type z_EffectIssue as EffectIssue, type z_EffectReturnType as EffectReturnType, type z_EnumValues as EnumValues, type z_EnumValuesMap as EnumValuesMap, type z_InvalidEffectReturnType as InvalidEffectReturnType, z_OK as OK, type z_SafeParseError as SafeParseError, type z_SafeParseReturnType as SafeParseReturnType, type z_SafeParseSuccess as SafeParseSuccess, type Schema$1 as Schema, type z_SomeZodObject as SomeZodObject, type z_TypeOf as TypeOf, type z_UIComponentDefinitions as UIComponentDefinitions, type z_UnknownKeysParam as UnknownKeysParam, type z_ValidEffectReturnType as ValidEffectReturnType, type IZodAny as ZodAny, type z_ZodAnyDef as ZodAnyDef, type IZodArray as ZodArray, type z_ZodArrayDef as ZodArrayDef, type IZodBigInt as ZodBigInt, type z_ZodBigIntCheck as ZodBigIntCheck, type z_ZodBigIntDef as ZodBigIntDef, type IZodBoolean as ZodBoolean, type z_ZodBooleanDef as ZodBooleanDef, type IZodBranded as ZodBranded, type z_ZodBrandedDef as ZodBrandedDef, type IZodCatch as ZodCatch, type z_ZodCatchDef as ZodCatchDef, type IZodDate as ZodDate, type z_ZodDateCheck as ZodDateCheck, type z_ZodDateDef as ZodDateDef, type IZodDefault as ZodDefault, type z_ZodDefaultDef as ZodDefaultDef, type IZodDiscriminatedUnion as ZodDiscriminatedUnion, type z_ZodDiscriminatedUnionDef as ZodDiscriminatedUnionDef, type z_ZodDiscriminatedUnionOption as ZodDiscriminatedUnionOption, type IZodEffects as ZodEffects, type z_ZodEffectsDef as ZodEffectsDef, type IZodEnum as ZodEnum, type z_ZodEnumDef as ZodEnumDef, type IZodError as ZodError, type z_ZodFirstPartySchemaTypes as ZodFirstPartySchemaTypes, type IZodFunction as ZodFunction, type z_ZodFunctionDef as ZodFunctionDef, type IZodIntersection as ZodIntersection, type z_ZodIntersectionDef as ZodIntersectionDef, type z_ZodIssue as ZodIssue, type IZodLazy as ZodLazy, type z_ZodLazyDef as ZodLazyDef, type IZodLiteral as ZodLiteral, type z_ZodLiteralDef as ZodLiteralDef, type IZodMap as ZodMap, type z_ZodMapDef as ZodMapDef, type IZodNaN as ZodNaN, type z_ZodNaNDef as ZodNaNDef, type IZodNativeEnum as ZodNativeEnum, type z_ZodNativeEnumDef as ZodNativeEnumDef, type z_ZodNativeType as ZodNativeType, type z_ZodNativeTypeDef as ZodNativeTypeDef, type z_ZodNativeTypeName as ZodNativeTypeName, type IZodNever as ZodNever, type z_ZodNeverDef as ZodNeverDef, type IZodNull as ZodNull, type z_ZodNullDef as ZodNullDef, type IZodNullable as ZodNullable, type z_ZodNullableDef as ZodNullableDef, type IZodNumber as ZodNumber, type z_ZodNumberCheck as ZodNumberCheck, type z_ZodNumberDef as ZodNumberDef, type IZodObject as ZodObject, type z_ZodObjectDef as ZodObjectDef, type IZodOptional as ZodOptional, type z_ZodOptionalDef as ZodOptionalDef, type IZodPipeline as ZodPipeline, type z_ZodPipelineDef as ZodPipelineDef, type IZodPromise as ZodPromise, type z_ZodPromiseDef as ZodPromiseDef, type z_ZodRawShape as ZodRawShape, type IZodReadonly as ZodReadonly, type z_ZodReadonlyDef as ZodReadonlyDef, type IZodRecord as ZodRecord, type z_ZodRecordDef as ZodRecordDef, type IZodRef as ZodRef, type z_ZodRefDef as ZodRefDef, type z_ZodSchema as ZodSchema, type IZodSet as ZodSet, type z_ZodSetDef as ZodSetDef, type IZodString as ZodString, type z_ZodStringCheck as ZodStringCheck, type z_ZodStringDef as ZodStringDef, type IZodSymbol as ZodSymbol, type z_ZodSymbolDef as ZodSymbolDef, type IZodTuple as ZodTuple, type z_ZodTupleDef as ZodTupleDef, type z_ZodTupleItems as ZodTupleItems, type IZodType as ZodType, type z_ZodTypeAny as ZodTypeAny, type z_ZodTypeDef as ZodTypeDef, type IZodUndefined as ZodUndefined, type z_ZodUndefinedDef as ZodUndefinedDef, type IZodUnion as ZodUnion, type z_ZodUnionDef as ZodUnionDef, type IZodUnknown as ZodUnknown, type z_ZodUnknownDef as ZodUnknownDef, type IZodVoid as ZodVoid, type z_ZodVoidDef as ZodVoidDef, type z_ZuiExtensionObject as ZuiExtensionObject, type z_ZuiMetadata as ZuiMetadata, anyType as any, arrayType as array, bigIntType as bigint, booleanType as boolean, brandedType as branded, catchType as catch, z_coerce as coerce, customType as custom, dateType as date, defaultType as default, discriminatedUnionType as discriminatedUnion, downstreamType as downstream, enumType as enum, functionType as function, type TypeOf as infer, type z_input as input, instanceOfType as instanceof, intersectionType as intersection, z_is as is, lazyType as lazy, literalType as literal, mapType as map, nanType as nan, nativeEnumType as nativeEnum, neverType as never, nullType as null, nullableType as nullable, numberType as number, objectType as object, optionalType as optional, type z_output as output, pipelineType as pipeline, preprocessType as preprocess, promiseType as promise, readonlyType as readonly, recordType as record, refType as ref, setType as set, strictObjectType as strictObject, stringType as string, symbolType as symbol, index as transforms, tupleType as tuple, undefinedType as undefined, unionType as union, unknownType as unknown, upstreamType as upstream, voidType as void, zuiKey$1 as zuiKey };
}

export { type AnyZodObject, type AnyZodTuple, DIRTY, type DirtyEffectReturnType, ERR, type EffectContext, type EffectIssue, type EffectReturnType, type EnumValues, type EnumValuesMap, type InvalidEffectReturnType, OK, type SafeParseError, type SafeParseReturnType, type SafeParseSuccess, type Schema$1 as Schema, type SomeZodObject, type TypeOf, type UIComponentDefinitions, type UnknownKeysParam, type ValidEffectReturnType, type IZodAny as ZodAny, type ZodAnyDef, type IZodArray as ZodArray, type ZodArrayDef, type IZodBigInt as ZodBigInt, type ZodBigIntCheck, type ZodBigIntDef, type IZodBoolean as ZodBoolean, type ZodBooleanDef, type IZodBranded as ZodBranded, type ZodBrandedDef, type IZodCatch as ZodCatch, type ZodCatchDef, type IZodDate as ZodDate, type ZodDateCheck, type ZodDateDef, type IZodDefault as ZodDefault, type ZodDefaultDef, type IZodDiscriminatedUnion as ZodDiscriminatedUnion, type ZodDiscriminatedUnionDef, type ZodDiscriminatedUnionOption, type IZodEffects as ZodEffects, type ZodEffectsDef, type IZodEnum as ZodEnum, type ZodEnumDef, type IZodError as ZodError, type ZodFirstPartySchemaTypes, type IZodFunction as ZodFunction, type ZodFunctionDef, type IZodIntersection as ZodIntersection, type ZodIntersectionDef, type ZodIssue, type IZodLazy as ZodLazy, type ZodLazyDef, type IZodLiteral as ZodLiteral, type ZodLiteralDef, type IZodMap as ZodMap, type ZodMapDef, type IZodNaN as ZodNaN, type ZodNaNDef, type IZodNativeEnum as ZodNativeEnum, type ZodNativeEnumDef, type ZodNativeType, type ZodNativeTypeDef, type ZodNativeTypeName, type IZodNever as ZodNever, type ZodNeverDef, type IZodNull as ZodNull, type ZodNullDef, type IZodNullable as ZodNullable, type ZodNullableDef, type IZodNumber as ZodNumber, type ZodNumberCheck, type ZodNumberDef, type IZodObject as ZodObject, type ZodObjectDef, type IZodOptional as ZodOptional, type ZodOptionalDef, type IZodPipeline as ZodPipeline, type ZodPipelineDef, type IZodPromise as ZodPromise, type ZodPromiseDef, type ZodRawShape, type IZodReadonly as ZodReadonly, type ZodReadonlyDef, type IZodRecord as ZodRecord, type ZodRecordDef, type IZodRef as ZodRef, type ZodRefDef, type ZodSchema, type IZodSet as ZodSet, type ZodSetDef, type IZodString as ZodString, type ZodStringCheck, type ZodStringDef, type IZodSymbol as ZodSymbol, type ZodSymbolDef, type IZodTuple as ZodTuple, type ZodTupleDef, type ZodTupleItems, type IZodType as ZodType, type ZodTypeAny, type ZodTypeDef, type IZodUndefined as ZodUndefined, type ZodUndefinedDef, type IZodUnion as ZodUnion, type ZodUnionDef, type IZodUnknown as ZodUnknown, type ZodUnknownDef, type IZodVoid as ZodVoid, type ZodVoidDef, type ZuiExtensionObject, type ZuiMetadata, anyType as any, arrayType as array, bigIntType as bigint, booleanType as boolean, brandedType as branded, catchType as catch, coerce, customType as custom, dateType as date, z as default, discriminatedUnionType as discriminatedUnion, downstreamType as downstream, enumType as enum, functionType as function, type TypeOf as infer, type input, instanceOfType as instanceof, intersectionType as intersection, is, lazyType as lazy, literalType as literal, mapType as map, nanType as nan, nativeEnumType as nativeEnum, neverType as never, nullType as null, nullableType as nullable, numberType as number, objectType as object, optionalType as optional, type output, pipelineType as pipeline, preprocessType as preprocess, promiseType as promise, readonlyType as readonly, recordType as record, refType as ref, setType as set, strictObjectType as strictObject, stringType as string, symbolType as symbol, index as transforms, tupleType as tuple, undefinedType as undefined, unionType as union, unknownType as unknown, upstreamType as upstream, voidType as void, z, zuiKey$1 as zuiKey };