@lucaapp/service-utils 5.43.1 → 6.0.0

package/dist/lib/validation.d.ts

@@ -1,4 +1,4 @@
-import { z as zod, ZodEffects, ZodNumber, ZodObject, ZodString, ZodType, ZodTypeAny } from 'zod';
+import { z as zod, ZodNumber, ZodObject, ZodPipe, ZodString, ZodTransform, ZodTypeAny } from 'zod';
 import validator from 'validator';
 import { Money } from '../lib/money/money';
 export declare const preprocessArrayFromQueryString: (input: unknown) => unknown[] | undefined;
@@ -6,263 +6,386 @@ export declare const preprocessNumberFromQueryString: (input: unknown) => number
 export declare const preprocessBooleanFromQueryString: (input: unknown) => boolean | unknown;
 export declare const preprocessBooleanFromString: typeof preprocessBooleanFromQueryString;
 declare const z: {
-    util: typeof zod.util;
-    objectUtil: typeof zod.objectUtil;
-    ZodParsedType: {
-        string: "string";
-        number: "number";
-        bigint: "bigint";
-        boolean: "boolean";
-        symbol: "symbol";
-        undefined: "undefined";
-        object: "object";
-        function: "function";
-        map: "map";
-        nan: "nan";
-        integer: "integer";
-        float: "float";
-        date: "date";
-        null: "null";
-        array: "array";
-        unknown: "unknown";
-        promise: "promise";
-        void: "void";
-        never: "never";
-        set: "set";
-    };
-    getParsedType: (data: any) => zod.ZodParsedType;
+    ZodError: zod.core.$constructor<zod.ZodError<unknown>, zod.core.$ZodIssue[]>;
+    ZodRealError: zod.core.$constructor<zod.ZodError>;
+    parse: <T extends zod.core.$ZodType>(schema: T, value: unknown, _ctx?: zod.core.ParseContext<zod.core.$ZodIssue>, _params?: {
+        callee?: zod.util.AnyFunc;
+        Err?: zod.core.$ZodErrorClass;
+    }) => zod.infer<T>;
+    parseAsync: <T extends zod.core.$ZodType>(schema: T, value: unknown, _ctx?: zod.core.ParseContext<zod.core.$ZodIssue>, _params?: {
+        callee?: zod.util.AnyFunc;
+        Err?: zod.core.$ZodErrorClass;
+    }) => Promise<zod.infer<T>>;
+    safeParse: <T extends zod.core.$ZodType>(schema: T, value: unknown, _ctx?: zod.core.ParseContext<zod.core.$ZodIssue>) => zod.ZodSafeParseResult<zod.infer<T>>;
+    safeParseAsync: <T extends zod.core.$ZodType>(schema: T, value: unknown, _ctx?: zod.core.ParseContext<zod.core.$ZodIssue>) => Promise<zod.ZodSafeParseResult<zod.infer<T>>>;
+    validate: zod.core.$Validate;
+    validateAsync: zod.core.$ValidateAsync;
+    encode: <T extends zod.core.$ZodType>(schema: T, value: zod.infer<T>, _ctx?: zod.core.ParseContext<zod.core.$ZodIssue>, _params?: {
+        callee?: zod.util.AnyFunc;
+        Err?: zod.core.$ZodErrorClass;
+    }) => zod.core.input<T>;
+    decode: <T extends zod.core.$ZodType>(schema: T, value: zod.core.input<T>, _ctx?: zod.core.ParseContext<zod.core.$ZodIssue>, _params?: {
+        callee?: zod.util.AnyFunc;
+        Err?: zod.core.$ZodErrorClass;
+    }) => zod.infer<T>;
+    encodeAsync: <T extends zod.core.$ZodType>(schema: T, value: zod.infer<T>, _ctx?: zod.core.ParseContext<zod.core.$ZodIssue>, _params?: {
+        callee?: zod.util.AnyFunc;
+        Err?: zod.core.$ZodErrorClass;
+    }) => Promise<zod.core.input<T>>;
+    decodeAsync: <T extends zod.core.$ZodType>(schema: T, value: zod.core.input<T>, _ctx?: zod.core.ParseContext<zod.core.$ZodIssue>, _params?: {
+        callee?: zod.util.AnyFunc;
+        Err?: zod.core.$ZodErrorClass;
+    }) => Promise<zod.infer<T>>;
+    safeEncode: <T extends zod.core.$ZodType>(schema: T, value: zod.infer<T>, _ctx?: zod.core.ParseContext<zod.core.$ZodIssue>) => zod.ZodSafeParseResult<zod.core.input<T>>;
+    safeDecode: <T extends zod.core.$ZodType>(schema: T, value: zod.core.input<T>, _ctx?: zod.core.ParseContext<zod.core.$ZodIssue>) => zod.ZodSafeParseResult<zod.infer<T>>;
+    safeEncodeAsync: <T extends zod.core.$ZodType>(schema: T, value: zod.infer<T>, _ctx?: zod.core.ParseContext<zod.core.$ZodIssue>) => Promise<zod.ZodSafeParseResult<zod.core.input<T>>>;
+    safeDecodeAsync: <T extends zod.core.$ZodType>(schema: T, value: zod.core.input<T>, _ctx?: zod.core.ParseContext<zod.core.$ZodIssue>) => Promise<zod.ZodSafeParseResult<zod.infer<T>>>;
+    ZodType: zod.core.$constructor<zod.ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>, zod.core.$ZodTypeDef>;
+    _ZodString: zod.core.$constructor<zod._ZodString<zod.core.$ZodStringInternals<unknown>>, zod.core.$ZodStringDef>;
+    ZodString: zod.core.$constructor<ZodString, zod.core.$ZodStringDef>;
+    ZodStringFormat: zod.core.$constructor<zod.ZodStringFormat<string>, zod.core.$ZodStringFormatDef<string>>;
+    ZodEmail: zod.core.$constructor<zod.ZodEmail, zod.core.$ZodStringFormatDef<"email">>;
+    ZodGUID: zod.core.$constructor<zod.ZodGUID, zod.core.$ZodStringFormatDef<"guid">>;
+    guid(params?: string | zod.core.$ZodGUIDParams): zod.ZodGUID;
+    ZodUUID: zod.core.$constructor<zod.ZodUUID, zod.core.$ZodUUIDDef>;
+    uuidv6(params?: string | zod.core.$ZodUUIDv6Params): zod.ZodUUID;
+    uuidv7(params?: string | zod.core.$ZodUUIDv7Params): zod.ZodUUID;
+    ZodURL: zod.core.$constructor<zod.ZodURL, zod.core.$ZodURLDef>;
+    url(params?: string | zod.core.$ZodURLParams): zod.ZodURL;
+    httpUrl(params?: string | Omit<zod.core.$ZodURLParams, "protocol" | "hostname">): zod.ZodURL;
+    ZodEmoji: zod.core.$constructor<zod.ZodEmoji, zod.core.$ZodStringFormatDef<"emoji">>;
+    emoji(params?: string | zod.core.$ZodEmojiParams): zod.ZodEmoji;
+    ZodNanoID: zod.core.$constructor<zod.ZodNanoID, zod.core.$ZodNanoIDDef>;
+    nanoid(params?: string | zod.core.$ZodNanoIDParams): zod.ZodNanoID;
+    ZodCUID: zod.core.$constructor<zod.ZodCUID, zod.core.$ZodStringFormatDef<"cuid">>;
+    cuid(params?: string | zod.core.$ZodCUIDParams): zod.ZodCUID;
+    ZodCUID2: zod.core.$constructor<zod.ZodCUID2, zod.core.$ZodStringFormatDef<"cuid2">>;
+    cuid2(params?: string | zod.core.$ZodCUID2Params): zod.ZodCUID2;
+    ZodULID: zod.core.$constructor<zod.ZodULID, zod.core.$ZodStringFormatDef<"ulid">>;
+    ulid(params?: string | zod.core.$ZodULIDParams): zod.ZodULID;
+    ZodXID: zod.core.$constructor<zod.ZodXID, zod.core.$ZodStringFormatDef<"xid">>;
+    xid(params?: string | zod.core.$ZodXIDParams): zod.ZodXID;
+    ZodKSUID: zod.core.$constructor<zod.ZodKSUID, zod.core.$ZodStringFormatDef<"ksuid">>;
+    ksuid(params?: string | zod.core.$ZodKSUIDParams): zod.ZodKSUID;
+    ZodIPv4: zod.core.$constructor<zod.ZodIPv4, zod.core.$ZodIPv4Def>;
+    ipv4(params?: string | zod.core.$ZodIPv4Params): zod.ZodIPv4;
+    ZodMAC: zod.core.$constructor<zod.ZodMAC, zod.core.$ZodMACDef>;
+    ZodIPv6: zod.core.$constructor<zod.ZodIPv6, zod.core.$ZodIPv6Def>;
+    ipv6(params?: string | zod.core.$ZodIPv6Params): zod.ZodIPv6;
+    ZodCIDRv4: zod.core.$constructor<zod.ZodCIDRv4, zod.core.$ZodCIDRv4Def>;
+    cidrv4(params?: string | zod.core.$ZodCIDRv4Params): zod.ZodCIDRv4;
+    ZodCIDRv6: zod.core.$constructor<zod.ZodCIDRv6, zod.core.$ZodCIDRv6Def>;
+    cidrv6(params?: string | zod.core.$ZodCIDRv6Params): zod.ZodCIDRv6;
+    ZodBase64: zod.core.$constructor<zod.ZodBase64, zod.core.$ZodStringFormatDef<"base64">>;
+    ZodBase64URL: zod.core.$constructor<zod.ZodBase64URL, zod.core.$ZodStringFormatDef<"base64url">>;
+    base64url(params?: string | zod.core.$ZodBase64URLParams): zod.ZodBase64URL;
+    ZodE164: zod.core.$constructor<zod.ZodE164, zod.core.$ZodStringFormatDef<"e164">>;
+    e164(params?: string | zod.core.$ZodE164Params): zod.ZodE164;
+    ZodCreditCard: zod.core.$constructor<zod.ZodCreditCard, zod.core.$ZodCreditCardDef>;
+    creditCard(params?: string | zod.core.$ZodCreditCardParams): zod.ZodCreditCard;
+    ZodIBAN: zod.core.$constructor<zod.ZodIBAN, zod.core.$ZodIBANDef>;
+    iban(params?: string | zod.core.$ZodIBANParams): zod.ZodIBAN;
+    ZodJWT: zod.core.$constructor<zod.ZodJWT, zod.core.$ZodJWTDef>;
+    ZodCustomStringFormat: zod.core.$constructor<zod.ZodCustomStringFormat<string>, zod.core.$ZodCustomStringFormatDef<string>>;
+    stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => zod.util.MaybeAsync<unknown>) | RegExp, _params?: string | zod.core.$ZodStringFormatParams): zod.ZodCustomStringFormat<Format>;
+    hostname(_params?: string | zod.core.$ZodStringFormatParams): zod.ZodCustomStringFormat<"hostname">;
+    currencyCode(_params?: string | zod.core.$ZodStringFormatParams): zod.ZodCustomStringFormat<"currency_code">;
+    hash<Alg extends zod.util.HashAlgorithm, Enc extends zod.util.HashEncoding = "hex">(alg: Alg, params?: {
+        enc?: Enc;
+    } & zod.core.$ZodStringFormatParams): zod.ZodCustomStringFormat<`${Alg}_${Enc}`>;
+    ZodNumber: zod.core.$constructor<ZodNumber, zod.core.$ZodNumberDef>;
+    number(params?: string | zod.core.$ZodNumberParams): ZodNumber;
+    ZodNumberFormat: zod.core.$constructor<zod.ZodNumberFormat<zod.core.$ZodNumberFormats>, zod.core.$ZodNumberFormatDef<zod.core.$ZodNumberFormats>>;
+    int(params?: string | zod.core.$ZodCheckNumberFormatParams): zod.ZodInt;
+    float32(params?: string | zod.core.$ZodCheckNumberFormatParams): zod.ZodFloat32;
+    float64(params?: string | zod.core.$ZodCheckNumberFormatParams): zod.ZodFloat64;
+    int32(params?: string | zod.core.$ZodCheckNumberFormatParams): zod.ZodInt32;
+    uint32(params?: string | zod.core.$ZodCheckNumberFormatParams): zod.ZodUInt32;
+    ZodBoolean: zod.core.$constructor<zod.ZodBoolean, zod.core.$ZodBooleanDef>;
+    boolean(params?: string | zod.core.$ZodBooleanParams): zod.ZodBoolean;
+    ZodBigInt: zod.core.$constructor<zod.ZodBigInt, zod.core.$ZodBigIntDef>;
+    bigint(params?: string | zod.core.$ZodBigIntParams): zod.ZodBigInt;
+    ZodBigIntFormat: zod.core.$constructor<zod.ZodBigIntFormat<zod.core.$ZodBigIntFormats>, zod.core.$ZodBigIntFormatDef<zod.core.$ZodBigIntFormats>>;
+    int64(params?: string | zod.core.$ZodBigIntFormatParams): zod.ZodInt64;
+    uint64(params?: string | zod.core.$ZodBigIntFormatParams): zod.ZodUInt64;
+    ZodSymbol: zod.core.$constructor<zod.ZodSymbol, zod.core.$ZodSymbolDef>;
+    symbol(params?: string | zod.core.$ZodSymbolParams): zod.ZodSymbol;
+    ZodUndefined: zod.core.$constructor<zod.ZodUndefined, zod.core.$ZodUndefinedDef>;
+    undefined: typeof zod.undefined;
+    ZodNull: zod.core.$constructor<zod.ZodNull, zod.core.$ZodNullDef>;
+    null: typeof zod.null;
+    ZodAny: zod.core.$constructor<zod.ZodAny, zod.core.$ZodAnyDef>;
+    any(): zod.ZodAny;
+    ZodUnknown: zod.core.$constructor<zod.ZodUnknown, zod.core.$ZodUnknownDef>;
+    unknown(): zod.ZodUnknown;
+    ZodNever: zod.core.$constructor<zod.ZodNever, zod.core.$ZodNeverDef>;
+    never(params?: string | zod.core.$ZodNeverParams): zod.ZodNever;
+    ZodVoid: zod.core.$constructor<zod.ZodVoid, zod.core.$ZodVoidDef>;
+    void: typeof zod.void;
+    ZodDate: zod.core.$constructor<zod.ZodDate, zod.core.$ZodDateDef>;
+    date(params?: string | zod.core.$ZodDateParams): zod.ZodDate;
+    ZodArray: zod.core.$constructor<zod.ZodArray<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>, zod.core.$ZodArrayDef<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>>;
+    array<T extends zod.core.SomeType>(element: T, params?: string | zod.core.$ZodArrayParams): zod.ZodArray<T>;
+    keyof<T extends ZodObject>(schema: T): zod.ZodEnum<zod.util.KeysEnum<T["_zod"]["output"]>>;
+    ZodObject: zod.core.$constructor<ZodObject<zod.core.$ZodLooseShape, zod.core.$strip>, zod.core.$ZodObjectDef<zod.core.$ZodLooseShape>>;
+    object<T extends zod.core.$ZodLooseShape = Partial<Record<never, zod.core.SomeType>>>(shape?: T, params?: string | zod.core.$ZodObjectParams): ZodObject<zod.util.Writeable<T>, zod.core.$strip>;
+    strictObject<T extends zod.core.$ZodLooseShape>(shape: T, params?: string | zod.core.$ZodObjectParams): ZodObject<zod.util.Writeable<T>, zod.core.$strict>;
+    looseObject<T extends zod.core.$ZodLooseShape>(shape: T, params?: string | zod.core.$ZodObjectParams): ZodObject<zod.util.Writeable<T>, zod.core.$loose>;
+    ZodUnion: zod.core.$constructor<zod.ZodUnion<readonly zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>[]>, zod.core.$ZodUnionDef<readonly zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>[]>>;
+    union<const T extends readonly zod.core.SomeType[]>(options: T, params?: string | zod.core.$ZodUnionParams): zod.ZodUnion<T>;
+    ZodXor: zod.core.$constructor<zod.ZodXor<readonly zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>[]>, zod.core.$ZodUnionDef<readonly zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>[]>>;
+    xor<const T extends readonly zod.core.SomeType[]>(options: T, params?: string | zod.core.$ZodXorParams): zod.ZodXor<T>;
+    ZodDiscriminatedUnion: zod.core.$constructor<zod.ZodDiscriminatedUnion<readonly zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>[], string>, zod.core.$ZodDiscriminatedUnionDef<readonly zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>[], string>>;
+    discriminatedUnion<Types extends readonly [zod.core.$ZodTypeDiscriminable, ...zod.core.$ZodTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | zod.core.$ZodDiscriminatedUnionParams): zod.ZodDiscriminatedUnion<Types, Disc>;
+    ZodIntersection: zod.core.$constructor<zod.ZodIntersection<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>, zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>, zod.core.$ZodIntersectionDef<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>, zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>>;
+    intersection<T extends zod.core.SomeType, U extends zod.core.SomeType>(left: T, right: U): zod.ZodIntersection<T, U>;
+    ZodTuple: zod.core.$constructor<zod.ZodTuple<readonly zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>[], zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>> | null>, zod.core.$ZodTupleDef<readonly zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>[], zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>> | null>>;
+    tuple<T extends readonly [zod.core.SomeType, ...zod.core.SomeType[]]>(items: T, params?: string | zod.core.$ZodTupleParams): zod.ZodTuple<T, null>;
+    tuple<T extends readonly [zod.core.SomeType, ...zod.core.SomeType[]], Rest extends zod.core.SomeType>(items: T, rest: Rest, params?: string | zod.core.$ZodTupleParams): zod.ZodTuple<T, Rest>;
+    tuple(items: [], params?: string | zod.core.$ZodTupleParams): zod.ZodTuple<[], null>;
+    ZodRecord: zod.core.$constructor<zod.ZodRecord<zod.core.$ZodRecordKey, zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>, zod.core.$ZodRecordDef<zod.core.$ZodRecordKey, zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>>;
+    record<Key extends zod.core.$ZodRecordKey, Value extends zod.core.SomeType>(keyType: Key, valueType: Value, params?: string | zod.core.$ZodRecordParams): zod.ZodRecord<Key, Value>;
+    partialRecord<Key extends zod.core.$ZodRecordKey, Value extends zod.core.SomeType>(keyType: Key, valueType: Value, params?: string | zod.core.$ZodRecordParams): zod.ZodRecord<Key & zod.core.$partial, Value>;
+    looseRecord<Key extends zod.core.$ZodRecordKey, Value extends zod.core.SomeType>(keyType: Key, valueType: Value, params?: string | zod.core.$ZodRecordParams): zod.ZodRecord<Key, Value>;
+    ZodMap: zod.core.$constructor<zod.ZodMap<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>, zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>, zod.core.$ZodMapDef<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>, zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>>;
+    map<Key extends zod.core.SomeType, Value extends zod.core.SomeType>(keyType: Key, valueType: Value, params?: string | zod.core.$ZodMapParams): zod.ZodMap<Key, Value>;
+    ZodSet: zod.core.$constructor<zod.ZodSet<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>, zod.core.$ZodSetDef<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>>;
+    set<Value extends zod.core.SomeType>(valueType: Value, params?: string | zod.core.$ZodSetParams): zod.ZodSet<Value>;
+    ZodEnum: zod.core.$constructor<zod.ZodEnum<Readonly<Record<string, zod.util.EnumValue>>>, zod.core.$ZodEnumDef<Readonly<Record<string, zod.util.EnumValue>>>>;
+    enum: typeof zod.enum;
+    nativeEnum<T extends zod.util.EnumLike>(entries: T, params?: string | zod.core.$ZodEnumParams): zod.ZodEnum<T>;
+    ZodLiteral: zod.core.$constructor<zod.ZodLiteral<zod.util.Literal>, zod.core.$ZodLiteralDef<zod.util.Literal>>;
+    literal<const T extends ReadonlyArray<zod.util.Literal>>(value: T, params?: string | zod.core.$ZodLiteralParams): zod.ZodLiteral<T[number]>;
+    literal<const T extends zod.util.Literal>(value: T, params?: string | zod.core.$ZodLiteralParams): zod.ZodLiteral<T>;
+    ZodFile: zod.core.$constructor<zod.ZodFile, zod.core.$ZodFileDef>;
+    file(params?: string | zod.core.$ZodFileParams): zod.ZodFile;
+    ZodTransform: zod.core.$constructor<ZodTransform<unknown, unknown>, zod.core.$ZodTransformDef>;
+    transform<I = unknown, O = I>(fn: (input: I, ctx: zod.RefinementCtx) => O): ZodTransform<Awaited<O>, I>;
+    ZodOptional: zod.core.$constructor<zod.ZodOptional<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>, zod.core.$ZodOptionalDef<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>>;
+    optional<T extends zod.core.SomeType>(innerType: T): zod.ZodOptional<T>;
+    ZodExactOptional: zod.core.$constructor<zod.ZodExactOptional<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>, zod.core.$ZodExactOptionalDef<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>>;
+    exactOptional<T extends zod.core.SomeType>(innerType: T): zod.ZodExactOptional<T>;
+    ZodNullable: zod.core.$constructor<zod.ZodNullable<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>, zod.core.$ZodNullableDef<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>>;
+    nullable<T extends zod.core.SomeType>(innerType: T): zod.ZodNullable<T>;
+    nullish<T extends zod.core.SomeType>(innerType: T): zod.ZodOptional<zod.ZodNullable<T>>;
+    ZodDefault: zod.core.$constructor<zod.ZodDefault<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>, zod.core.$ZodDefaultDef<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>>;
+    _default<T extends zod.core.SomeType>(innerType: T, defaultValue: zod.util.NoUndefined<zod.infer<T>> | (() => zod.util.NoUndefined<zod.infer<T>>)): zod.ZodDefault<T>;
+    ZodPrefault: zod.core.$constructor<zod.ZodPrefault<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>, zod.core.$ZodPrefaultDef<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>>;
+    prefault<T extends zod.core.SomeType>(innerType: T, defaultValue: zod.core.input<T> | (() => zod.core.input<T>)): zod.ZodPrefault<T>;
+    ZodNonOptional: zod.core.$constructor<zod.ZodNonOptional<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>, zod.core.$ZodNonOptionalDef<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>>;
+    nonoptional<T extends zod.core.SomeType>(innerType: T, params?: string | zod.core.$ZodNonOptionalParams): zod.ZodNonOptional<T>;
+    ZodSuccess: zod.core.$constructor<zod.ZodSuccess<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>, zod.core.$ZodSuccessDef<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>>;
+    success<T extends zod.core.SomeType>(innerType: T): zod.ZodSuccess<T>;
+    ZodCatch: zod.core.$constructor<zod.ZodCatch<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>, zod.core.$ZodCatchDef<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>>;
+    catch: typeof zod.catch;
+    ZodNaN: zod.core.$constructor<zod.ZodNaN, zod.core.$ZodNaNDef>;
+    nan(params?: string | zod.core.$ZodNaNParams): zod.ZodNaN;
+    ZodPipe: zod.core.$constructor<ZodPipe<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>, zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>, zod.core.$ZodPipeDef<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>, zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>>;
+    pipe<const A extends zod.core.SomeType, B extends zod.core.$ZodType<unknown, zod.infer<A>> = zod.core.$ZodType<unknown, zod.infer<A>, zod.core.$ZodTypeInternals<unknown, zod.infer<A>>>>(in_: A, out: B | zod.core.$ZodType<unknown, zod.infer<A>>): ZodPipe<A, B>;
+    ZodCodec: zod.core.$constructor<zod.ZodCodec<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>, zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>, zod.core.$ZodCodecDef<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>, zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>>;
+    codec<const A extends zod.core.SomeType, B extends zod.core.SomeType = zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>(in_: A, out: B, params: {
+        decode: (value: zod.infer<A>, payload: zod.core.ParsePayload<zod.infer<A>>) => zod.util.MaybeAsync<zod.core.input<B>>;
+        encode: (value: zod.core.input<B>, payload: zod.core.ParsePayload<zod.core.input<B>>) => zod.util.MaybeAsync<zod.infer<A>>;
+    }): zod.ZodCodec<A, B>;
+    invertCodec<A extends zod.core.SomeType, B extends zod.core.SomeType>(codec: zod.ZodCodec<A, B>): zod.ZodCodec<B, A>;
+    ZodPreprocess: zod.core.$constructor<zod.ZodPreprocess<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>, unknown>, zod.core.$ZodPreprocessDef<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>, unknown>>;
+    ZodReadonly: zod.core.$constructor<zod.ZodReadonly<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>, zod.core.$ZodReadonlyDef<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>>;
+    readonly<T extends zod.core.SomeType>(innerType: T): zod.ZodReadonly<T>;
+    ZodTemplateLiteral: zod.core.$constructor<zod.ZodTemplateLiteral<string>, zod.core.$ZodTemplateLiteralDef>;
+    templateLiteral<const Parts extends zod.core.$ZodTemplateLiteralPart[]>(parts: Parts, params?: string | zod.core.$ZodTemplateLiteralParams): zod.ZodTemplateLiteral<zod.core.$PartsToTemplateLiteral<Parts>>;
+    ZodLazy: zod.core.$constructor<zod.ZodLazy<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>, zod.core.$ZodLazyDef<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>>;
+    lazy<T extends zod.core.SomeType>(getter: () => T): zod.ZodLazy<T>;
+    ZodPromise: zod.core.$constructor<zod.ZodPromise<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>, zod.core.$ZodPromiseDef<zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>>;
+    promise<T extends zod.core.SomeType>(innerType: T): zod.ZodPromise<T>;
+    ZodFunction: zod.core.$constructor<zod.ZodFunction<zod.core.$ZodFunctionArgs, zod.core.$ZodFunctionOut>, zod.core.$ZodFunctionDef<zod.core.$ZodFunctionArgs, zod.core.$ZodFunctionOut>>;
+    _function(): zod.ZodFunction;
+    _function<const In extends ReadonlyArray<zod.core.$ZodType>>(params: {
+        input: In;
+    }): zod.ZodFunction<zod.ZodTuple<In, null>, zod.core.$ZodFunctionOut>;
+    _function<const In extends ReadonlyArray<zod.core.$ZodType>, const Out extends zod.core.$ZodFunctionOut = zod.core.$ZodFunctionOut>(params: {
+        input: In;
+        output: Out;
+    }): zod.ZodFunction<zod.ZodTuple<In, null>, Out>;
+    _function<const In extends zod.core.$ZodFunctionIn = zod.core.$ZodFunctionArgs>(params: {
+        input: In;
+    }): zod.ZodFunction<In, zod.core.$ZodFunctionOut>;
+    _function<const Out extends zod.core.$ZodFunctionOut = zod.core.$ZodFunctionOut>(params: {
+        output: Out;
+    }): zod.ZodFunction<zod.core.$ZodFunctionIn, Out>;
+    _function<In extends zod.core.$ZodFunctionIn = zod.core.$ZodFunctionArgs, Out extends zod.core.$ZodType = zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>(params?: {
+        input: In;
+        output: Out;
+    }): zod.ZodFunction<In, Out>;
+    function: typeof zod._function;
+    ZodCustom: zod.core.$constructor<zod.ZodCustom<unknown, unknown>, zod.core.$ZodCustomDef<unknown>>;
+    check<O = unknown>(fn: zod.core.CheckFn<O>): zod.core.$ZodCheck<O>;
+    custom<O>(fn?: (data: unknown) => unknown, _params?: string | zod.core.$ZodCustomParams | undefined): zod.ZodCustom<O, O>;
+    refine<T>(fn: (arg: NoInfer<T>) => zod.util.MaybeAsync<unknown>, _params?: string | zod.core.$ZodCustomParams): zod.core.$ZodCheck<T>;
+    superRefine<T>(fn: (arg: T, payload: zod.RefinementCtx<T>) => void | Promise<void>, params?: zod.core.$ZodSuperRefineParams): zod.core.$ZodCheck<T>;
+    describe: typeof zod.core.describe;
+    meta: typeof zod.core.meta;
+    ZodInstanceOf: zod.core.$constructor<zod.ZodInstanceOf<unknown>, zod.core.$ZodCustomDef<unknown>>;
+    instanceof: typeof zod.instanceof;
+    stringbool: (_params?: string | zod.core.$ZodStringBoolParams) => zod.ZodCodec<ZodString, zod.ZodBoolean>;
+    json(params?: string | zod.core.$ZodCustomParams): zod.ZodJSONSchema;
+    preprocess<A, U extends zod.core.SomeType, B = unknown>(fn: (arg: B, ctx: zod.RefinementCtx) => A, schema: U): zod.ZodPreprocess<U, B>;
+    lt: typeof zod.lt;
+    lte: typeof zod.lte;
+    gt: typeof zod.gt;
+    gte: typeof zod.gte;
+    positive: typeof zod.positive;
+    negative: typeof zod.negative;
+    nonpositive: typeof zod.nonpositive;
+    nonnegative: typeof zod.nonnegative;
+    multipleOf: typeof zod.multipleOf;
+    maxSize: typeof zod.maxSize;
+    minSize: typeof zod.minSize;
+    size: typeof zod.size;
+    maxLength: typeof zod.maxLength;
+    minLength: typeof zod.minLength;
+    length: typeof zod.length;
+    regex: typeof zod.regex;
+    lowercase: typeof zod.lowercase;
+    uppercase: typeof zod.uppercase;
+    includes: typeof zod.includes;
+    startsWith: typeof zod.startsWith;
+    endsWith: typeof zod.endsWith;
+    property: typeof zod.property;
+    properties: typeof zod.properties;
+    mime: typeof zod.mime;
+    overwrite: typeof zod.overwrite;
+    normalize: typeof zod.normalize;
+    trim: typeof zod.trim;
+    toLowerCase: typeof zod.toLowerCase;
+    toUpperCase: typeof zod.toUpperCase;
+    slugify: typeof zod.slugify;
     ZodIssueCode: {
-        invalid_type: "invalid_type";
-        invalid_literal: "invalid_literal";
-        custom: "custom";
-        invalid_union: "invalid_union";
-        invalid_union_discriminator: "invalid_union_discriminator";
-        invalid_enum_value: "invalid_enum_value";
-        unrecognized_keys: "unrecognized_keys";
-        invalid_arguments: "invalid_arguments";
-        invalid_return_type: "invalid_return_type";
-        invalid_date: "invalid_date";
-        invalid_string: "invalid_string";
-        too_small: "too_small";
-        too_big: "too_big";
-        invalid_intersection_types: "invalid_intersection_types";
-        not_multiple_of: "not_multiple_of";
-        not_finite: "not_finite";
-    };
-    quotelessJson: (obj: any) => string;
-    ZodError: typeof zod.ZodError;
-    defaultErrorMap: zod.ZodErrorMap;
-    setErrorMap(map: zod.ZodErrorMap): void;
-    getErrorMap(): zod.ZodErrorMap;
-    makeIssue: (params: {
-        data: any;
-        path: (string | number)[];
-        errorMaps: zod.ZodErrorMap[];
-        issueData: zod.IssueData;
-    }) => zod.ZodIssue;
-    EMPTY_PATH: zod.ParsePath;
-    addIssueToContext(ctx: zod.ParseContext, issueData: zod.IssueData): void;
-    ParseStatus: typeof zod.ParseStatus;
-    INVALID: zod.INVALID;
-    DIRTY: <T>(value: T) => zod.DIRTY<T>;
-    OK: <T>(value: T) => zod.OK<T>;
-    isAborted: (x: zod.ParseReturnType<any>) => x is zod.INVALID;
-    isDirty: <T>(x: zod.ParseReturnType<T>) => x is zod.OK<T> | zod.DIRTY<T>;
-    isValid: <T>(x: zod.ParseReturnType<T>) => x is zod.OK<T>;
-    isAsync: <T>(x: zod.ParseReturnType<T>) => x is zod.AsyncParseReturnType<T>;
-    ZodType: typeof ZodType;
-    datetimeRegex(args: {
-        precision?: number | null;
-        offset?: boolean;
-        local?: boolean;
-    }): RegExp;
-    ZodString: typeof ZodString;
-    ZodNumber: typeof ZodNumber;
-    ZodBigInt: typeof zod.ZodBigInt;
-    ZodBoolean: typeof zod.ZodBoolean;
-    ZodDate: typeof zod.ZodDate;
-    ZodSymbol: typeof zod.ZodSymbol;
-    ZodUndefined: typeof zod.ZodUndefined;
-    ZodNull: typeof zod.ZodNull;
-    ZodAny: typeof zod.ZodAny;
-    ZodUnknown: typeof zod.ZodUnknown;
-    ZodNever: typeof zod.ZodNever;
-    ZodVoid: typeof zod.ZodVoid;
-    ZodArray: typeof zod.ZodArray;
-    ZodObject: typeof ZodObject;
-    ZodUnion: typeof zod.ZodUnion;
-    ZodDiscriminatedUnion: typeof zod.ZodDiscriminatedUnion;
-    ZodIntersection: typeof zod.ZodIntersection;
-    ZodTuple: typeof zod.ZodTuple;
-    ZodRecord: typeof zod.ZodRecord;
-    ZodMap: typeof zod.ZodMap;
-    ZodSet: typeof zod.ZodSet;
-    ZodFunction: typeof zod.ZodFunction;
-    ZodLazy: typeof zod.ZodLazy;
-    ZodLiteral: typeof zod.ZodLiteral;
-    ZodEnum: typeof zod.ZodEnum;
-    ZodNativeEnum: typeof zod.ZodNativeEnum;
-    ZodPromise: typeof zod.ZodPromise;
-    ZodEffects: typeof ZodEffects;
-    ZodTransformer: typeof ZodEffects;
-    ZodOptional: typeof zod.ZodOptional;
-    ZodNullable: typeof zod.ZodNullable;
-    ZodDefault: typeof zod.ZodDefault;
-    ZodCatch: typeof zod.ZodCatch;
-    ZodNaN: typeof zod.ZodNaN;
-    BRAND: typeof zod.BRAND;
-    ZodBranded: typeof zod.ZodBranded;
-    ZodPipeline: typeof zod.ZodPipeline;
-    ZodReadonly: typeof zod.ZodReadonly;
-    custom<T>(check?: (data: any) => any, params?: string | (Partial<zod.util.Omit<zod.ZodCustomIssue, "code">> & {
-        fatal?: boolean;
-    }) | ((input: any) => Partial<zod.util.Omit<zod.ZodCustomIssue, "code">> & {
-        fatal?: boolean;
-    }), fatal?: boolean): ZodType<T, zod.ZodTypeDef, T>;
-    Schema: typeof ZodType;
-    ZodSchema: typeof ZodType;
-    late: {
-        object: <T extends zod.ZodRawShape>(shape: () => T, params?: zod.RawCreateParams) => ZodObject<T, "strip">;
+        readonly invalid_type: "invalid_type";
+        readonly too_big: "too_big";
+        readonly too_small: "too_small";
+        readonly invalid_format: "invalid_format";
+        readonly not_multiple_of: "not_multiple_of";
+        readonly unrecognized_keys: "unrecognized_keys";
+        readonly invalid_union: "invalid_union";
+        readonly invalid_key: "invalid_key";
+        readonly invalid_element: "invalid_element";
+        readonly invalid_value: "invalid_value";
+        readonly custom: "custom";
     };
