fullstacked 0.12.0-1273 → 0.12.0-1291

package/fullstacked_modules/zod/v4/core/api.d.ts

@@ -19,73 +19,73 @@ export type CheckTypeParams<T extends schemas.$ZodType & checks.$ZodCheck = sche
 export type $ZodStringParams = TypeParams<schemas.$ZodString<string>, "coerce">;
 export declare function _string<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;
 export declare function _coercedString<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;
-export type $ZodStringFormatParams = CheckTypeParams<schemas.$ZodStringFormat, "format" | "coerce" | "when" | "pattern">;
+export type $ZodStringFormatParams = CheckTypeParams<schemas.$ZodStringFormat, "format" | "coerce">;
 export type $ZodCheckStringFormatParams = CheckParams<checks.$ZodCheckStringFormat, "format">;
-export type $ZodEmailParams = StringFormatParams<schemas.$ZodEmail, "when">;
-export type $ZodCheckEmailParams = CheckStringFormatParams<schemas.$ZodEmail, "when">;
+export type $ZodEmailParams = StringFormatParams<schemas.$ZodEmail>;
+export type $ZodCheckEmailParams = CheckStringFormatParams<schemas.$ZodEmail>;
 export declare function _email<T extends schemas.$ZodEmail>(Class: util.SchemaClass<T>, params?: string | $ZodEmailParams | $ZodCheckEmailParams): T;
-export type $ZodGUIDParams = StringFormatParams<schemas.$ZodGUID, "pattern" | "when">;
-export type $ZodCheckGUIDParams = CheckStringFormatParams<schemas.$ZodGUID, "pattern" | "when">;
+export type $ZodGUIDParams = StringFormatParams<schemas.$ZodGUID, "pattern">;
+export type $ZodCheckGUIDParams = CheckStringFormatParams<schemas.$ZodGUID, "pattern">;
 export declare function _guid<T extends schemas.$ZodGUID>(Class: util.SchemaClass<T>, params?: string | $ZodGUIDParams | $ZodCheckGUIDParams): T;
-export type $ZodUUIDParams = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
-export type $ZodCheckUUIDParams = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
+export type $ZodUUIDParams = StringFormatParams<schemas.$ZodUUID, "pattern">;
+export type $ZodCheckUUIDParams = CheckStringFormatParams<schemas.$ZodUUID, "pattern">;
 export declare function _uuid<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDParams | $ZodCheckUUIDParams): T;
-export type $ZodUUIDv4Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
-export type $ZodCheckUUIDv4Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
+export type $ZodUUIDv4Params = StringFormatParams<schemas.$ZodUUID, "pattern">;
+export type $ZodCheckUUIDv4Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern">;
 export declare function _uuidv4<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv4Params | $ZodCheckUUIDv4Params): T;
-export type $ZodUUIDv6Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
-export type $ZodCheckUUIDv6Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
+export type $ZodUUIDv6Params = StringFormatParams<schemas.$ZodUUID, "pattern">;
+export type $ZodCheckUUIDv6Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern">;
 export declare function _uuidv6<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv6Params | $ZodCheckUUIDv6Params): T;
-export type $ZodUUIDv7Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
-export type $ZodCheckUUIDv7Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
+export type $ZodUUIDv7Params = StringFormatParams<schemas.$ZodUUID, "pattern">;
+export type $ZodCheckUUIDv7Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern">;
 export declare function _uuidv7<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv7Params | $ZodCheckUUIDv7Params): T;
-export type $ZodURLParams = StringFormatParams<schemas.$ZodURL, "when">;
-export type $ZodCheckURLParams = CheckStringFormatParams<schemas.$ZodURL, "when">;
+export type $ZodURLParams = StringFormatParams<schemas.$ZodURL>;
+export type $ZodCheckURLParams = CheckStringFormatParams<schemas.$ZodURL>;
 export declare function _url<T extends schemas.$ZodURL>(Class: util.SchemaClass<T>, params?: string | $ZodURLParams | $ZodCheckURLParams): T;
-export type $ZodEmojiParams = StringFormatParams<schemas.$ZodEmoji, "when">;
-export type $ZodCheckEmojiParams = CheckStringFormatParams<schemas.$ZodEmoji, "when">;
+export type $ZodEmojiParams = StringFormatParams<schemas.$ZodEmoji>;
+export type $ZodCheckEmojiParams = CheckStringFormatParams<schemas.$ZodEmoji>;
 export declare function _emoji<T extends schemas.$ZodEmoji>(Class: util.SchemaClass<T>, params?: string | $ZodEmojiParams | $ZodCheckEmojiParams): T;
-export type $ZodNanoIDParams = StringFormatParams<schemas.$ZodNanoID, "when">;
-export type $ZodCheckNanoIDParams = CheckStringFormatParams<schemas.$ZodNanoID, "when">;
+export type $ZodNanoIDParams = StringFormatParams<schemas.$ZodNanoID>;
+export type $ZodCheckNanoIDParams = CheckStringFormatParams<schemas.$ZodNanoID>;
 export declare function _nanoid<T extends schemas.$ZodNanoID>(Class: util.SchemaClass<T>, params?: string | $ZodNanoIDParams | $ZodCheckNanoIDParams): T;
-export type $ZodCUIDParams = StringFormatParams<schemas.$ZodCUID, "when">;
-export type $ZodCheckCUIDParams = CheckStringFormatParams<schemas.$ZodCUID, "when">;
+export type $ZodCUIDParams = StringFormatParams<schemas.$ZodCUID>;
+export type $ZodCheckCUIDParams = CheckStringFormatParams<schemas.$ZodCUID>;
 export declare function _cuid<T extends schemas.$ZodCUID>(Class: util.SchemaClass<T>, params?: string | $ZodCUIDParams | $ZodCheckCUIDParams): T;
