@temporary-name/zod 1.9.3-alpha.021f5c8fe9793dff332b025dce560e804c45a7b1 → 1.9.3-alpha.03f5d40e5b399f85012c2fb4e98167e26d551d36

package/dist/index.d.mts

@@ -1,91 +1,754 @@
-import { JSONSchema, ConditionalSchemaConverter, SchemaConvertOptions } from '@temporary-name/server/openapi';
-import { ZodTypeAny, input, output, ZodTypeDef, CustomErrorParams, ZodType, ZodEffects } from 'zod/v3';
-import { Context } from '@temporary-name/server';
-import { StandardHandlerPlugin, StandardHandlerOptions } from '@temporary-name/server/standard';
-import { AnySchema } from '@temporary-name/contract';
-
-declare function getCustomJsonSchema(def: ZodTypeDef, options: {
-    strategy: 'input' | 'output' | 'both';
-}): Exclude<JSONSchema, boolean> | undefined;
-declare function customJsonSchema<T extends ZodTypeAny, TStrategy extends 'input' | 'output' | 'both' = 'both'>(schema: T, custom: Exclude<JSONSchema<TStrategy extends 'input' ? input<T> : TStrategy extends 'output' ? output<T> : input<T> & output<T>>, boolean>, options?: {
-    strategy?: TStrategy;
-}): T;
+import * as core from 'zod/v4/core';
+import { $ZodError, util, $ZodType } from 'zod/v4/core';
+export { core };
+export { $RefinementCtx as RefinementCtx, _endsWith as endsWith, _gt as gt, _gte as gte, _includes as includes, infer, input, _length as length, _lowercase as lowercase, _lt as lt, _lte as lte, _maxLength as maxLength, _maxSize as maxSize, _mime as mime, _minLength as minLength, _minSize as minSize, _multipleOf as multipleOf, _negative as negative, _nonnegative as nonnegative, _nonpositive as nonpositive, _normalize as normalize, output, _overwrite as overwrite, _positive as positive, _property as property, _regex as regex, _size as size, _startsWith as startsWith, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, _trim as trim, _uppercase as uppercase } from 'zod/v4/core';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { CustomErrorParams, ZodType, ZodTypeDef } from 'zod/v3';
 