+    setErrorMap(map: zod.core.$ZodErrorMap): void;
+    getErrorMap(): zod.core.$ZodErrorMap<zod.core.$ZodIssue> | undefined;
     ZodFirstPartyTypeKind: typeof zod.ZodFirstPartyTypeKind;
-    coerce: {
-        string: (params?: zod.RawCreateParams & {
-            coerce?: true;
-        }) => ZodString;
-        number: (params?: zod.RawCreateParams & {
-            coerce?: boolean;
-        }) => ZodNumber;
-        boolean: (params?: zod.RawCreateParams & {
-            coerce?: boolean;
-        }) => zod.ZodBoolean;
-        bigint: (params?: zod.RawCreateParams & {
-            coerce?: boolean;
-        }) => zod.ZodBigInt;
-        date: (params?: zod.RawCreateParams & {
-            coerce?: boolean;
-        }) => zod.ZodDate;
+    core: typeof zod.core;
+    globalRegistry: zod.core.$ZodRegistry<zod.GlobalMeta, zod.core.$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>;
+    registry: typeof zod.registry;
+    config: typeof zod.config;
+    memoizer: typeof zod.memoizer;
+    $output: typeof zod.$output;
+    $input: typeof zod.$input;
+    $brand: typeof zod.$brand;
+    clone: typeof zod.clone;
+    regexes: typeof zod.regexes;
+    treeifyError: typeof zod.treeifyError;
+    prettifyError: typeof zod.prettifyError;
+    formatError: typeof zod.formatError;
+    flattenError: typeof zod.flattenError;
+    TimePrecision: {
+        readonly Any: null;
+        readonly Minute: -1;
+        readonly Second: 0;
+        readonly Millisecond: 3;
+        readonly Microsecond: 6;
     };
-    any: (params?: zod.RawCreateParams) => zod.ZodAny;
-    array: <T extends ZodTypeAny>(schema: T, params?: zod.RawCreateParams) => zod.ZodArray<T>;
-    bigint: (params?: zod.RawCreateParams & {
-        coerce?: boolean;
-    }) => zod.ZodBigInt;
-    boolean: (params?: zod.RawCreateParams & {
-        coerce?: boolean;
-    }) => zod.ZodBoolean;
-    date: (params?: zod.RawCreateParams & {
-        coerce?: boolean;
-    }) => zod.ZodDate;
-    discriminatedUnion: typeof zod.ZodDiscriminatedUnion.create;
-    effect: <I extends ZodTypeAny>(schema: I, effect: zod.Effect<I["_output"]>, params?: zod.RawCreateParams) => ZodEffects<I, I["_output"]>;
-    enum: {
-        <U extends string, T extends Readonly<[U, ...U[]]>>(values: T, params?: zod.RawCreateParams): zod.ZodEnum<zod.Writeable<T>>;
-        <U extends string, T extends [U, ...U[]]>(values: T, params?: zod.RawCreateParams): zod.ZodEnum<T>;
-    };
-    function: typeof zod.ZodFunction.create;
-    instanceof: <T extends abstract new (..._: any[]) => {}>(cls: T, params?: Partial<zod.util.Omit<zod.ZodCustomIssue, "code">> & {
-        fatal?: boolean;
-    }) => ZodType<InstanceType<T>, zod.ZodTypeDef, InstanceType<T>>;
-    intersection: <T extends ZodTypeAny, U extends ZodTypeAny>(left: T, right: U, params?: zod.RawCreateParams) => zod.ZodIntersection<T, U>;
-    lazy: <T extends ZodTypeAny>(getter: () => T, params?: zod.RawCreateParams) => zod.ZodLazy<T>;
-    literal: <T extends zod.Primitive>(value: T, params?: zod.RawCreateParams) => zod.ZodLiteral<T>;
-    map: <Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny>(keyType: Key, valueType: Value, params?: zod.RawCreateParams) => zod.ZodMap<Key, Value>;
-    nan: (params?: zod.RawCreateParams) => zod.ZodNaN;
-    nativeEnum: <T extends zod.EnumLike>(values: T, params?: zod.RawCreateParams) => zod.ZodNativeEnum<T>;
-    never: (params?: zod.RawCreateParams) => zod.ZodNever;
-    null: (params?: zod.RawCreateParams) => zod.ZodNull;
-    nullable: <T extends ZodTypeAny>(type: T, params?: zod.RawCreateParams) => zod.ZodNullable<T>;
-    number: (params?: zod.RawCreateParams & {
-        coerce?: boolean;
-    }) => ZodNumber;
-    object: <T extends zod.ZodRawShape>(shape: T, params?: zod.RawCreateParams) => ZodObject<T, "strip", ZodTypeAny, zod.objectOutputType<T, ZodTypeAny, "strip">, zod.objectInputType<T, ZodTypeAny, "strip">>;
-    oboolean: () => zod.ZodOptional<zod.ZodBoolean>;
-    onumber: () => zod.ZodOptional<ZodNumber>;
-    optional: <T extends ZodTypeAny>(type: T, params?: zod.RawCreateParams) => zod.ZodOptional<T>;
-    ostring: () => zod.ZodOptional<ZodString>;
-    pipeline: typeof zod.ZodPipeline.create;
-    preprocess: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: zod.RefinementCtx) => unknown, schema: I, params?: zod.RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
-    promise: <T extends ZodTypeAny>(schema: T, params?: zod.RawCreateParams) => zod.ZodPromise<T>;
-    record: typeof zod.ZodRecord.create;
-    set: <Value extends ZodTypeAny = ZodTypeAny>(valueType: Value, params?: zod.RawCreateParams) => zod.ZodSet<Value>;
-    strictObject: <T extends zod.ZodRawShape>(shape: T, params?: zod.RawCreateParams) => ZodObject<T, "strict">;
-    symbol: (params?: zod.RawCreateParams) => zod.ZodSymbol;
-    transformer: <I extends ZodTypeAny>(schema: I, effect: zod.Effect<I["_output"]>, params?: zod.RawCreateParams) => ZodEffects<I, I["_output"]>;
-    tuple: <T extends [] | [ZodTypeAny, ...ZodTypeAny[]]>(schemas: T, params?: zod.RawCreateParams) => zod.ZodTuple<T, null>;
-    undefined: (params?: zod.RawCreateParams) => zod.ZodUndefined;
-    union: <T extends readonly [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T, params?: zod.RawCreateParams) => zod.ZodUnion<T>;
-    unknown: (params?: zod.RawCreateParams) => zod.ZodUnknown;
-    void: (params?: zod.RawCreateParams) => zod.ZodVoid;
+    util: typeof zod.util;
     NEVER: never;