-export type $ZodCUID2Params = StringFormatParams<schemas.$ZodCUID2, "when">;
-export type $ZodCheckCUID2Params = CheckStringFormatParams<schemas.$ZodCUID2, "when">;
+export type $ZodCUID2Params = StringFormatParams<schemas.$ZodCUID2>;
+export type $ZodCheckCUID2Params = CheckStringFormatParams<schemas.$ZodCUID2>;
 export declare function _cuid2<T extends schemas.$ZodCUID2>(Class: util.SchemaClass<T>, params?: string | $ZodCUID2Params | $ZodCheckCUID2Params): T;
-export type $ZodULIDParams = StringFormatParams<schemas.$ZodULID, "when">;
-export type $ZodCheckULIDParams = CheckStringFormatParams<schemas.$ZodULID, "when">;
+export type $ZodULIDParams = StringFormatParams<schemas.$ZodULID>;
+export type $ZodCheckULIDParams = CheckStringFormatParams<schemas.$ZodULID>;
 export declare function _ulid<T extends schemas.$ZodULID>(Class: util.SchemaClass<T>, params?: string | $ZodULIDParams | $ZodCheckULIDParams): T;
-export type $ZodXIDParams = StringFormatParams<schemas.$ZodXID, "when">;
-export type $ZodCheckXIDParams = CheckStringFormatParams<schemas.$ZodXID, "when">;
+export type $ZodXIDParams = StringFormatParams<schemas.$ZodXID>;
+export type $ZodCheckXIDParams = CheckStringFormatParams<schemas.$ZodXID>;
 export declare function _xid<T extends schemas.$ZodXID>(Class: util.SchemaClass<T>, params?: string | $ZodXIDParams | $ZodCheckXIDParams): T;
-export type $ZodKSUIDParams = StringFormatParams<schemas.$ZodKSUID, "when">;
-export type $ZodCheckKSUIDParams = CheckStringFormatParams<schemas.$ZodKSUID, "when">;
+export type $ZodKSUIDParams = StringFormatParams<schemas.$ZodKSUID>;
+export type $ZodCheckKSUIDParams = CheckStringFormatParams<schemas.$ZodKSUID>;
 export declare function _ksuid<T extends schemas.$ZodKSUID>(Class: util.SchemaClass<T>, params?: string | $ZodKSUIDParams | $ZodCheckKSUIDParams): T;
-export type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, "pattern" | "when">;
-export type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, "pattern" | "when">;
+export type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, "pattern">;
+export type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, "pattern">;
 export declare function _ipv4<T extends schemas.$ZodIPv4>(Class: util.SchemaClass<T>, params?: string | $ZodIPv4Params | $ZodCheckIPv4Params): T;
-export type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, "pattern" | "when">;
-export type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, "pattern" | "when">;
+export type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, "pattern">;
+export type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, "pattern">;
 export declare function _ipv6<T extends schemas.$ZodIPv6>(Class: util.SchemaClass<T>, params?: string | $ZodIPv6Params | $ZodCheckIPv6Params): T;
-export type $ZodCIDRv4Params = StringFormatParams<schemas.$ZodCIDRv4, "pattern" | "when">;
-export type $ZodCheckCIDRv4Params = CheckStringFormatParams<schemas.$ZodCIDRv4, "pattern" | "when">;
+export type $ZodCIDRv4Params = StringFormatParams<schemas.$ZodCIDRv4, "pattern">;
+export type $ZodCheckCIDRv4Params = CheckStringFormatParams<schemas.$ZodCIDRv4, "pattern">;
 export declare function _cidrv4<T extends schemas.$ZodCIDRv4>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv4Params | $ZodCheckCIDRv4Params): T;
-export type $ZodCIDRv6Params = StringFormatParams<schemas.$ZodCIDRv6, "pattern" | "when">;
-export type $ZodCheckCIDRv6Params = CheckStringFormatParams<schemas.$ZodCIDRv6, "pattern" | "when">;
+export type $ZodCIDRv6Params = StringFormatParams<schemas.$ZodCIDRv6, "pattern">;
+export type $ZodCheckCIDRv6Params = CheckStringFormatParams<schemas.$ZodCIDRv6, "pattern">;
 export declare function _cidrv6<T extends schemas.$ZodCIDRv6>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv6Params | $ZodCheckCIDRv6Params): T;
-export type $ZodBase64Params = StringFormatParams<schemas.$ZodBase64, "pattern" | "when">;
-export type $ZodCheckBase64Params = CheckStringFormatParams<schemas.$ZodBase64, "pattern" | "when">;
+export type $ZodBase64Params = StringFormatParams<schemas.$ZodBase64, "pattern">;
+export type $ZodCheckBase64Params = CheckStringFormatParams<schemas.$ZodBase64, "pattern">;
 export declare function _base64<T extends schemas.$ZodBase64>(Class: util.SchemaClass<T>, params?: string | $ZodBase64Params | $ZodCheckBase64Params): T;