-type CustomParams = CustomErrorParams & {
-    fatal?: boolean;
+/** @deprecated Use `z.core.$ZodIssue` from `@zod/core` instead, especially if you are building a library on top of Zod. */
+type ZodIssue = core.$ZodIssue;
+/** An Error-like class used to store Zod validation issues.  */
+interface ZodError<T = unknown> extends $ZodError<T> {
+    /** @deprecated Use the `z.treeifyError(err)` function instead. */
+    format(): core.$ZodFormattedError<T>;
+    format<U>(mapper: (issue: core.$ZodIssue) => U): core.$ZodFormattedError<T, U>;
+    /** @deprecated Use the `z.treeifyError(err)` function instead. */
+    flatten(): core.$ZodFlattenedError<T>;
+    flatten<U>(mapper: (issue: core.$ZodIssue) => U): core.$ZodFlattenedError<T, U>;
+    /** @deprecated Push directly to `.issues` instead. */
+    addIssue(issue: core.$ZodIssue): void;
+    /** @deprecated Push directly to `.issues` instead. */
+    addIssues(issues: core.$ZodIssue[]): void;
+    /** @deprecated Check `err.issues.length === 0` instead. */
+    isEmpty: boolean;
+}
+declare const ZodError: core.$constructor<ZodError>;
+declare const ZodRealError: core.$constructor<ZodError>;
+/** @deprecated Use `z.core.$ZodRawIssue` instead. */
+type IssueData = core.$ZodRawIssue;
+
+type ZodSafeParseResult<T> = ZodSafeParseSuccess<T> | ZodSafeParseError<T>;
+type ZodSafeParseSuccess<T> = {
+    success: true;
+    data: T;
+    error?: never;
 };
-type CustomZodDef = {
-    type: 'blob' | 'regexp' | 'url';
-} | {
-    type: 'file';
-    mimeType?: string;
+type ZodSafeParseError<T> = {
+    success: false;
+    data?: never;
+    error: ZodError<T>;
 };
-declare function setCustomZodDef<T extends ZodTypeDef>(def: T, custom: CustomZodDef): void;
-declare function getCustomZodDef(def: ZodTypeDef): CustomZodDef | undefined;
-declare function composeParams<T = unknown>(defaultMessage: (input: T) => string, params: undefined | string | CustomParams | ((input: T) => CustomParams)): (input: T) => CustomParams;
+declare const parse: <T extends core.$ZodType>(schema: T, value: unknown, _ctx?: core.ParseContext<core.$ZodIssue>, _params?: {
+    callee?: core.util.AnyFunc;
+    Err?: core.$ZodErrorClass;
+}) => core.output<T>;
+declare const parseAsync: <T extends core.$ZodType>(schema: T, value: unknown, _ctx?: core.ParseContext<core.$ZodIssue>, _params?: {
+    callee?: core.util.AnyFunc;
+    Err?: core.$ZodErrorClass;
+}) => Promise<core.output<T>>;
+declare const safeParse: <T extends core.$ZodType>(schema: T, value: unknown, _ctx?: core.ParseContext<core.$ZodIssue>) => ZodSafeParseResult<core.output<T>>;
+declare const safeParseAsync: <T extends core.$ZodType>(schema: T, value: unknown, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<ZodSafeParseResult<core.output<T>>>;
+declare const encode: <T extends core.$ZodType>(schema: T, value: core.output<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => core.input<T>;
+declare const decode: <T extends core.$ZodType>(schema: T, value: core.input<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => core.output<T>;
+declare const encodeAsync: <T extends core.$ZodType>(schema: T, value: core.output<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<core.input<T>>;
+declare const decodeAsync: <T extends core.$ZodType>(schema: T, value: core.input<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<core.output<T>>;
+declare const safeEncode: <T extends core.$ZodType>(schema: T, value: core.output<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => ZodSafeParseResult<core.input<T>>;
+declare const safeDecode: <T extends core.$ZodType>(schema: T, value: core.input<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => ZodSafeParseResult<core.output<T>>;
+declare const safeEncodeAsync: <T extends core.$ZodType>(schema: T, value: core.output<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<ZodSafeParseResult<core.input<T>>>;
+declare const safeDecodeAsync: <T extends core.$ZodType>(schema: T, value: core.input<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<ZodSafeParseResult<core.output<T>>>;
 
-declare function blob(params?: string | CustomParams | ((input: unknown) => CustomParams)): ZodType<Blob, ZodTypeDef, Blob>;
+type IsGateEnabled = (gate: string) => boolean;
+declare const gatingContext: AsyncLocalStorage<IsGateEnabled>;
+declare function isGateIssueRaw(issue: core.$ZodRawIssue): boolean;
+declare function isGateIssue(issue: core.$ZodIssue): boolean;
+interface $ZodGateDef<T extends core.SomeType = core.$ZodType> extends core.$ZodOptionalDef<T> {
+    gateName: string;
+}
+interface $ZodGateInternals<T extends core.SomeType = core.$ZodType> extends core.$ZodOptionalInternals<T> {
+    def: $ZodGateDef<T>;
+}
+interface $ZodGate<T extends core.SomeType = core.$ZodType> extends core.$ZodType {
+    _zod: $ZodGateInternals<T>;
+}
+declare const $ZodGate: core.$constructor<$ZodGate>;
+interface ZodGate<T extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<$ZodGateInternals<T>, K>, $ZodGate<T> {
+    unwrap(): T;
+}
+declare const ZodGate: core.$constructor<ZodGate>;
+declare function gate<T extends core.SomeType, K extends KrustyInternals>(innerType: T, gateName: K['gateNames']): ZodGate<T, K>;
 
-declare function file(params?: string | CustomParams | ((input: unknown) => CustomParams)): ZodType<File, ZodTypeDef, File> & {
-    type(mimeType: string, params?: string | CustomParams | ((input: unknown) => CustomParams)): ZodEffects<ZodType<File, ZodTypeDef, File>, File, File>;
+type SafeExtendShape<Base extends core.$ZodShape, Ext extends core.$ZodLooseShape> = {
+    [K in keyof Ext]: K extends keyof Base ? core.output<Ext[K]> extends core.output<Base[K]> ? core.input<Ext[K]> extends core.input<Base[K]> ? Ext[K] : never : never : Ext[K];
 };
+interface ZodObject<
+/** @ts-expect-error Cast variance */
+out Shape extends core.$ZodShape = core.$ZodLooseShape, out Config extends core.$ZodObjectConfig = core.$strip, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodObjectInternals<Shape, Config>, K>, core.$ZodObject<Shape, Config> {
+    shape: Shape;
+    keyof(): ZodEnum<util.ToEnum<keyof Shape & string>, K>;
+    /** Define a schema to validate all unrecognized keys. This overrides the existing strict/loose behavior. */
+    catchall<T extends core.SomeType>(schema: T): ZodObject<Shape, core.$catchall<T>, K>;
+    /** @deprecated Use `z.looseObject()` or `.loose()` instead. */
+    passthrough(): ZodObject<Shape, core.$loose, K>;
+    /** Consider `z.looseObject(A.shape)` instead */
+    loose(): ZodObject<Shape, core.$loose, K>;
+    /** Consider `z.strictObject(A.shape)` instead */
+    strict(): ZodObject<Shape, core.$strict, K>;
+    /** This is the default behavior. This method call is likely unnecessary. */
+    strip(): ZodObject<Shape, core.$strip, K>;
+    extend<U extends core.$ZodLooseShape>(shape: U): ZodObject<util.Extend<Shape, U>, Config, K>;
+    safeExtend<U extends core.$ZodLooseShape>(shape: SafeExtendShape<Shape, U> & Partial<Record<keyof Shape, core.SomeType>>): ZodObject<util.Extend<Shape, U>, Config, K>;
+    /**
+     * @deprecated Use [`A.extend(B.shape)`](https://zod.dev/api?id=extend) instead.
+     */
+    merge<U extends ZodObject>(other: U): ZodObject<util.Extend<Shape, U['shape']>, U['_zod']['config'], K>;
+    pick<M extends util.Mask<keyof Shape>>(mask: M): ZodObject<util.Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, Config, K>;
+    omit<M extends util.Mask<keyof Shape>>(mask: M): ZodObject<util.Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>, Config, K>;
+    partial(): ZodObject<{
+        [k in keyof Shape]: ZodOptional<Shape[k], K>;
+    }, Config, K>;
+    partial<M extends util.Mask<keyof Shape>>(mask: M): ZodObject<{
+        [k in keyof Shape]: k extends keyof M ? ZodOptional<Shape[k], K> : Shape[k];
+    }, Config, K>;
+    required(): ZodObject<{
+        [k in keyof Shape]: ZodNonOptional<Shape[k], K>;
+    }, Config, K>;
+    required<M extends util.Mask<keyof Shape>>(mask: M): ZodObject<{
+        [k in keyof Shape]: k extends keyof M ? ZodNonOptional<Shape[k], K> : Shape[k];
+    }, Config, K>;
+}
+declare const ZodObject: core.$constructor<ZodObject>;
+declare function object<T extends core.$ZodLooseShape = Partial<Record<never, core.SomeType>>, K extends KrustyInternals = KrustyInternals>(shape?: T, params?: string | core.$ZodObjectParams): ZodObject<util.Writeable<T>, core.$strip, K>;
+declare function strictObject<T extends core.$ZodLooseShape, K extends KrustyInternals>(shape: T, params?: string | core.$ZodObjectParams): ZodObject<T, core.$strict, K>;
+declare function looseObject<T extends core.$ZodLooseShape, K extends KrustyInternals>(shape: T, params?: string | core.$ZodObjectParams): ZodObject<T, core.$loose, K>;
+
+interface ZodUnion<T extends readonly core.SomeType[] = readonly core.$ZodType[], K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodUnionInternals<T>, K>, core.$ZodUnion<T> {
+    options: T;
+}
+declare const ZodUnion: core.$constructor<ZodUnion>;
+declare function union<const T extends readonly core.SomeType[], K extends KrustyInternals>(options: T, params?: string | core.$ZodUnionParams): ZodUnion<T, K>;
+interface ZodDiscriminatedUnion<Options extends readonly core.SomeType[] = readonly core.$ZodType[], Disc extends string = string, K extends KrustyInternals = KrustyInternals> extends ZodUnion<Options, K>, core.$ZodDiscriminatedUnion<Options, Disc> {
+    _zod: core.$ZodDiscriminatedUnionInternals<Options, Disc>;
+    def: core.$ZodDiscriminatedUnionDef<Options, Disc>;
+}
+declare const ZodDiscriminatedUnion: core.$constructor<ZodDiscriminatedUnion>;
+declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable, ...core.$ZodTypeDiscriminable[]], Disc extends string, K extends KrustyInternals = KrustyInternals>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodDiscriminatedUnion<Types, Disc, K>;
+
+type CustomParams = CustomErrorParams & {
+    fatal?: boolean;
+};
+
+declare function blob(params?: string | CustomParams | ((input: unknown) => CustomParams)): ZodType<Blob, ZodTypeDef, Blob>;
 
 declare function regexp(params?: string | CustomParams | ((input: unknown) => CustomParams)): ZodType<RegExp, ZodTypeDef, RegExp>;
 
-declare function url(params?: string | CustomParams | ((input: unknown) => CustomParams)): ZodType<URL, ZodTypeDef, URL>;
+interface KrustyInternals<GateNames extends string = string> {
+    gateNames: GateNames;
+}
+interface _KrustyType<out Internals extends core.$ZodTypeInternals = core.$ZodTypeInternals, out KInternals extends KrustyInternals = KrustyInternals> extends KrustyType<any, any, Internals, KInternals> {
+}
+interface KrustyType<out Output = unknown, out Input = unknown, out Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>, KInternals extends KrustyInternals = KrustyInternals> extends core.$ZodType<Output, Input, Internals> {
+    def: Internals['def'];
+    type: Internals['def']['type'];
+    check(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;
+    clone(def?: Internals['def'], params?: {
+        parent: boolean;
+    }): this;
+    register<R extends core.$ZodRegistry>(registry: R, ...meta: this extends R['_schema'] ? undefined extends R['_meta'] ? [
+        core.$replace<R['_meta'], this>?
+    ] : [core.$replace<R['_meta'], this>] : ['Incompatible schema']): this;
+    brand<T extends PropertyKey = PropertyKey>(value?: T): PropertyKey extends T ? this : core.$ZodBranded<this, T>;
+    parse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): core.output<this>;
+    safeParse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): ZodSafeParseResult<core.output<this>>;
+    parseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<core.output<this>>;
+    safeParseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<ZodSafeParseResult<core.output<this>>>;
+    spa: (data: unknown, params?: core.ParseContext<core.$ZodIssue>) => Promise<ZodSafeParseResult<core.output<this>>>;
+    encode(data: core.output<this>, params?: core.ParseContext<core.$ZodIssue>): core.input<this>;
+    decode(data: core.input<this>, params?: core.ParseContext<core.$ZodIssue>): core.output<this>;
+    encodeAsync(data: core.output<this>, params?: core.ParseContext<core.$ZodIssue>): Promise<core.input<this>>;
+    decodeAsync(data: core.input<this>, params?: core.ParseContext<core.$ZodIssue>): Promise<core.output<this>>;
+    safeEncode(data: core.output<this>, params?: core.ParseContext<core.$ZodIssue>): ZodSafeParseResult<core.input<this>>;
+    safeDecode(data: core.input<this>, params?: core.ParseContext<core.$ZodIssue>): ZodSafeParseResult<core.output<this>>;
+    safeEncodeAsync(data: core.output<this>, params?: core.ParseContext<core.$ZodIssue>): Promise<ZodSafeParseResult<core.input<this>>>;
+    safeDecodeAsync(data: core.input<this>, params?: core.ParseContext<core.$ZodIssue>): Promise<ZodSafeParseResult<core.output<this>>>;
+    refine(check: (arg: core.output<this>) => unknown | Promise<unknown>, params?: string | core.$ZodCustomParams): this;
+    superRefine(refinement: (arg: core.output<this>, ctx: core.$RefinementCtx<core.output<this>>) => void | Promise<void>): this;
+    overwrite(fn: (x: core.output<this>) => core.output<this>): this;
+    gate(gateName: KInternals['gateNames']): ZodGate<this, KInternals>;
+    optional(): ZodOptional<this, KInternals>;
+    nonoptional(params?: string | core.$ZodNonOptionalParams): ZodNonOptional<this, KInternals>;
+    nullable(): ZodNullable<this, KInternals>;
+    nullish(): ZodOptional<ZodNullable<this, KInternals>, KInternals>;
+    default(def: util.NoUndefined<core.output<this>>): ZodDefault<this, KInternals>;
+    default(def: () => util.NoUndefined<core.output<this>>): ZodDefault<this, KInternals>;
+    prefault(def: () => core.input<this>): ZodPrefault<this, KInternals>;
+    prefault(def: core.input<this>): ZodPrefault<this, KInternals>;
+    array(): ZodArray<this, KInternals>;
+    or<T extends core.SomeType>(option: T): ZodUnion<[this, T], KInternals>;
+    and<T extends core.SomeType>(incoming: T): ZodIntersection<this, T, KInternals>;
+    transform<NewOut>(transform: (arg: core.output<this>, ctx: core.$RefinementCtx<core.output<this>>) => NewOut | Promise<NewOut>): ZodPipe<this, ZodTransform<Awaited<NewOut>, core.output<this>>, KInternals>;
+}
+declare const KrustyType: core.$constructor<KrustyType>;
+interface _ZodString<T extends core.$ZodStringInternals<unknown> = core.$ZodStringInternals<unknown>, K extends KrustyInternals = KrustyInternals> extends _KrustyType<T, K> {
+    format: string | null;
+    minLength: number | null;
+    maxLength: number | null;
+    regex(regex: RegExp, params?: string | core.$ZodCheckRegexParams): this;
+    includes(value: string, params?: core.$ZodCheckIncludesParams): this;
+    startsWith(value: string, params?: string | core.$ZodCheckStartsWithParams): this;
+    endsWith(value: string, params?: string | core.$ZodCheckEndsWithParams): this;
+    min(minLength: number, params?: string | core.$ZodCheckMinLengthParams): this;
+    max(maxLength: number, params?: string | core.$ZodCheckMaxLengthParams): this;
+    length(len: number, params?: string | core.$ZodCheckLengthEqualsParams): this;
+    nonempty(params?: string | core.$ZodCheckMinLengthParams): this;
+    lowercase(params?: string | core.$ZodCheckLowerCaseParams): this;
+    uppercase(params?: string | core.$ZodCheckUpperCaseParams): this;
+    trim(): this;
+    normalize(form?: 'NFC' | 'NFD' | 'NFKC' | 'NFKD' | (string & {})): this;
+    toLowerCase(): this;
+    toUpperCase(): this;
+}
+/** @internal */
+declare const _ZodString: core.$constructor<_ZodString>;
+interface ZodString<K extends KrustyInternals = KrustyInternals> extends _ZodString<core.$ZodStringInternals<string>, K> {
+    /** @deprecated Use `z.email()` instead. */
+    email(params?: string | core.$ZodCheckEmailParams): this;
+    /** @deprecated Use `z.url()` instead. */
+    url(params?: string | core.$ZodCheckURLParams): this;
+    /** @deprecated Use `z.jwt()` instead. */
+    jwt(params?: string | core.$ZodCheckJWTParams): this;
+    /** @deprecated Use `z.emoji()` instead. */
+    emoji(params?: string | core.$ZodCheckEmojiParams): this;
+    /** @deprecated Use `z.guid()` instead. */
+    guid(params?: string | core.$ZodCheckGUIDParams): this;
+    /** @deprecated Use `z.uuid()` instead. */
+    uuid(params?: string | core.$ZodCheckUUIDParams): this;
+    /** @deprecated Use `z.uuid()` instead. */
+    uuidv4(params?: string | core.$ZodCheckUUIDParams): this;
+    /** @deprecated Use `z.uuid()` instead. */
+    uuidv6(params?: string | core.$ZodCheckUUIDParams): this;
+    /** @deprecated Use `z.uuid()` instead. */
+    uuidv7(params?: string | core.$ZodCheckUUIDParams): this;
+    /** @deprecated Use `z.nanoid()` instead. */
+    nanoid(params?: string | core.$ZodCheckNanoIDParams): this;
+    /** @deprecated Use `z.guid()` instead. */
+    guid(params?: string | core.$ZodCheckGUIDParams): this;
+    /** @deprecated Use `z.cuid()` instead. */
+    cuid(params?: string | core.$ZodCheckCUIDParams): this;
+    /** @deprecated Use `z.cuid2()` instead. */
+    cuid2(params?: string | core.$ZodCheckCUID2Params): this;
+    /** @deprecated Use `z.ulid()` instead. */
+    ulid(params?: string | core.$ZodCheckULIDParams): this;
+    /** @deprecated Use `z.base64()` instead. */
+    base64(params?: string | core.$ZodCheckBase64Params): this;
+    /** @deprecated Use `z.base64url()` instead. */
+    base64url(params?: string | core.$ZodCheckBase64URLParams): this;
+    /** @deprecated Use `z.xid()` instead. */
+    xid(params?: string | core.$ZodCheckXIDParams): this;
+    /** @deprecated Use `z.ksuid()` instead. */
+    ksuid(params?: string | core.$ZodCheckKSUIDParams): this;
+    /** @deprecated Use `z.ipv4()` instead. */
+    ipv4(params?: string | core.$ZodCheckIPv4Params): this;
+    /** @deprecated Use `z.ipv6()` instead. */
+    ipv6(params?: string | core.$ZodCheckIPv6Params): this;
+    /** @deprecated Use `z.cidrv4()` instead. */
+    cidrv4(params?: string | core.$ZodCheckCIDRv4Params): this;
+    /** @deprecated Use `z.cidrv6()` instead. */
+    cidrv6(params?: string | core.$ZodCheckCIDRv6Params): this;
+    /** @deprecated Use `z.e164()` instead. */
+    e164(params?: string | core.$ZodCheckE164Params): this;
+    /** @deprecated Use `z.iso.datetime()` instead. */
+    datetime(params?: string | core.$ZodCheckISODateTimeParams): this;
+    /** @deprecated Use `z.iso.date()` instead. */
+    date(params?: string | core.$ZodCheckISODateParams): this;
+    /** @deprecated Use `z.iso.time()` instead. */
+    time(params?: string | core.$ZodCheckISOTimeParams): this;
+    /** @deprecated Use `z.iso.duration()` instead. */
+    duration(params?: string | core.$ZodCheckISODurationParams): this;
+}
+declare const ZodString: core.$constructor<ZodString>;
+declare function string<K extends KrustyInternals = KrustyInternals>(params?: string | core.$ZodStringParams): ZodString<K>;
+interface ZodStringFormat<Format extends string = string, K extends KrustyInternals = KrustyInternals> extends _ZodString<core.$ZodStringFormatInternals<Format>, K> {
+}
+declare const ZodStringFormat: core.$constructor<ZodStringFormat>;
+interface ZodEmail<K extends KrustyInternals = KrustyInternals> extends ZodStringFormat<'email', K> {
+    _zod: core.$ZodEmailInternals;
+}
+declare const ZodEmail: core.$constructor<ZodEmail>;
+declare function email(params?: string | core.$ZodEmailParams): ZodEmail;
+interface ZodGUID<K extends KrustyInternals = KrustyInternals> extends ZodStringFormat<'guid', K> {
+    _zod: core.$ZodGUIDInternals;
+}
+declare const ZodGUID: core.$constructor<ZodGUID>;
+declare function guid(params?: string | core.$ZodGUIDParams): ZodGUID;
+interface ZodUUID<K extends KrustyInternals = KrustyInternals> extends ZodStringFormat<'uuid', K> {
+    _zod: core.$ZodUUIDInternals;
+}
+declare const ZodUUID: core.$constructor<ZodUUID>;
+declare function uuid(params?: string | core.$ZodUUIDParams): ZodUUID;
+declare function uuidv4(params?: string | core.$ZodUUIDv4Params): ZodUUID;
+declare function uuidv6(params?: string | core.$ZodUUIDv6Params): ZodUUID;
+declare function uuidv7(params?: string | core.$ZodUUIDv7Params): ZodUUID;
+interface ZodURL extends ZodStringFormat<'url'> {
+    _zod: core.$ZodURLInternals;
+}
+declare const ZodURL: core.$constructor<ZodURL>;
+declare function url(params?: string | core.$ZodURLParams): ZodURL;
+declare function httpUrl(params?: string | Omit<core.$ZodURLParams, 'protocol' | 'hostname'>): ZodURL;
+interface ZodEmoji extends ZodStringFormat<'emoji'> {
+    _zod: core.$ZodEmojiInternals;
+}
+declare const ZodEmoji: core.$constructor<ZodEmoji>;
+declare function emoji(params?: string | core.$ZodEmojiParams): ZodEmoji;
+interface ZodNanoID extends ZodStringFormat<'nanoid'> {
+    _zod: core.$ZodNanoIDInternals;
+}
+declare const ZodNanoID: core.$constructor<ZodNanoID>;
+declare function nanoid(params?: string | core.$ZodNanoIDParams): ZodNanoID;
+interface ZodCUID extends ZodStringFormat<'cuid'> {
+    _zod: core.$ZodCUIDInternals;
+}
+declare const ZodCUID: core.$constructor<ZodCUID>;
+declare function cuid(params?: string | core.$ZodCUIDParams): ZodCUID;
+interface ZodCUID2 extends ZodStringFormat<'cuid2'> {
+    _zod: core.$ZodCUID2Internals;
+}
+declare const ZodCUID2: core.$constructor<ZodCUID2>;
+declare function cuid2(params?: string | core.$ZodCUID2Params): ZodCUID2;
+interface ZodULID extends ZodStringFormat<'ulid'> {
+    _zod: core.$ZodULIDInternals;
+}
+declare const ZodULID: core.$constructor<ZodULID>;
+declare function ulid(params?: string | core.$ZodULIDParams): ZodULID;
+interface ZodXID extends ZodStringFormat<'xid'> {
+    _zod: core.$ZodXIDInternals;
+}
+declare const ZodXID: core.$constructor<ZodXID>;
+declare function xid(params?: string | core.$ZodXIDParams): ZodXID;
+interface ZodKSUID extends ZodStringFormat<'ksuid'> {
+    _zod: core.$ZodKSUIDInternals;
+}
+declare const ZodKSUID: core.$constructor<ZodKSUID>;
+declare function ksuid(params?: string | core.$ZodKSUIDParams): ZodKSUID;
+interface ZodIPv4 extends ZodStringFormat<'ipv4'> {
+    _zod: core.$ZodIPv4Internals;
+}
+declare const ZodIPv4: core.$constructor<ZodIPv4>;
+declare function ipv4(params?: string | core.$ZodIPv4Params): ZodIPv4;
+interface ZodIPv6 extends ZodStringFormat<'ipv6'> {
+    _zod: core.$ZodIPv6Internals;
+}
+declare const ZodIPv6: core.$constructor<ZodIPv6>;
+declare function ipv6(params?: string | core.$ZodIPv6Params): ZodIPv6;
+interface ZodCIDRv4 extends ZodStringFormat<'cidrv4'> {
+    _zod: core.$ZodCIDRv4Internals;
+}
+declare const ZodCIDRv4: core.$constructor<ZodCIDRv4>;
+declare function cidrv4(params?: string | core.$ZodCIDRv4Params): ZodCIDRv4;
+interface ZodCIDRv6 extends ZodStringFormat<'cidrv6'> {
+    _zod: core.$ZodCIDRv6Internals;
+}
+declare const ZodCIDRv6: core.$constructor<ZodCIDRv6>;
+declare function cidrv6(params?: string | core.$ZodCIDRv6Params): ZodCIDRv6;
+interface ZodBase64 extends ZodStringFormat<'base64'> {
+    _zod: core.$ZodBase64Internals;
+}
+declare const ZodBase64: core.$constructor<ZodBase64>;
+declare function base64(params?: string | core.$ZodBase64Params): ZodBase64;
+interface ZodBase64URL extends ZodStringFormat<'base64url'> {
+    _zod: core.$ZodBase64URLInternals;
+}
+declare const ZodBase64URL: core.$constructor<ZodBase64URL>;
+declare function base64url(params?: string | core.$ZodBase64URLParams): ZodBase64URL;
+interface ZodE164 extends ZodStringFormat<'e164'> {
+    _zod: core.$ZodE164Internals;
+}
+declare const ZodE164: core.$constructor<ZodE164>;
+declare function e164(params?: string | core.$ZodE164Params): ZodE164;
+interface ZodJWT extends ZodStringFormat<'jwt'> {
+    _zod: core.$ZodJWTInternals;
+}
+declare const ZodJWT: core.$constructor<ZodJWT>;
+declare function jwt(params?: string | core.$ZodJWTParams): ZodJWT;
+interface ZodCustomStringFormat<Format extends string = string> extends ZodStringFormat<Format>, core.$ZodCustomStringFormat<Format> {
+    _zod: core.$ZodCustomStringFormatInternals<Format>;
+}
+declare const ZodCustomStringFormat: core.$constructor<ZodCustomStringFormat>;
+declare function stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp, _params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<Format>;
+declare function hostname(_params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<'hostname'>;
+declare function hex(_params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<'hex'>;
+declare function hash<Alg extends util.HashAlgorithm, Enc extends util.HashEncoding = 'hex'>(alg: Alg, params?: {
+    enc?: Enc;
+} & core.$ZodStringFormatParams): ZodCustomStringFormat<`${Alg}_${Enc}`>;
+interface _ZodNumber<Internals extends core.$ZodNumberInternals = core.$ZodNumberInternals, K extends KrustyInternals = KrustyInternals> extends _KrustyType<Internals, K> {
+    gt(value: number, params?: string | core.$ZodCheckGreaterThanParams): this;
+    /** Identical to .min() */
+    gte(value: number, params?: string | core.$ZodCheckGreaterThanParams): this;
+    min(value: number, params?: string | core.$ZodCheckGreaterThanParams): this;
+    lt(value: number, params?: string | core.$ZodCheckLessThanParams): this;
+    /** Identical to .max() */
+    lte(value: number, params?: string | core.$ZodCheckLessThanParams): this;
+    max(value: number, params?: string | core.$ZodCheckLessThanParams): this;
+    /** Consider `z.int()` instead. This API is considered *legacy*; it will never be removed but a better alternative exists. */
+    int(params?: string | core.$ZodCheckNumberFormatParams): this;
+    /** @deprecated This is now identical to `.int()`. Only numbers in the safe integer range are accepted. */
+    safe(params?: string | core.$ZodCheckNumberFormatParams): this;
+    positive(params?: string | core.$ZodCheckGreaterThanParams): this;
+    nonnegative(params?: string | core.$ZodCheckGreaterThanParams): this;
+    negative(params?: string | core.$ZodCheckLessThanParams): this;
+    nonpositive(params?: string | core.$ZodCheckLessThanParams): this;
+    multipleOf(value: number, params?: string | core.$ZodCheckMultipleOfParams): this;
+    /** @deprecated Use `.multipleOf()` instead. */
+    step(value: number, params?: string | core.$ZodCheckMultipleOfParams): this;
+    /** @deprecated In v4 and later, z.number() does not allow infinite values by default. This is a no-op. */
+    finite(params?: unknown): this;
+    minValue: number | null;
+    maxValue: number | null;
+    /** @deprecated Check the `format` property instead.  */
+    isInt: boolean;
+    /** @deprecated Number schemas no longer accept infinite values, so this always returns `true`. */
+    isFinite: boolean;
+    format: string | null;
+}
+interface ZodNumber<K extends KrustyInternals = KrustyInternals> extends _ZodNumber<core.$ZodNumberInternals<number>, K> {
+}
+declare const ZodNumber: core.$constructor<ZodNumber>;
+declare function number(params?: string | core.$ZodNumberParams): ZodNumber;
+interface ZodNumberFormat extends ZodNumber {
+    _zod: core.$ZodNumberFormatInternals;
+}
+declare const ZodNumberFormat: core.$constructor<ZodNumberFormat>;
+interface ZodInt extends ZodNumberFormat {
+}
+declare function int(params?: string | core.$ZodCheckNumberFormatParams): ZodInt;
+interface ZodFloat32 extends ZodNumberFormat {
+}
+declare function float32(params?: string | core.$ZodCheckNumberFormatParams): ZodFloat32;
+interface ZodFloat64 extends ZodNumberFormat {
+}
+declare function float64(params?: string | core.$ZodCheckNumberFormatParams): ZodFloat64;
+interface ZodInt32 extends ZodNumberFormat {
+}
+declare function int32(params?: string | core.$ZodCheckNumberFormatParams): ZodInt32;
+interface ZodUInt32 extends ZodNumberFormat {
+}
+declare function uint32(params?: string | core.$ZodCheckNumberFormatParams): ZodUInt32;
+interface _ZodBoolean<T extends core.$ZodBooleanInternals = core.$ZodBooleanInternals, K extends KrustyInternals = KrustyInternals> extends _KrustyType<T, K> {
+}
+interface ZodBoolean<K extends KrustyInternals = KrustyInternals> extends _ZodBoolean<core.$ZodBooleanInternals<boolean>, K> {
+}
+declare const ZodBoolean: core.$constructor<ZodBoolean>;
+declare function boolean(params?: string | core.$ZodBooleanParams): ZodBoolean;
+interface _ZodBigInt<T extends core.$ZodBigIntInternals = core.$ZodBigIntInternals, K extends KrustyInternals = KrustyInternals> extends _KrustyType<T, K> {
+    gte(value: bigint, params?: string | core.$ZodCheckGreaterThanParams): this;
+    /** Alias of `.gte()` */
+    min(value: bigint, params?: string | core.$ZodCheckGreaterThanParams): this;
+    gt(value: bigint, params?: string | core.$ZodCheckGreaterThanParams): this;
+    /** Alias of `.lte()` */
+    lte(value: bigint, params?: string | core.$ZodCheckLessThanParams): this;
+    max(value: bigint, params?: string | core.$ZodCheckLessThanParams): this;
+    lt(value: bigint, params?: string | core.$ZodCheckLessThanParams): this;
+    positive(params?: string | core.$ZodCheckGreaterThanParams): this;
+    negative(params?: string | core.$ZodCheckLessThanParams): this;
+    nonpositive(params?: string | core.$ZodCheckLessThanParams): this;
+    nonnegative(params?: string | core.$ZodCheckGreaterThanParams): this;
+    multipleOf(value: bigint, params?: string | core.$ZodCheckMultipleOfParams): this;
+    minValue: bigint | null;
+    maxValue: bigint | null;
+    format: string | null;
+}
+interface ZodBigInt<K extends KrustyInternals = KrustyInternals> extends _ZodBigInt<core.$ZodBigIntInternals<bigint>, K> {
+}
+declare const ZodBigInt: core.$constructor<ZodBigInt>;
+declare function bigint(params?: string | core.$ZodBigIntParams): ZodBigInt;
+interface ZodBigIntFormat extends ZodBigInt {
+    _zod: core.$ZodBigIntFormatInternals;
+}
+declare const ZodBigIntFormat: core.$constructor<ZodBigIntFormat>;
+declare function int64(params?: string | core.$ZodBigIntFormatParams): ZodBigIntFormat;
+declare function uint64(params?: string | core.$ZodBigIntFormatParams): ZodBigIntFormat;
+interface ZodSymbol<K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodSymbolInternals, K> {
+}
+declare const ZodSymbol: core.$constructor<ZodSymbol>;
+declare function symbol(params?: string | core.$ZodSymbolParams): ZodSymbol;
+interface ZodUndefined<K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodUndefinedInternals, K> {
+}
+declare const ZodUndefined: core.$constructor<ZodUndefined>;
+declare function _undefined(params?: string | core.$ZodUndefinedParams): ZodUndefined;
 
-declare class ZodSmartCoercionPlugin<TContext extends Context> implements StandardHandlerPlugin<TContext> {
-    init(options: StandardHandlerOptions<TContext>): void;
+interface ZodNull<K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodNullInternals, K> {
 }
+declare const ZodNull: core.$constructor<ZodNull>;
+declare function _null(params?: string | core.$ZodNullParams): ZodNull;
 
-interface ZodToJsonSchemaOptions {
-    /**
-     * Max depth of lazy type
-     *
-     * Used `{}` when exceed max depth
-     *
-     * @default 3
-     */
-    maxLazyDepth?: number;
-    /**
-     * Max depth of nested types
-     *
-     * Used anyJsonSchema (`{}`) when exceed max depth
-     *
-     * @default 10
-     */
-    maxStructureDepth?: number;
-    /**
-     * The schema to be used to represent the any | unknown type.
-     *
-     * @default { }
-     */
-    anyJsonSchema?: Exclude<JSONSchema, boolean>;
-    /**
-     * The schema to be used when the Zod schema is unsupported.
-     *
-     * @default { not: {} }
-     */
-    unsupportedJsonSchema?: Exclude<JSONSchema, boolean>;
-}
-declare class ZodToJsonSchemaConverter implements ConditionalSchemaConverter {
-    #private;
-    private readonly maxLazyDepth;
-    private readonly maxStructureDepth;
-    private readonly unsupportedJsonSchema;
-    private readonly anyJsonSchema;
-    constructor(options?: ZodToJsonSchemaOptions);
-    condition(schema: AnySchema | undefined): boolean;
-    convert(schema: AnySchema | undefined, options: SchemaConvertOptions, lazyDepth?: number, isHandledCustomJSONSchema?: boolean, isHandledZodDescription?: boolean, structureDepth?: number): [required: boolean, jsonSchema: Exclude<JSONSchema, boolean>];
-}
-
-declare const oz: {
-    file: typeof file;
-    blob: typeof blob;
-    url: typeof url;
-    regexp: typeof regexp;
-    openapi: typeof customJsonSchema;
-};
+interface ZodAny<K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodAnyInternals, K> {
+}
+declare const ZodAny: core.$constructor<ZodAny>;
+declare function any(): ZodAny;
+interface ZodUnknown<K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodUnknownInternals, K> {
+}
+declare const ZodUnknown: core.$constructor<ZodUnknown>;
+declare function unknown(): ZodUnknown;
+interface ZodNever<K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodNeverInternals, K> {
+}
+declare const ZodNever: core.$constructor<ZodNever>;
+declare function never(params?: string | core.$ZodNeverParams): ZodNever;
+interface ZodVoid<K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodVoidInternals, K> {
+}
+declare const ZodVoid: core.$constructor<ZodVoid>;
+declare function _void(params?: string | core.$ZodVoidParams): ZodVoid;
+
+interface _ZodDate<T extends core.$ZodDateInternals = core.$ZodDateInternals, K extends KrustyInternals = KrustyInternals> extends _KrustyType<T, K> {
+    min(value: number | Date, params?: string | core.$ZodCheckGreaterThanParams): this;
+    max(value: number | Date, params?: string | core.$ZodCheckLessThanParams): this;
+    /** @deprecated Not recommended. */
+    minDate: Date | null;
+    /** @deprecated Not recommended. */
+    maxDate: Date | null;
+}
+interface ZodDate<K extends KrustyInternals = KrustyInternals> extends _ZodDate<core.$ZodDateInternals<Date>, K> {
+}
+declare const ZodDate: core.$constructor<ZodDate>;
+declare function date(params?: string | core.$ZodDateParams): ZodDate;
+interface ZodArray<T extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodArrayInternals<T>, K>, core.$ZodArray<T> {
+    element: T;
+    min(minLength: number, params?: string | core.$ZodCheckMinLengthParams): this;
+    nonempty(params?: string | core.$ZodCheckMinLengthParams): this;
+    max(maxLength: number, params?: string | core.$ZodCheckMaxLengthParams): this;
+    length(len: number, params?: string | core.$ZodCheckLengthEqualsParams): this;
+    unwrap(): T;
+}
+declare const ZodArray: core.$constructor<ZodArray>;
+declare function array<T extends core.SomeType, K extends KrustyInternals>(element: T, params?: string | core.$ZodArrayParams): ZodArray<T, K>;
+declare function keyof<T extends ZodObject, K extends KrustyInternals>(schema: T): ZodEnum<util.KeysEnum<T['_zod']['output']>, K>;
+interface ZodIntersection<A extends core.SomeType = core.$ZodType, B extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodIntersectionInternals<A, B>, K>, core.$ZodIntersection<A, B> {
+}
+declare const ZodIntersection: core.$constructor<ZodIntersection>;
+declare function intersection<T extends core.SomeType, U extends core.SomeType, K extends KrustyInternals>(left: T, right: U): ZodIntersection<T, U, K>;
+interface ZodTuple<T extends util.TupleItems = readonly core.$ZodType[], Rest extends core.SomeType | null = core.$ZodType | null, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodTupleInternals<T, Rest>, K>, core.$ZodTuple<T, Rest> {
+    rest<Rest extends core.SomeType = core.$ZodType>(rest: Rest): ZodTuple<T, Rest, K>;
+}
+declare const ZodTuple: core.$constructor<ZodTuple>;
+declare function tuple<T extends readonly [core.SomeType, ...core.SomeType[]], K extends KrustyInternals>(items: T, params?: string | core.$ZodTupleParams): ZodTuple<T, null, K>;
+declare function tuple<T extends readonly [core.SomeType, ...core.SomeType[]], Rest extends core.SomeType, K extends KrustyInternals>(items: T, rest: Rest, params?: string | core.$ZodTupleParams): ZodTuple<T, Rest, K>;
+declare function tuple(items: [], params?: string | core.$ZodTupleParams): ZodTuple<[], null, KrustyInternals>;
+interface ZodRecord<Key extends core.$ZodRecordKey = core.$ZodRecordKey, Value extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodRecordInternals<Key, Value>, K>, core.$ZodRecord<Key, Value> {
+    keyType: Key;
+    valueType: Value;
+}
+declare const ZodRecord: core.$constructor<ZodRecord>;
+declare function record<Key extends core.$ZodRecordKey, Value extends core.SomeType, K extends KrustyInternals>(keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams): ZodRecord<Key, Value, K>;
+declare function partialRecord<Key extends core.$ZodRecordKey, Value extends core.SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams): ZodRecord<Key & core.$partial, Value>;
+interface ZodMap<Key extends core.SomeType = core.$ZodType, Value extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodMapInternals<Key, Value>, K>, core.$ZodMap<Key, Value> {
+    keyType: Key;
+    valueType: Value;
+}
+declare const ZodMap: core.$constructor<ZodMap>;
+declare function map<Key extends core.SomeType, Value extends core.SomeType, K extends KrustyInternals>(keyType: Key, valueType: Value, params?: string | core.$ZodMapParams): ZodMap<Key, Value, K>;
+interface ZodSet<T extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodSetInternals<T>, K>, core.$ZodSet<T> {
+    min(minSize: number, params?: string | core.$ZodCheckMinSizeParams): this;
+    nonempty(params?: string | core.$ZodCheckMinSizeParams): this;
+    max(maxSize: number, params?: string | core.$ZodCheckMaxSizeParams): this;
+    size(size: number, params?: string | core.$ZodCheckSizeEqualsParams): this;
+}
+declare const ZodSet: core.$constructor<ZodSet>;
+declare function set<Value extends core.SomeType, K extends KrustyInternals>(valueType: Value, params?: string | core.$ZodSetParams): ZodSet<Value, K>;
+interface ZodEnum<
+/** @ts-expect-error Cast variance */
+out T extends util.EnumLike = util.EnumLike, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodEnumInternals<T>, K>, core.$ZodEnum<T> {
+    enum: T;
+    options: Array<T[keyof T]>;
+    extract<const U extends readonly (keyof T)[]>(values: U, params?: string | core.$ZodEnumParams): ZodEnum<util.Flatten<Pick<T, U[number]>>, K>;
+    exclude<const U extends readonly (keyof T)[]>(values: U, params?: string | core.$ZodEnumParams): ZodEnum<util.Flatten<Omit<T, U[number]>>, K>;
+}
+declare const ZodEnum: core.$constructor<ZodEnum>;
+declare function _enum<const T extends readonly string[], K extends KrustyInternals>(values: T, params?: string | core.$ZodEnumParams): ZodEnum<util.ToEnum<T[number]>, K>;
+declare function _enum<const T extends util.EnumLike, K extends KrustyInternals>(entries: T, params?: string | core.$ZodEnumParams): ZodEnum<T, K>;
+
+/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.
+ *
+ * ```ts
+ * enum Colors { red, green, blue }
+ * z.enum(Colors);
+ * ```
+ */
+declare function nativeEnum<T extends util.EnumLike, K extends KrustyInternals>(entries: T, params?: string | core.$ZodEnumParams): ZodEnum<T, K>;
+interface ZodLiteral<T extends util.Literal = util.Literal, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodLiteralInternals<T>, K>, core.$ZodLiteral<T> {
+    values: Set<T>;
+    /** @legacy Use `.values` instead. Accessing this property will throw an error if the literal accepts multiple values. */
+    value: T;
+}
+declare const ZodLiteral: core.$constructor<ZodLiteral>;
+declare function literal<const T extends ReadonlyArray<util.Literal>, K extends KrustyInternals>(value: T, params?: string | core.$ZodLiteralParams): ZodLiteral<T[number], K>;
+declare function literal<const T extends util.Literal, K extends KrustyInternals>(value: T, params?: string | core.$ZodLiteralParams): ZodLiteral<T, K>;
+interface ZodFile<K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodFileInternals, K>, core.$ZodFile {
+    min(size: number, params?: string | core.$ZodCheckMinSizeParams): this;
+    max(size: number, params?: string | core.$ZodCheckMaxSizeParams): this;
+    mime(types: util.MimeTypes | Array<util.MimeTypes>, params?: string | core.$ZodCheckMimeTypeParams): this;
+}
+declare const ZodFile: core.$constructor<ZodFile>;
+declare function file(params?: string | core.$ZodFileParams): ZodFile;
+interface ZodTransform<O = unknown, I = unknown, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodTransformInternals<O, I>, K>, core.$ZodTransform<O, I> {
+}
+declare const ZodTransform: core.$constructor<ZodTransform>;
+declare function transform<I = unknown, O = I>(fn: (input: I, ctx: core.ParsePayload) => O): ZodTransform<Awaited<O>, I>;
+interface ZodOptional<T extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodOptionalInternals<T>, K>, core.$ZodOptional<T> {
+    unwrap(): T;
+}
+declare const ZodOptional: core.$constructor<ZodOptional>;
+declare function optional<T extends core.SomeType, K extends KrustyInternals>(innerType: T): ZodOptional<T, K>;
+interface ZodNullable<T extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodNullableInternals<T>, K>, core.$ZodNullable<T> {
+    unwrap(): T;
+}
+declare const ZodNullable: core.$constructor<ZodNullable>;
+declare function nullable<T extends core.SomeType, K extends KrustyInternals>(innerType: T): ZodNullable<T, K>;
+declare function nullish<T extends core.SomeType, K extends KrustyInternals>(innerType: T): ZodOptional<ZodNullable<T, K>, K>;
+interface ZodDefault<T extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodDefaultInternals<T>, K>, core.$ZodDefault<T> {
+    unwrap(): T;
+    /** @deprecated Use `.unwrap()` instead. */
+    removeDefault(): T;
+}
+declare const ZodDefault: core.$constructor<ZodDefault>;
+declare function _default<T extends core.SomeType, K extends KrustyInternals>(innerType: T, defaultValue: util.NoUndefined<core.output<T>> | (() => util.NoUndefined<core.output<T>>)): ZodDefault<T, K>;
+interface ZodPrefault<T extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodPrefaultInternals<T>, K>, core.$ZodPrefault<T> {
+    unwrap(): T;
+}
+declare const ZodPrefault: core.$constructor<ZodPrefault>;
+declare function prefault<T extends core.SomeType, K extends KrustyInternals>(innerType: T, defaultValue: core.input<T> | (() => core.input<T>)): ZodPrefault<T, K>;
+interface ZodNonOptional<T extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodNonOptionalInternals<T>, K>, core.$ZodNonOptional<T> {
+    unwrap(): T;
+}
+declare const ZodNonOptional: core.$constructor<ZodNonOptional>;
+declare function nonoptional<T extends core.SomeType, K extends KrustyInternals>(innerType: T, params?: string | core.$ZodNonOptionalParams): ZodNonOptional<T, K>;
+interface ZodSuccess<T extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodSuccessInternals<T>, K>, core.$ZodSuccess<T> {
+    unwrap(): T;
+}
+declare const ZodSuccess: core.$constructor<ZodSuccess>;
+declare function success<T extends core.SomeType, K extends KrustyInternals>(innerType: T): ZodSuccess<T, K>;
+interface ZodCatch<T extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodCatchInternals<T>, K>, core.$ZodCatch<T> {
+    unwrap(): T;
+    /** @deprecated Use `.unwrap()` instead. */
+    removeCatch(): T;
+}
+declare const ZodCatch: core.$constructor<ZodCatch>;
+declare function _catch<T extends core.SomeType, K extends KrustyInternals>(innerType: T, catchValue: core.output<T> | ((ctx: core.$ZodCatchCtx) => core.output<T>)): ZodCatch<T, K>;
+
+interface ZodNaN<K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodNaNInternals, K>, core.$ZodNaN {
+}
+declare const ZodNaN: core.$constructor<ZodNaN>;
+declare function nan(params?: string | core.$ZodNaNParams): ZodNaN;
+interface ZodPipe<A extends core.SomeType = core.$ZodType, B extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodPipeInternals<A, B>, K>, core.$ZodPipe<A, B> {
+    in: A;
+    out: B;
+}
+declare const ZodPipe: core.$constructor<ZodPipe>;
+declare function pipe<const A extends core.SomeType, B extends core.$ZodType<unknown, core.output<A>> = core.$ZodType<unknown, core.output<A>>, K extends KrustyInternals = KrustyInternals>(in_: A, out: B | core.$ZodType<unknown, core.output<A>>): ZodPipe<A, B, K>;
+interface ZodCodec<A extends core.SomeType = core.$ZodType, B extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends ZodPipe<A, B, K>, core.$ZodCodec<A, B> {
+    _zod: core.$ZodCodecInternals<A, B>;
+    def: core.$ZodCodecDef<A, B>;
+}
+declare const ZodCodec: core.$constructor<ZodCodec>;
+declare function codec<const A extends core.SomeType, B extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals>(in_: A, out: B, params: {
+    decode: (value: core.output<A>, payload: core.ParsePayload<core.output<A>>) => core.util.MaybeAsync<core.input<B>>;
+    encode: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.util.MaybeAsync<core.output<A>>;
+}): ZodCodec<A, B, K>;
+interface ZodReadonly<T extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodReadonlyInternals<T>, K>, core.$ZodReadonly<T> {
+    unwrap(): T;
+}
+declare const ZodReadonly: core.$constructor<ZodReadonly>;
+declare function readonly<T extends core.SomeType, K extends KrustyInternals>(innerType: T): ZodReadonly<T, K>;
+interface ZodTemplateLiteral<Template extends string = string, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodTemplateLiteralInternals<Template>, K>, core.$ZodTemplateLiteral<Template> {
+}
+declare const ZodTemplateLiteral: core.$constructor<ZodTemplateLiteral>;
+declare function templateLiteral<const Parts extends core.$ZodTemplateLiteralPart[], K extends KrustyInternals>(parts: Parts, params?: string | core.$ZodTemplateLiteralParams): ZodTemplateLiteral<core.$PartsToTemplateLiteral<Parts>, K>;
+interface ZodLazy<T extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodLazyInternals<T>, K>, core.$ZodLazy<T> {
+    unwrap(): T;
+}
+declare const ZodLazy: core.$constructor<ZodLazy>;
+declare function lazy<T extends core.SomeType, K extends KrustyInternals>(getter: () => T): ZodLazy<T, K>;
+interface ZodPromise<T extends core.SomeType = core.$ZodType, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodPromiseInternals<T>, K>, core.$ZodPromise<T> {
+    unwrap(): T;
+}
+declare const ZodPromise: core.$constructor<ZodPromise>;
+declare function promise<T extends core.SomeType, K extends KrustyInternals>(innerType: T): ZodPromise<T, K>;
+interface ZodFunction<Args extends core.$ZodFunctionIn = core.$ZodFunctionIn, Returns extends core.$ZodFunctionOut = core.$ZodFunctionOut, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodFunctionInternals<Args, Returns>, K>, core.$ZodFunction<Args, Returns> {
+    _def: core.$ZodFunctionDef<Args, Returns>;
+    _input: core.$InferInnerFunctionType<Args, Returns>;
+    _output: core.$InferOuterFunctionType<Args, Returns>;
+    input<const Items extends util.TupleItems, const Rest extends core.$ZodFunctionOut = core.$ZodFunctionOut>(args: Items, rest?: Rest): ZodFunction<core.$ZodTuple<Items, Rest>, Returns, K>;
+    input<NewArgs extends core.$ZodFunctionIn>(args: NewArgs): ZodFunction<NewArgs, Returns, K>;
+    input(...args: any[]): ZodFunction<any, Returns, K>;
+    output<NewReturns extends core.$ZodType>(output: NewReturns): ZodFunction<Args, NewReturns, K>;
+}
+declare const ZodFunction: core.$constructor<ZodFunction>;
+declare function _function(): ZodFunction;
+declare function _function<const In extends ReadonlyArray<core.$ZodType>, K extends KrustyInternals>(params: {
+    input: In;
+}): ZodFunction<ZodTuple<In, null, K>, core.$ZodFunctionOut, K>;
+declare function _function<const In extends ReadonlyArray<core.$ZodType>, const Out extends core.$ZodFunctionOut = core.$ZodFunctionOut, K extends KrustyInternals = KrustyInternals>(params: {
+    input: In;
+    output: Out;
+}): ZodFunction<ZodTuple<In, null, K>, Out, K>;
+declare function _function<const In extends core.$ZodFunctionIn = core.$ZodFunctionIn, K extends KrustyInternals = KrustyInternals>(params: {
+    input: In;
+}): ZodFunction<In, core.$ZodFunctionOut, K>;
+declare function _function<const Out extends core.$ZodFunctionOut = core.$ZodFunctionOut, K extends KrustyInternals = KrustyInternals>(params: {
+    output: Out;
+}): ZodFunction<core.$ZodFunctionIn, Out, K>;
+declare function _function<In extends core.$ZodFunctionIn = core.$ZodFunctionIn, Out extends core.$ZodType = core.$ZodType, K extends KrustyInternals = KrustyInternals>(params?: {
+    input: In;
+    output: Out;
+}): ZodFunction<In, Out, K>;
+
+interface ZodCustom<O = unknown, I = unknown, K extends KrustyInternals = KrustyInternals> extends _KrustyType<core.$ZodCustomInternals<O, I>, K>, core.$ZodCustom<O, I> {
+}
+declare const ZodCustom: core.$constructor<ZodCustom>;
+declare function check<O = unknown>(fn: core.CheckFn<O>): core.$ZodCheck<O>;
+declare function custom<O, K extends KrustyInternals>(fn?: (data: unknown) => unknown, _params?: string | core.$ZodCustomParams | undefined): ZodCustom<O, O, K>;
+declare function refine<T>(fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>, _params?: string | core.$ZodCustomParams): core.$ZodCheck<T>;
+declare function superRefine<T>(fn: (arg: T, payload: core.$RefinementCtx<T>) => void | Promise<void>): core.$ZodCheck<T>;
+type ZodInstanceOfParams = core.Params<ZodCustom, core.$ZodIssueCustom, 'type' | 'check' | 'checks' | 'fn' | 'abort' | 'error' | 'params' | 'path'>;
+declare function _instanceof<T extends typeof util.Class, K extends KrustyInternals>(cls: T, params?: ZodInstanceOfParams): ZodCustom<InstanceType<T>, InstanceType<T>, K>;
+
+declare const stringbool: <K extends KrustyInternals = KrustyInternals>(_params?: string | core.$ZodStringBoolParams) => ZodCodec<ZodString, ZodBoolean, K>;
+type _ZodJSONSchema<K extends KrustyInternals = KrustyInternals> = ZodUnion<[
+    ZodString,
+    ZodNumber,
+    ZodBoolean,
+    ZodNull,
+    ZodArray<ZodJSONSchema, K>,
+    ZodRecord<ZodString, ZodJSONSchema, K>
+], K>;
+type _ZodJSONSchemaInternals = _ZodJSONSchema['_zod'];
+interface ZodJSONSchemaInternals extends _ZodJSONSchemaInternals {
+    output: util.JSONType;
+    input: util.JSONType;
+}
+interface ZodJSONSchema<K extends KrustyInternals = KrustyInternals> extends _ZodJSONSchema<K> {
+    _zod: ZodJSONSchemaInternals;
+}
+declare function json<K extends KrustyInternals = KrustyInternals>(params?: string | core.$ZodCustomParams): ZodJSONSchema<K>;
+declare function preprocess<A, U extends core.SomeType, B = unknown, K extends KrustyInternals = KrustyInternals>(fn: (arg: B, ctx: core.$RefinementCtx) => A, schema: U): ZodPipe<ZodTransform<A, B>, U, K>;
+
+declare class SchemaClass<GateNames extends string = string, K extends KrustyInternals = KrustyInternals<GateNames>> {
+    string(params?: string | core.$ZodStringParams): ZodString<K>;
+    number(params?: string | core.$ZodNumberParams): ZodNumber<K>;
+    int(params?: string | core.$ZodCheckNumberFormatParams): ZodNumber<K>;
+    boolean(params?: string | core.$ZodBooleanParams): ZodBoolean<K>;
+    null(params?: string | core.$ZodNullParams): ZodNull<K>;
+    array<T extends core.SomeType>(element: T, params?: string | core.$ZodArrayParams): ZodArray<T, K>;
+    record<Key extends core.$ZodRecordKey, Value extends core.SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams): ZodRecord<Key, Value, K>;
+    union<const T extends readonly core.SomeType[]>(options: T, params?: string | core.$ZodUnionParams): ZodUnion<T, K>;
+    discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable, ...core.$ZodTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodDiscriminatedUnion<Types, Disc, K>;
+    object<T extends core.$ZodLooseShape = Partial<Record<never, core.SomeType>>>(shape?: T, params?: string | core.$ZodObjectParams): ZodObject<core.util.Writeable<T>, core.$strip, K>;
+    date(params?: string | core.$ZodDateParams): ZodDate<K>;
+    any(): ZodAny<K>;
+    unknown(): ZodUnknown<K>;
+    never(params?: string | core.$ZodNeverParams): ZodNever<K>;
+    lazy<T extends core.SomeType>(getter: () => T): ZodLazy<T, K>;
+    json(params?: string | core.$ZodCustomParams): ZodJSONSchema<K>;
+}
+
+type AnySchema = $ZodType<any, any>;
 
-export { ZodSmartCoercionPlugin, ZodToJsonSchemaConverter, blob, composeParams, customJsonSchema, file, getCustomJsonSchema, getCustomZodDef, oz, regexp, setCustomZodDef, url };
-export type { CustomParams, CustomZodDef, ZodToJsonSchemaOptions };
+export { $ZodGate, KrustyType, SchemaClass, ZodAny, ZodArray, ZodBase64, ZodBase64URL, ZodBigInt, ZodBigIntFormat, ZodBoolean, ZodCIDRv4, ZodCIDRv6, ZodCUID, ZodCUID2, ZodCatch, ZodCodec, ZodCustom, ZodCustomStringFormat, ZodDate, ZodDefault, ZodDiscriminatedUnion, ZodE164, ZodEmail, ZodEmoji, ZodEnum, ZodError, ZodFile, ZodFunction, ZodGUID, ZodGate, ZodIPv4, ZodIPv6, ZodIntersection, ZodJWT, ZodKSUID, ZodLazy, ZodLiteral, ZodMap, ZodNaN, ZodNanoID, ZodNever, ZodNonOptional, ZodNull, ZodNullable, ZodNumber, ZodNumberFormat, ZodObject, ZodOptional, ZodPipe, ZodPrefault, ZodPromise, ZodReadonly, ZodRealError, ZodRecord, ZodSet, ZodString, ZodStringFormat, ZodSuccess, ZodSymbol, ZodTemplateLiteral, ZodTransform, ZodTuple, ZodULID, ZodURL, ZodUUID, ZodUndefined, ZodUnion, ZodUnknown, ZodVoid, ZodXID, _ZodString, _default, _function, any, array, base64, base64url, bigint, blob, boolean, _catch as catch, check, cidrv4, cidrv6, codec, cuid, cuid2, custom, date, decode, decodeAsync, discriminatedUnion, e164, email, emoji, encode, encodeAsync, _enum as enum, file, float32, float64, _function as function, gate, gatingContext, guid, hash, hex, hostname, httpUrl, _instanceof as instanceof, int, int32, int64, intersection, ipv4, ipv6, isGateIssue, isGateIssueRaw, json, jwt, keyof, ksuid, lazy, literal, looseObject, map, nan, nanoid, nativeEnum, never, nonoptional, _null as null, nullable, nullish, number, object, optional, parse, parseAsync, partialRecord, pipe, prefault, preprocess, promise, readonly, record, refine, regexp, safeDecode, safeDecodeAsync, safeEncode, safeEncodeAsync, safeParse, safeParseAsync, set, strictObject, string, stringFormat, stringbool, success, superRefine, symbol, templateLiteral, transform, tuple, uint32, uint64, ulid, _undefined as undefined, union, unknown, url, uuid, uuidv4, uuidv6, uuidv7, _void as void, xid };
+export type { $ZodGateDef, $ZodGateInternals, AnySchema, IsGateEnabled, IssueData, KrustyInternals, SafeExtendShape, ZodFloat32, ZodFloat64, ZodInt, ZodInt32, ZodIssue, ZodJSONSchema, ZodJSONSchemaInternals, ZodSafeParseError, ZodSafeParseResult, ZodSafeParseSuccess, ZodUInt32, _KrustyType, _ZodBigInt, _ZodBoolean, _ZodDate, _ZodNumber };