@cossistant/react 0.0.29 → 0.0.31

package/utils/conversation.js

@@ -1,7 +1,5 @@
-import { ConversationStatus } from "@cossistant/types";
-
 //#region src/utils/conversation.ts
-const HIDDEN_STATUSES = new Set([ConversationStatus.RESOLVED, "closed"]);
+const HIDDEN_STATUSES = new Set(["closed"]);
 function hasDisplayableTitle(conversation) {
 	const title = conversation.title?.trim();
 	if (title && title.length > 0) return true;

package/utils/conversation.js.map

@@ -1 +1 @@
-{"version":3,"file":"conversation.js","names":[],"sources":["../../src/utils/conversation.ts"],"sourcesContent":["import { type Conversation, ConversationStatus } from \"@cossistant/types\";\n\nconst HIDDEN_STATUSES = new Set<ConversationStatus | \"closed\">([\n\tConversationStatus.RESOLVED,\n\t\"closed\",\n]);\n\nfunction hasDisplayableTitle(conversation: Conversation): boolean {\n\tconst title = conversation.title?.trim();\n\n\tif (title && title.length > 0) {\n\t\treturn true;\n\t}\n\n\t// Allow conversations with messages even if no explicit title\n\tconst lastMessageText = conversation.lastTimelineItem?.text?.trim();\n\treturn Boolean(lastMessageText && lastMessageText.length > 0);\n}\n\nexport function shouldDisplayConversation(conversation: Conversation): boolean {\n\tif (!hasDisplayableTitle(conversation)) {\n\t\treturn false;\n\t}\n\n\tif (conversation.deletedAt) {\n\t\treturn false;\n\t}\n\n\tif (HIDDEN_STATUSES.has(conversation.status)) {\n\t\treturn false;\n\t}\n\n\treturn true;\n}\n"],"mappings":";;;AAEA,MAAM,kBAAkB,IAAI,IAAmC,CAC9D,mBAAmB,UACnB,SACA,CAAC;AAEF,SAAS,oBAAoB,cAAqC;CACjE,MAAM,QAAQ,aAAa,OAAO,MAAM;AAExC,KAAI,SAAS,MAAM,SAAS,EAC3B,QAAO;CAIR,MAAM,kBAAkB,aAAa,kBAAkB,MAAM,MAAM;AACnE,QAAO,QAAQ,mBAAmB,gBAAgB,SAAS,EAAE;;AAG9D,SAAgB,0BAA0B,cAAqC;AAC9E,KAAI,CAAC,oBAAoB,aAAa,CACrC,QAAO;AAGR,KAAI,aAAa,UAChB,QAAO;AAGR,KAAI,gBAAgB,IAAI,aAAa,OAAO,CAC3C,QAAO;AAGR,QAAO"}
+{"version":3,"file":"conversation.js","names":[],"sources":["../../src/utils/conversation.ts"],"sourcesContent":["import type { Conversation, ConversationStatus } from \"@cossistant/types\";\n\nconst HIDDEN_STATUSES = new Set<ConversationStatus | \"closed\">([\"closed\"]);\n\nfunction hasDisplayableTitle(conversation: Conversation): boolean {\n\tconst title = conversation.title?.trim();\n\n\tif (title && title.length > 0) {\n\t\treturn true;\n\t}\n\n\t// Allow conversations with messages even if no explicit title\n\tconst lastMessageText = conversation.lastTimelineItem?.text?.trim();\n\treturn Boolean(lastMessageText && lastMessageText.length > 0);\n}\n\nexport function shouldDisplayConversation(conversation: Conversation): boolean {\n\tif (!hasDisplayableTitle(conversation)) {\n\t\treturn false;\n\t}\n\n\tif (conversation.deletedAt) {\n\t\treturn false;\n\t}\n\n\tif (HIDDEN_STATUSES.has(conversation.status)) {\n\t\treturn false;\n\t}\n\n\treturn true;\n}\n"],"mappings":";AAEA,MAAM,kBAAkB,IAAI,IAAmC,CAAC,SAAS,CAAC;AAE1E,SAAS,oBAAoB,cAAqC;CACjE,MAAM,QAAQ,aAAa,OAAO,MAAM;AAExC,KAAI,SAAS,MAAM,SAAS,EAC3B,QAAO;CAIR,MAAM,kBAAkB,aAAa,kBAAkB,MAAM,MAAM;AACnE,QAAO,QAAQ,mBAAmB,gBAAgB,SAAS,EAAE;;AAG9D,SAAgB,0BAA0B,cAAqC;AAC9E,KAAI,CAAC,oBAAoB,aAAa,CACrC,QAAO;AAGR,KAAI,aAAa,UAChB,QAAO;AAGR,KAAI,gBAAgB,IAAI,aAAa,OAAO,CAC3C,QAAO;AAGR,QAAO"}

package/utils/use-render-element.js

@@ -23,7 +23,7 @@ function getElementRef(element) {
 * Slot component that properly forwards refs when using asChild pattern.
 * Uses forwardRef to receive the ref and merges it with any existing ref on the child.
 */
-const Slot = React$1.forwardRef(({ children,...props }, forwardedRef) => {
+const Slot = React$1.forwardRef(({ children, ...props }, forwardedRef) => {
 	const mergedRef = mergeRefs([forwardedRef, getElementRef(children)]);
 	return React$1.cloneElement(children, {
 		...props,
@@ -51,7 +51,7 @@ function useRenderElement(tag, componentProps, params) {
 		ref: getElementRef(render) || ref
 	});
 	if (asChild && React$1.isValidElement(propsWithClassName.children)) {
-		const { ref: slotRef,...restMergedProps } = mergedProps;
+		const { ref: slotRef, ...restMergedProps } = mergedProps;
 		return /* @__PURE__ */ jsx(Slot, {
 			ref: slotRef,
 			...restMergedProps,

package/utils/use-render-element.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-render-element.js","names":["React"],"sources":["../../src/utils/use-render-element.tsx"],"sourcesContent":["/** biome-ignore-all lint/suspicious/noExplicitAny: works well here */\n/** biome-ignore-all lint/nursery/noUnnecessaryConditions: ok */\n\nimport type { JSX } from \"react\";\nimport * as React from \"react\";\nimport { mergeRefs } from \"./merge-refs\";\n\n/**\n * Gets the ref from a React element in a way that's compatible with both React 18 and React 19.\n *\n * - Before React 19: accessing `element.props.ref` throws a warning, use `element.ref`\n * - After React 19: accessing `element.ref` throws a warning, use `element.props.ref`\n *\n * This function detects which version of React is being used by checking for the\n * `isReactWarning` property descriptor that React adds in DEV mode.\n *\n * @see https://github.com/radix-ui/primitives/pull/2811\n */\nfunction getElementRef(element: React.ReactElement): React.Ref<unknown> | null {\n\t// React 18 in DEV mode will throw a warning when accessing `element.props.ref`\n\t// and suggest using `element.ref` instead.\n\t// We detect this by checking for the `isReactWarning` getter on `props.ref`.\n\tconst getter = Object.getOwnPropertyDescriptor(element.props, \"ref\")?.get;\n\tconst mayWarn = getter && \"isReactWarning\" in getter && getter.isReactWarning;\n\n\tif (mayWarn) {\n\t\t// React 18: use element.ref\n\t\treturn (element as any).ref;\n\t}\n\n\t// React 19 or production: prefer props.ref, fallback to element.ref for older versions\n\treturn (element.props as any).ref ?? (element as any).ref;\n}\n\ntype IntrinsicTag = keyof JSX.IntrinsicElements;\n\ntype ClassName<State> = string | ((state: State) => string);\n\ntype RenderFn<Props, State> = (\n\tprops: Props,\n\tstate: State\n) => React.ReactElement;\n\ntype RenderProps<State, Tag extends IntrinsicTag> = {\n\trender?: React.ReactElement | RenderFn<JSX.IntrinsicElements[Tag], State>;\n\tclassName?: ClassName<State>;\n\tasChild?: boolean;\n};\n\ntype RenderParams<State, Tag extends IntrinsicTag> = {\n\tstate?: State;\n\tref?: React.Ref<any>;\n\tprops?: Partial<JSX.IntrinsicElements[Tag]>;\n\tenabled?: boolean;\n};\n\ntype SlotProps = {\n\tchildren: React.ReactElement;\n\t[key: string]: any;\n};\n\n/**\n * Slot component that properly forwards refs when using asChild pattern.\n * Uses forwardRef to receive the ref and merges it with any existing ref on the child.\n */\nconst Slot = React.forwardRef<HTMLElement, SlotProps>(\n\t({ children, ...props }, forwardedRef) => {\n\t\t// Get the child's existing ref using React 18/19 compatible helper\n\t\tconst childRef = getElementRef(children);\n\n\t\t// Merge the forwarded ref with the child's ref\n\t\tconst mergedRef = mergeRefs([forwardedRef, childRef]);\n\n\t\treturn React.cloneElement(children, {\n\t\t\t...props,\n\t\t\tref: mergedRef,\n\t\t\tclassName: [(children.props as any).className, props.className]\n\t\t\t\t.filter(Boolean)\n\t\t\t\t.join(\" \"),\n\t\t} as any);\n\t}\n);\n\n/**\n * Utility hook to support slot-style component overrides.\n */\nexport function useRenderElement<\n\tState extends Record<string, any>,\n\tTag extends IntrinsicTag,\n>(\n\ttag: Tag,\n\tcomponentProps: RenderProps<State, Tag>,\n\tparams?: RenderParams<State, Tag>\n): React.ReactElement | null {\n\tconst { render, className: classNameProp, asChild = false } = componentProps;\n\n\tconst {\n\t\tstate = {} as State,\n\t\tref,\n\t\tprops = {} as Partial<JSX.IntrinsicElements[Tag]>,\n\t\tenabled = true,\n\t} = params || {};\n\n\tif (!enabled) {\n\t\treturn null;\n\t}\n\n\tconst computedClassName =\n\t\ttypeof classNameProp === \"function\" ? classNameProp(state) : classNameProp;\n\n\tconst propsWithClassName = props as {\n\t\tclassName?: string;\n\t\tchildren?: React.ReactNode;\n\t};\n\tconst mergedProps = {\n\t\t...props,\n\t\tclassName: [propsWithClassName.className, computedClassName]\n\t\t\t.filter(Boolean)\n\t\t\t.join(\" \"),\n\t\tref,\n\t};\n\n\tif (typeof render === \"function\") {\n\t\treturn render(mergedProps as JSX.IntrinsicElements[Tag], state);\n\t}\n\n\tif (React.isValidElement(render)) {\n\t\treturn React.cloneElement(render, {\n\t\t\t...mergedProps,\n\t\t\tref: getElementRef(render) || ref,\n\t\t});\n\t}\n\n\tif (asChild && React.isValidElement(propsWithClassName.children)) {\n\t\t// Extract ref to pass explicitly to the forwardRef Slot component\n\t\t// React extracts ref from spread props, so we must pass it separately\n\t\tconst { ref: slotRef, ...restMergedProps } = mergedProps;\n\t\treturn (\n\t\t\t<Slot ref={slotRef} {...restMergedProps}>\n\t\t\t\t{propsWithClassName.children}\n\t\t\t</Slot>\n\t\t);\n\t}\n\n\treturn React.createElement(tag, mergedProps as any);\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAkBA,SAAS,cAAc,SAAwD;CAI9E,MAAM,SAAS,OAAO,yBAAyB,QAAQ,OAAO,MAAM,EAAE;AAGtE,KAFgB,UAAU,oBAAoB,UAAU,OAAO,eAI9D,QAAQ,QAAgB;AAIzB,QAAQ,QAAQ,MAAc,OAAQ,QAAgB;;;;;;AAkCvD,MAAM,OAAOA,QAAM,YACjB,EAAE,SAAU,GAAG,SAAS,iBAAiB;CAKzC,MAAM,YAAY,UAAU,CAAC,cAHZ,cAAc,SAAS,CAGY,CAAC;AAErD,QAAOA,QAAM,aAAa,UAAU;EACnC,GAAG;EACH,KAAK;EACL,WAAW,CAAE,SAAS,MAAc,WAAW,MAAM,UAAU,CAC7D,OAAO,QAAQ,CACf,KAAK,IAAI;EACX,CAAQ;EAEV;;;;AAKD,SAAgB,iBAIf,KACA,gBACA,QAC4B;CAC5B,MAAM,EAAE,QAAQ,WAAW,eAAe,UAAU,UAAU;CAE9D,MAAM,EACL,QAAQ,EAAE,EACV,KACA,QAAQ,EAAE,EACV,UAAU,SACP,UAAU,EAAE;AAEhB,KAAI,CAAC,QACJ,QAAO;CAGR,MAAM,oBACL,OAAO,kBAAkB,aAAa,cAAc,MAAM,GAAG;CAE9D,MAAM,qBAAqB;CAI3B,MAAM,cAAc;EACnB,GAAG;EACH,WAAW,CAAC,mBAAmB,WAAW,kBAAkB,CAC1D,OAAO,QAAQ,CACf,KAAK,IAAI;EACX;EACA;AAED,KAAI,OAAO,WAAW,WACrB,QAAO,OAAO,aAA2C,MAAM;AAGhE,KAAIA,QAAM,eAAe,OAAO,CAC/B,QAAOA,QAAM,aAAa,QAAQ;EACjC,GAAG;EACH,KAAK,cAAc,OAAO,IAAI;EAC9B,CAAC;AAGH,KAAI,WAAWA,QAAM,eAAe,mBAAmB,SAAS,EAAE;EAGjE,MAAM,EAAE,KAAK,QAAS,GAAG,oBAAoB;AAC7C,SACC,oBAAC;GAAK,KAAK;GAAS,GAAI;aACtB,mBAAmB;IACd;;AAIT,QAAOA,QAAM,cAAc,KAAK,YAAmB"}
+{"version":3,"file":"use-render-element.js","names":["React"],"sources":["../../src/utils/use-render-element.tsx"],"sourcesContent":["/** biome-ignore-all lint/suspicious/noExplicitAny: works well here */\n/** biome-ignore-all lint/nursery/noUnnecessaryConditions: ok */\n\nimport type { JSX } from \"react\";\nimport * as React from \"react\";\nimport { mergeRefs } from \"./merge-refs\";\n\n/**\n * Gets the ref from a React element in a way that's compatible with both React 18 and React 19.\n *\n * - Before React 19: accessing `element.props.ref` throws a warning, use `element.ref`\n * - After React 19: accessing `element.ref` throws a warning, use `element.props.ref`\n *\n * This function detects which version of React is being used by checking for the\n * `isReactWarning` property descriptor that React adds in DEV mode.\n *\n * @see https://github.com/radix-ui/primitives/pull/2811\n */\nfunction getElementRef(element: React.ReactElement): React.Ref<unknown> | null {\n\t// React 18 in DEV mode will throw a warning when accessing `element.props.ref`\n\t// and suggest using `element.ref` instead.\n\t// We detect this by checking for the `isReactWarning` getter on `props.ref`.\n\tconst getter = Object.getOwnPropertyDescriptor(element.props, \"ref\")?.get;\n\tconst mayWarn = getter && \"isReactWarning\" in getter && getter.isReactWarning;\n\n\tif (mayWarn) {\n\t\t// React 18: use element.ref\n\t\treturn (element as any).ref;\n\t}\n\n\t// React 19 or production: prefer props.ref, fallback to element.ref for older versions\n\treturn (element.props as any).ref ?? (element as any).ref;\n}\n\ntype IntrinsicTag = keyof JSX.IntrinsicElements;\n\ntype ClassName<State> = string | ((state: State) => string);\n\ntype RenderFn<Props, State> = (\n\tprops: Props,\n\tstate: State\n) => React.ReactElement;\n\ntype RenderProps<State, Tag extends IntrinsicTag> = {\n\trender?: React.ReactElement | RenderFn<JSX.IntrinsicElements[Tag], State>;\n\tclassName?: ClassName<State>;\n\tasChild?: boolean;\n};\n\ntype RenderParams<State, Tag extends IntrinsicTag> = {\n\tstate?: State;\n\tref?: React.Ref<any>;\n\tprops?: Partial<JSX.IntrinsicElements[Tag]>;\n\tenabled?: boolean;\n};\n\ntype SlotProps = {\n\tchildren: React.ReactElement;\n\t[key: string]: any;\n};\n\n/**\n * Slot component that properly forwards refs when using asChild pattern.\n * Uses forwardRef to receive the ref and merges it with any existing ref on the child.\n */\nconst Slot = React.forwardRef<HTMLElement, SlotProps>(\n\t({ children, ...props }, forwardedRef) => {\n\t\t// Get the child's existing ref using React 18/19 compatible helper\n\t\tconst childRef = getElementRef(children);\n\n\t\t// Merge the forwarded ref with the child's ref\n\t\tconst mergedRef = mergeRefs([forwardedRef, childRef]);\n\n\t\treturn React.cloneElement(children, {\n\t\t\t...props,\n\t\t\tref: mergedRef,\n\t\t\tclassName: [(children.props as any).className, props.className]\n\t\t\t\t.filter(Boolean)\n\t\t\t\t.join(\" \"),\n\t\t} as any);\n\t}\n);\n\n/**\n * Utility hook to support slot-style component overrides.\n */\nexport function useRenderElement<\n\tState extends Record<string, any>,\n\tTag extends IntrinsicTag,\n>(\n\ttag: Tag,\n\tcomponentProps: RenderProps<State, Tag>,\n\tparams?: RenderParams<State, Tag>\n): React.ReactElement | null {\n\tconst { render, className: classNameProp, asChild = false } = componentProps;\n\n\tconst {\n\t\tstate = {} as State,\n\t\tref,\n\t\tprops = {} as Partial<JSX.IntrinsicElements[Tag]>,\n\t\tenabled = true,\n\t} = params || {};\n\n\tif (!enabled) {\n\t\treturn null;\n\t}\n\n\tconst computedClassName =\n\t\ttypeof classNameProp === \"function\" ? classNameProp(state) : classNameProp;\n\n\tconst propsWithClassName = props as {\n\t\tclassName?: string;\n\t\tchildren?: React.ReactNode;\n\t};\n\tconst mergedProps = {\n\t\t...props,\n\t\tclassName: [propsWithClassName.className, computedClassName]\n\t\t\t.filter(Boolean)\n\t\t\t.join(\" \"),\n\t\tref,\n\t};\n\n\tif (typeof render === \"function\") {\n\t\treturn render(mergedProps as JSX.IntrinsicElements[Tag], state);\n\t}\n\n\tif (React.isValidElement(render)) {\n\t\treturn React.cloneElement(render, {\n\t\t\t...mergedProps,\n\t\t\tref: getElementRef(render) || ref,\n\t\t});\n\t}\n\n\tif (asChild && React.isValidElement(propsWithClassName.children)) {\n\t\t// Extract ref to pass explicitly to the forwardRef Slot component\n\t\t// React extracts ref from spread props, so we must pass it separately\n\t\tconst { ref: slotRef, ...restMergedProps } = mergedProps;\n\t\treturn (\n\t\t\t<Slot ref={slotRef} {...restMergedProps}>\n\t\t\t\t{propsWithClassName.children}\n\t\t\t</Slot>\n\t\t);\n\t}\n\n\treturn React.createElement(tag, mergedProps as any);\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAkBA,SAAS,cAAc,SAAwD;CAI9E,MAAM,SAAS,OAAO,yBAAyB,QAAQ,OAAO,MAAM,EAAE;AAGtE,KAFgB,UAAU,oBAAoB,UAAU,OAAO,eAI9D,QAAQ,QAAgB;AAIzB,QAAQ,QAAQ,MAAc,OAAQ,QAAgB;;;;;;AAkCvD,MAAM,OAAOA,QAAM,YACjB,EAAE,UAAU,GAAG,SAAS,iBAAiB;CAKzC,MAAM,YAAY,UAAU,CAAC,cAHZ,cAAc,SAAS,CAGY,CAAC;AAErD,QAAOA,QAAM,aAAa,UAAU;EACnC,GAAG;EACH,KAAK;EACL,WAAW,CAAE,SAAS,MAAc,WAAW,MAAM,UAAU,CAC7D,OAAO,QAAQ,CACf,KAAK,IAAI;EACX,CAAQ;EAEV;;;;AAKD,SAAgB,iBAIf,KACA,gBACA,QAC4B;CAC5B,MAAM,EAAE,QAAQ,WAAW,eAAe,UAAU,UAAU;CAE9D,MAAM,EACL,QAAQ,EAAE,EACV,KACA,QAAQ,EAAE,EACV,UAAU,SACP,UAAU,EAAE;AAEhB,KAAI,CAAC,QACJ,QAAO;CAGR,MAAM,oBACL,OAAO,kBAAkB,aAAa,cAAc,MAAM,GAAG;CAE9D,MAAM,qBAAqB;CAI3B,MAAM,cAAc;EACnB,GAAG;EACH,WAAW,CAAC,mBAAmB,WAAW,kBAAkB,CAC1D,OAAO,QAAQ,CACf,KAAK,IAAI;EACX;EACA;AAED,KAAI,OAAO,WAAW,WACrB,QAAO,OAAO,aAA2C,MAAM;AAGhE,KAAIA,QAAM,eAAe,OAAO,CAC/B,QAAOA,QAAM,aAAa,QAAQ;EACjC,GAAG;EACH,KAAK,cAAc,OAAO,IAAI;EAC9B,CAAC;AAGH,KAAI,WAAWA,QAAM,eAAe,mBAAmB,SAAS,EAAE;EAGjE,MAAM,EAAE,KAAK,SAAS,GAAG,oBAAoB;AAC7C,SACC,oBAAC;GAAK,KAAK;GAAS,GAAI;aACtB,mBAAmB;IACd;;AAIT,QAAOA,QAAM,cAAc,KAAK,YAAmB"}

package/api.d.ts

@@ -1,71 +0,0 @@
-import { EmptyToNever, Flatten, MakePartial } from "./util.js";
-import { $ZodBase64, $ZodBase64URL, $ZodCIDRv4, $ZodCIDRv6, $ZodCUID, $ZodCUID2, $ZodCustom, $ZodE164, $ZodEmail, $ZodEmoji, $ZodEnum, $ZodGUID, $ZodIPv4, $ZodIPv6, $ZodISODate, $ZodISODateTime, $ZodISODuration, $ZodISOTime, $ZodJWT, $ZodKSUID, $ZodNanoID, $ZodNonOptional, $ZodStringFormat, $ZodType, $ZodULID, $ZodURL, $ZodUUID, $ZodXID, ParsePayload } from "./schemas.js";
-import { $ZodCheck, $ZodCheckEndsWith, $ZodCheckGreaterThan, $ZodCheckIncludes, $ZodCheckLengthEquals, $ZodCheckLessThan, $ZodCheckLowerCase, $ZodCheckMaxLength, $ZodCheckMinLength, $ZodCheckMultipleOf, $ZodCheckNumberFormat, $ZodCheckRegex, $ZodCheckStartsWith, $ZodCheckUpperCase } from "./checks.js";
-import { $ZodErrorMap, $ZodIssue, $ZodIssueBase } from "./errors.js";
-
-//#region ../../node_modules/.bun/zod@4.2.1/node_modules/zod/v4/core/api.d.cts
-type Params<T extends $ZodType | $ZodCheck, IssueTypes extends $ZodIssueBase, OmitKeys extends keyof T["_zod"]["def"] = never> = Flatten<Partial<EmptyToNever<Omit<T["_zod"]["def"], OmitKeys> & ([IssueTypes] extends [never] ? {} : {
-  error?: string | $ZodErrorMap<IssueTypes> | undefined;
-  /** @deprecated This parameter is deprecated. Use `error` instead. */
-  message?: string | undefined;
-})>>>;
-type TypeParams<T extends $ZodType = $ZodType & {
-  _isst: never;
-}, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error"> = never> = Params<T, NonNullable<T["_zod"]["isst"]>, "type" | "checks" | "error" | AlsoOmit>;
-type CheckParams<T extends $ZodCheck = $ZodCheck,
-// & { _issc: never },
-AlsoOmit extends Exclude<keyof T["_zod"]["def"], "check" | "error"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "check" | "error" | AlsoOmit>;
-type CheckStringFormatParams<T extends $ZodStringFormat = $ZodStringFormat, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "coerce" | "checks" | "error" | "check" | "format"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "type" | "coerce" | "checks" | "error" | "check" | "format" | AlsoOmit>;
-type CheckTypeParams<T extends $ZodType & $ZodCheck = $ZodType & $ZodCheck, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error" | "check"> = never> = Params<T, NonNullable<T["_zod"]["isst"] | T["_zod"]["issc"]>, "type" | "checks" | "error" | "check" | AlsoOmit>;
-type $ZodCheckEmailParams = CheckStringFormatParams<$ZodEmail, "when">;
-type $ZodCheckGUIDParams = CheckStringFormatParams<$ZodGUID, "pattern" | "when">;
-type $ZodCheckUUIDParams = CheckStringFormatParams<$ZodUUID, "pattern" | "when">;
-type $ZodCheckURLParams = CheckStringFormatParams<$ZodURL, "when">;
-type $ZodCheckEmojiParams = CheckStringFormatParams<$ZodEmoji, "when">;
-type $ZodCheckNanoIDParams = CheckStringFormatParams<$ZodNanoID, "when">;
-type $ZodCheckCUIDParams = CheckStringFormatParams<$ZodCUID, "when">;
-type $ZodCheckCUID2Params = CheckStringFormatParams<$ZodCUID2, "when">;
-type $ZodCheckULIDParams = CheckStringFormatParams<$ZodULID, "when">;
-type $ZodCheckXIDParams = CheckStringFormatParams<$ZodXID, "when">;
-type $ZodCheckKSUIDParams = CheckStringFormatParams<$ZodKSUID, "when">;
-type $ZodCheckIPv4Params = CheckStringFormatParams<$ZodIPv4, "pattern" | "when" | "version">;
-type $ZodCheckIPv6Params = CheckStringFormatParams<$ZodIPv6, "pattern" | "when" | "version">;
-type $ZodCheckCIDRv4Params = CheckStringFormatParams<$ZodCIDRv4, "pattern" | "when">;
-type $ZodCheckCIDRv6Params = CheckStringFormatParams<$ZodCIDRv6, "pattern" | "when">;
-type $ZodCheckBase64Params = CheckStringFormatParams<$ZodBase64, "pattern" | "when">;
-type $ZodCheckBase64URLParams = CheckStringFormatParams<$ZodBase64URL, "pattern" | "when">;
-type $ZodCheckE164Params = CheckStringFormatParams<$ZodE164, "when">;
-type $ZodCheckJWTParams = CheckStringFormatParams<$ZodJWT, "pattern" | "when">;
-type $ZodCheckISODateTimeParams = CheckStringFormatParams<$ZodISODateTime, "pattern" | "when">;
-type $ZodCheckISODateParams = CheckStringFormatParams<$ZodISODate, "pattern" | "when">;
-type $ZodCheckISOTimeParams = CheckStringFormatParams<$ZodISOTime, "pattern" | "when">;
-type $ZodCheckISODurationParams = CheckStringFormatParams<$ZodISODuration, "when">;
-type $ZodCheckNumberFormatParams = CheckParams<$ZodCheckNumberFormat, "format" | "when">;
-type $ZodCheckLessThanParams = CheckParams<$ZodCheckLessThan, "inclusive" | "value" | "when">;
-type $ZodCheckGreaterThanParams = CheckParams<$ZodCheckGreaterThan, "inclusive" | "value" | "when">;
-type $ZodCheckMultipleOfParams = CheckParams<$ZodCheckMultipleOf, "value" | "when">;
-type $ZodCheckMaxLengthParams = CheckParams<$ZodCheckMaxLength, "maximum" | "when">;
-type $ZodCheckMinLengthParams = CheckParams<$ZodCheckMinLength, "minimum" | "when">;
-type $ZodCheckLengthEqualsParams = CheckParams<$ZodCheckLengthEquals, "length" | "when">;
-type $ZodCheckRegexParams = CheckParams<$ZodCheckRegex, "format" | "pattern" | "when">;
-type $ZodCheckLowerCaseParams = CheckParams<$ZodCheckLowerCase, "format" | "when">;
-type $ZodCheckUpperCaseParams = CheckParams<$ZodCheckUpperCase, "format" | "when">;
-type $ZodCheckIncludesParams = CheckParams<$ZodCheckIncludes, "includes" | "format" | "when" | "pattern">;
-type $ZodCheckStartsWithParams = CheckParams<$ZodCheckStartsWith, "prefix" | "format" | "when" | "pattern">;
-type $ZodCheckEndsWithParams = CheckParams<$ZodCheckEndsWith, "suffix" | "format" | "pattern" | "when">;
-type $ZodEnumParams = TypeParams<$ZodEnum, "entries">;
-type $ZodNonOptionalParams = TypeParams<$ZodNonOptional, "innerType">;
-type $ZodCustomParams = CheckTypeParams<$ZodCustom, "fn">;
-type $ZodSuperRefineIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
-type RawIssue<T extends $ZodIssueBase> = T extends any ? Flatten<MakePartial<T, "message" | "path"> & {
-  /** The schema or check that originated this issue. */
-  readonly inst?: $ZodType | $ZodCheck;
-  /** If `true`, Zod will execute subsequent checks/refinements instead of immediately aborting */
-  readonly continue?: boolean | undefined;
-} & Record<string, unknown>> : never;
-interface $RefinementCtx<T = unknown> extends ParsePayload<T> {
-  addIssue(arg: string | $ZodSuperRefineIssue): void;
-}
-//#endregion
-export { $RefinementCtx, $ZodCheckBase64Params, $ZodCheckBase64URLParams, $ZodCheckCIDRv4Params, $ZodCheckCIDRv6Params, $ZodCheckCUID2Params, $ZodCheckCUIDParams, $ZodCheckE164Params, $ZodCheckEmailParams, $ZodCheckEmojiParams, $ZodCheckEndsWithParams, $ZodCheckGUIDParams, $ZodCheckGreaterThanParams, $ZodCheckIPv4Params, $ZodCheckIPv6Params, $ZodCheckISODateParams, $ZodCheckISODateTimeParams, $ZodCheckISODurationParams, $ZodCheckISOTimeParams, $ZodCheckIncludesParams, $ZodCheckJWTParams, $ZodCheckKSUIDParams, $ZodCheckLengthEqualsParams, $ZodCheckLessThanParams, $ZodCheckLowerCaseParams, $ZodCheckMaxLengthParams, $ZodCheckMinLengthParams, $ZodCheckMultipleOfParams, $ZodCheckNanoIDParams, $ZodCheckNumberFormatParams, $ZodCheckRegexParams, $ZodCheckStartsWithParams, $ZodCheckULIDParams, $ZodCheckURLParams, $ZodCheckUUIDParams, $ZodCheckUpperCaseParams, $ZodCheckXIDParams, $ZodCustomParams, $ZodEnumParams, $ZodNonOptionalParams };
-//# sourceMappingURL=api.d.ts.map

package/api.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"api.d.ts","names":["checks","core","errors","registries","schemas","util","Params","T","IssueTypes","OmitKeys","$ZodType","$ZodCheck","$ZodIssueBase","Omit","$ZodErrorMap","EmptyToNever","Partial","Flatten","TypeParams","AlsoOmit","Exclude","NonNullable","CheckParams","StringFormatParams","$ZodStringFormat","CheckStringFormatParams","CheckTypeParams","$ZodStringParams","$ZodString","_string","SchemaClass","_coercedString","$ZodStringFormatParams","$ZodCheckStringFormatParams","$ZodCheckStringFormat","$ZodEmailParams","$ZodEmail","$ZodCheckEmailParams","_email","$ZodGUIDParams","$ZodGUID","$ZodCheckGUIDParams","_guid","$ZodUUIDParams","$ZodUUID","$ZodCheckUUIDParams","_uuid","$ZodUUIDv4Params","$ZodCheckUUIDv4Params","_uuidv4","$ZodUUIDv6Params","$ZodCheckUUIDv6Params","_uuidv6","$ZodUUIDv7Params","$ZodCheckUUIDv7Params","_uuidv7","$ZodURLParams","$ZodURL","$ZodCheckURLParams","_url","$ZodEmojiParams","$ZodEmoji","$ZodCheckEmojiParams","_emoji","$ZodNanoIDParams","$ZodNanoID","$ZodCheckNanoIDParams","_nanoid","$ZodCUIDParams","$ZodCUID","$ZodCheckCUIDParams","_cuid","$ZodCUID2Params","$ZodCUID2","$ZodCheckCUID2Params","_cuid2","$ZodULIDParams","$ZodULID","$ZodCheckULIDParams","_ulid","$ZodXIDParams","$ZodXID","$ZodCheckXIDParams","_xid","$ZodKSUIDParams","$ZodKSUID","$ZodCheckKSUIDParams","_ksuid","$ZodIPv4Params","$ZodIPv4","$ZodCheckIPv4Params","_ipv4","$ZodIPv6Params","$ZodIPv6","$ZodCheckIPv6Params","_ipv6","$ZodMACParams","$ZodMAC","$ZodCheckMACParams","_mac","$ZodCIDRv4Params","$ZodCIDRv4","$ZodCheckCIDRv4Params","_cidrv4","$ZodCIDRv6Params","$ZodCIDRv6","$ZodCheckCIDRv6Params","_cidrv6","$ZodBase64Params","$ZodBase64","$ZodCheckBase64Params","_base64","$ZodBase64URLParams","$ZodBase64URL","$ZodCheckBase64URLParams","_base64url","$ZodE164Params","$ZodE164","$ZodCheckE164Params","_e164","$ZodJWTParams","$ZodJWT","$ZodCheckJWTParams","_jwt","TimePrecision","$ZodISODateTimeParams","$ZodISODateTime","$ZodCheckISODateTimeParams","_isoDateTime","$ZodISODateParams","$ZodISODate","$ZodCheckISODateParams","_isoDate","$ZodISOTimeParams","$ZodISOTime","$ZodCheckISOTimeParams","_isoTime","$ZodISODurationParams","$ZodISODuration","$ZodCheckISODurationParams","_isoDuration","$ZodNumberParams","$ZodNumber","$ZodNumberFormatParams","$ZodNumberFormat","$ZodCheckNumberFormatParams","$ZodCheckNumberFormat","_number","_coercedNumber","_int","_float32","_float64","_int32","_uint32","$ZodBooleanParams","$ZodBoolean","_boolean","_coercedBoolean","$ZodBigIntParams","$ZodBigInt","$ZodBigIntFormatParams","$ZodBigIntFormat","$ZodCheckBigIntFormatParams","$ZodCheckBigIntFormat","_bigint","_coercedBigint","_int64","_uint64","$ZodSymbolParams","$ZodSymbol","_symbol","$ZodUndefinedParams","$ZodUndefined","_undefined","$ZodNullParams","$ZodNull","_null","$ZodAnyParams","$ZodAny","_any","$ZodUnknownParams","$ZodUnknown","_unknown","$ZodNeverParams","$ZodNever","_never","$ZodVoidParams","$ZodVoid","_void","$ZodDateParams","$ZodDate","_date","_coercedDate","$ZodNaNParams","$ZodNaN","_nan","$ZodCheckLessThanParams","$ZodCheckLessThan","_lt","Numeric","_lte","_max","$ZodCheckGreaterThanParams","$ZodCheckGreaterThan","_gt","_gte","_min","_positive","_negative","_nonpositive","_nonnegative","$ZodCheckMultipleOfParams","$ZodCheckMultipleOf","_multipleOf","$ZodCheckMaxSizeParams","$ZodCheckMaxSize","_maxSize","HasSize","$ZodCheckMinSizeParams","$ZodCheckMinSize","_minSize","$ZodCheckSizeEqualsParams","$ZodCheckSizeEquals","_size","$ZodCheckMaxLengthParams","$ZodCheckMaxLength","_maxLength","HasLength","$ZodCheckMinLengthParams","$ZodCheckMinLength","_minLength","$ZodCheckLengthEqualsParams","$ZodCheckLengthEquals","_length","$ZodCheckRegexParams","$ZodCheckRegex","_regex","RegExp","$ZodCheckLowerCaseParams","$ZodCheckLowerCase","_lowercase","$ZodCheckUpperCaseParams","$ZodCheckUpperCase","_uppercase","$ZodCheckIncludesParams","$ZodCheckIncludes","_includes","$ZodCheckStartsWithParams","$ZodCheckStartsWith","_startsWith","$ZodCheckEndsWithParams","$ZodCheckEndsWith","_endsWith","$ZodCheckPropertyParams","$ZodCheckProperty","_property","K","output","$ZodCheckMimeTypeParams","$ZodCheckMimeType","_mime","MimeTypes","_overwrite","$ZodCheckOverwrite","_normalize","_trim","_toLowerCase","_toUpperCase","_slugify","$ZodArrayParams","$ZodArray","_array","$ZodObjectParams","$ZodObject","$ZodUnionParams","$ZodUnion","_union","$ZodXorParams","$ZodXor","_xor","$ZodTypeDiscriminableInternals","PropValues","$ZodTypeInternals","$ZodTypeDiscriminable","$ZodDiscriminatedUnionParams","$ZodDiscriminatedUnion","_discriminatedUnion","Types","Disc","$ZodIntersectionParams","$ZodIntersection","_intersection","U","$ZodTupleParams","$ZodTuple","_tuple","Rest","$ZodRecordParams","$ZodRecord","_record","Key","Value","$ZodRecordKey","$ZodMapParams","$ZodMap","_map","$ZodSetParams","$ZodSet","_set","$ZodEnumParams","$ZodEnum","_enum","ToEnum","EnumLike","_nativeEnum","$ZodLiteralParams","$ZodLiteral","_literal","Literal","Array","$ZodFileParams","$ZodFile","_file","$ZodTransformParams","$ZodTransform","_transform","I","O","ParsePayload","Awaited","$ZodOptionalParams","$ZodOptional","_optional","$ZodNullableParams","$ZodNullable","_nullable","$ZodDefaultParams","$ZodDefault","_default","NoUndefined","$ZodNonOptionalParams","$ZodNonOptional","_nonoptional","$ZodSuccessParams","$ZodSuccess","_success","$ZodCatchParams","$ZodCatch","_catch","$ZodCatchCtx","$ZodPipeParams","$ZodPipe","_pipe","A","B","$ZodReadonlyParams","$ZodReadonly","_readonly","$ZodTemplateLiteralParams","$ZodTemplateLiteral","_templateLiteral","Parts","$ZodTemplateLiteralPart","$PartsToTemplateLiteral","$ZodLazyParams","$ZodLazy","_lazy","$ZodPromiseParams","$ZodPromise","_promise","$ZodCustomParams","$ZodCustom","_custom","_refine","$ZodSuperRefineIssue","$ZodIssue","RawIssue","MakePartial","Record","$RefinementCtx","_superRefine","Promise","_check","CheckFn","describe","meta","GlobalMeta","$ZodStringBoolParams","_stringbool","$ZodCodec","_stringFormat","Format","$ZodCustomStringFormat","MaybeAsync"],"sources":["../../../node_modules/.bun/zod@4.2.1/node_modules/zod/v4/core/api.d.cts"],"sourcesContent":["import * as checks from \"./checks.cjs\";\nimport type * as core from \"./core.cjs\";\nimport type * as errors from \"./errors.cjs\";\nimport * as registries from \"./registries.cjs\";\nimport * as schemas from \"./schemas.cjs\";\nimport * as util from \"./util.cjs\";\nexport type Params<T extends schemas.$ZodType | checks.$ZodCheck, IssueTypes extends errors.$ZodIssueBase, OmitKeys extends keyof T[\"_zod\"][\"def\"] = never> = util.Flatten<Partial<util.EmptyToNever<Omit<T[\"_zod\"][\"def\"], OmitKeys> & ([IssueTypes] extends [never] ? {} : {\n    error?: string | errors.$ZodErrorMap<IssueTypes> | undefined;\n    /** @deprecated This parameter is deprecated. Use `error` instead. */\n    message?: string | undefined;\n})>>>;\nexport type TypeParams<T extends schemas.$ZodType = schemas.$ZodType & {\n    _isst: never;\n}, AlsoOmit extends Exclude<keyof T[\"_zod\"][\"def\"], \"type\" | \"checks\" | \"error\"> = never> = Params<T, NonNullable<T[\"_zod\"][\"isst\"]>, \"type\" | \"checks\" | \"error\" | AlsoOmit>;\nexport type CheckParams<T extends checks.$ZodCheck = checks.$ZodCheck, // & { _issc: never },\nAlsoOmit extends Exclude<keyof T[\"_zod\"][\"def\"], \"check\" | \"error\"> = never> = Params<T, NonNullable<T[\"_zod\"][\"issc\"]>, \"check\" | \"error\" | AlsoOmit>;\nexport type StringFormatParams<T extends schemas.$ZodStringFormat = schemas.$ZodStringFormat, AlsoOmit extends Exclude<keyof T[\"_zod\"][\"def\"], \"type\" | \"coerce\" | \"checks\" | \"error\" | \"check\" | \"format\"> = never> = Params<T, NonNullable<T[\"_zod\"][\"isst\"] | T[\"_zod\"][\"issc\"]>, \"type\" | \"coerce\" | \"checks\" | \"error\" | \"check\" | \"format\" | AlsoOmit>;\nexport type CheckStringFormatParams<T extends schemas.$ZodStringFormat = schemas.$ZodStringFormat, AlsoOmit extends Exclude<keyof T[\"_zod\"][\"def\"], \"type\" | \"coerce\" | \"checks\" | \"error\" | \"check\" | \"format\"> = never> = Params<T, NonNullable<T[\"_zod\"][\"issc\"]>, \"type\" | \"coerce\" | \"checks\" | \"error\" | \"check\" | \"format\" | AlsoOmit>;\nexport type CheckTypeParams<T extends schemas.$ZodType & checks.$ZodCheck = schemas.$ZodType & checks.$ZodCheck, AlsoOmit extends Exclude<keyof T[\"_zod\"][\"def\"], \"type\" | \"checks\" | \"error\" | \"check\"> = never> = Params<T, NonNullable<T[\"_zod\"][\"isst\"] | T[\"_zod\"][\"issc\"]>, \"type\" | \"checks\" | \"error\" | \"check\" | AlsoOmit>;\nexport type $ZodStringParams = TypeParams<schemas.$ZodString<string>, \"coerce\">;\nexport declare function _string<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;\nexport declare function _coercedString<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;\nexport type $ZodStringFormatParams = CheckTypeParams<schemas.$ZodStringFormat, \"format\" | \"coerce\" | \"when\" | \"pattern\">;\nexport type $ZodCheckStringFormatParams = CheckParams<checks.$ZodCheckStringFormat, \"format\">;\nexport type $ZodEmailParams = StringFormatParams<schemas.$ZodEmail, \"when\">;\nexport type $ZodCheckEmailParams = CheckStringFormatParams<schemas.$ZodEmail, \"when\">;\nexport declare function _email<T extends schemas.$ZodEmail>(Class: util.SchemaClass<T>, params?: string | $ZodEmailParams | $ZodCheckEmailParams): T;\nexport type $ZodGUIDParams = StringFormatParams<schemas.$ZodGUID, \"pattern\" | \"when\">;\nexport type $ZodCheckGUIDParams = CheckStringFormatParams<schemas.$ZodGUID, \"pattern\" | \"when\">;\nexport declare function _guid<T extends schemas.$ZodGUID>(Class: util.SchemaClass<T>, params?: string | $ZodGUIDParams | $ZodCheckGUIDParams): T;\nexport type $ZodUUIDParams = StringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport type $ZodCheckUUIDParams = CheckStringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport declare function _uuid<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDParams | $ZodCheckUUIDParams): T;\nexport type $ZodUUIDv4Params = StringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport type $ZodCheckUUIDv4Params = CheckStringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport declare function _uuidv4<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv4Params | $ZodCheckUUIDv4Params): T;\nexport type $ZodUUIDv6Params = StringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport type $ZodCheckUUIDv6Params = CheckStringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport declare function _uuidv6<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv6Params | $ZodCheckUUIDv6Params): T;\nexport type $ZodUUIDv7Params = StringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport type $ZodCheckUUIDv7Params = CheckStringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport declare function _uuidv7<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv7Params | $ZodCheckUUIDv7Params): T;\nexport type $ZodURLParams = StringFormatParams<schemas.$ZodURL, \"when\">;\nexport type $ZodCheckURLParams = CheckStringFormatParams<schemas.$ZodURL, \"when\">;\nexport declare function _url<T extends schemas.$ZodURL>(Class: util.SchemaClass<T>, params?: string | $ZodURLParams | $ZodCheckURLParams): T;\nexport type $ZodEmojiParams = StringFormatParams<schemas.$ZodEmoji, \"when\">;\nexport type $ZodCheckEmojiParams = CheckStringFormatParams<schemas.$ZodEmoji, \"when\">;\nexport declare function _emoji<T extends schemas.$ZodEmoji>(Class: util.SchemaClass<T>, params?: string | $ZodEmojiParams | $ZodCheckEmojiParams): T;\nexport type $ZodNanoIDParams = StringFormatParams<schemas.$ZodNanoID, \"when\">;\nexport type $ZodCheckNanoIDParams = CheckStringFormatParams<schemas.$ZodNanoID, \"when\">;\nexport declare function _nanoid<T extends schemas.$ZodNanoID>(Class: util.SchemaClass<T>, params?: string | $ZodNanoIDParams | $ZodCheckNanoIDParams): T;\nexport type $ZodCUIDParams = StringFormatParams<schemas.$ZodCUID, \"when\">;\nexport type $ZodCheckCUIDParams = CheckStringFormatParams<schemas.$ZodCUID, \"when\">;\nexport declare function _cuid<T extends schemas.$ZodCUID>(Class: util.SchemaClass<T>, params?: string | $ZodCUIDParams | $ZodCheckCUIDParams): T;\nexport type $ZodCUID2Params = StringFormatParams<schemas.$ZodCUID2, \"when\">;\nexport type $ZodCheckCUID2Params = CheckStringFormatParams<schemas.$ZodCUID2, \"when\">;\nexport declare function _cuid2<T extends schemas.$ZodCUID2>(Class: util.SchemaClass<T>, params?: string | $ZodCUID2Params | $ZodCheckCUID2Params): T;\nexport type $ZodULIDParams = StringFormatParams<schemas.$ZodULID, \"when\">;\nexport type $ZodCheckULIDParams = CheckStringFormatParams<schemas.$ZodULID, \"when\">;\nexport declare function _ulid<T extends schemas.$ZodULID>(Class: util.SchemaClass<T>, params?: string | $ZodULIDParams | $ZodCheckULIDParams): T;\nexport type $ZodXIDParams = StringFormatParams<schemas.$ZodXID, \"when\">;\nexport type $ZodCheckXIDParams = CheckStringFormatParams<schemas.$ZodXID, \"when\">;\nexport declare function _xid<T extends schemas.$ZodXID>(Class: util.SchemaClass<T>, params?: string | $ZodXIDParams | $ZodCheckXIDParams): T;\nexport type $ZodKSUIDParams = StringFormatParams<schemas.$ZodKSUID, \"when\">;\nexport type $ZodCheckKSUIDParams = CheckStringFormatParams<schemas.$ZodKSUID, \"when\">;\nexport declare function _ksuid<T extends schemas.$ZodKSUID>(Class: util.SchemaClass<T>, params?: string | $ZodKSUIDParams | $ZodCheckKSUIDParams): T;\nexport type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, \"pattern\" | \"when\" | \"version\">;\nexport type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, \"pattern\" | \"when\" | \"version\">;\nexport declare function _ipv4<T extends schemas.$ZodIPv4>(Class: util.SchemaClass<T>, params?: string | $ZodIPv4Params | $ZodCheckIPv4Params): T;\nexport type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, \"pattern\" | \"when\" | \"version\">;\nexport type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, \"pattern\" | \"when\" | \"version\">;\nexport declare function _ipv6<T extends schemas.$ZodIPv6>(Class: util.SchemaClass<T>, params?: string | $ZodIPv6Params | $ZodCheckIPv6Params): T;\nexport type $ZodMACParams = StringFormatParams<schemas.$ZodMAC, \"pattern\" | \"when\">;\nexport type $ZodCheckMACParams = CheckStringFormatParams<schemas.$ZodMAC, \"pattern\" | \"when\">;\nexport declare function _mac<T extends schemas.$ZodMAC>(Class: util.SchemaClass<T>, params?: string | $ZodMACParams | $ZodCheckMACParams): T;\nexport type $ZodCIDRv4Params = StringFormatParams<schemas.$ZodCIDRv4, \"pattern\" | \"when\">;\nexport type $ZodCheckCIDRv4Params = CheckStringFormatParams<schemas.$ZodCIDRv4, \"pattern\" | \"when\">;\nexport declare function _cidrv4<T extends schemas.$ZodCIDRv4>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv4Params | $ZodCheckCIDRv4Params): T;\nexport type $ZodCIDRv6Params = StringFormatParams<schemas.$ZodCIDRv6, \"pattern\" | \"when\">;\nexport type $ZodCheckCIDRv6Params = CheckStringFormatParams<schemas.$ZodCIDRv6, \"pattern\" | \"when\">;\nexport declare function _cidrv6<T extends schemas.$ZodCIDRv6>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv6Params | $ZodCheckCIDRv6Params): T;\nexport type $ZodBase64Params = StringFormatParams<schemas.$ZodBase64, \"pattern\" | \"when\">;\nexport type $ZodCheckBase64Params = CheckStringFormatParams<schemas.$ZodBase64, \"pattern\" | \"when\">;\nexport declare function _base64<T extends schemas.$ZodBase64>(Class: util.SchemaClass<T>, params?: string | $ZodBase64Params | $ZodCheckBase64Params): T;\nexport type $ZodBase64URLParams = StringFormatParams<schemas.$ZodBase64URL, \"pattern\" | \"when\">;\nexport type $ZodCheckBase64URLParams = CheckStringFormatParams<schemas.$ZodBase64URL, \"pattern\" | \"when\">;\nexport declare function _base64url<T extends schemas.$ZodBase64URL>(Class: util.SchemaClass<T>, params?: string | $ZodBase64URLParams | $ZodCheckBase64URLParams): T;\nexport type $ZodE164Params = StringFormatParams<schemas.$ZodE164, \"when\">;\nexport type $ZodCheckE164Params = CheckStringFormatParams<schemas.$ZodE164, \"when\">;\nexport declare function _e164<T extends schemas.$ZodE164>(Class: util.SchemaClass<T>, params?: string | $ZodE164Params | $ZodCheckE164Params): T;\nexport type $ZodJWTParams = StringFormatParams<schemas.$ZodJWT, \"pattern\" | \"when\">;\nexport type $ZodCheckJWTParams = CheckStringFormatParams<schemas.$ZodJWT, \"pattern\" | \"when\">;\nexport declare function _jwt<T extends schemas.$ZodJWT>(Class: util.SchemaClass<T>, params?: string | $ZodJWTParams | $ZodCheckJWTParams): T;\nexport declare const TimePrecision: {\n    readonly Any: null;\n    readonly Minute: -1;\n    readonly Second: 0;\n    readonly Millisecond: 3;\n    readonly Microsecond: 6;\n};\nexport type $ZodISODateTimeParams = StringFormatParams<schemas.$ZodISODateTime, \"pattern\" | \"when\">;\nexport type $ZodCheckISODateTimeParams = CheckStringFormatParams<schemas.$ZodISODateTime, \"pattern\" | \"when\">;\nexport declare function _isoDateTime<T extends schemas.$ZodISODateTime>(Class: util.SchemaClass<T>, params?: string | $ZodISODateTimeParams | $ZodCheckISODateTimeParams): T;\nexport type $ZodISODateParams = StringFormatParams<schemas.$ZodISODate, \"pattern\" | \"when\">;\nexport type $ZodCheckISODateParams = CheckStringFormatParams<schemas.$ZodISODate, \"pattern\" | \"when\">;\nexport declare function _isoDate<T extends schemas.$ZodISODate>(Class: util.SchemaClass<T>, params?: string | $ZodISODateParams | $ZodCheckISODateParams): T;\nexport type $ZodISOTimeParams = StringFormatParams<schemas.$ZodISOTime, \"pattern\" | \"when\">;\nexport type $ZodCheckISOTimeParams = CheckStringFormatParams<schemas.$ZodISOTime, \"pattern\" | \"when\">;\nexport declare function _isoTime<T extends schemas.$ZodISOTime>(Class: util.SchemaClass<T>, params?: string | $ZodISOTimeParams | $ZodCheckISOTimeParams): T;\nexport type $ZodISODurationParams = StringFormatParams<schemas.$ZodISODuration, \"when\">;\nexport type $ZodCheckISODurationParams = CheckStringFormatParams<schemas.$ZodISODuration, \"when\">;\nexport declare function _isoDuration<T extends schemas.$ZodISODuration>(Class: util.SchemaClass<T>, params?: string | $ZodISODurationParams | $ZodCheckISODurationParams): T;\nexport type $ZodNumberParams = TypeParams<schemas.$ZodNumber<number>, \"coerce\">;\nexport type $ZodNumberFormatParams = CheckTypeParams<schemas.$ZodNumberFormat, \"format\" | \"coerce\">;\nexport type $ZodCheckNumberFormatParams = CheckParams<checks.$ZodCheckNumberFormat, \"format\" | \"when\">;\nexport declare function _number<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;\nexport declare function _coercedNumber<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;\nexport declare function _int<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;\nexport declare function _float32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;\nexport declare function _float64<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;\nexport declare function _int32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;\nexport declare function _uint32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;\nexport type $ZodBooleanParams = TypeParams<schemas.$ZodBoolean<boolean>, \"coerce\">;\nexport declare function _boolean<T extends schemas.$ZodBoolean>(Class: util.SchemaClass<T>, params?: string | $ZodBooleanParams): T;\nexport declare function _coercedBoolean<T extends schemas.$ZodBoolean>(Class: util.SchemaClass<T>, params?: string | $ZodBooleanParams): T;\nexport type $ZodBigIntParams = TypeParams<schemas.$ZodBigInt<bigint>>;\nexport type $ZodBigIntFormatParams = CheckTypeParams<schemas.$ZodBigIntFormat, \"format\" | \"coerce\">;\nexport type $ZodCheckBigIntFormatParams = CheckParams<checks.$ZodCheckBigIntFormat, \"format\" | \"when\">;\nexport declare function _bigint<T extends schemas.$ZodBigInt>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntParams): T;\nexport declare function _coercedBigint<T extends schemas.$ZodBigInt>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntParams): T;\nexport declare function _int64<T extends schemas.$ZodBigIntFormat>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntFormatParams): T;\nexport declare function _uint64<T extends schemas.$ZodBigIntFormat>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntFormatParams): T;\nexport type $ZodSymbolParams = TypeParams<schemas.$ZodSymbol>;\nexport declare function _symbol<T extends schemas.$ZodSymbol>(Class: util.SchemaClass<T>, params?: string | $ZodSymbolParams): T;\nexport type $ZodUndefinedParams = TypeParams<schemas.$ZodUndefined>;\nexport declare function _undefined<T extends schemas.$ZodUndefined>(Class: util.SchemaClass<T>, params?: string | $ZodUndefinedParams): T;\nexport type $ZodNullParams = TypeParams<schemas.$ZodNull>;\nexport declare function _null<T extends schemas.$ZodNull>(Class: util.SchemaClass<T>, params?: string | $ZodNullParams): T;\nexport type $ZodAnyParams = TypeParams<schemas.$ZodAny>;\nexport declare function _any<T extends schemas.$ZodAny>(Class: util.SchemaClass<T>): T;\nexport type $ZodUnknownParams = TypeParams<schemas.$ZodUnknown>;\nexport declare function _unknown<T extends schemas.$ZodUnknown>(Class: util.SchemaClass<T>): T;\nexport type $ZodNeverParams = TypeParams<schemas.$ZodNever>;\nexport declare function _never<T extends schemas.$ZodNever>(Class: util.SchemaClass<T>, params?: string | $ZodNeverParams): T;\nexport type $ZodVoidParams = TypeParams<schemas.$ZodVoid>;\nexport declare function _void<T extends schemas.$ZodVoid>(Class: util.SchemaClass<T>, params?: string | $ZodVoidParams): T;\nexport type $ZodDateParams = TypeParams<schemas.$ZodDate, \"coerce\">;\nexport declare function _date<T extends schemas.$ZodDate>(Class: util.SchemaClass<T>, params?: string | $ZodDateParams): T;\nexport declare function _coercedDate<T extends schemas.$ZodDate>(Class: util.SchemaClass<T>, params?: string | $ZodDateParams): T;\nexport type $ZodNaNParams = TypeParams<schemas.$ZodNaN>;\nexport declare function _nan<T extends schemas.$ZodNaN>(Class: util.SchemaClass<T>, params?: string | $ZodNaNParams): T;\nexport type $ZodCheckLessThanParams = CheckParams<checks.$ZodCheckLessThan, \"inclusive\" | \"value\" | \"when\">;\nexport declare function _lt(value: util.Numeric, params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan<util.Numeric>;\nexport declare function _lte(value: util.Numeric, params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan<util.Numeric>;\nexport { \n/** @deprecated Use `z.lte()` instead. */\n_lte as _max, };\nexport type $ZodCheckGreaterThanParams = CheckParams<checks.$ZodCheckGreaterThan, \"inclusive\" | \"value\" | \"when\">;\nexport declare function _gt(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;\nexport declare function _gte(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;\nexport { \n/** @deprecated Use `z.gte()` instead. */\n_gte as _min, };\nexport declare function _positive(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;\nexport declare function _negative(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan;\nexport declare function _nonpositive(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan;\nexport declare function _nonnegative(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;\nexport type $ZodCheckMultipleOfParams = CheckParams<checks.$ZodCheckMultipleOf, \"value\" | \"when\">;\nexport declare function _multipleOf(value: number | bigint, params?: string | $ZodCheckMultipleOfParams): checks.$ZodCheckMultipleOf;\nexport type $ZodCheckMaxSizeParams = CheckParams<checks.$ZodCheckMaxSize, \"maximum\" | \"when\">;\nexport declare function _maxSize(maximum: number, params?: string | $ZodCheckMaxSizeParams): checks.$ZodCheckMaxSize<util.HasSize>;\nexport type $ZodCheckMinSizeParams = CheckParams<checks.$ZodCheckMinSize, \"minimum\" | \"when\">;\nexport declare function _minSize(minimum: number, params?: string | $ZodCheckMinSizeParams): checks.$ZodCheckMinSize<util.HasSize>;\nexport type $ZodCheckSizeEqualsParams = CheckParams<checks.$ZodCheckSizeEquals, \"size\" | \"when\">;\nexport declare function _size(size: number, params?: string | $ZodCheckSizeEqualsParams): checks.$ZodCheckSizeEquals<util.HasSize>;\nexport type $ZodCheckMaxLengthParams = CheckParams<checks.$ZodCheckMaxLength, \"maximum\" | \"when\">;\nexport declare function _maxLength(maximum: number, params?: string | $ZodCheckMaxLengthParams): checks.$ZodCheckMaxLength<util.HasLength>;\nexport type $ZodCheckMinLengthParams = CheckParams<checks.$ZodCheckMinLength, \"minimum\" | \"when\">;\nexport declare function _minLength(minimum: number, params?: string | $ZodCheckMinLengthParams): checks.$ZodCheckMinLength<util.HasLength>;\nexport type $ZodCheckLengthEqualsParams = CheckParams<checks.$ZodCheckLengthEquals, \"length\" | \"when\">;\nexport declare function _length(length: number, params?: string | $ZodCheckLengthEqualsParams): checks.$ZodCheckLengthEquals<util.HasLength>;\nexport type $ZodCheckRegexParams = CheckParams<checks.$ZodCheckRegex, \"format\" | \"pattern\" | \"when\">;\nexport declare function _regex(pattern: RegExp, params?: string | $ZodCheckRegexParams): checks.$ZodCheckRegex;\nexport type $ZodCheckLowerCaseParams = CheckParams<checks.$ZodCheckLowerCase, \"format\" | \"when\">;\nexport declare function _lowercase(params?: string | $ZodCheckLowerCaseParams): checks.$ZodCheckLowerCase;\nexport type $ZodCheckUpperCaseParams = CheckParams<checks.$ZodCheckUpperCase, \"format\" | \"when\">;\nexport declare function _uppercase(params?: string | $ZodCheckUpperCaseParams): checks.$ZodCheckUpperCase;\nexport type $ZodCheckIncludesParams = CheckParams<checks.$ZodCheckIncludes, \"includes\" | \"format\" | \"when\" | \"pattern\">;\nexport declare function _includes(includes: string, params?: string | $ZodCheckIncludesParams): checks.$ZodCheckIncludes;\nexport type $ZodCheckStartsWithParams = CheckParams<checks.$ZodCheckStartsWith, \"prefix\" | \"format\" | \"when\" | \"pattern\">;\nexport declare function _startsWith(prefix: string, params?: string | $ZodCheckStartsWithParams): checks.$ZodCheckStartsWith;\nexport type $ZodCheckEndsWithParams = CheckParams<checks.$ZodCheckEndsWith, \"suffix\" | \"format\" | \"pattern\" | \"when\">;\nexport declare function _endsWith(suffix: string, params?: string | $ZodCheckEndsWithParams): checks.$ZodCheckEndsWith;\nexport type $ZodCheckPropertyParams = CheckParams<checks.$ZodCheckProperty, \"property\" | \"schema\" | \"when\">;\nexport declare function _property<K extends string, T extends schemas.$ZodType>(property: K, schema: T, params?: string | $ZodCheckPropertyParams): checks.$ZodCheckProperty<{\n    [k in K]: core.output<T>;\n}>;\nexport type $ZodCheckMimeTypeParams = CheckParams<checks.$ZodCheckMimeType, \"mime\" | \"when\">;\nexport declare function _mime(types: util.MimeTypes[], params?: string | $ZodCheckMimeTypeParams): checks.$ZodCheckMimeType;\nexport declare function _overwrite<T>(tx: (input: T) => T): checks.$ZodCheckOverwrite<T>;\nexport declare function _normalize(form?: \"NFC\" | \"NFD\" | \"NFKC\" | \"NFKD\" | (string & {})): checks.$ZodCheckOverwrite<string>;\nexport declare function _trim(): checks.$ZodCheckOverwrite<string>;\nexport declare function _toLowerCase(): checks.$ZodCheckOverwrite<string>;\nexport declare function _toUpperCase(): checks.$ZodCheckOverwrite<string>;\nexport declare function _slugify(): checks.$ZodCheckOverwrite<string>;\nexport type $ZodArrayParams = TypeParams<schemas.$ZodArray, \"element\">;\nexport declare function _array<T extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodArray>, element: T, params?: string | $ZodArrayParams): schemas.$ZodArray<T>;\nexport type $ZodObjectParams = TypeParams<schemas.$ZodObject, \"shape\" | \"catchall\">;\nexport type $ZodUnionParams = TypeParams<schemas.$ZodUnion, \"options\">;\nexport declare function _union<const T extends readonly schemas.$ZodObject[]>(Class: util.SchemaClass<schemas.$ZodUnion>, options: T, params?: string | $ZodUnionParams): schemas.$ZodUnion<T>;\nexport type $ZodXorParams = TypeParams<schemas.$ZodXor, \"options\">;\nexport declare function _xor<const T extends readonly schemas.$ZodObject[]>(Class: util.SchemaClass<schemas.$ZodXor>, options: T, params?: string | $ZodXorParams): schemas.$ZodXor<T>;\nexport interface $ZodTypeDiscriminableInternals extends schemas.$ZodTypeInternals {\n    propValues: util.PropValues;\n}\nexport interface $ZodTypeDiscriminable extends schemas.$ZodType {\n    _zod: $ZodTypeDiscriminableInternals;\n}\nexport type $ZodDiscriminatedUnionParams = TypeParams<schemas.$ZodDiscriminatedUnion, \"options\" | \"discriminator\">;\nexport declare function _discriminatedUnion<Types extends [$ZodTypeDiscriminable, ...$ZodTypeDiscriminable[]], Disc extends string>(Class: util.SchemaClass<schemas.$ZodDiscriminatedUnion>, discriminator: Disc, options: Types, params?: string | $ZodDiscriminatedUnionParams): schemas.$ZodDiscriminatedUnion<Types, Disc>;\nexport type $ZodIntersectionParams = TypeParams<schemas.$ZodIntersection, \"left\" | \"right\">;\nexport declare function _intersection<T extends schemas.$ZodObject, U extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodIntersection>, left: T, right: U): schemas.$ZodIntersection<T, U>;\nexport type $ZodTupleParams = TypeParams<schemas.$ZodTuple, \"items\" | \"rest\">;\nexport declare function _tuple<T extends readonly [schemas.$ZodType, ...schemas.$ZodType[]]>(Class: util.SchemaClass<schemas.$ZodTuple>, items: T, params?: string | $ZodTupleParams): schemas.$ZodTuple<T, null>;\nexport declare function _tuple<T extends readonly [schemas.$ZodType, ...schemas.$ZodType[]], Rest extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodTuple>, items: T, rest: Rest, params?: string | $ZodTupleParams): schemas.$ZodTuple<T, Rest>;\nexport type $ZodRecordParams = TypeParams<schemas.$ZodRecord, \"keyType\" | \"valueType\">;\nexport declare function _record<Key extends schemas.$ZodRecordKey, Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodRecord>, keyType: Key, valueType: Value, params?: string | $ZodRecordParams): schemas.$ZodRecord<Key, Value>;\nexport type $ZodMapParams = TypeParams<schemas.$ZodMap, \"keyType\" | \"valueType\">;\nexport declare function _map<Key extends schemas.$ZodObject, Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodMap>, keyType: Key, valueType: Value, params?: string | $ZodMapParams): schemas.$ZodMap<Key, Value>;\nexport type $ZodSetParams = TypeParams<schemas.$ZodSet, \"valueType\">;\nexport declare function _set<Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodSet>, valueType: Value, params?: string | $ZodSetParams): schemas.$ZodSet<Value>;\nexport type $ZodEnumParams = TypeParams<schemas.$ZodEnum, \"entries\">;\nexport declare function _enum<const T extends string[]>(Class: util.SchemaClass<schemas.$ZodEnum>, values: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<util.ToEnum<T[number]>>;\nexport declare function _enum<T extends util.EnumLike>(Class: util.SchemaClass<schemas.$ZodEnum>, entries: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<T>;\n/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.\n *\n * ```ts\n * enum Colors { red, green, blue }\n * z.enum(Colors);\n * ```\n */\nexport declare function _nativeEnum<T extends util.EnumLike>(Class: util.SchemaClass<schemas.$ZodEnum>, entries: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<T>;\nexport type $ZodLiteralParams = TypeParams<schemas.$ZodLiteral, \"values\">;\nexport declare function _literal<const T extends Array<util.Literal>>(Class: util.SchemaClass<schemas.$ZodLiteral>, value: T, params?: string | $ZodLiteralParams): schemas.$ZodLiteral<T[number]>;\nexport declare function _literal<const T extends util.Literal>(Class: util.SchemaClass<schemas.$ZodLiteral>, value: T, params?: string | $ZodLiteralParams): schemas.$ZodLiteral<T>;\nexport type $ZodFileParams = TypeParams<schemas.$ZodFile>;\nexport declare function _file(Class: util.SchemaClass<schemas.$ZodFile>, params?: string | $ZodFileParams): schemas.$ZodFile;\nexport type $ZodTransformParams = TypeParams<schemas.$ZodTransform, \"transform\">;\nexport declare function _transform<I = unknown, O = I>(Class: util.SchemaClass<schemas.$ZodTransform>, fn: (input: I, ctx?: schemas.ParsePayload) => O): schemas.$ZodTransform<Awaited<O>, I>;\nexport type $ZodOptionalParams = TypeParams<schemas.$ZodOptional, \"innerType\">;\nexport declare function _optional<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodOptional>, innerType: T): schemas.$ZodOptional<T>;\nexport type $ZodNullableParams = TypeParams<schemas.$ZodNullable, \"innerType\">;\nexport declare function _nullable<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodNullable>, innerType: T): schemas.$ZodNullable<T>;\nexport type $ZodDefaultParams = TypeParams<schemas.$ZodDefault, \"innerType\" | \"defaultValue\">;\nexport declare function _default<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodDefault>, innerType: T, defaultValue: util.NoUndefined<core.output<T>> | (() => util.NoUndefined<core.output<T>>)): schemas.$ZodDefault<T>;\nexport type $ZodNonOptionalParams = TypeParams<schemas.$ZodNonOptional, \"innerType\">;\nexport declare function _nonoptional<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodNonOptional>, innerType: T, params?: string | $ZodNonOptionalParams): schemas.$ZodNonOptional<T>;\nexport type $ZodSuccessParams = TypeParams<schemas.$ZodSuccess, \"innerType\">;\nexport declare function _success<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodSuccess>, innerType: T): schemas.$ZodSuccess<T>;\nexport type $ZodCatchParams = TypeParams<schemas.$ZodCatch, \"innerType\" | \"catchValue\">;\nexport declare function _catch<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodCatch>, innerType: T, catchValue: core.output<T> | ((ctx: schemas.$ZodCatchCtx) => core.output<T>)): schemas.$ZodCatch<T>;\nexport type $ZodPipeParams = TypeParams<schemas.$ZodPipe, \"in\" | \"out\">;\nexport declare function _pipe<const A extends schemas.$ZodType, B extends schemas.$ZodType<unknown, core.output<A>> = schemas.$ZodType<unknown, core.output<A>>>(Class: util.SchemaClass<schemas.$ZodPipe>, in_: A, out: B | schemas.$ZodType<unknown, core.output<A>>): schemas.$ZodPipe<A, B>;\nexport type $ZodReadonlyParams = TypeParams<schemas.$ZodReadonly, \"innerType\">;\nexport declare function _readonly<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodReadonly>, innerType: T): schemas.$ZodReadonly<T>;\nexport type $ZodTemplateLiteralParams = TypeParams<schemas.$ZodTemplateLiteral, \"parts\">;\nexport declare function _templateLiteral<const Parts extends schemas.$ZodTemplateLiteralPart[]>(Class: util.SchemaClass<schemas.$ZodTemplateLiteral>, parts: Parts, params?: string | $ZodTemplateLiteralParams): schemas.$ZodTemplateLiteral<schemas.$PartsToTemplateLiteral<Parts>>;\nexport type $ZodLazyParams = TypeParams<schemas.$ZodLazy, \"getter\">;\nexport declare function _lazy<T extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodLazy>, getter: () => T): schemas.$ZodLazy<T>;\nexport type $ZodPromiseParams = TypeParams<schemas.$ZodPromise, \"innerType\">;\nexport declare function _promise<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodPromise>, innerType: T): schemas.$ZodPromise<T>;\nexport type $ZodCustomParams = CheckTypeParams<schemas.$ZodCustom, \"fn\">;\nexport declare function _custom<O = unknown, I = O>(Class: util.SchemaClass<schemas.$ZodCustom>, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined): schemas.$ZodCustom<O, I>;\nexport declare function _refine<O = unknown, I = O>(Class: util.SchemaClass<schemas.$ZodCustom>, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined): schemas.$ZodCustom<O, I>;\nexport type $ZodSuperRefineIssue<T extends errors.$ZodIssueBase = errors.$ZodIssue> = T extends any ? RawIssue<T> : never;\ntype RawIssue<T extends errors.$ZodIssueBase> = T extends any ? util.Flatten<util.MakePartial<T, \"message\" | \"path\"> & {\n    /** The schema or check that originated this issue. */\n    readonly inst?: schemas.$ZodType | checks.$ZodCheck;\n    /** If `true`, Zod will execute subsequent checks/refinements instead of immediately aborting */\n    readonly continue?: boolean | undefined;\n} & Record<string, unknown>> : never;\nexport interface $RefinementCtx<T = unknown> extends schemas.ParsePayload<T> {\n    addIssue(arg: string | $ZodSuperRefineIssue): void;\n}\nexport declare function _superRefine<T>(fn: (arg: T, payload: $RefinementCtx<T>) => void | Promise<void>): checks.$ZodCheck<T>;\nexport declare function _check<O = unknown>(fn: schemas.CheckFn<O>, params?: string | $ZodCustomParams): checks.$ZodCheck<O>;\nexport declare function describe<T>(description: string): checks.$ZodCheck<T>;\nexport declare function meta<T>(metadata: registries.GlobalMeta): checks.$ZodCheck<T>;\nexport interface $ZodStringBoolParams extends TypeParams {\n    truthy?: string[];\n    falsy?: string[];\n    /**\n     * Options: `\"sensitive\"`, `\"insensitive\"`\n     *\n     * @default `\"insensitive\"`\n     */\n    case?: \"sensitive\" | \"insensitive\" | undefined;\n}\nexport declare function _stringbool(Classes: {\n    Codec?: typeof schemas.$ZodCodec;\n    Boolean?: typeof schemas.$ZodBoolean;\n    String?: typeof schemas.$ZodString;\n}, _params?: string | $ZodStringBoolParams): schemas.$ZodCodec<schemas.$ZodString, schemas.$ZodBoolean>;\nexport declare function _stringFormat<Format extends string>(Class: typeof schemas.$ZodCustomStringFormat, format: Format, fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp, _params?: string | $ZodStringFormatParams): schemas.$ZodCustomStringFormat<Format>;\n"],"x_google_ignoreList":[0],"mappings":";;;;;;AAMYM,KAAAA,MAAM,CAAA,UAAWF,QAAXK,GAA8BT,SAA9B,EAAA,mBAAmEE,aAAnE,EAAA,iBAAA,MAAgHK,CAAhH,CAAA,MAAA,CAAA,CAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAA4IF,OAA5I,CAAyJW,OAAzJ,CAAiKX,YAAjK,CAAmLQ,IAAnL,CAAwLN,CAAxL,CAAA,MAAA,CAAA,CAAA,KAAA,CAAA,EAA0ME,QAA1M,CAAA,GAAA,CAAA,CAAwND,UAAxN,CAAA,SAAA,CAAA,KAAA,CAAA,GAAA,CAAA,CAAA,GAAA;EAAWJ,KAAAA,CAAAA,EAAAA,MAAAA,GACRF,YADQE,CACYI,UADZJ,CAAAA,GAAAA,SAAAA;EAAmBJ;EAAqCE,OAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;CAA6CK,CAAAA,CAAAA,CAAAA,CAAAA;AAAwEA,KAK9LW,UAL8LX,CAAAA,UAKzKH,QALyKG,GAKtJH,QALsJG,GAAAA;EAAkBE,KAAAA,EAAAA,KAAAA;CAAvBI,EAAAA,iBAOjLO,OAPiLP,CAAAA,MAOnKN,CAPmKM,CAAAA,MAAAA,CAAAA,CAAAA,KAAAA,CAAAA,EAAAA,MAAAA,GAAAA,QAAAA,GAAAA,OAAAA,CAAAA,GAAAA,KAAAA,CAAAA,GAOzGP,MAPyGO,CAOlGN,CAPkGM,EAO/FQ,WAP+FR,CAOnFN,CAPmFM,CAAAA,MAAAA,CAAAA,CAAAA,MAAAA,CAAAA,CAAAA,EAAAA,MAAAA,GAAAA,QAAAA,GAAAA,OAAAA,GAOjCM,QAPiCN,CAAAA;AAAqCL,KAQ9Nc,WAR8Nd,CAAAA,UAQxMR,SARwMQ,GAQrLR,SARqLQ;AAAAA;iBASzNY,OARwBZ,CAAAA,MAQVD,CARUC,CAAAA,MAAAA,CAAAA,CAAAA,KAAAA,CAAAA,EAAAA,OAAAA,GAAAA,OAAAA,CAAAA,GAAAA,KAAAA,CAAAA,GAQsCF,MARtCE,CAQ6CD,CAR7CC,EAQgDa,WARhDb,CAQ4DD,CAR5DC,CAAAA,MAAAA,CAAAA,CAAAA,MAAAA,CAAAA,CAAAA,EAAAA,OAAAA,GAAAA,OAAAA,GAQoGW,QARpGX,CAAAA;AAD0IH,KAWvKoB,uBAXuKpB,CAAAA,UAWrID,gBAXqIC,GAW1GD,gBAX0GC,EAAAA,iBAW/De,OAX+Df,CAAAA,MAWjDE,CAXiDF,CAAAA,MAAAA,CAAAA,CAAAA,KAAAA,CAAAA,EAAAA,MAAAA,GAAAA,QAAAA,GAAAA,QAAAA,GAAAA,OAAAA,GAAAA,OAAAA,GAAAA,QAAAA,CAAAA,GAAAA,KAAAA,CAAAA,GAWyCC,MAXzCD,CAWgDE,CAXhDF,EAWmDgB,WAXnDhB,CAW+DE,CAX/DF,CAAAA,MAAAA,CAAAA,CAAAA,MAAAA,CAAAA,CAAAA,EAAAA,MAAAA,GAAAA,QAAAA,GAAAA,QAAAA,GAAAA,OAAAA,GAAAA,OAAAA,GAAAA,QAAAA,GAWiJc,QAXjJd,CAAAA;AAARW,KAY/JU,eAZ+JV,CAAAA,UAYrIZ,QAZqIY,GAYlHhB,SAZkHgB,GAY/FZ,QAZ+FY,GAY5EhB,SAZ4EgB,EAAAA,iBAYzCI,OAZyCJ,CAAAA,MAY3BT,CAZ2BS,CAAAA,MAAAA,CAAAA,CAAAA,KAAAA,CAAAA,EAAAA,MAAAA,GAAAA,QAAAA,GAAAA,OAAAA,GAAAA,OAAAA,CAAAA,GAAAA,KAAAA,CAAAA,GAYyCV,MAZzCU,CAYgDT,CAZhDS,EAYmDK,WAZnDL,CAY+DT,CAZ/DS,CAAAA,MAAAA,CAAAA,CAAAA,MAAAA,CAAAA,GAYmFT,CAZnFS,CAAAA,MAAAA,CAAAA,CAAAA,MAAAA,CAAAA,CAAAA,EAAAA,MAAAA,GAAAA,QAAAA,GAAAA,OAAAA,GAAAA,OAAAA,GAY+IG,QAZ/IH,CAAAA;AAOvJI,KAYRiB,oBAAAA,GAAuBZ,uBAZfL,CAYuChB,SAZvCgB,EAAAA,MAAAA,CAAAA;AAAkFC,KAe1FoB,mBAAAA,GAAsBhB,uBAfoEJ,CAe5CjB,QAf4CiB,EAAAA,SAAAA,GAAAA,MAAAA,CAAAA;AAAJ,KAkBtFwB,mBAAAA,GAAsBpB,uBAlBgE,CAkBxCrB,QAlBwC,EAAA,SAAA,GAAA,MAAA,CAAA;AAItFqB,KA0BAiC,kBAAAA,GAAqBjC,uBA1BE,CA0BsBrB,OA1BtB,EAAA,MAAA,CAAA;AAA+FG,KA6BtHuD,oBAAAA,GAAuBrC,uBA7B+FlB,CA6BvEH,SA7BuEG,EAAAA,MAAAA,CAAAA;AAAgHA,KAgCtO2D,qBAAAA,GAAwBzC,uBAhC8MlB,CAgCtLH,UAhCsLG,EAAAA,MAAAA,CAAAA;AAAtBD,KAmChNgE,mBAAAA,GAAsB7C,uBAnC0LnB,CAmClKF,QAnCkKE,EAAAA,MAAAA,CAAAA;AACtLF,KAqC1BsE,oBAAAA,GAAuBjD,uBArCGrB,CAqCqBA,SArCrBA,EAAAA,MAAAA,CAAAA;AAAyDJ,KAwCnF8E,mBAAAA,GAAsBrD,uBAxC6DzB,CAwCrCI,QAxCqCJ,EAAAA,MAAAA,CAAAA;AAA4HO,KA2C/M2E,kBAAAA,GAAqBzD,uBA3C0LlB,CA2ClKH,OA3CkKG,EAAAA,MAAAA,CAAAA;AAAGc,KA8ClNiE,oBAAAA,GAAuB7D,uBA9C2LJ,CA8CnKjB,SA9CmKiB,EAAAA,MAAAA,CAAAA;AAAJ,KAiD9MqE,mBAAAA,GAAsBjE,uBAjDwL,CAiDhKrB,QAjDgK,EAAA,SAAA,GAAA,MAAA,GAAA,SAAA,CAAA;AAa9MyC,KAuCAiD,mBAAAA,GAAsBrE,uBAvCAA,CAuCwBrB,QAvCD,EAAA,SAAA,GAAA,MAAA,GAAA,SAAA,CAAA;AA2B7C0E,KAkBAwB,qBAAAA,GAAwB7E,uBAlBFA,CAkB0BrB,UAlBH,EAAA,SAAA,GAAA,MAAA,CAAA;AAS7CsF,KAYAgB,qBAAAA,GAAwBjF,uBAZFA,CAY0BrB,UAZH,EAAA,SAAA,GAAA,MAAA,CAAA;AAY7CsG,KAGAI,qBAAAA,GAAwBrF,uBAHAA,CAGwBrB,UAHD,EAAA,SAAA,GAAA,MAAA,CAAA;AAS/CkH,KAHAJ,wBAAAA,GAA2BzF,uBAGLA,CAH6BrB,aAGN,EAAA,SAAA,GAAA,MAAA,CAAA;AAgB7C+H,KAhBAb,mBAAAA,GAAsB7F,uBAgBGA,CAhBqBrB,QAgBrBqB,EAAAA,MAAuB,CAAA;AAUhDwH,KAvBAvB,kBAAAA,GAAqBjG,uBAuBqBzB,CAvBGI,OAuBfkB,EAAAA,SAAW,GAAA,MAAA,CAAA;AAyEzC8N,KAtFArH,0BAAAA,GAA6BtG,uBAsFHH,CAtF2BlB,eAsFhB,EAAA,SAAA,GAAA,MAAA,CAAA;AA4CrCiT,KA/HAlL,sBAAAA,GAAyB1G,uBA+HE,CA/HsBrB,WA+HtB,EAAA,SAAA,GAAA,MAAA,CAAA;AA2C3BkX,KAvKA/O,sBAAAA,GAAyB9G,uBAuKL,CAvK6BrB,WAuK7B,EAAA,SAAA,GAAA,MAAA,CAAA;AAAsDG,KApK1EoI,0BAAAA,GAA6BlH,uBAoK6ClB,CApKrBH,eAoKqBG,EAAAA,MAAAA,CAAAA;AACjFiX,KAjKOvO,2BAAAA,GAA8B3H,WAiK7B,CAjKyCtB,qBAiKzC,EAAA,QAAA,GAAA,MAAA,CAAA;KA5HDoM,uBAAAA,GAA0B9K,YAAYtB;KAMtC0M,0BAAAA,GAA6BpL,YAAYtB;KAUzCmN,yBAAAA,GAA4B7L,YAAYtB;KAQxCgO,wBAAAA,GAA2B1M,YAAYtB;KAEvCoO,wBAAAA,GAA2B9M,YAAYtB;KAEvCuO,2BAAAA,GAA8BjN,YAAYtB;KAE1C0O,oBAAAA,GAAuBpN,YAAYtB;KAEnC8O,wBAAAA,GAA2BxN,YAAYtB;KAEvCiP,wBAAAA,GAA2B3N,YAAYtB;KAEvCoP,uBAAAA,GAA0B9N,YAAYtB;KAEtCuP,yBAAAA,GAA4BjO,YAAYtB;KAExC0P,uBAAAA,GAA0BpO,YAAYtB;KAwCtCqT,cAAAA,GAAiBnS,WAAWd;KAwB5BgV,qBAAAA,GAAwBlU,WAAWd;KAgBnC8W,gBAAAA,GAAmBxV,gBAAgBtB;KAGnCkX,+BAA+BpX,gBAAuBA,aAAoBK,gBAAgBiX,SAASjX;KAC1GiX,mBAAmBtX,iBAAwBK,gBAAgBF,QAAaA,YAAiBE;;kBAE1EH,WAAmBJ;;;IAGnC0X;UACaC,oCAAoCvX,aAAqBG;yBAC/C+W"}

package/checks.d.ts

@@ -1,189 +0,0 @@
-import { HasLength, MaybeAsync, Numeric } from "./util.js";
-import { $ZodType, ParsePayload } from "./schemas.js";
-import { $ZodErrorMap, $ZodIssueBase, $ZodIssueInvalidStringFormat, $ZodIssueInvalidType, $ZodIssueNotMultipleOf, $ZodIssueTooBig, $ZodIssueTooSmall } from "./errors.js";
-import { $constructor } from "./core.js";
-
-//#region ../../node_modules/.bun/zod@4.2.1/node_modules/zod/v4/core/checks.d.cts
-interface $ZodCheckDef {
-  check: string;
-  error?: $ZodErrorMap<never> | undefined;
-  /** If true, no later checks will be executed if this check fails. Default `false`. */
-  abort?: boolean | undefined;
-  /** If provided, this check will only be executed if the function returns `true`. Defaults to `payload => z.util.isAborted(payload)`. */
-  when?: ((payload: ParsePayload) => boolean) | undefined;
-}
-interface $ZodCheckInternals<T> {
-  def: $ZodCheckDef;
-  /** The set of issues this check might throw. */
-  issc?: $ZodIssueBase;
-  check(payload: ParsePayload<T>): MaybeAsync<void>;
-  onattach: ((schema: $ZodType) => void)[];
-}
-interface $ZodCheck<in T = never> {
-  _zod: $ZodCheckInternals<T>;
-}
-declare const $ZodCheck: $constructor<$ZodCheck<any>>;
-interface $ZodCheckLessThanDef extends $ZodCheckDef {
-  check: "less_than";
-  value: Numeric;
-  inclusive: boolean;
-}
-interface $ZodCheckLessThanInternals<T extends Numeric = Numeric> extends $ZodCheckInternals<T> {
-  def: $ZodCheckLessThanDef;
-  issc: $ZodIssueTooBig<T>;
-}
-interface $ZodCheckLessThan<T extends Numeric = Numeric> extends $ZodCheck<T> {
-  _zod: $ZodCheckLessThanInternals<T>;
-}
-declare const $ZodCheckLessThan: $constructor<$ZodCheckLessThan>;
-interface $ZodCheckGreaterThanDef extends $ZodCheckDef {
-  check: "greater_than";
-  value: Numeric;
-  inclusive: boolean;
-}
-interface $ZodCheckGreaterThanInternals<T extends Numeric = Numeric> extends $ZodCheckInternals<T> {
-  def: $ZodCheckGreaterThanDef;
-  issc: $ZodIssueTooSmall<T>;
-}
-interface $ZodCheckGreaterThan<T extends Numeric = Numeric> extends $ZodCheck<T> {
-  _zod: $ZodCheckGreaterThanInternals<T>;
-}
-declare const $ZodCheckGreaterThan: $constructor<$ZodCheckGreaterThan>;
-interface $ZodCheckMultipleOfDef<T extends number | bigint = number | bigint> extends $ZodCheckDef {
-  check: "multiple_of";
-  value: T;
-}
-interface $ZodCheckMultipleOfInternals<T extends number | bigint = number | bigint> extends $ZodCheckInternals<T> {
-  def: $ZodCheckMultipleOfDef<T>;
-  issc: $ZodIssueNotMultipleOf;
-}
-interface $ZodCheckMultipleOf<T extends number | bigint = number | bigint> extends $ZodCheck<T> {
-  _zod: $ZodCheckMultipleOfInternals<T>;
-}
-declare const $ZodCheckMultipleOf: $constructor<$ZodCheckMultipleOf<number | bigint>>;
-type $ZodNumberFormats = "int32" | "uint32" | "float32" | "float64" | "safeint";
-interface $ZodCheckNumberFormatDef extends $ZodCheckDef {
-  check: "number_format";
-  format: $ZodNumberFormats;
-}
-interface $ZodCheckNumberFormatInternals extends $ZodCheckInternals<number> {
-  def: $ZodCheckNumberFormatDef;
-  issc: $ZodIssueInvalidType | $ZodIssueTooBig<"number"> | $ZodIssueTooSmall<"number">;
-}
-interface $ZodCheckNumberFormat extends $ZodCheck<number> {
-  _zod: $ZodCheckNumberFormatInternals;
-}
-declare const $ZodCheckNumberFormat: $constructor<$ZodCheckNumberFormat>;
-interface $ZodCheckMaxLengthDef extends $ZodCheckDef {
-  check: "max_length";
-  maximum: number;
-}
-interface $ZodCheckMaxLengthInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
-  def: $ZodCheckMaxLengthDef;
-  issc: $ZodIssueTooBig<T>;
-}
-interface $ZodCheckMaxLength<T extends HasLength = HasLength> extends $ZodCheck<T> {
-  _zod: $ZodCheckMaxLengthInternals<T>;
-}
-declare const $ZodCheckMaxLength: $constructor<$ZodCheckMaxLength>;
-interface $ZodCheckMinLengthDef extends $ZodCheckDef {
-  check: "min_length";
-  minimum: number;
-}
-interface $ZodCheckMinLengthInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
-  def: $ZodCheckMinLengthDef;
-  issc: $ZodIssueTooSmall<T>;
-}
-interface $ZodCheckMinLength<T extends HasLength = HasLength> extends $ZodCheck<T> {
-  _zod: $ZodCheckMinLengthInternals<T>;
-}
-declare const $ZodCheckMinLength: $constructor<$ZodCheckMinLength>;
-interface $ZodCheckLengthEqualsDef extends $ZodCheckDef {
-  check: "length_equals";
-  length: number;
-}
-interface $ZodCheckLengthEqualsInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
-  def: $ZodCheckLengthEqualsDef;
-  issc: $ZodIssueTooBig<T> | $ZodIssueTooSmall<T>;
-}
-interface $ZodCheckLengthEquals<T extends HasLength = HasLength> extends $ZodCheck<T> {
-  _zod: $ZodCheckLengthEqualsInternals<T>;
-}
-declare const $ZodCheckLengthEquals: $constructor<$ZodCheckLengthEquals>;
-type $ZodStringFormats = "email" | "url" | "emoji" | "uuid" | "guid" | "nanoid" | "cuid" | "cuid2" | "ulid" | "xid" | "ksuid" | "datetime" | "date" | "time" | "duration" | "ipv4" | "ipv6" | "cidrv4" | "cidrv6" | "base64" | "base64url" | "json_string" | "e164" | "lowercase" | "uppercase" | "regex" | "jwt" | "starts_with" | "ends_with" | "includes";
-interface $ZodCheckStringFormatDef<Format extends string = string> extends $ZodCheckDef {
-  check: "string_format";
-  format: Format;
-  pattern?: RegExp | undefined;
-}
-interface $ZodCheckStringFormatInternals extends $ZodCheckInternals<string> {
-  def: $ZodCheckStringFormatDef;
-  issc: $ZodIssueInvalidStringFormat;
-}
-interface $ZodCheckRegexDef extends $ZodCheckStringFormatDef {
-  format: "regex";
-  pattern: RegExp;
-}
-interface $ZodCheckRegexInternals extends $ZodCheckInternals<string> {
-  def: $ZodCheckRegexDef;
-  issc: $ZodIssueInvalidStringFormat;
-}
-interface $ZodCheckRegex extends $ZodCheck<string> {
-  _zod: $ZodCheckRegexInternals;
-}
-declare const $ZodCheckRegex: $constructor<$ZodCheckRegex>;
-interface $ZodCheckLowerCaseDef extends $ZodCheckStringFormatDef<"lowercase"> {}
-interface $ZodCheckLowerCaseInternals extends $ZodCheckInternals<string> {
-  def: $ZodCheckLowerCaseDef;
-  issc: $ZodIssueInvalidStringFormat;
-}
-interface $ZodCheckLowerCase extends $ZodCheck<string> {
-  _zod: $ZodCheckLowerCaseInternals;
-}
-declare const $ZodCheckLowerCase: $constructor<$ZodCheckLowerCase>;
-interface $ZodCheckUpperCaseDef extends $ZodCheckStringFormatDef<"uppercase"> {}
-interface $ZodCheckUpperCaseInternals extends $ZodCheckInternals<string> {
-  def: $ZodCheckUpperCaseDef;
-  issc: $ZodIssueInvalidStringFormat;
-}
-interface $ZodCheckUpperCase extends $ZodCheck<string> {
-  _zod: $ZodCheckUpperCaseInternals;
-}
-declare const $ZodCheckUpperCase: $constructor<$ZodCheckUpperCase>;
-interface $ZodCheckIncludesDef extends $ZodCheckStringFormatDef<"includes"> {
-  includes: string;
-  position?: number | undefined;
-}
-interface $ZodCheckIncludesInternals extends $ZodCheckInternals<string> {
-  def: $ZodCheckIncludesDef;
-  issc: $ZodIssueInvalidStringFormat;
-}
-interface $ZodCheckIncludes extends $ZodCheck<string> {
-  _zod: $ZodCheckIncludesInternals;
-}
-declare const $ZodCheckIncludes: $constructor<$ZodCheckIncludes>;
-interface $ZodCheckStartsWithDef extends $ZodCheckStringFormatDef<"starts_with"> {
-  prefix: string;
-}
-interface $ZodCheckStartsWithInternals extends $ZodCheckInternals<string> {
-  def: $ZodCheckStartsWithDef;
-  issc: $ZodIssueInvalidStringFormat;
-}
-interface $ZodCheckStartsWith extends $ZodCheck<string> {
-  _zod: $ZodCheckStartsWithInternals;
-}
-declare const $ZodCheckStartsWith: $constructor<$ZodCheckStartsWith>;
-interface $ZodCheckEndsWithDef extends $ZodCheckStringFormatDef<"ends_with"> {
-  suffix: string;
-}
-interface $ZodCheckEndsWithInternals extends $ZodCheckInternals<string> {
-  def: $ZodCheckEndsWithDef;
-  issc: $ZodIssueInvalidStringFormat;
-}
-interface $ZodCheckEndsWith extends $ZodCheckInternals<string> {
-  _zod: $ZodCheckEndsWithInternals;
-}
-declare const $ZodCheckEndsWith: $constructor<$ZodCheckEndsWith>;
-//#endregion
-export { $ZodCheck, $ZodCheckDef, $ZodCheckEndsWith, $ZodCheckGreaterThan, $ZodCheckIncludes, $ZodCheckInternals, $ZodCheckLengthEquals, $ZodCheckLessThan, $ZodCheckLowerCase, $ZodCheckMaxLength, $ZodCheckMinLength, $ZodCheckMultipleOf, $ZodCheckNumberFormat, $ZodCheckRegex, $ZodCheckStartsWith, $ZodCheckStringFormatDef, $ZodCheckStringFormatInternals, $ZodCheckUpperCase, $ZodStringFormats };
-//# sourceMappingURL=checks.d.ts.map

package/checks.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"checks.d.ts","names":["core","errors","schemas","util","$ZodCheckDef","$ZodErrorMap","ParsePayload","$ZodCheckInternals","T","$ZodIssueBase","MaybeAsync","$ZodType","$ZodCheck","$constructor","$ZodCheckLessThanDef","Numeric","$ZodCheckLessThanInternals","$ZodIssueTooBig","$ZodCheckLessThan","$ZodCheckGreaterThanDef","$ZodCheckGreaterThanInternals","$ZodIssueTooSmall","$ZodCheckGreaterThan","$ZodCheckMultipleOfDef","$ZodCheckMultipleOfInternals","$ZodIssueNotMultipleOf","$ZodCheckMultipleOf","$ZodNumberFormats","$ZodCheckNumberFormatDef","$ZodCheckNumberFormatInternals","$ZodIssueInvalidType","$ZodCheckNumberFormat","$ZodBigIntFormats","$ZodCheckBigIntFormatDef","$ZodCheckBigIntFormatInternals","$ZodCheckBigIntFormat","$ZodCheckMaxSizeDef","$ZodCheckMaxSizeInternals","HasSize","$ZodCheckMaxSize","$ZodCheckMinSizeDef","$ZodCheckMinSizeInternals","$ZodCheckMinSize","$ZodCheckSizeEqualsDef","$ZodCheckSizeEqualsInternals","$ZodCheckSizeEquals","$ZodCheckMaxLengthDef","$ZodCheckMaxLengthInternals","HasLength","$ZodCheckMaxLength","$ZodCheckMinLengthDef","$ZodCheckMinLengthInternals","$ZodCheckMinLength","$ZodCheckLengthEqualsDef","$ZodCheckLengthEqualsInternals","$ZodCheckLengthEquals","$ZodStringFormats","$ZodCheckStringFormatDef","Format","RegExp","$ZodCheckStringFormatInternals","$ZodIssueInvalidStringFormat","$ZodCheckStringFormat","$ZodCheckRegexDef","$ZodCheckRegexInternals","$ZodCheckRegex","$ZodCheckLowerCaseDef","$ZodCheckLowerCaseInternals","$ZodCheckLowerCase","$ZodCheckUpperCaseDef","$ZodCheckUpperCaseInternals","$ZodCheckUpperCase","$ZodCheckIncludesDef","$ZodCheckIncludesInternals","$ZodCheckIncludes","$ZodCheckStartsWithDef","$ZodCheckStartsWithInternals","$ZodCheckStartsWith","$ZodCheckEndsWithDef","$ZodCheckEndsWithInternals","$ZodCheckEndsWith","$ZodCheckPropertyDef","$ZodCheckPropertyInternals","$ZodIssue","$ZodCheckProperty","$ZodCheckMimeTypeDef","MimeTypes","$ZodCheckMimeTypeInternals","File","$ZodIssueInvalidValue","$ZodCheckMimeType","$ZodCheckOverwriteDef","$ZodCheckOverwriteInternals","$ZodCheckOverwrite","$ZodChecks","$ZodStringFormatChecks","$ZodStringFormatTypes"],"sources":["../../../node_modules/.bun/zod@4.2.1/node_modules/zod/v4/core/checks.d.cts"],"sourcesContent":["import * as core from \"./core.cjs\";\nimport type * as errors from \"./errors.cjs\";\nimport type * as schemas from \"./schemas.cjs\";\nimport * as util from \"./util.cjs\";\nexport interface $ZodCheckDef {\n    check: string;\n    error?: errors.$ZodErrorMap<never> | undefined;\n    /** If true, no later checks will be executed if this check fails. Default `false`. */\n    abort?: boolean | undefined;\n    /** If provided, this check will only be executed if the function returns `true`. Defaults to `payload => z.util.isAborted(payload)`. */\n    when?: ((payload: schemas.ParsePayload) => boolean) | undefined;\n}\nexport interface $ZodCheckInternals<T> {\n    def: $ZodCheckDef;\n    /** The set of issues this check might throw. */\n    issc?: errors.$ZodIssueBase;\n    check(payload: schemas.ParsePayload<T>): util.MaybeAsync<void>;\n    onattach: ((schema: schemas.$ZodType) => void)[];\n}\nexport interface $ZodCheck<in T = never> {\n    _zod: $ZodCheckInternals<T>;\n}\nexport declare const $ZodCheck: core.$constructor<$ZodCheck<any>>;\nexport interface $ZodCheckLessThanDef extends $ZodCheckDef {\n    check: \"less_than\";\n    value: util.Numeric;\n    inclusive: boolean;\n}\nexport interface $ZodCheckLessThanInternals<T extends util.Numeric = util.Numeric> extends $ZodCheckInternals<T> {\n    def: $ZodCheckLessThanDef;\n    issc: errors.$ZodIssueTooBig<T>;\n}\nexport interface $ZodCheckLessThan<T extends util.Numeric = util.Numeric> extends $ZodCheck<T> {\n    _zod: $ZodCheckLessThanInternals<T>;\n}\nexport declare const $ZodCheckLessThan: core.$constructor<$ZodCheckLessThan>;\nexport interface $ZodCheckGreaterThanDef extends $ZodCheckDef {\n    check: \"greater_than\";\n    value: util.Numeric;\n    inclusive: boolean;\n}\nexport interface $ZodCheckGreaterThanInternals<T extends util.Numeric = util.Numeric> extends $ZodCheckInternals<T> {\n    def: $ZodCheckGreaterThanDef;\n    issc: errors.$ZodIssueTooSmall<T>;\n}\nexport interface $ZodCheckGreaterThan<T extends util.Numeric = util.Numeric> extends $ZodCheck<T> {\n    _zod: $ZodCheckGreaterThanInternals<T>;\n}\nexport declare const $ZodCheckGreaterThan: core.$constructor<$ZodCheckGreaterThan>;\nexport interface $ZodCheckMultipleOfDef<T extends number | bigint = number | bigint> extends $ZodCheckDef {\n    check: \"multiple_of\";\n    value: T;\n}\nexport interface $ZodCheckMultipleOfInternals<T extends number | bigint = number | bigint> extends $ZodCheckInternals<T> {\n    def: $ZodCheckMultipleOfDef<T>;\n    issc: errors.$ZodIssueNotMultipleOf;\n}\nexport interface $ZodCheckMultipleOf<T extends number | bigint = number | bigint> extends $ZodCheck<T> {\n    _zod: $ZodCheckMultipleOfInternals<T>;\n}\nexport declare const $ZodCheckMultipleOf: core.$constructor<$ZodCheckMultipleOf<number | bigint>>;\nexport type $ZodNumberFormats = \"int32\" | \"uint32\" | \"float32\" | \"float64\" | \"safeint\";\nexport interface $ZodCheckNumberFormatDef extends $ZodCheckDef {\n    check: \"number_format\";\n    format: $ZodNumberFormats;\n}\nexport interface $ZodCheckNumberFormatInternals extends $ZodCheckInternals<number> {\n    def: $ZodCheckNumberFormatDef;\n    issc: errors.$ZodIssueInvalidType | errors.$ZodIssueTooBig<\"number\"> | errors.$ZodIssueTooSmall<\"number\">;\n}\nexport interface $ZodCheckNumberFormat extends $ZodCheck<number> {\n    _zod: $ZodCheckNumberFormatInternals;\n}\nexport declare const $ZodCheckNumberFormat: core.$constructor<$ZodCheckNumberFormat>;\nexport type $ZodBigIntFormats = \"int64\" | \"uint64\";\nexport interface $ZodCheckBigIntFormatDef extends $ZodCheckDef {\n    check: \"bigint_format\";\n    format: $ZodBigIntFormats | undefined;\n}\nexport interface $ZodCheckBigIntFormatInternals extends $ZodCheckInternals<bigint> {\n    def: $ZodCheckBigIntFormatDef;\n    issc: errors.$ZodIssueTooBig<\"bigint\"> | errors.$ZodIssueTooSmall<\"bigint\">;\n}\nexport interface $ZodCheckBigIntFormat extends $ZodCheck<bigint> {\n    _zod: $ZodCheckBigIntFormatInternals;\n}\nexport declare const $ZodCheckBigIntFormat: core.$constructor<$ZodCheckBigIntFormat>;\nexport interface $ZodCheckMaxSizeDef extends $ZodCheckDef {\n    check: \"max_size\";\n    maximum: number;\n}\nexport interface $ZodCheckMaxSizeInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {\n    def: $ZodCheckMaxSizeDef;\n    issc: errors.$ZodIssueTooBig<T>;\n}\nexport interface $ZodCheckMaxSize<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {\n    _zod: $ZodCheckMaxSizeInternals<T>;\n}\nexport declare const $ZodCheckMaxSize: core.$constructor<$ZodCheckMaxSize>;\nexport interface $ZodCheckMinSizeDef extends $ZodCheckDef {\n    check: \"min_size\";\n    minimum: number;\n}\nexport interface $ZodCheckMinSizeInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {\n    def: $ZodCheckMinSizeDef;\n    issc: errors.$ZodIssueTooSmall<T>;\n}\nexport interface $ZodCheckMinSize<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {\n    _zod: $ZodCheckMinSizeInternals<T>;\n}\nexport declare const $ZodCheckMinSize: core.$constructor<$ZodCheckMinSize>;\nexport interface $ZodCheckSizeEqualsDef extends $ZodCheckDef {\n    check: \"size_equals\";\n    size: number;\n}\nexport interface $ZodCheckSizeEqualsInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {\n    def: $ZodCheckSizeEqualsDef;\n    issc: errors.$ZodIssueTooBig<T> | errors.$ZodIssueTooSmall<T>;\n}\nexport interface $ZodCheckSizeEquals<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {\n    _zod: $ZodCheckSizeEqualsInternals<T>;\n}\nexport declare const $ZodCheckSizeEquals: core.$constructor<$ZodCheckSizeEquals>;\nexport interface $ZodCheckMaxLengthDef extends $ZodCheckDef {\n    check: \"max_length\";\n    maximum: number;\n}\nexport interface $ZodCheckMaxLengthInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {\n    def: $ZodCheckMaxLengthDef;\n    issc: errors.$ZodIssueTooBig<T>;\n}\nexport interface $ZodCheckMaxLength<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {\n    _zod: $ZodCheckMaxLengthInternals<T>;\n}\nexport declare const $ZodCheckMaxLength: core.$constructor<$ZodCheckMaxLength>;\nexport interface $ZodCheckMinLengthDef extends $ZodCheckDef {\n    check: \"min_length\";\n    minimum: number;\n}\nexport interface $ZodCheckMinLengthInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {\n    def: $ZodCheckMinLengthDef;\n    issc: errors.$ZodIssueTooSmall<T>;\n}\nexport interface $ZodCheckMinLength<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {\n    _zod: $ZodCheckMinLengthInternals<T>;\n}\nexport declare const $ZodCheckMinLength: core.$constructor<$ZodCheckMinLength>;\nexport interface $ZodCheckLengthEqualsDef extends $ZodCheckDef {\n    check: \"length_equals\";\n    length: number;\n}\nexport interface $ZodCheckLengthEqualsInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {\n    def: $ZodCheckLengthEqualsDef;\n    issc: errors.$ZodIssueTooBig<T> | errors.$ZodIssueTooSmall<T>;\n}\nexport interface $ZodCheckLengthEquals<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {\n    _zod: $ZodCheckLengthEqualsInternals<T>;\n}\nexport declare const $ZodCheckLengthEquals: core.$constructor<$ZodCheckLengthEquals>;\nexport type $ZodStringFormats = \"email\" | \"url\" | \"emoji\" | \"uuid\" | \"guid\" | \"nanoid\" | \"cuid\" | \"cuid2\" | \"ulid\" | \"xid\" | \"ksuid\" | \"datetime\" | \"date\" | \"time\" | \"duration\" | \"ipv4\" | \"ipv6\" | \"cidrv4\" | \"cidrv6\" | \"base64\" | \"base64url\" | \"json_string\" | \"e164\" | \"lowercase\" | \"uppercase\" | \"regex\" | \"jwt\" | \"starts_with\" | \"ends_with\" | \"includes\";\nexport interface $ZodCheckStringFormatDef<Format extends string = string> extends $ZodCheckDef {\n    check: \"string_format\";\n    format: Format;\n    pattern?: RegExp | undefined;\n}\nexport interface $ZodCheckStringFormatInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckStringFormatDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckStringFormat extends $ZodCheck<string> {\n    _zod: $ZodCheckStringFormatInternals;\n}\nexport declare const $ZodCheckStringFormat: core.$constructor<$ZodCheckStringFormat>;\nexport interface $ZodCheckRegexDef extends $ZodCheckStringFormatDef {\n    format: \"regex\";\n    pattern: RegExp;\n}\nexport interface $ZodCheckRegexInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckRegexDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckRegex extends $ZodCheck<string> {\n    _zod: $ZodCheckRegexInternals;\n}\nexport declare const $ZodCheckRegex: core.$constructor<$ZodCheckRegex>;\nexport interface $ZodCheckLowerCaseDef extends $ZodCheckStringFormatDef<\"lowercase\"> {\n}\nexport interface $ZodCheckLowerCaseInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckLowerCaseDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckLowerCase extends $ZodCheck<string> {\n    _zod: $ZodCheckLowerCaseInternals;\n}\nexport declare const $ZodCheckLowerCase: core.$constructor<$ZodCheckLowerCase>;\nexport interface $ZodCheckUpperCaseDef extends $ZodCheckStringFormatDef<\"uppercase\"> {\n}\nexport interface $ZodCheckUpperCaseInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckUpperCaseDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckUpperCase extends $ZodCheck<string> {\n    _zod: $ZodCheckUpperCaseInternals;\n}\nexport declare const $ZodCheckUpperCase: core.$constructor<$ZodCheckUpperCase>;\nexport interface $ZodCheckIncludesDef extends $ZodCheckStringFormatDef<\"includes\"> {\n    includes: string;\n    position?: number | undefined;\n}\nexport interface $ZodCheckIncludesInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckIncludesDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckIncludes extends $ZodCheck<string> {\n    _zod: $ZodCheckIncludesInternals;\n}\nexport declare const $ZodCheckIncludes: core.$constructor<$ZodCheckIncludes>;\nexport interface $ZodCheckStartsWithDef extends $ZodCheckStringFormatDef<\"starts_with\"> {\n    prefix: string;\n}\nexport interface $ZodCheckStartsWithInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckStartsWithDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckStartsWith extends $ZodCheck<string> {\n    _zod: $ZodCheckStartsWithInternals;\n}\nexport declare const $ZodCheckStartsWith: core.$constructor<$ZodCheckStartsWith>;\nexport interface $ZodCheckEndsWithDef extends $ZodCheckStringFormatDef<\"ends_with\"> {\n    suffix: string;\n}\nexport interface $ZodCheckEndsWithInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckEndsWithDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckEndsWith extends $ZodCheckInternals<string> {\n    _zod: $ZodCheckEndsWithInternals;\n}\nexport declare const $ZodCheckEndsWith: core.$constructor<$ZodCheckEndsWith>;\nexport interface $ZodCheckPropertyDef extends $ZodCheckDef {\n    check: \"property\";\n    property: string;\n    schema: schemas.$ZodType;\n}\nexport interface $ZodCheckPropertyInternals<T extends object = object> extends $ZodCheckInternals<T> {\n    def: $ZodCheckPropertyDef;\n    issc: errors.$ZodIssue;\n}\nexport interface $ZodCheckProperty<T extends object = object> extends $ZodCheck<T> {\n    _zod: $ZodCheckPropertyInternals<T>;\n}\nexport declare const $ZodCheckProperty: core.$constructor<$ZodCheckProperty>;\nexport interface $ZodCheckMimeTypeDef extends $ZodCheckDef {\n    check: \"mime_type\";\n    mime: util.MimeTypes[];\n}\nexport interface $ZodCheckMimeTypeInternals<T extends schemas.File = schemas.File> extends $ZodCheckInternals<T> {\n    def: $ZodCheckMimeTypeDef;\n    issc: errors.$ZodIssueInvalidValue;\n}\nexport interface $ZodCheckMimeType<T extends schemas.File = schemas.File> extends $ZodCheck<T> {\n    _zod: $ZodCheckMimeTypeInternals<T>;\n}\nexport declare const $ZodCheckMimeType: core.$constructor<$ZodCheckMimeType>;\nexport interface $ZodCheckOverwriteDef<T = unknown> extends $ZodCheckDef {\n    check: \"overwrite\";\n    tx(value: T): T;\n}\nexport interface $ZodCheckOverwriteInternals<T = unknown> extends $ZodCheckInternals<T> {\n    def: $ZodCheckOverwriteDef<T>;\n    issc: never;\n}\nexport interface $ZodCheckOverwrite<T = unknown> extends $ZodCheck<T> {\n    _zod: $ZodCheckOverwriteInternals<T>;\n}\nexport declare const $ZodCheckOverwrite: core.$constructor<$ZodCheckOverwrite>;\nexport type $ZodChecks = $ZodCheckLessThan | $ZodCheckGreaterThan | $ZodCheckMultipleOf | $ZodCheckNumberFormat | $ZodCheckBigIntFormat | $ZodCheckMaxSize | $ZodCheckMinSize | $ZodCheckSizeEquals | $ZodCheckMaxLength | $ZodCheckMinLength | $ZodCheckLengthEquals | $ZodCheckStringFormat | $ZodCheckProperty | $ZodCheckMimeType | $ZodCheckOverwrite;\nexport type $ZodStringFormatChecks = $ZodCheckRegex | $ZodCheckLowerCase | $ZodCheckUpperCase | $ZodCheckIncludes | $ZodCheckStartsWith | $ZodCheckEndsWith | schemas.$ZodStringFormatTypes;\n"],"x_google_ignoreList":[0],"mappings":"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"}

package/clsx.d.ts

@@ -1,7 +0,0 @@
-//#region ../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/clsx.d.mts
-type ClassValue = ClassArray | ClassDictionary | string | number | bigint | null | boolean | undefined;
-type ClassDictionary = Record<string, any>;
-type ClassArray = ClassValue[];
-//#endregion
-export { ClassValue };
-//# sourceMappingURL=clsx.d.ts.map

package/clsx.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"clsx.d.ts","names":["ClassValue","ClassArray","ClassDictionary","Record","clsx","default"],"sources":["../../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/clsx.d.mts"],"sourcesContent":["export type ClassValue = ClassArray | ClassDictionary | string | number | bigint | null | boolean | undefined;\nexport type ClassDictionary = Record<string, any>;\nexport type ClassArray = ClassValue[];\n\nexport function clsx(...inputs: ClassValue[]): string;\nexport default clsx;\n"],"x_google_ignoreList":[0],"mappings":";KAAYA,UAAAA,GAAaC,aAAaC;AAA1BF,KACAE,eAAAA,GAAkBC,MADLF,CAAAA,MAAaC,EAAAA,GAAAA,CAAAA;AAC1BA,KACAD,UAAAA,GAAaD,UADKG,EAAAA"}

package/coerce.d.ts

@@ -1,9 +0,0 @@
-import { $ZodNumberInternals } from "./schemas.js";
-import { _ZodNumber } from "./schemas2.js";
-
-//#region ../../node_modules/.bun/zod@4.2.1/node_modules/zod/v4/classic/coerce.d.cts
-
-interface ZodCoercedNumber<T = unknown> extends _ZodNumber<$ZodNumberInternals<T>> {}
-//#endregion
-export { ZodCoercedNumber };
-//# sourceMappingURL=coerce.d.ts.map

package/coerce.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"coerce.d.ts","names":["core","schemas","ZodCoercedString","T","$ZodStringInternals","_ZodString","string","$ZodStringParams","ZodCoercedNumber","$ZodNumberInternals","_ZodNumber","number","$ZodNumberParams","ZodCoercedBoolean","$ZodBooleanInternals","_ZodBoolean","boolean","$ZodBooleanParams","ZodCoercedBigInt","$ZodBigIntInternals","_ZodBigInt","bigint","$ZodBigIntParams","ZodCoercedDate","$ZodDateInternals","_ZodDate","date","$ZodDateParams"],"sources":["../../../node_modules/.bun/zod@4.2.1/node_modules/zod/v4/classic/coerce.d.cts"],"sourcesContent":["import * as core from \"../core/index.cjs\";\nimport * as schemas from \"./schemas.cjs\";\nexport interface ZodCoercedString<T = unknown> extends schemas._ZodString<core.$ZodStringInternals<T>> {\n}\nexport declare function string<T = unknown>(params?: string | core.$ZodStringParams): ZodCoercedString<T>;\nexport interface ZodCoercedNumber<T = unknown> extends schemas._ZodNumber<core.$ZodNumberInternals<T>> {\n}\nexport declare function number<T = unknown>(params?: string | core.$ZodNumberParams): ZodCoercedNumber<T>;\nexport interface ZodCoercedBoolean<T = unknown> extends schemas._ZodBoolean<core.$ZodBooleanInternals<T>> {\n}\nexport declare function boolean<T = unknown>(params?: string | core.$ZodBooleanParams): ZodCoercedBoolean<T>;\nexport interface ZodCoercedBigInt<T = unknown> extends schemas._ZodBigInt<core.$ZodBigIntInternals<T>> {\n}\nexport declare function bigint<T = unknown>(params?: string | core.$ZodBigIntParams): ZodCoercedBigInt<T>;\nexport interface ZodCoercedDate<T = unknown> extends schemas._ZodDate<core.$ZodDateInternals<T>> {\n}\nexport declare function date<T = unknown>(params?: string | core.$ZodDateParams): ZodCoercedDate<T>;\n"],"x_google_ignoreList":[0],"mappings":";;;;;AAKmGG,UAAlFK,gBAAkFL,CAAAA,IAAAA,OAAAA,CAAAA,SAA5CF,UAA4CE,CAAzBH,mBAAyBG,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA"}

package/conversation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"conversation.d.ts","names":[],"sources":["../../types/src/api/conversation.ts"],"sourcesContent":[],"mappings":";;;;;;;;cA8Ba,kCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAA,IAAA,SAAA,CAAA;QAAA,OAAA,EAAA,SAAA;QASjC,KAAA,EAAA,OAAA;QAIC,cAAA,EAAA,gBA2BV;;;;;;;;;;;;;;UA3BwC,gBAAA,EAAA,kBAAA;UAAA,cAAA,EAAA,gBAAA;UA6B/B,gBAAwB,EAAA,kBAC5B;UAGK,SAAA,EAAA,WAaV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAlDS,8BAAA,GAAiC,cACrC;cAGK,gCAA8B;;;;;;;;;;;;;;;;;KA6B/B,wBAAA,GAA2B,cAC/B;cAGK,iCAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAAA,QAAA,EAAA,UAAA;UAAA,UAAA,EAAA,YAAA;UAehC,qBAAyB,EAAA,uBAC7B;UAGK,kBAQV,EAAA,oBAAA;;;UARsC,gBAAA,EAAA,kBAAA;UAAA,SAAA,EAAA,WAAA;UAU7B,WAAsB,EAAA,aAC1B;UAGK,QAAA,EAAA,UAMV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAxBS,yBAAA,GAA4B,cAChC;cAGK,8BAA4B;;;KAU7B,sBAAA,GAAyB,cAC7B;cAGK,+BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAAA,UAAA,EAAA,YAAA;UAAA,qBAAA,EAAA,uBAAA;UAQ9B,kBAAuB,EAAA,oBAC3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KADI,uBAAA,GAA0B,cAC9B"}

package/core.d.ts

@@ -1,35 +0,0 @@
-import { Class } from "./util.js";
-import { SomeType } from "./schemas.js";
-
-//#region ../../node_modules/.bun/zod@4.2.1/node_modules/zod/v4/core/core.d.cts
-type ZodTrait = {
-  _zod: {
-    def: any;
-    [k: string]: any;
-  };
-};
-interface $constructor<T extends ZodTrait, D = T["_zod"]["def"]> {
-  new (def: D): T;
-  init(inst: T, def: D): asserts inst is T;
-}
-declare function $constructor<T extends ZodTrait, D = T["_zod"]["def"]>(name: string, initializer: (inst: T, def: D) => void, params?: {
-  Parent?: typeof Class;
-}): $constructor<T, D>;
-declare const $brand: unique symbol;
-type $brand<T extends string | number | symbol = string | number | symbol> = {
-  [$brand]: { [k in T]: true };
-};
-type $ZodBranded<T extends SomeType, Brand extends string | number | symbol> = T & Record<"_zod", Record<"output", output<T> & $brand<Brand>>>;
-type input<T> = T extends {
-  _zod: {
-    input: any;
-  };
-} ? T["_zod"]["input"] : unknown;
-type output<T> = T extends {
-  _zod: {
-    output: any;
-  };
-} ? T["_zod"]["output"] : unknown;
-//#endregion
-export { $ZodBranded, $constructor, input, output };
-//# sourceMappingURL=core.d.ts.map

package/core.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"core.d.ts","names":["errors","schemas","Class","ZodTrait","$constructor","T","D","NEVER","$brand","$ZodBranded","Brand","SomeType","output","Record","$ZodAsyncError","Error","$ZodEncodeError","input","infer","$ZodConfig","$ZodErrorMap","globalConfig","config","Partial"],"sources":["../../../node_modules/.bun/zod@4.2.1/node_modules/zod/v4/core/core.d.cts"],"sourcesContent":["import type * as errors from \"./errors.cjs\";\nimport type * as schemas from \"./schemas.cjs\";\nimport type { Class } from \"./util.cjs\";\ntype ZodTrait = {\n    _zod: {\n        def: any;\n        [k: string]: any;\n    };\n};\nexport interface $constructor<T extends ZodTrait, D = T[\"_zod\"][\"def\"]> {\n    new (def: D): T;\n    init(inst: T, def: D): asserts inst is T;\n}\n/** A special constant with type `never` */\nexport declare const NEVER: never;\nexport declare function $constructor<T extends ZodTrait, D = T[\"_zod\"][\"def\"]>(name: string, initializer: (inst: T, def: D) => void, params?: {\n    Parent?: typeof Class;\n}): $constructor<T, D>;\nexport declare const $brand: unique symbol;\nexport type $brand<T extends string | number | symbol = string | number | symbol> = {\n    [$brand]: {\n        [k in T]: true;\n    };\n};\nexport type $ZodBranded<T extends schemas.SomeType, Brand extends string | number | symbol> = T & Record<\"_zod\", Record<\"output\", output<T> & $brand<Brand>>>;\nexport declare class $ZodAsyncError extends Error {\n    constructor();\n}\nexport declare class $ZodEncodeError extends Error {\n    constructor(name: string);\n}\nexport type input<T> = T extends {\n    _zod: {\n        input: any;\n    };\n} ? T[\"_zod\"][\"input\"] : unknown;\nexport type output<T> = T extends {\n    _zod: {\n        output: any;\n    };\n} ? T[\"_zod\"][\"output\"] : unknown;\nexport type { output as infer };\nexport interface $ZodConfig {\n    /** Custom error map. Overrides `config().localeError`. */\n    customError?: errors.$ZodErrorMap | undefined;\n    /** Localized error map. Lowest priority. */\n    localeError?: errors.$ZodErrorMap | undefined;\n    /** Disable JIT schema compilation. Useful in environments that disallow `eval`. */\n    jitless?: boolean | undefined;\n}\nexport declare const globalConfig: $ZodConfig;\nexport declare function config(newConfig?: Partial<$ZodConfig>): $ZodConfig;\n"],"x_google_ignoreList":[0],"mappings":";;;;KAGKG,QAAAA;EAAAA,IAAAA,EAAAA;IAMYC,GAAAA,EAAAA,GAAAA;IAAuBD,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAAAA,GAAAA;EAAcE,CAAAA;CACxCC;AAAID,UADDD,YACCC,CAAAA,UADsBF,QACtBE,EAAAA,IADoCA,CACpCA,CAAAA,MAAAA,CAAAA,CAAAA,KAAAA,CAAAA,CAAAA,CAAAA;EACHA,KAAAA,GAAAA,EADDC,CACCD,CAAAA,EADGA,CACHA;EAAQC,IAAAA,CAAAA,IAAAA,EAARD,CAAQC,EAAAA,GAAAA,EAAAA,CAAAA,CAAAA,EAAAA,QAAAA,IAAAA,IAAoBD,CAApBC;;AAIwBH,iBAAvBC,YAAuBD,CAAAA,UAAAA,QAAAA,EAAAA,IAAcE,CAAdF,CAAAA,MAAAA,CAAAA,CAAAA,KAAAA,CAAAA,CAAAA,CAAAA,IAAAA,EAAAA,MAAAA,EAAAA,WAAAA,EAAAA,CAAAA,IAAAA,EAAkEE,CAAlEF,EAAAA,GAAAA,EAA0EG,CAA1EH,EAAAA,GAAAA,IAAAA,EAAAA,MAAkEE,CAAlEF,EAAAA;EAAcE,MAAAA,CAAAA,EAAAA,OACzCH,KADyCG;CAAoDA,CAAAA,EAE7GD,YAF6GC,CAEhGA,CAFgGA,EAE7FC,CAF6FD,CAAAA;AAAQC,cAGpGE,MAHoGF,EAAAA,OAAAA,MAAAA;AACrGJ,KAGRM,MAHQN,CAAAA,UAAAA,MAAAA,GAAAA,MAAAA,GAAAA,MAAAA,GAAAA,MAAAA,GAAAA,MAAAA,GAAAA,MAAAA,CAAAA,GAAAA;EACHG,CAGZG,MAAAA,CAHYH,EAAAA,QAIHA,CAJMC,GAAAA,IAAAA,EAAhBF;CAAY;AACKI,KAMTC,WAN8B,CAAA,UAMRR,QANQ,EAAA,cAAA,MAAA,GAAA,MAAA,GAAA,MAAA,CAAA,GAMoDI,CANpD,GAMwDQ,MANxD,CAAA,MAAA,EAMuEA,MANvE,CAAA,QAAA,EAMwFD,MANxF,CAM+FP,CAN/F,CAAA,GAMoGG,MANpG,CAM2GE,KAN3G,CAAA,CAAA,CAAA;AAM2GA,KAOzIO,KAPyIP,CAAAA,CAAAA,CAAAA,GAO9HL,CAP8HK,SAAAA;EAAPF,IAAAA,EAAAA;IAA7BK,KAAAA,EAAAA,GAAAA;EAAfA,CAAAA;CAAM,GAWpGR,CAXoG,CAAA,MAAA,CAAA,CAAA,OAAA,CAAA,GAAA,OAAA;AAO5FY,KAKAL,MALK,CAAA,CAAAP,CAAAA,GAKOA,CALPA,SAIZ;EACOO,IAAAA,EAAAA;;;IAIRP"}