-export type $ZodBase64URLParams = StringFormatParams<schemas.$ZodBase64URL, "pattern" | "when">;
-export type $ZodCheckBase64URLParams = CheckStringFormatParams<schemas.$ZodBase64URL, "pattern" | "when">;
+export type $ZodBase64URLParams = StringFormatParams<schemas.$ZodBase64URL, "pattern">;
+export type $ZodCheckBase64URLParams = CheckStringFormatParams<schemas.$ZodBase64URL, "pattern">;
 export declare function _base64url<T extends schemas.$ZodBase64URL>(Class: util.SchemaClass<T>, params?: string | $ZodBase64URLParams | $ZodCheckBase64URLParams): T;
-export type $ZodE164Params = StringFormatParams<schemas.$ZodE164, "when">;
-export type $ZodCheckE164Params = CheckStringFormatParams<schemas.$ZodE164, "when">;
+export type $ZodE164Params = StringFormatParams<schemas.$ZodE164>;
+export type $ZodCheckE164Params = CheckStringFormatParams<schemas.$ZodE164>;
 export declare function _e164<T extends schemas.$ZodE164>(Class: util.SchemaClass<T>, params?: string | $ZodE164Params | $ZodCheckE164Params): T;
-export type $ZodJWTParams = StringFormatParams<schemas.$ZodJWT, "pattern" | "when">;
-export type $ZodCheckJWTParams = CheckStringFormatParams<schemas.$ZodJWT, "pattern" | "when">;
+export type $ZodJWTParams = StringFormatParams<schemas.$ZodJWT, "pattern">;
+export type $ZodCheckJWTParams = CheckStringFormatParams<schemas.$ZodJWT, "pattern">;
 export declare function _jwt<T extends schemas.$ZodJWT>(Class: util.SchemaClass<T>, params?: string | $ZodJWTParams | $ZodCheckJWTParams): T;
 export declare const TimePrecision: {
     readonly Any: null;
@@ -94,21 +94,21 @@ export declare const TimePrecision: {
     readonly Millisecond: 3;
     readonly Microsecond: 6;
 };
-export type $ZodISODateTimeParams = StringFormatParams<schemas.$ZodISODateTime, "pattern" | "when">;
-export type $ZodCheckISODateTimeParams = CheckStringFormatParams<schemas.$ZodISODateTime, "pattern" | "when">;
+export type $ZodISODateTimeParams = StringFormatParams<schemas.$ZodISODateTime, "pattern">;
+export type $ZodCheckISODateTimeParams = CheckStringFormatParams<schemas.$ZodISODateTime, "pattern">;
 export declare function _isoDateTime<T extends schemas.$ZodISODateTime>(Class: util.SchemaClass<T>, params?: string | $ZodISODateTimeParams | $ZodCheckISODateTimeParams): T;
-export type $ZodISODateParams = StringFormatParams<schemas.$ZodISODate, "pattern" | "when">;
-export type $ZodCheckISODateParams = CheckStringFormatParams<schemas.$ZodISODate, "pattern" | "when">;
+export type $ZodISODateParams = StringFormatParams<schemas.$ZodISODate, "pattern">;
+export type $ZodCheckISODateParams = CheckStringFormatParams<schemas.$ZodISODate, "pattern">;
 export declare function _isoDate<T extends schemas.$ZodISODate>(Class: util.SchemaClass<T>, params?: string | $ZodISODateParams | $ZodCheckISODateParams): T;
-export type $ZodISOTimeParams = StringFormatParams<schemas.$ZodISOTime, "pattern" | "when">;
-export type $ZodCheckISOTimeParams = CheckStringFormatParams<schemas.$ZodISOTime, "pattern" | "when">;
+export type $ZodISOTimeParams = StringFormatParams<schemas.$ZodISOTime, "pattern">;
+export type $ZodCheckISOTimeParams = CheckStringFormatParams<schemas.$ZodISOTime, "pattern">;
 export declare function _isoTime<T extends schemas.$ZodISOTime>(Class: util.SchemaClass<T>, params?: string | $ZodISOTimeParams | $ZodCheckISOTimeParams): T;
-export type $ZodISODurationParams = StringFormatParams<schemas.$ZodISODuration, "when">;
-export type $ZodCheckISODurationParams = CheckStringFormatParams<schemas.$ZodISODuration, "when">;
+export type $ZodISODurationParams = StringFormatParams<schemas.$ZodISODuration>;
+export type $ZodCheckISODurationParams = CheckStringFormatParams<schemas.$ZodISODuration>;
 export declare function _isoDuration<T extends schemas.$ZodISODuration>(Class: util.SchemaClass<T>, params?: string | $ZodISODurationParams | $ZodCheckISODurationParams): T;
 export type $ZodNumberParams = TypeParams<schemas.$ZodNumber<number>, "coerce">;
 export type $ZodNumberFormatParams = CheckTypeParams<schemas.$ZodNumberFormat, "format" | "coerce">;
-export type $ZodCheckNumberFormatParams = CheckParams<checks.$ZodCheckNumberFormat, "format" | "when">;
+export type $ZodCheckNumberFormatParams = CheckParams<checks.$ZodCheckNumberFormat, "format">;
 export declare function _number<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;
 export declare function _coercedNumber<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;
 export declare function _int<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
@@ -121,7 +121,7 @@ export declare function _boolean<T extends schemas.$ZodBoolean>(Class: util.Sche
 export declare function _coercedBoolean<T extends schemas.$ZodBoolean>(Class: util.SchemaClass<T>, params?: string | $ZodBooleanParams): T;
 export type $ZodBigIntParams = TypeParams<schemas.$ZodBigInt<bigint>>;
 export type $ZodBigIntFormatParams = CheckTypeParams<schemas.$ZodBigIntFormat, "format" | "coerce">;
-export type $ZodCheckBigIntFormatParams = CheckParams<checks.$ZodCheckBigIntFormat, "format" | "when">;
+export type $ZodCheckBigIntFormatParams = CheckParams<checks.$ZodCheckBigIntFormat, "format">;
 export declare function _bigint<T extends schemas.$ZodBigInt>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntParams): T;
 export declare function _coercedBigint<T extends schemas.$ZodBigInt>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntParams): T;
 export declare function _int64<T extends schemas.$ZodBigIntFormat>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntFormatParams): T;