+    INVALID: typeof zod.INVALID;
+    toZod: typeof zod.toZod;
+    compile: typeof zod.compile;
+    withParser: typeof zod.withParser;
+    ZodCompileAsyncError: typeof zod.ZodCompileAsyncError;
+    ZodCompileUnsupportedError: typeof zod.ZodCompileUnsupportedError;
+    getDiscriminatedOption: typeof zod.getDiscriminatedOption;
+    toJSONSchema: typeof zod.toJSONSchema;
+    fromJSONSchema: typeof zod.fromJSONSchema;
+    deepPartial: typeof zod.deepPartial;
+    input: typeof zod.input;
+    output: typeof zod.output;
+    locales: typeof zod.locales;
+    ZodISODateTime: zod.core.$constructor<zod.ZodISODateTime, zod.core.$ZodISODateTimeDef>;
+    ZodISODate: zod.core.$constructor<zod.ZodISODate, zod.core.$ZodStringFormatDef<"date">>;
+    ZodISOTime: zod.core.$constructor<zod.ZodISOTime, zod.core.$ZodISOTimeDef>;
+    ZodISODuration: zod.core.$constructor<zod.ZodISODuration, zod.core.$ZodStringFormatDef<"duration">>;
+    iso: typeof zod.iso;
+    coerce: typeof zod.coerce;
     string: () => ZodString;
     safeString: () => ZodString;
     safeText: () => ZodString;
