@openclaw/matrix 2026.9.4 → 2026.9.6

package/node_modules/zod/v4/core/schemas.d.cts

@@ -1,4 +1,6 @@
 import * as checks from "./checks.cjs";
+import type { $ZodNumberFormats } from "./checks.cjs";
+import type { $ZodBigIntFormats } from "./checks.cjs";
 import * as core from "./core.cjs";
 import type * as errors from "./errors.cjs";
 import type * as JSONSchema from "./json-schema.cjs";
@@ -19,17 +21,23 @@ export interface ParseContextInternal<T extends errors.$ZodIssueBase = never> ex
     readonly async?: boolean | undefined;
     readonly direction?: "forward" | "backward";
     readonly skipChecks?: boolean;
+    /** Set only by `validate`/`validateAsync`. A container may stop before its next child, never inside one, so a map entry and a tuple's fixed items parse whole. */
+    readonly abortEarly?: boolean;
+}
+/** Gives a container cycle support: `attach` wraps its parse, and `alloc` registers the object it builds into before any child is parsed so a reference back to the same input resolves to it. */
+export interface $ZodMemoizer {
+    attach(inst: $ZodType): void;
+    guard(inst: $ZodType): void;
+    alloc<T extends object>(inst: $ZodType, payload: ParsePayload, empty: T, ctx: ParseContextInternal): T;
 }
 export interface ParsePayload<T = unknown> {
     value: T;
     issues: errors.$ZodRawIssue[];
     /** A way to mark a whole payload as aborted. Used in codecs/pipes. */
     aborted?: boolean;
-    /** @internal Marks a value as a fallback that an outer wrapper (e.g.
-     * $ZodOptional) may override with its own interpretation when input was
-     * undefined. Set by $ZodCatch when catchValue substitutes and by every
-     * $ZodTransform invocation. */
-    fallback?: boolean | undefined;
+    /** @internal Set when the value came from a repeat visit to a node still being
+     * parsed. Its checks run on the node itself, against the finished value. */
+    memo?: boolean | undefined;
 }
 export type CheckFn<T> = (input: ParsePayload<T>) => util.MaybeAsync<void>;
 export interface $ZodTypeDef {
@@ -54,8 +62,13 @@ export interface _$ZodTypeInternals {
     /** @internal Indicates that a schema output type should be considered optional inside objects.
      * @default Required
      */
-    /** @internal */
-    optin?: "optional" | undefined;
+    /** @internal Three rungs, each strictly stronger than the last:
+     *   undefined    — required; the container may not omit this slot
+     *   "optional"   — the container may omit it; nothing is supplied in its place
+     *   "defaulted"  — the container may omit it AND this schema substitutes a value
+     * Consumers asking "may the slot be absent?" test `!== undefined`.
+     * $ZodOptional asks the stronger question and tests `=== "defaulted"`. */
+    optin?: "optional" | "defaulted" | undefined;
     /** @internal */
     optout?: "optional" | undefined;
     /** @internal The set of literal values that will pass validation. Must be an exhaustive set. Used to determine optionality in z.record().
@@ -101,6 +114,7 @@ export interface $ZodType<O = unknown, I = unknown, Internals extends $ZodTypeIn
 export interface _$ZodType<T extends $ZodTypeInternals = $ZodTypeInternals> extends $ZodType<T["output"], T["input"], T> {
 }
 export declare const $ZodType: core.$constructor<$ZodType>;
+export declare function standardProps(inst: $ZodType): StandardSchemaV1.Props<any, any>;
 export { clone } from "./util.cjs";
 export interface $ZodStringDef extends $ZodTypeDef {
     type: "string";
@@ -119,6 +133,8 @@ export interface $ZodStringInternals<Input> extends $ZodTypeInternals<string, In
         patterns: Set<RegExp>;
         format: string;
         contentEncoding: string;
+        /** the pattern admits strings its `format` keyword forbids, so `toJSONSchema` must not emit it */
+        laxFormat: boolean;
     }>;
 }
 export interface $ZodString<Input = unknown> extends _$ZodType<$ZodStringInternals<Input>> {
@@ -170,6 +186,18 @@ export interface $ZodURLInternals extends $ZodStringFormatInternals<"url"> {
 export interface $ZodURL extends $ZodType {
     _zod: $ZodURLInternals;
 }
+/** The `://` guard rejected the input before the URL constructor saw it. */
+export declare const URL_BAD_FORMAT = 1;
+/** The URL parser rejected the input. */
+export declare const URL_UNPARSEABLE = 2;
+export declare function canParseURL(input: string): boolean;
+export declare function validateURL(trimmed: string, def: Pick<$ZodURLDef, "protocol" | "hostname" | "normalize">): URL | true | typeof URL_BAD_FORMAT | typeof URL_UNPARSEABLE;
+/** Parses a URL while preserving the non-normalizing HTTP guard. */
+export declare function parseURLObject(trimmed: string, def: Pick<$ZodURLDef, "protocol" | "normalize">): URL | typeof URL_BAD_FORMAT | typeof URL_UNPARSEABLE;
+/** The URL parser deletes every ASCII tab, LF and CR from its input before it parses, so `new URL("https://exa\nmple.com")` reports on `example.com`. Applying the same deletion to the returned value closes the half of that divergence which can move the host; the parser's other rewrite, stripping C0 controls at the edges, cannot. */
+export declare function stripTabAndNewline(value: string): string;
+export declare function urlHostnameOk(url: URL, hostname: RegExp): boolean;
+export declare function urlProtocolOk(url: URL, protocol: RegExp): boolean;
 export declare const $ZodURL: core.$constructor<$ZodURL>;
 export interface $ZodEmojiDef extends $ZodStringFormatDef<"emoji"> {
 }
@@ -180,8 +208,10 @@ export interface $ZodEmoji extends $ZodType {
 }
 export declare const $ZodEmoji: core.$constructor<$ZodEmoji>;
 export interface $ZodNanoIDDef extends $ZodStringFormatDef<"nanoid"> {
+    length?: number | undefined;
 }
 export interface $ZodNanoIDInternals extends $ZodStringFormatInternals<"nanoid"> {
+    def: $ZodNanoIDDef;
 }
 export interface $ZodNanoID extends $ZodType {
     _zod: $ZodNanoIDInternals;
@@ -304,6 +334,7 @@ export interface $ZodIPv6Internals extends $ZodStringFormatInternals<"ipv6"> {
 export interface $ZodIPv6 extends $ZodType {
     _zod: $ZodIPv6Internals;
 }
+export declare function isValidIPv6(value: string): boolean;
 export declare const $ZodIPv6: core.$constructor<$ZodIPv6>;
 export interface $ZodMACDef extends $ZodStringFormatDef<"mac"> {
     delimiter?: string;
@@ -334,6 +365,7 @@ export interface $ZodCIDRv6Internals extends $ZodStringFormatInternals<"cidrv6">
 export interface $ZodCIDRv6 extends $ZodType {
     _zod: $ZodCIDRv6Internals;
 }
+export declare function isValidCIDRv6(value: string): boolean;
 export declare const $ZodCIDRv6: core.$constructor<$ZodCIDRv6>;
 export declare function isValidBase64(data: string): boolean;
 export interface $ZodBase64Def extends $ZodStringFormatDef<"base64"> {
@@ -343,7 +375,9 @@ export interface $ZodBase64Internals extends $ZodStringFormatInternals<"base64">
 export interface $ZodBase64 extends $ZodType {
     _zod: $ZodBase64Internals;
 }
+export declare const base64Charset: RegExp;
 export declare const $ZodBase64: core.$constructor<$ZodBase64>;
+export declare const base64urlCharset: RegExp;
 export declare function isValidBase64URL(data: string): boolean;
 export interface $ZodBase64URLDef extends $ZodStringFormatDef<"base64url"> {
 }
@@ -361,6 +395,26 @@ export interface $ZodE164 extends $ZodType {
     _zod: $ZodE164Internals;
 }
 export declare const $ZodE164: core.$constructor<$ZodE164>;
+export declare function isValidCreditCard(input: string): boolean;
+export interface $ZodCreditCardDef extends $ZodStringFormatDef<"credit_card"> {
+}
+export interface $ZodCreditCardInternals extends $ZodStringFormatInternals<"credit_card"> {
+    def: $ZodCreditCardDef;
+}
+export interface $ZodCreditCard extends $ZodType {
+    _zod: $ZodCreditCardInternals;
+}
+export declare const $ZodCreditCard: core.$constructor<$ZodCreditCard>;
+export declare function isValidIBAN(input: string): boolean;
+export interface $ZodIBANDef extends $ZodStringFormatDef<"iban"> {
+}
+export interface $ZodIBANInternals extends $ZodStringFormatInternals<"iban"> {
+    def: $ZodIBANDef;
+}
+export interface $ZodIBAN extends $ZodType {
+    _zod: $ZodIBANInternals;
+}
+export declare const $ZodIBAN: core.$constructor<$ZodIBAN>;
 export declare function isValidJWT(token: string, algorithm?: util.JWTAlgorithm | null): boolean;
 export interface $ZodJWTDef extends $ZodStringFormatDef<"jwt"> {
     alg?: util.JWTAlgorithm | undefined;
@@ -405,14 +459,14 @@ export interface $ZodNumber<Input = unknown> extends $ZodType {
     _zod: $ZodNumberInternals<Input>;
 }
 export declare const $ZodNumber: core.$constructor<$ZodNumber>;
-export interface $ZodNumberFormatDef extends $ZodNumberDef, checks.$ZodCheckNumberFormatDef {
+export interface $ZodNumberFormatDef<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodNumberDef, checks.$ZodCheckNumberFormatDef<Format> {
 }
-export interface $ZodNumberFormatInternals extends $ZodNumberInternals<number>, checks.$ZodCheckNumberFormatInternals {
-    def: $ZodNumberFormatDef;
+export interface $ZodNumberFormatInternals<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodNumberInternals<number>, checks.$ZodCheckNumberFormatInternals<Format> {
+    def: $ZodNumberFormatDef<Format>;
     isst: errors.$ZodIssueInvalidType;
 }
-export interface $ZodNumberFormat extends $ZodType {
-    _zod: $ZodNumberFormatInternals;
+export interface $ZodNumberFormat<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodType {
+    _zod: $ZodNumberFormatInternals<Format>;
 }
 export declare const $ZodNumberFormat: core.$constructor<$ZodNumberFormat>;
 export interface $ZodBooleanDef extends $ZodTypeDef {
@@ -448,14 +502,14 @@ export interface $ZodBigInt<T = unknown> extends $ZodType {
     _zod: $ZodBigIntInternals<T>;
 }
 export declare const $ZodBigInt: core.$constructor<$ZodBigInt>;
-export interface $ZodBigIntFormatDef extends $ZodBigIntDef, checks.$ZodCheckBigIntFormatDef {
+export interface $ZodBigIntFormatDef<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends $ZodBigIntDef, checks.$ZodCheckBigIntFormatDef<Format> {
     check: "bigint_format";
 }
-export interface $ZodBigIntFormatInternals extends $ZodBigIntInternals<bigint>, checks.$ZodCheckBigIntFormatInternals {
-    def: $ZodBigIntFormatDef;
+export interface $ZodBigIntFormatInternals<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends $ZodBigIntInternals<bigint>, checks.$ZodCheckBigIntFormatInternals<Format> {
+    def: $ZodBigIntFormatDef<Format>;
 }
-export interface $ZodBigIntFormat extends $ZodType {
-    _zod: $ZodBigIntFormatInternals;
+export interface $ZodBigIntFormat<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends $ZodType {
+    _zod: $ZodBigIntFormatInternals<Format>;
 }
 export declare const $ZodBigIntFormat: core.$constructor<$ZodBigIntFormat>;
 export interface $ZodSymbolDef extends $ZodTypeDef {
@@ -576,15 +630,19 @@ type OptionalOutSchema = {
 };
 type OptionalInSchema = {
     _zod: {
-        optin: "optional";
+        optin: "optional" | "defaulted";
     };
 };
-export type $InferObjectOutput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? util.IsAny<T[keyof T]> extends true ? Record<string, unknown> : Record<string, core.output<T[keyof T]>> : keyof (T & Extra) extends never ? Record<string, never> : util.Prettify<{
+export type $InferObjectOutput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? util.IsAny<T[keyof T]> extends true ? Record<string, unknown> : {
+    [k in string]: core.output<T[keyof T]>;
+} : keyof (T & Extra) extends never ? Record<string, never> : util.Prettify<{
     -readonly [k in keyof T as T[k] extends OptionalOutSchema ? never : k]: T[k]["_zod"]["output"];
 } & {
     -readonly [k in keyof T as T[k] extends OptionalOutSchema ? k : never]?: T[k]["_zod"]["output"];
 } & Extra>;
-export type $InferObjectInput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? util.IsAny<T[keyof T]> extends true ? Record<string, unknown> : Record<string, core.input<T[keyof T]>> : keyof (T & Extra) extends never ? Record<string, never> : util.Prettify<{
+export type $InferObjectInput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? util.IsAny<T[keyof T]> extends true ? Record<string, unknown> : {
+    [k in string]: core.input<T[keyof T]>;
+} : keyof (T & Extra) extends never ? Record<string, never> : util.Prettify<{
     -readonly [k in keyof T as T[k] extends OptionalInSchema ? never : k]: T[k]["_zod"]["input"];
 } & {
     -readonly [k in keyof T as T[k] extends OptionalInSchema ? k : never]?: T[k]["_zod"]["input"];
@@ -656,7 +714,7 @@ export interface $ZodUnionInternals<T extends readonly SomeType[] = readonly $Zo
     values: T[number]["_zod"]["values"];
     output: $InferUnionOutput<T[number]>;
     input: $InferUnionInput<T[number]>;
-    optin: IsOptionalIn<T[number]> extends false ? "optional" | undefined : "optional";
+    optin: IsOptionalIn<T[number]> extends false ? "optional" | "defaulted" | undefined : "optional" | "defaulted";
     optout: IsOptionalOut<T[number]> extends false ? "optional" | undefined : "optional";
 }
 export interface $ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType<any, any, $ZodUnionInternals<T>> {
@@ -676,7 +734,28 @@ export interface $ZodDiscriminatedUnionDef<Options extends readonly SomeType[] =
 export interface $ZodDiscriminatedUnionInternals<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodUnionInternals<Options> {
     def: $ZodDiscriminatedUnionDef<Options, Disc>;
     propValues: util.PropValues;
+    bag: util.LoosePartial<{
+        optionsMap: Map<util.Primitive, $ZodType | null>;
+    }>;
 }
+/** The discriminator values a member of `Options` can declare. An omittable discriminator contributes `undefined`, matching what `propValues` claims for it. */
+export type $DiscriminatorValue<Options extends readonly SomeType[], Disc extends string> = {
+    [I in keyof Options]: Options[I] extends {
+        _zod: {
+            output: infer Out;
+        };
+    } ? Disc extends keyof Out ? Out[Disc] : never : never;
+}[number];
+/** The member of `Options` that declares `V`. */
+export type $DiscriminatedOption<Options extends readonly SomeType[], Disc extends string, V> = {
+    [I in keyof Options]: Options[I] extends {
+        _zod: {
+            output: infer Out;
+        };
+    } ? Disc extends keyof Out ? V extends Out[Disc] ? Options[I] : never : never : never;
+}[number];
+/** Returns the option whose discriminator claims `value`, or throws if ambiguous. */
+export declare function getDiscriminatedOption<Options extends readonly SomeType[], Disc extends string, const V extends $DiscriminatorValue<Options, Disc>>(union: $ZodDiscriminatedUnion<Options, Disc>, value: V): $DiscriminatedOption<Options, Disc, V>;
 export interface $ZodDiscriminatedUnion<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodType {
     _zod: $ZodDiscriminatedUnionInternals<Options, Disc>;
 }
@@ -698,6 +777,13 @@ export interface $ZodIntersection<A extends SomeType = $ZodType, B extends SomeT
     _zod: $ZodIntersectionInternals<A, B>;
 }
 export declare const $ZodIntersection: core.$constructor<$ZodIntersection>;
+export declare function mergeValues(a: any, b: any): {
+    valid: true;
+    data: any;
+} | {
+    valid: false;
+    mergeErrorPath: (string | number)[];
+};
 export interface $ZodTupleDef<T extends util.TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends $ZodTypeDef {
     type: "tuple";
     items: T;
@@ -713,7 +799,7 @@ type TupleInputTypeNoOptionals<T extends util.TupleItems> = {
 type TupleInputTypeWithOptionals<T extends util.TupleItems> = T extends readonly [
     ...infer Prefix extends SomeType[],
     infer Tail extends SomeType
-] ? Tail["_zod"]["optin"] extends "optional" ? [...TupleInputTypeWithOptionals<Prefix>, core.input<Tail>?] : TupleInputTypeNoOptionals<T> : [];
+] ? Tail["_zod"]["optin"] extends "optional" | "defaulted" ? [...TupleInputTypeWithOptionals<Prefix>, core.input<Tail>?] : TupleInputTypeNoOptionals<T> : [];
 export type $InferTupleOutputType<T extends util.TupleItems, Rest extends SomeType | null> = [
     ...TupleOutputTypeWithOptionals<T>,
     ...(Rest extends SomeType ? core.output<Rest>[] : [])
@@ -742,9 +828,12 @@ export interface $ZodRecordDef<Key extends $ZodRecordKey = $ZodRecordKey, Value
     valueType: Value;
     /** @default "strict" - errors on keys not matching keyType. "loose" passes through non-matching keys unchanged. */
     mode?: "strict" | "loose";
+    partial?: boolean;
 }
 export type $InferZodRecordOutput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<core.output<Key>, core.output<Value>>> : Record<core.output<Key>, core.output<Value>>;
-export type $InferZodRecordInput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<core.input<Key> & PropertyKey, core.input<Value>>> : Record<core.input<Key> & PropertyKey, core.input<Value>>;
+export type $InferZodRecordInput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<core.input<Key> & PropertyKey, core.input<Value>>> : [
+    Value
+] extends [OptionalInSchema] ? Partial<Record<core.input<Key> & PropertyKey, core.input<Value>>> : Record<core.input<Key> & PropertyKey, core.input<Value>>;
 export interface $ZodRecordInternals<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeInternals<$InferZodRecordOutput<Key, Value>, $InferZodRecordInput<Key, Value>> {
     def: $ZodRecordDef<Key, Value>;
     isst: errors.$ZodIssueInvalidType | errors.$ZodIssueInvalidKey<Record<PropertyKey, unknown>>;
@@ -863,7 +952,7 @@ export interface $ZodOptionalDef<T extends SomeType = $ZodType> extends $ZodType
 }
 export interface $ZodOptionalInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<T> | undefined, core.input<T> | undefined> {
     def: $ZodOptionalDef<T>;
-    optin: "optional";
+    optin: "optional" | "defaulted";
     optout: "optional";
     isst: never;
     values: T["_zod"]["values"];
@@ -908,7 +997,7 @@ export interface $ZodDefaultDef<T extends SomeType = $ZodType> extends $ZodTypeD
 }
 export interface $ZodDefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<util.NoUndefined<core.output<T>>, core.input<T> | undefined> {
     def: $ZodDefaultDef<T>;
-    optin: "optional";
+    optin: "defaulted";
     optout?: "optional" | undefined;
     isst: never;
     values: T["_zod"]["values"];
@@ -923,9 +1012,9 @@ export interface $ZodPrefaultDef<T extends SomeType = $ZodType> extends $ZodType
     /** The default value. May be a getter. */
     defaultValue: core.input<T>;
 }
-export interface $ZodPrefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<util.NoUndefined<core.output<T>>, core.input<T> | undefined> {
+export interface $ZodPrefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<T>, core.input<T> | undefined> {
     def: $ZodPrefaultDef<T>;
-    optin: "optional";
+    optin: "defaulted";
     optout?: "optional" | undefined;
     isst: never;
     values: T["_zod"]["values"];
@@ -1035,17 +1124,17 @@ export interface $ZodCodec<A extends SomeType = $ZodType, B extends SomeType = $
     _zod: $ZodCodecInternals<A, B>;
 }
 export declare const $ZodCodec: core.$constructor<$ZodCodec>;
-export interface $ZodPreprocessDef<B extends SomeType = $ZodType> extends $ZodPipeDef<$ZodTransform, B> {
-    in: $ZodTransform;
+export interface $ZodPreprocessDef<B extends SomeType = $ZodType, I = unknown> extends $ZodPipeDef<$ZodTransform<unknown, I>, B> {
+    in: $ZodTransform<unknown, I>;
     out: B;
 }
-export interface $ZodPreprocessInternals<B extends SomeType = $ZodType> extends $ZodPipeInternals<$ZodTransform, B> {
-    def: $ZodPreprocessDef<B>;
+export interface $ZodPreprocessInternals<B extends SomeType = $ZodType, I = unknown> extends $ZodPipeInternals<$ZodTransform<unknown, I>, B> {
+    def: $ZodPreprocessDef<B, I>;
     optin: B["_zod"]["optin"];
     optout: B["_zod"]["optout"];
 }
-export interface $ZodPreprocess<B extends SomeType = $ZodType> extends $ZodPipe<$ZodTransform, B> {
-    _zod: $ZodPreprocessInternals<B>;
+export interface $ZodPreprocess<B extends SomeType = $ZodType, I = unknown> extends $ZodPipe<$ZodTransform<unknown, I>, B> {
+    _zod: $ZodPreprocessInternals<B, I>;
 }
 export declare const $ZodPreprocess: core.$constructor<$ZodPreprocess>;
 export interface $ZodReadonlyDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
@@ -1181,4 +1270,4 @@ export interface $ZodCustom<O = unknown, I = unknown> extends $ZodType {
 }
 export declare const $ZodCustom: core.$constructor<$ZodCustom>;
 export type $ZodTypes = $ZodString | $ZodNumber | $ZodBigInt | $ZodBoolean | $ZodDate | $ZodSymbol | $ZodUndefined | $ZodNullable | $ZodNull | $ZodAny | $ZodUnknown | $ZodNever | $ZodVoid | $ZodArray | $ZodObject | $ZodUnion | $ZodIntersection | $ZodTuple | $ZodRecord | $ZodMap | $ZodSet | $ZodLiteral | $ZodEnum | $ZodFunction | $ZodPromise | $ZodLazy | $ZodOptional | $ZodDefault | $ZodPrefault | $ZodTemplateLiteral | $ZodCustom | $ZodTransform | $ZodNonOptional | $ZodReadonly | $ZodNaN | $ZodPipe | $ZodSuccess | $ZodCatch | $ZodFile;
-export type $ZodStringFormatTypes = $ZodGUID | $ZodUUID | $ZodEmail | $ZodURL | $ZodEmoji | $ZodNanoID | $ZodCUID | $ZodCUID2 | $ZodULID | $ZodXID | $ZodKSUID | $ZodISODateTime | $ZodISODate | $ZodISOTime | $ZodISODuration | $ZodIPv4 | $ZodIPv6 | $ZodMAC | $ZodCIDRv4 | $ZodCIDRv6 | $ZodBase64 | $ZodBase64URL | $ZodE164 | $ZodJWT | $ZodCustomStringFormat<"hex"> | $ZodCustomStringFormat<util.HashFormat> | $ZodCustomStringFormat<"hostname">;
+export type $ZodStringFormatTypes = $ZodGUID | $ZodUUID | $ZodEmail | $ZodURL | $ZodEmoji | $ZodNanoID | $ZodCUID | $ZodCUID2 | $ZodULID | $ZodXID | $ZodKSUID | $ZodISODateTime | $ZodISODate | $ZodISOTime | $ZodISODuration | $ZodIPv4 | $ZodIPv6 | $ZodMAC | $ZodCIDRv4 | $ZodCIDRv6 | $ZodBase64 | $ZodBase64URL | $ZodE164 | $ZodCreditCard | $ZodIBAN | $ZodJWT | $ZodCustomStringFormat<"hex"> | $ZodCustomStringFormat<util.HashFormat> | $ZodCustomStringFormat<"hostname"> | $ZodCustomStringFormat<"currency_code">;