@@ -145,13 +145,13 @@ export declare function _date<T extends schemas.$ZodDate>(Class: util.SchemaClas
 export declare function _coercedDate<T extends schemas.$ZodDate>(Class: util.SchemaClass<T>, params?: string | $ZodDateParams): T;
 export type $ZodNaNParams = TypeParams<schemas.$ZodNaN>;
 export declare function _nan<T extends schemas.$ZodNaN>(Class: util.SchemaClass<T>, params?: string | $ZodNaNParams): T;
-export type $ZodCheckLessThanParams = CheckParams<checks.$ZodCheckLessThan, "inclusive" | "value" | "when">;
+export type $ZodCheckLessThanParams = CheckParams<checks.$ZodCheckLessThan, "inclusive" | "value">;
 export declare function _lt(value: util.Numeric, params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan<util.Numeric>;
 export declare function _lte(value: util.Numeric, params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan<util.Numeric>;
 export { 
 /** @deprecated Use `z.lte()` instead. */
 _lte as _max, };
-export type $ZodCheckGreaterThanParams = CheckParams<checks.$ZodCheckGreaterThan, "inclusive" | "value" | "when">;
+export type $ZodCheckGreaterThanParams = CheckParams<checks.$ZodCheckGreaterThan, "inclusive" | "value">;
 export declare function _gt(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;
 export declare function _gte(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;
 export { 
@@ -161,37 +161,37 @@ export declare function _positive(params?: string | $ZodCheckGreaterThanParams):
 export declare function _negative(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan;
 export declare function _nonpositive(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan;
 export declare function _nonnegative(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;
-export type $ZodCheckMultipleOfParams = CheckParams<checks.$ZodCheckMultipleOf, "value" | "when">;
+export type $ZodCheckMultipleOfParams = CheckParams<checks.$ZodCheckMultipleOf, "value">;
 export declare function _multipleOf(value: number | bigint, params?: string | $ZodCheckMultipleOfParams): checks.$ZodCheckMultipleOf;
-export type $ZodCheckMaxSizeParams = CheckParams<checks.$ZodCheckMaxSize, "maximum" | "when">;
+export type $ZodCheckMaxSizeParams = CheckParams<checks.$ZodCheckMaxSize, "maximum">;
 export declare function _maxSize(maximum: number, params?: string | $ZodCheckMaxSizeParams): checks.$ZodCheckMaxSize<util.HasSize>;
-export type $ZodCheckMinSizeParams = CheckParams<checks.$ZodCheckMinSize, "minimum" | "when">;
+export type $ZodCheckMinSizeParams = CheckParams<checks.$ZodCheckMinSize, "minimum">;
 export declare function _minSize(minimum: number, params?: string | $ZodCheckMinSizeParams): checks.$ZodCheckMinSize<util.HasSize>;
-export type $ZodCheckSizeEqualsParams = CheckParams<checks.$ZodCheckSizeEquals, "size" | "when">;
+export type $ZodCheckSizeEqualsParams = CheckParams<checks.$ZodCheckSizeEquals, "size">;
 export declare function _size(size: number, params?: string | $ZodCheckSizeEqualsParams): checks.$ZodCheckSizeEquals<util.HasSize>;
-export type $ZodCheckMaxLengthParams = CheckParams<checks.$ZodCheckMaxLength, "maximum" | "when">;
+export type $ZodCheckMaxLengthParams = CheckParams<checks.$ZodCheckMaxLength, "maximum">;
 export declare function _maxLength(maximum: number, params?: string | $ZodCheckMaxLengthParams): checks.$ZodCheckMaxLength<util.HasLength>;
-export type $ZodCheckMinLengthParams = CheckParams<checks.$ZodCheckMinLength, "minimum" | "when">;
+export type $ZodCheckMinLengthParams = CheckParams<checks.$ZodCheckMinLength, "minimum">;
 export declare function _minLength(minimum: number, params?: string | $ZodCheckMinLengthParams): checks.$ZodCheckMinLength<util.HasLength>;
-export type $ZodCheckLengthEqualsParams = CheckParams<checks.$ZodCheckLengthEquals, "length" | "when">;
+export type $ZodCheckLengthEqualsParams = CheckParams<checks.$ZodCheckLengthEquals, "length">;
 export declare function _length(length: number, params?: string | $ZodCheckLengthEqualsParams): checks.$ZodCheckLengthEquals<util.HasLength>;
-export type $ZodCheckRegexParams = CheckParams<checks.$ZodCheckRegex, "format" | "pattern" | "when">;
+export type $ZodCheckRegexParams = CheckParams<checks.$ZodCheckRegex, "format" | "pattern">;
 export declare function _regex(pattern: RegExp, params?: string | $ZodCheckRegexParams): checks.$ZodCheckRegex;
-export type $ZodCheckLowerCaseParams = CheckParams<checks.$ZodCheckLowerCase, "format" | "when">;
+export type $ZodCheckLowerCaseParams = CheckParams<checks.$ZodCheckLowerCase, "format">;
 export declare function _lowercase(params?: string | $ZodCheckLowerCaseParams): checks.$ZodCheckLowerCase;
-export type $ZodCheckUpperCaseParams = CheckParams<checks.$ZodCheckUpperCase, "format" | "when">;
+export type $ZodCheckUpperCaseParams = CheckParams<checks.$ZodCheckUpperCase, "format">;
 export declare function _uppercase(params?: string | $ZodCheckUpperCaseParams): checks.$ZodCheckUpperCase;
-export type $ZodCheckIncludesParams = CheckParams<checks.$ZodCheckIncludes, "includes" | "format" | "when" | "pattern">;
+export type $ZodCheckIncludesParams = CheckParams<checks.$ZodCheckIncludes, "includes" | "format" | "pattern">;
 export declare function _includes(includes: string, params?: string | $ZodCheckIncludesParams): checks.$ZodCheckIncludes;
-export type $ZodCheckStartsWithParams = CheckParams<checks.$ZodCheckStartsWith, "prefix" | "format" | "when" | "pattern">;
+export type $ZodCheckStartsWithParams = CheckParams<checks.$ZodCheckStartsWith, "prefix" | "format" | "pattern">;
 export declare function _startsWith(prefix: string, params?: string | $ZodCheckStartsWithParams): checks.$ZodCheckStartsWith;
-export type $ZodCheckEndsWithParams = CheckParams<checks.$ZodCheckEndsWith, "suffix" | "format" | "pattern" | "when">;
+export type $ZodCheckEndsWithParams = CheckParams<checks.$ZodCheckEndsWith, "suffix" | "format" | "pattern">;
 export declare function _endsWith(suffix: string, params?: string | $ZodCheckEndsWithParams): checks.$ZodCheckEndsWith;
-export type $ZodCheckPropertyParams = CheckParams<checks.$ZodCheckProperty, "property" | "schema" | "when">;
+export type $ZodCheckPropertyParams = CheckParams<checks.$ZodCheckProperty, "property" | "schema">;
 export declare function _property<K extends string, T extends schemas.$ZodType>(property: K, schema: T, params?: string | $ZodCheckPropertyParams): checks.$ZodCheckProperty<{
     [k in K]: core.output<T>;
 }>;
-export type $ZodCheckMimeTypeParams = CheckParams<checks.$ZodCheckMimeType, "mime" | "when">;
+export type $ZodCheckMimeTypeParams = CheckParams<checks.$ZodCheckMimeType, "mime">;
 export declare function _mime(types: util.MimeTypes[], params?: string | $ZodCheckMimeTypeParams): checks.$ZodCheckMimeType;
 export declare function _overwrite<T>(tx: (input: T) => T): checks.$ZodCheckOverwrite<T>;
 export declare function _normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): checks.$ZodCheckOverwrite<string>;
@@ -265,18 +265,6 @@ export declare function _promise<T extends schemas.$ZodObject>(Class: util.Schem
 export type $ZodCustomParams = CheckTypeParams<schemas.$ZodCustom, "fn">;
 export declare function _custom<O = unknown, I = O>(Class: util.SchemaClass<schemas.$ZodCustom>, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined): schemas.$ZodCustom<O, I>;
 export declare function _refine<O = unknown, I = O>(Class: util.SchemaClass<schemas.$ZodCustom>, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined): schemas.$ZodCustom<O, I>;
-export type $ZodSuperRefineIssue<T extends errors.$ZodIssueBase = errors.$ZodIssue> = T extends any ? RawIssue<T> : never;
-type RawIssue<T extends errors.$ZodIssueBase> = T extends any ? util.Flatten<util.MakePartial<T, "message" | "path"> & {
-    /** The schema or check that originated this issue. */
-    readonly inst?: schemas.$ZodType | checks.$ZodCheck;
-    /** If `true`, Zod will continue executing checks/refinements after this issue. */
-    readonly continue?: boolean | undefined;
-} & Record<string, unknown>> : never;
-export interface $RefinementCtx<T = unknown> extends schemas.ParsePayload<T> {
-    addIssue(arg: string | $ZodSuperRefineIssue): void;
-}
-export declare function _superRefine<T>(fn: (arg: T, payload: $RefinementCtx<T>) => void | Promise<void>): checks.$ZodCheck<T>;
-export declare function _check<O = unknown>(fn: schemas.CheckFn<O>, params?: string | $ZodCustomParams): checks.$ZodCheck<O>;
 export interface $ZodStringBoolParams extends TypeParams {
     truthy?: string[];
     falsy?: string[];

package/fullstacked_modules/zod/v4/core/checks.d.cts

@@ -254,11 +254,11 @@ export interface $ZodCheckMimeTypeDef extends $ZodCheckDef {
     check: "mime_type";
     mime: util.MimeTypes[];
 }
-export interface $ZodCheckMimeTypeInternals<T extends schemas.File = schemas.File> extends $ZodCheckInternals<T> {
+export interface $ZodCheckMimeTypeInternals<T extends File = File> extends $ZodCheckInternals<T> {
     def: $ZodCheckMimeTypeDef;
     issc: errors.$ZodIssueInvalidValue;
 }
-export interface $ZodCheckMimeType<T extends schemas.File = schemas.File> extends $ZodCheck<T> {
+export interface $ZodCheckMimeType<T extends File = File> extends $ZodCheck<T> {
     _zod: $ZodCheckMimeTypeInternals<T>;
 }
 export declare const $ZodCheckMimeType: core.$constructor<$ZodCheckMimeType>;

package/fullstacked_modules/zod/v4/core/checks.d.ts

@@ -254,11 +254,11 @@ export interface $ZodCheckMimeTypeDef extends $ZodCheckDef {
     check: "mime_type";
     mime: util.MimeTypes[];
 }
-export interface $ZodCheckMimeTypeInternals<T extends schemas.File = schemas.File> extends $ZodCheckInternals<T> {
+export interface $ZodCheckMimeTypeInternals<T extends File = File> extends $ZodCheckInternals<T> {
     def: $ZodCheckMimeTypeDef;
     issc: errors.$ZodIssueInvalidValue;
 }
-export interface $ZodCheckMimeType<T extends schemas.File = schemas.File> extends $ZodCheck<T> {
+export interface $ZodCheckMimeType<T extends File = File> extends $ZodCheck<T> {
     _zod: $ZodCheckMimeTypeInternals<T>;
 }
 export declare const $ZodCheckMimeType: core.$constructor<$ZodCheckMimeType>;

package/fullstacked_modules/zod/v4/core/doc.d.cts

@@ -9,6 +9,6 @@ export declare class Doc {
     indented(fn: (doc: Doc) => void): void;
     write(fn: ModeWriter): void;
     write(line: string): void;
-    compile(): any;
+    compile(): Function;
 }
 export {};

package/fullstacked_modules/zod/v4/core/doc.d.ts

@@ -9,6 +9,6 @@ export declare class Doc {
     indented(fn: (doc: Doc) => void): void;
     write(fn: ModeWriter): void;
     write(line: string): void;
-    compile(): any;
+    compile(): Function;
 }
 export {};

package/fullstacked_modules/zod/v4/core/errors.d.cts

@@ -1,7 +1,6 @@
 import type { $ZodCheck, $ZodStringFormats } from "./checks.cjs";
 import { $constructor } from "./core.cjs";
 import type { $ZodType } from "./schemas.cjs";
-import type { StandardSchemaV1 } from "./standard-schema.cjs";
 import * as util from "./util.cjs";
 export interface $ZodIssueBase {
     readonly code?: string;
@@ -12,7 +11,7 @@ export interface $ZodIssueBase {
 export interface $ZodIssueInvalidType<Input = unknown> extends $ZodIssueBase {
     readonly code: "invalid_type";
     readonly expected: $ZodType["_zod"]["def"]["type"];
-    readonly input?: Input;
+    readonly input: Input;
 }
 export interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
     readonly code: "too_big";
@@ -20,7 +19,7 @@ export interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
     readonly maximum: number | bigint;
     readonly inclusive?: boolean;
     readonly exact?: boolean;
-    readonly input?: Input;
+    readonly input: Input;
 }
 export interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {
     readonly code: "too_small";
@@ -30,52 +29,51 @@ export interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {
     readonly inclusive?: boolean;
     /** True if the allowed value is fixed (e.g.` z.length(5)`), not a range (`z.minLength(5)`) */
     readonly exact?: boolean;
-    readonly input?: Input;
+    readonly input: Input;
 }
 export interface $ZodIssueInvalidStringFormat extends $ZodIssueBase {
     readonly code: "invalid_format";
     readonly format: $ZodStringFormats | (string & {});
     readonly pattern?: string;
-    readonly input?: string;
+    readonly input: string;
 }
 export interface $ZodIssueNotMultipleOf<Input extends number | bigint = number | bigint> extends $ZodIssueBase {
     readonly code: "not_multiple_of";
     readonly divisor: number;
-    readonly input?: Input;
+    readonly input: Input;
 }
 export interface $ZodIssueUnrecognizedKeys extends $ZodIssueBase {
     readonly code: "unrecognized_keys";
     readonly keys: string[];
-    readonly input?: Record<string, unknown>;
+    readonly input: Record<string, unknown>;
 }
 export interface $ZodIssueInvalidUnion extends $ZodIssueBase {
     readonly code: "invalid_union";
     readonly errors: $ZodIssue[][];
-    readonly input?: unknown;
-    readonly discriminator?: string | undefined;
+    readonly input: unknown;
 }
 export interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
     readonly code: "invalid_key";
     readonly origin: "map" | "record";
     readonly issues: $ZodIssue[];
-    readonly input?: Input;
+    readonly input: Input;
 }
 export interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase {
     readonly code: "invalid_element";
     readonly origin: "map" | "set";
     readonly key: unknown;
     readonly issues: $ZodIssue[];
-    readonly input?: Input;
+    readonly input: Input;
 }
 export interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {
     readonly code: "invalid_value";
     readonly values: util.Primitive[];
-    readonly input?: Input;
+    readonly input: Input;
 }
 export interface $ZodIssueCustom extends $ZodIssueBase {
     readonly code: "custom";
     readonly params?: Record<string, any> | undefined;
-    readonly input?: unknown;
+    readonly input: unknown;
 }
 export interface $ZodIssueStringCommonFormats extends $ZodIssueInvalidStringFormat {
     format: Exclude<$ZodStringFormats, "regex" | "jwt" | "starts_with" | "ends_with" | "includes">;
@@ -103,16 +101,15 @@ export interface $ZodIssueStringIncludes extends $ZodIssueInvalidStringFormat {
 export type $ZodStringFormatIssues = $ZodIssueStringCommonFormats | $ZodIssueStringInvalidRegex | $ZodIssueStringInvalidJWT | $ZodIssueStringStartsWith | $ZodIssueStringEndsWith | $ZodIssueStringIncludes;
 export type $ZodIssue = $ZodIssueInvalidType | $ZodIssueTooBig | $ZodIssueTooSmall | $ZodIssueInvalidStringFormat | $ZodIssueNotMultipleOf | $ZodIssueUnrecognizedKeys | $ZodIssueInvalidUnion | $ZodIssueInvalidKey | $ZodIssueInvalidElement | $ZodIssueInvalidValue | $ZodIssueCustom;
 export type $ZodIssueCode = $ZodIssue["code"];
-export type $ZodInternalIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
-type RawIssue<T extends $ZodIssueBase> = T extends any ? util.Flatten<util.MakePartial<T, "message" | "path"> & {
+export type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
+type RawIssue<T extends $ZodIssueBase> = util.Flatten<util.MakePartial<T, "message" | "path"> & {
     /** The input data */
-    readonly input: unknown;
+    readonly input?: unknown;
     /** The schema or check that originated this issue. */
     readonly inst?: $ZodType | $ZodCheck;
-    /** If `true`, Zod will continue executing checks/refinements after this issue. */
+    /** @deprecated Internal use only. If `true`, Zod will continue executing validation despite this issue. */
     readonly continue?: boolean | undefined;
-} & Record<string, unknown>> : never;
-export type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = $ZodInternalIssue<T>;
+} & Record<string, any>>;
 export interface $ZodErrorMap<T extends $ZodIssueBase = $ZodIssue> {
     (issue: $ZodRawIssue<T>): {
         message: string;
@@ -153,9 +150,7 @@ export type $ZodFormattedError<T, U = string> = {
 } & util.Flatten<_ZodFormattedError<T, U>>;
 export declare function formatError<T>(error: $ZodError<T>): $ZodFormattedError<T>;
 export declare function formatError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodFormattedError<T, U>;
-export type $ZodErrorTree<T, U = string> = T extends util.Primitive ? {
-    errors: U[];
-} : T extends [any, ...any[]] ? {
+export type $ZodErrorTree<T, U = string> = T extends [any, ...any[]] ? {
     errors: U[];
     items?: {
         [K in keyof T]?: $ZodErrorTree<T[K], U>;
@@ -205,6 +200,9 @@ export declare function treeifyError<T, U>(error: $ZodError<T>, mapper?: (issue:
  *   ✖ Invalid input: expected number
  * ```
  */
-export declare function toDotPath(_path: readonly (string | number | symbol | StandardSchemaV1.PathSegment)[]): string;
-export declare function prettifyError(error: StandardSchemaV1.FailureResult): string;
+export declare function toDotPath(path: (string | number | symbol)[]): string;
+interface BaseError {
+    issues: $ZodIssueBase[];
+}
+export declare function prettifyError(error: BaseError): string;
 export {};

package/fullstacked_modules/zod/v4/core/errors.d.ts

@@ -1,7 +1,6 @@
 import type { $ZodCheck, $ZodStringFormats } from "./checks.js";
 import { $constructor } from "./core.js";
 import type { $ZodType } from "./schemas.js";
-import type { StandardSchemaV1 } from "./standard-schema.js";
 import * as util from "./util.js";
 export interface $ZodIssueBase {
     readonly code?: string;
@@ -12,7 +11,7 @@ export interface $ZodIssueBase {
 export interface $ZodIssueInvalidType<Input = unknown> extends $ZodIssueBase {
     readonly code: "invalid_type";
     readonly expected: $ZodType["_zod"]["def"]["type"];
-    readonly input?: Input;
+    readonly input: Input;
 }
 export interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
     readonly code: "too_big";
@@ -20,7 +19,7 @@ export interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
     readonly maximum: number | bigint;
     readonly inclusive?: boolean;
     readonly exact?: boolean;
-    readonly input?: Input;
+    readonly input: Input;
 }
 export interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {
     readonly code: "too_small";
@@ -30,52 +29,51 @@ export interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {
     readonly inclusive?: boolean;
     /** True if the allowed value is fixed (e.g.` z.length(5)`), not a range (`z.minLength(5)`) */
     readonly exact?: boolean;
-    readonly input?: Input;
+    readonly input: Input;
 }
 export interface $ZodIssueInvalidStringFormat extends $ZodIssueBase {
     readonly code: "invalid_format";
     readonly format: $ZodStringFormats | (string & {});
     readonly pattern?: string;
-    readonly input?: string;
+    readonly input: string;
 }
 export interface $ZodIssueNotMultipleOf<Input extends number | bigint = number | bigint> extends $ZodIssueBase {
     readonly code: "not_multiple_of";
     readonly divisor: number;
-    readonly input?: Input;
+    readonly input: Input;
 }
 export interface $ZodIssueUnrecognizedKeys extends $ZodIssueBase {
     readonly code: "unrecognized_keys";
     readonly keys: string[];
-    readonly input?: Record<string, unknown>;
+    readonly input: Record<string, unknown>;
 }
 export interface $ZodIssueInvalidUnion extends $ZodIssueBase {
     readonly code: "invalid_union";
     readonly errors: $ZodIssue[][];
-    readonly input?: unknown;
-    readonly discriminator?: string | undefined;
+    readonly input: unknown;
 }
 export interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
     readonly code: "invalid_key";
     readonly origin: "map" | "record";
     readonly issues: $ZodIssue[];
-    readonly input?: Input;
+    readonly input: Input;
 }
 export interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase {
     readonly code: "invalid_element";
     readonly origin: "map" | "set";
     readonly key: unknown;
     readonly issues: $ZodIssue[];
-    readonly input?: Input;
+    readonly input: Input;
 }
 export interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {
     readonly code: "invalid_value";
     readonly values: util.Primitive[];
-    readonly input?: Input;
+    readonly input: Input;
 }
 export interface $ZodIssueCustom extends $ZodIssueBase {
     readonly code: "custom";
     readonly params?: Record<string, any> | undefined;
-    readonly input?: unknown;
+    readonly input: unknown;
 }
 export interface $ZodIssueStringCommonFormats extends $ZodIssueInvalidStringFormat {
     format: Exclude<$ZodStringFormats, "regex" | "jwt" | "starts_with" | "ends_with" | "includes">;
@@ -103,16 +101,15 @@ export interface $ZodIssueStringIncludes extends $ZodIssueInvalidStringFormat {
 export type $ZodStringFormatIssues = $ZodIssueStringCommonFormats | $ZodIssueStringInvalidRegex | $ZodIssueStringInvalidJWT | $ZodIssueStringStartsWith | $ZodIssueStringEndsWith | $ZodIssueStringIncludes;
 export type $ZodIssue = $ZodIssueInvalidType | $ZodIssueTooBig | $ZodIssueTooSmall | $ZodIssueInvalidStringFormat | $ZodIssueNotMultipleOf | $ZodIssueUnrecognizedKeys | $ZodIssueInvalidUnion | $ZodIssueInvalidKey | $ZodIssueInvalidElement | $ZodIssueInvalidValue | $ZodIssueCustom;
 export type $ZodIssueCode = $ZodIssue["code"];
-export type $ZodInternalIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
-type RawIssue<T extends $ZodIssueBase> = T extends any ? util.Flatten<util.MakePartial<T, "message" | "path"> & {
+export type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
+type RawIssue<T extends $ZodIssueBase> = util.Flatten<util.MakePartial<T, "message" | "path"> & {
     /** The input data */
-    readonly input: unknown;
+    readonly input?: unknown;
     /** The schema or check that originated this issue. */
     readonly inst?: $ZodType | $ZodCheck;
-    /** If `true`, Zod will continue executing checks/refinements after this issue. */
+    /** @deprecated Internal use only. If `true`, Zod will continue executing validation despite this issue. */
     readonly continue?: boolean | undefined;
-} & Record<string, unknown>> : never;
-export type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = $ZodInternalIssue<T>;
+} & Record<string, any>>;
 export interface $ZodErrorMap<T extends $ZodIssueBase = $ZodIssue> {
     (issue: $ZodRawIssue<T>): {
         message: string;
@@ -153,9 +150,7 @@ export type $ZodFormattedError<T, U = string> = {
 } & util.Flatten<_ZodFormattedError<T, U>>;
 export declare function formatError<T>(error: $ZodError<T>): $ZodFormattedError<T>;
 export declare function formatError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodFormattedError<T, U>;
-export type $ZodErrorTree<T, U = string> = T extends util.Primitive ? {
-    errors: U[];
-} : T extends [any, ...any[]] ? {
+export type $ZodErrorTree<T, U = string> = T extends [any, ...any[]] ? {
     errors: U[];
     items?: {
         [K in keyof T]?: $ZodErrorTree<T[K], U>;
@@ -205,6 +200,9 @@ export declare function treeifyError<T, U>(error: $ZodError<T>, mapper?: (issue:
  *   ✖ Invalid input: expected number
  * ```
  */
-export declare function toDotPath(_path: readonly (string | number | symbol | StandardSchemaV1.PathSegment)[]): string;
-export declare function prettifyError(error: StandardSchemaV1.FailureResult): string;
+export declare function toDotPath(path: (string | number | symbol)[]): string;
+interface BaseError {
+    issues: $ZodIssueBase[];
+}
+export declare function prettifyError(error: BaseError): string;
 export {};

package/fullstacked_modules/zod/v4/core/json-schema.d.cts

@@ -2,7 +2,7 @@ export type Schema = ObjectSchema | ArraySchema | StringSchema | NumberSchema |
 export type _JSONSchema = boolean | JSONSchema;
 export type JSONSchema = {
     [k: string]: unknown;
-    $schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#" | "http://json-schema.org/draft-04/schema#";
+    $schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#";
     $id?: string;
     $anchor?: string;
     $ref?: string;
@@ -32,9 +32,9 @@ export type JSONSchema = {
     not?: _JSONSchema;
     multipleOf?: number;
     maximum?: number;
-    exclusiveMaximum?: number | boolean;
+    exclusiveMaximum?: number;
     minimum?: number;
-    exclusiveMinimum?: number | boolean;
+    exclusiveMinimum?: number;
     maxLength?: number;
     minLength?: number;
     pattern?: string;

package/fullstacked_modules/zod/v4/core/json-schema.d.ts

@@ -2,7 +2,7 @@ export type Schema = ObjectSchema | ArraySchema | StringSchema | NumberSchema |
 export type _JSONSchema = boolean | JSONSchema;
 export type JSONSchema = {
     [k: string]: unknown;
-    $schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#" | "http://json-schema.org/draft-04/schema#";
+    $schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#";
     $id?: string;
     $anchor?: string;
     $ref?: string;
@@ -32,9 +32,9 @@ export type JSONSchema = {
     not?: _JSONSchema;
     multipleOf?: number;
     maximum?: number;
-    exclusiveMaximum?: number | boolean;
+    exclusiveMaximum?: number;
     minimum?: number;
-    exclusiveMinimum?: number | boolean;
+    exclusiveMinimum?: number;
     maxLength?: number;
     minLength?: number;
     pattern?: string;