-    safeBusinessStringForOnboarding: () => ZodEffects<ZodString, string, string>;
-    safeNameForOnboarding: () => ZodEffects<ZodString, string, string>;
+    safeBusinessStringForOnboarding: () => ZodPipe<ZodString, ZodTransform<string, string>>;
+    safeNameForOnboarding: () => ZodPipe<ZodString, ZodTransform<string, string>>;
     nonemptyString: () => ZodString;
     alphaNumericString: () => ZodString;
     tableId: () => ZodString;
     uuid: () => ZodString;
-    uuidv4: () => ZodEffects<ZodString, string, string>;
-    email: () => ZodEffects<ZodString>;
-    phoneNumber: () => ZodEffects<ZodEffects<ZodString>>;
-    nullablePhoneNumber: () => ZodEffects<ZodEffects<ZodString, string, string>, string | null, string>;
-    strongPassword: () => ZodEffects<ZodString, string, string>;
-    zipCode: (locale?: validator.PostalCodeLocale) => ZodEffects<ZodString, string>;
-    countryCode: () => ZodEffects<ZodString, string, string>;
-    moneyDecimalString: (locale?: string) => ZodEffects<ZodString, string, string>;
-    moneyFromFloat: () => ZodEffects<ZodEffects<ZodNumber>, Money>;
-    moneyFromInt: () => ZodEffects<ZodNumber, Money>;
-    convertMoneyFieldsToCurrency: <T extends ZodObject<Record<string, ZodTypeAny>>>(schema: T) => ZodEffects<T>;
+    uuidv4: () => ZodString;
+    email: () => ZodString;
+    phoneNumber: () => ZodPipe<ZodString, ZodTransform<string, string>>;
+    nullablePhoneNumber: () => ZodPipe<ZodString, ZodTransform<string | null, string>>;
+    strongPassword: () => ZodString;
+    zipCode: (locale?: validator.PostalCodeLocale) => ZodString;
+    countryCode: () => ZodString;
+    moneyDecimalString: (locale?: string) => ZodString;
+    moneyFromFloat: () => ZodPipe<ZodNumber, ZodTransform<Money, number>>;
+    moneyFromInt: () => ZodPipe<ZodNumber, ZodTransform<Money, number>>;
+    convertMoneyFieldsToCurrency: <T extends ZodObject<Record<string, ZodTypeAny>>>(schema: T) => T;
     unixTimestamp: () => ZodNumber;
     integerString: (options?: {
         maxLength?: number;
         lt?: number;
         gt?: number;
         transform?: boolean;
-    }) => ZodEffects<ZodEffects<ZodType<string, zod.ZodTypeDef, string>, string, string>, number, string>;
+    }) => ZodPipe<ZodString, ZodTransform<number, string>>;
     integerStringRaw: (options?: {
         maxLength?: number;
         lt?: number;
         gt?: number;
         transform?: boolean;
-    }) => typeof options.transform extends true ? ZodEffects<ZodType<number>> : ZodEffects<ZodType<string>>;
-    bigIntegerString: () => ZodEffects<ZodString, string, string>;
+    }) => ZodString;
+    bigIntegerString: () => ZodString;
     floatString: (options?: {
         maxLength?: number;
         lt: number;
         gt: number;
-    }) => ZodEffects<ZodEffects<ZodString, string, string>, number, string>;
+    }) => ZodPipe<ZodString, ZodTransform<number, string>>;
     hex: ({ min, max, length, rawLength, }?: {
         min?: number;
         max?: number;
         length?: number;
         rawLength?: number;
-    }) => ZodEffects<ZodString, string, string>;
-    sha256: () => ZodEffects<ZodString, string, string>;
+    }) => ZodString;
+    sha256: () => ZodString;
     base64: ({ min, max, length, rawLength, isBase64Url, }?: {
         min?: number;
         max?: number;
         length?: number;
         rawLength?: number;
         isBase64Url?: boolean;
-    }) => ZodEffects<ZodString>;
-    bearerToken: () => ZodEffects<ZodEffects<ZodString>>;
+    }) => ZodString;
+    bearerToken: () => ZodPipe<ZodString, ZodTransform<string, string>>;
     jwt: ({ max }: {
         max: number;
-    }) => ZodEffects<ZodString>;
-    ecPublicKey: () => ZodEffects<ZodString, string, string>;
-    ecCompressedPublicKey: () => ZodEffects<ZodString, string, string>;
-    uncompressedECPublicKey: () => ZodEffects<ZodString, string, string>;
-    ecSignature: () => ZodEffects<ZodString, string, string>;
-    iv: () => ZodEffects<ZodString, string, string>;
-    mac: () => ZodEffects<ZodString, string, string>;
-    traceId: () => ZodEffects<ZodString, string, string>;
-    isoDateString: () => ZodEffects<ZodString, string>;
-    rfc3339String: () => ZodEffects<ZodString, string>;
-    iso8601Date: () => ZodEffects<ZodString, string, string>;
-    urlHttpsString: () => ZodEffects<ZodString, string, string>;
-    urlHttpOrHttpsString: () => ZodEffects<ZodString, string, string>;
+    }) => ZodString;
+    ecPublicKey: () => ZodString;
+    ecCompressedPublicKey: () => ZodString;
+    uncompressedECPublicKey: () => ZodString;
+    ecSignature: () => ZodString;
+    iv: () => ZodString;
+    mac: () => ZodString;
+    traceId: () => ZodString;
+    isoDateString: () => ZodString;
+    rfc3339String: () => ZodString;
+    iso8601Date: () => ZodString;
+    urlHttpsString: () => ZodString;
+    urlHttpOrHttpsString: () => ZodString;
     language: () => ZodTypeAny;
     dsgcPayload: () => ZodObject<{
         certificates: zod.ZodArray<ZodObject<{
@@ -273,60 +396,14 @@ declare const z: {
             signature: ZodString;
             thumbprint: ZodString;
             timestamp: ZodString;
-        }, "strip", ZodTypeAny, {
-            certificateType: string;
-            country: string;
-            kid: string;
-            rawData: string;
-            signature: string;
-            thumbprint: string;
-            timestamp: string;
-        }, {
-            certificateType: string;
-            country: string;
-            kid: string;
-            rawData: string;
-            signature: string;
-            thumbprint: string;
-            timestamp: string;
-        }>, "many">;
-    }, "strip", ZodTypeAny, {
-        certificates: {
-            certificateType: string;
-            country: string;
-            kid: string;
-            rawData: string;
-            signature: string;
-            thumbprint: string;
-            timestamp: string;
-        }[];
-    }, {
-        certificates: {
-            certificateType: string;
-            country: string;
-            kid: string;
-            rawData: string;
-            signature: string;
-            thumbprint: string;
-            timestamp: string;
-        }[];
-    }>;
+        }, zod.core.$strip>>;
+    }, zod.core.$strip>;
     dccListPayload: () => zod.ZodArray<ZodObject<{
         identifier: ZodString;
         version: ZodString;
         country: ZodString;
         hash: ZodString;
-    }, "strip", ZodTypeAny, {
-        identifier: string;
-        version: string;
-        country: string;
-        hash: string;
-    }, {
-        identifier: string;
-        version: string;
-        country: string;
-        hash: string;
-    }>, "many">;
+    }, zod.core.$strip>>;
     dccRulePayload: () => ZodObject<{
         Identifier: ZodString;
         Type: ZodString;
@@ -339,52 +416,12 @@ declare const z: {
         Description: zod.ZodArray<ZodObject<{
             lang: ZodString;
             desc: ZodString;
-        }, "strip", ZodTypeAny, {
-            lang: string;
-            desc: string;
-        }, {
-            lang: string;
-            desc: string;
-        }>, "many">;
+        }, zod.core.$strip>>;
         ValidFrom: ZodString;
         ValidTo: ZodString;
-        AffectedFields: zod.ZodArray<ZodString, "many">;
-        Logic: zod.ZodAny;
-    }, "strip", ZodTypeAny, {
-        Identifier: string;
-        Type: string;
-        Country: string;
-        Version: string;
-        SchemaVersion: string;
-        Engine: string;
-        EngineVersion: string;
-        CertificateType: string;
-        Description: {
-            lang: string;
-            desc: string;
-        }[];
-        ValidFrom: string;
-        ValidTo: string;
-        AffectedFields: string[];
-        Logic?: any;
-    }, {
-        Identifier: string;
-        Type: string;
-        Country: string;
-        Version: string;
-        SchemaVersion: string;
-        Engine: string;
-        EngineVersion: string;
-        CertificateType: string;
-        Description: {
-            lang: string;
-            desc: string;
-        }[];
-        ValidFrom: string;
-        ValidTo: string;
-        AffectedFields: string[];
-        Logic?: any;
-    }>;
+        AffectedFields: zod.ZodArray<ZodString>;
+        Logic: zod.ZodOptional<zod.ZodAny>;
+    }, zod.core.$strip>;
 };
 export declare const isPostalCodeForCountry: (postalCode: string, countryCode: string) => boolean;
 export * from 'zod';