@agimon-ai/po-web-components 0.0.0-alpha.0

package/dist/node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/checks.d.mts

@@ -0,0 +1,296 @@
+import { HasLength, HasSize, MaybeAsync, MimeTypes, Numeric, Widen, util_d_exports } from "./util.mjs";
+import { $ZodShape, $ZodStringFormatTypes, $ZodType, File, ParsePayload, schemas_d_exports } from "./schemas.mjs";
+import { $ZodErrorMap, $ZodIssue, $ZodIssueBase, $ZodIssueInvalidStringFormat, $ZodIssueInvalidType, $ZodIssueInvalidValue, $ZodIssueNotMultipleOf, $ZodIssueTooBig, $ZodIssueTooSmall, errors_d_exports } from "./errors.mjs";
+import { $constructor, core_d_exports, input } from "./core.mjs";
+declare namespace checks_d_exports {
+  export { $ZodBigIntFormats, $ZodCheck, $ZodCheckBigIntFormat, $ZodCheckBigIntFormatDef, $ZodCheckBigIntFormatInternals, $ZodCheckDef, $ZodCheckEndsWith, $ZodCheckEndsWithDef, $ZodCheckEndsWithInternals, $ZodCheckGreaterThan, $ZodCheckGreaterThanDef, $ZodCheckGreaterThanInternals, $ZodCheckIncludes, $ZodCheckIncludesDef, $ZodCheckIncludesInternals, $ZodCheckInternals, $ZodCheckLengthEquals, $ZodCheckLengthEqualsDef, $ZodCheckLengthEqualsInternals, $ZodCheckLessThan, $ZodCheckLessThanDef, $ZodCheckLessThanInternals, $ZodCheckLowerCase, $ZodCheckLowerCaseDef, $ZodCheckLowerCaseInternals, $ZodCheckMaxLength, $ZodCheckMaxLengthDef, $ZodCheckMaxLengthInternals, $ZodCheckMaxSize, $ZodCheckMaxSizeDef, $ZodCheckMaxSizeInternals, $ZodCheckMimeType, $ZodCheckMimeTypeDef, $ZodCheckMimeTypeInternals, $ZodCheckMinLength, $ZodCheckMinLengthDef, $ZodCheckMinLengthInternals, $ZodCheckMinSize, $ZodCheckMinSizeDef, $ZodCheckMinSizeInternals, $ZodCheckMultipleOf, $ZodCheckMultipleOfDef, $ZodCheckMultipleOfInternals, $ZodCheckNumberFormat, $ZodCheckNumberFormatDef, $ZodCheckNumberFormatInternals, $ZodCheckOverwrite, $ZodCheckOverwriteDef, $ZodCheckOverwriteInternals, $ZodCheckProperties, $ZodCheckPropertiesDef, $ZodCheckPropertiesInput, $ZodCheckPropertiesInternals, $ZodCheckProperty, $ZodCheckPropertyDef, $ZodCheckPropertyInternals, $ZodCheckRegex, $ZodCheckRegexDef, $ZodCheckRegexInternals, $ZodCheckSizeEquals, $ZodCheckSizeEqualsDef, $ZodCheckSizeEqualsInternals, $ZodCheckStartsWith, $ZodCheckStartsWithDef, $ZodCheckStartsWithInternals, $ZodCheckStringFormat, $ZodCheckStringFormatDef, $ZodCheckStringFormatInternals, $ZodCheckUpperCase, $ZodCheckUpperCaseDef, $ZodCheckUpperCaseInternals, $ZodChecks, $ZodNumberFormats, $ZodStringFormatChecks, $ZodStringFormats };
+}
+export 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, the check runs only when this returns `true`. By default, it is skipped if prior parsing produced aborting issues. */
+  when?: ((payload: ParsePayload) => boolean) | undefined;
+}
+export 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)[];
+}
+export interface $ZodCheck<in T = never> {
+  _zod: $ZodCheckInternals<T>;
+}
+export declare const $ZodCheck: $constructor<$ZodCheck<any>>;
+export interface $ZodCheckLessThanDef extends $ZodCheckDef {
+  check: "less_than";
+  value: Numeric;
+  inclusive: boolean;
+}
+export interface $ZodCheckLessThanInternals<T extends Numeric = Numeric> extends $ZodCheckInternals<T> {
+  def: $ZodCheckLessThanDef;
+  issc: $ZodIssueTooBig<T>;
+}
+export interface $ZodCheckLessThan<T extends Numeric = Numeric> extends $ZodCheck<T> {
+  _zod: $ZodCheckLessThanInternals<T>;
+}
+export declare const $ZodCheckLessThan: $constructor<$ZodCheckLessThan>;
+export interface $ZodCheckGreaterThanDef extends $ZodCheckDef {
+  check: "greater_than";
+  value: Numeric;
+  inclusive: boolean;
+}
+export interface $ZodCheckGreaterThanInternals<T extends Numeric = Numeric> extends $ZodCheckInternals<T> {
+  def: $ZodCheckGreaterThanDef;
+  issc: $ZodIssueTooSmall<T>;
+}
+export interface $ZodCheckGreaterThan<T extends Numeric = Numeric> extends $ZodCheck<T> {
+  _zod: $ZodCheckGreaterThanInternals<T>;
+}
+export declare const $ZodCheckGreaterThan: $constructor<$ZodCheckGreaterThan>;
+export interface $ZodCheckMultipleOfDef<T extends number | bigint = number | bigint> extends $ZodCheckDef {
+  check: "multiple_of";
+  value: T;
+}
+export interface $ZodCheckMultipleOfInternals<T extends number | bigint = number | bigint> extends $ZodCheckInternals<T> {
+  def: $ZodCheckMultipleOfDef<T>;
+  issc: $ZodIssueNotMultipleOf;
+}
+export interface $ZodCheckMultipleOf<T extends number | bigint = number | bigint> extends $ZodCheck<T> {
+  _zod: $ZodCheckMultipleOfInternals<T>;
+}
+export declare const $ZodCheckMultipleOf: $constructor<$ZodCheckMultipleOf<number | bigint>>;
+export type $ZodNumberFormats = "int32" | "uint32" | "float32" | "float64" | "safeint";
+export interface $ZodCheckNumberFormatDef<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodCheckDef {
+  check: "number_format";
+  format: Format;
+}
+export interface $ZodCheckNumberFormatInternals<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodCheckInternals<number> {
+  def: $ZodCheckNumberFormatDef<Format>;
+  issc: $ZodIssueInvalidType | $ZodIssueTooBig<"number"> | $ZodIssueTooSmall<"number">;
+}
+export interface $ZodCheckNumberFormat<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodCheck<number> {
+  _zod: $ZodCheckNumberFormatInternals<Format>;
+}
+export declare const $ZodCheckNumberFormat: $constructor<$ZodCheckNumberFormat>;
+export type $ZodBigIntFormats = "int64" | "uint64";
+export interface $ZodCheckBigIntFormatDef<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends $ZodCheckDef {
+  check: "bigint_format";
+  format: Format;
+}
+export interface $ZodCheckBigIntFormatInternals<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends $ZodCheckInternals<bigint> {
+  def: $ZodCheckBigIntFormatDef<Format>;
+  issc: $ZodIssueTooBig<"bigint"> | $ZodIssueTooSmall<"bigint">;
+}
+export interface $ZodCheckBigIntFormat<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends $ZodCheck<bigint> {
+  _zod: $ZodCheckBigIntFormatInternals<Format>;
+}
+export declare const $ZodCheckBigIntFormat: $constructor<$ZodCheckBigIntFormat>;
+export interface $ZodCheckMaxSizeDef extends $ZodCheckDef {
+  check: "max_size";
+  maximum: number;
+}
+export interface $ZodCheckMaxSizeInternals<T extends HasSize = HasSize> extends $ZodCheckInternals<T> {
+  def: $ZodCheckMaxSizeDef;
+  issc: $ZodIssueTooBig<T>;
+}
+export interface $ZodCheckMaxSize<T extends HasSize = HasSize> extends $ZodCheck<T> {
+  _zod: $ZodCheckMaxSizeInternals<T>;
+}
+export declare const $ZodCheckMaxSize: $constructor<$ZodCheckMaxSize>;
+export interface $ZodCheckMinSizeDef extends $ZodCheckDef {
+  check: "min_size";
+  minimum: number;
+}
+export interface $ZodCheckMinSizeInternals<T extends HasSize = HasSize> extends $ZodCheckInternals<T> {
+  def: $ZodCheckMinSizeDef;
+  issc: $ZodIssueTooSmall<T>;
+}
+export interface $ZodCheckMinSize<T extends HasSize = HasSize> extends $ZodCheck<T> {
+  _zod: $ZodCheckMinSizeInternals<T>;
+}
+export declare const $ZodCheckMinSize: $constructor<$ZodCheckMinSize>;
+export interface $ZodCheckSizeEqualsDef extends $ZodCheckDef {
+  check: "size_equals";
+  size: number;
+}
+export interface $ZodCheckSizeEqualsInternals<T extends HasSize = HasSize> extends $ZodCheckInternals<T> {
+  def: $ZodCheckSizeEqualsDef;
+  issc: $ZodIssueTooBig<T> | $ZodIssueTooSmall<T>;
+}
+export interface $ZodCheckSizeEquals<T extends HasSize = HasSize> extends $ZodCheck<T> {
+  _zod: $ZodCheckSizeEqualsInternals<T>;
+}
+export declare const $ZodCheckSizeEquals: $constructor<$ZodCheckSizeEquals>;
+export interface $ZodCheckMaxLengthDef extends $ZodCheckDef {
+  check: "max_length";
+  maximum: number;
+}
+export interface $ZodCheckMaxLengthInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+  def: $ZodCheckMaxLengthDef;
+  issc: $ZodIssueTooBig<T>;
+}
+export interface $ZodCheckMaxLength<T extends HasLength = HasLength> extends $ZodCheck<T> {
+  _zod: $ZodCheckMaxLengthInternals<T>;
+}
+export declare const $ZodCheckMaxLength: $constructor<$ZodCheckMaxLength>;
+export interface $ZodCheckMinLengthDef extends $ZodCheckDef {
+  check: "min_length";
+  minimum: number;
+}
+export interface $ZodCheckMinLengthInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+  def: $ZodCheckMinLengthDef;
+  issc: $ZodIssueTooSmall<T>;
+}
+export interface $ZodCheckMinLength<T extends HasLength = HasLength> extends $ZodCheck<T> {
+  _zod: $ZodCheckMinLengthInternals<T>;
+}
+export declare const $ZodCheckMinLength: $constructor<$ZodCheckMinLength>;
+export interface $ZodCheckLengthEqualsDef extends $ZodCheckDef {
+  check: "length_equals";
+  length: number;
+}
+export interface $ZodCheckLengthEqualsInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+  def: $ZodCheckLengthEqualsDef;
+  issc: $ZodIssueTooBig<T> | $ZodIssueTooSmall<T>;
+}
+export interface $ZodCheckLengthEquals<T extends HasLength = HasLength> extends $ZodCheck<T> {
+  _zod: $ZodCheckLengthEqualsInternals<T>;
+}
+export declare const $ZodCheckLengthEquals: $constructor<$ZodCheckLengthEquals>;
+export 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" | "credit_card" | "iban" | "lowercase" | "uppercase" | "regex" | "jwt" | "starts_with" | "ends_with" | "includes";
+export interface $ZodCheckStringFormatDef<Format extends string = string> extends $ZodCheckDef {
+  check: "string_format";
+  format: Format;
+  pattern?: RegExp | undefined;
+}
+export interface $ZodCheckStringFormatInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckStringFormatDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+export interface $ZodCheckStringFormat extends $ZodCheck<string> {
+  _zod: $ZodCheckStringFormatInternals;
+}
+export declare const $ZodCheckStringFormat: $constructor<$ZodCheckStringFormat>;
+export interface $ZodCheckRegexDef extends $ZodCheckStringFormatDef {
+  format: "regex";
+  pattern: RegExp;
+}
+export interface $ZodCheckRegexInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckRegexDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+export interface $ZodCheckRegex extends $ZodCheck<string> {
+  _zod: $ZodCheckRegexInternals;
+}
+export declare const $ZodCheckRegex: $constructor<$ZodCheckRegex>;
+export interface $ZodCheckLowerCaseDef extends $ZodCheckStringFormatDef<"lowercase"> {}
+export interface $ZodCheckLowerCaseInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckLowerCaseDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+export interface $ZodCheckLowerCase extends $ZodCheck<string> {
+  _zod: $ZodCheckLowerCaseInternals;
+}
+export declare const $ZodCheckLowerCase: $constructor<$ZodCheckLowerCase>;
+export interface $ZodCheckUpperCaseDef extends $ZodCheckStringFormatDef<"uppercase"> {}
+export interface $ZodCheckUpperCaseInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckUpperCaseDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+export interface $ZodCheckUpperCase extends $ZodCheck<string> {
+  _zod: $ZodCheckUpperCaseInternals;
+}
+export declare const $ZodCheckUpperCase: $constructor<$ZodCheckUpperCase>;
+export interface $ZodCheckIncludesDef extends $ZodCheckStringFormatDef<"includes"> {
+  includes: string;
+  position?: number | undefined;
+}
+export interface $ZodCheckIncludesInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckIncludesDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+export interface $ZodCheckIncludes extends $ZodCheck<string> {
+  _zod: $ZodCheckIncludesInternals;
+}
+export declare const $ZodCheckIncludes: $constructor<$ZodCheckIncludes>;
+export interface $ZodCheckStartsWithDef extends $ZodCheckStringFormatDef<"starts_with"> {
+  prefix: string;
+}
+export interface $ZodCheckStartsWithInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckStartsWithDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+export interface $ZodCheckStartsWith extends $ZodCheck<string> {
+  _zod: $ZodCheckStartsWithInternals;
+}
+export declare const $ZodCheckStartsWith: $constructor<$ZodCheckStartsWith>;
+export interface $ZodCheckEndsWithDef extends $ZodCheckStringFormatDef<"ends_with"> {
+  suffix: string;
+}
+export interface $ZodCheckEndsWithInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckEndsWithDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+export interface $ZodCheckEndsWith extends $ZodCheckInternals<string> {
+  _zod: $ZodCheckEndsWithInternals;
+}
+export declare const $ZodCheckEndsWith: $constructor<$ZodCheckEndsWith>;
+export interface $ZodCheckPropertyDef extends $ZodCheckDef {
+  check: "property";
+  property: string;
+  schema: $ZodType;
+}
+export interface $ZodCheckPropertyInternals<T extends object = object> extends $ZodCheckInternals<T> {
+  def: $ZodCheckPropertyDef;
+  issc: $ZodIssue;
+}
+export interface $ZodCheckProperty<T extends object = object> extends $ZodCheck<T> {
+  _zod: $ZodCheckPropertyInternals<T>;
+}
+export declare const $ZodCheckProperty: $constructor<$ZodCheckProperty>;
+export interface $ZodCheckPropertiesDef<Shape extends $ZodShape = $ZodShape> extends $ZodCheckDef {
+  check: "properties";
+  shape: Shape;
+}
+export type $ZodCheckPropertiesInput<Shape extends $ZodShape = $ZodShape> = { -readonly [k in keyof Shape]: Widen<input<Shape[k]>>; };
+export interface $ZodCheckPropertiesInternals<Shape extends $ZodShape = $ZodShape> extends $ZodCheckInternals<$ZodCheckPropertiesInput<Shape>> {
+  def: $ZodCheckPropertiesDef<Shape>;
+  issc: $ZodIssue;
+}
+export interface $ZodCheckProperties<Shape extends $ZodShape = $ZodShape> extends $ZodCheck<$ZodCheckPropertiesInput<Shape>> {
+  _zod: $ZodCheckPropertiesInternals<Shape>;
+  [Symbol.iterator](): Iterator<this>;
+}
+export declare const $ZodCheckProperties: $constructor<$ZodCheckProperties>;
+export interface $ZodCheckMimeTypeDef extends $ZodCheckDef {
+  check: "mime_type";
+  mime: MimeTypes[];
+}
+export interface $ZodCheckMimeTypeInternals<T extends File = File> extends $ZodCheckInternals<T> {
+  def: $ZodCheckMimeTypeDef;
+  issc: $ZodIssueInvalidValue;
+}
+export interface $ZodCheckMimeType<T extends File = File> extends $ZodCheck<T> {
+  _zod: $ZodCheckMimeTypeInternals<T>;
+}
+export declare const $ZodCheckMimeType: $constructor<$ZodCheckMimeType>;
+export interface $ZodCheckOverwriteDef<T = unknown> extends $ZodCheckDef {
+  check: "overwrite";
+  tx(value: T): T;
+}
+export interface $ZodCheckOverwriteInternals<T = unknown> extends $ZodCheckInternals<T> {
+  def: $ZodCheckOverwriteDef<T>;
+  issc: never;
+}
+export interface $ZodCheckOverwrite<T = unknown> extends $ZodCheck<T> {
+  _zod: $ZodCheckOverwriteInternals<T>;
+}
+export declare const $ZodCheckOverwrite: $constructor<$ZodCheckOverwrite>;
+export type $ZodChecks = $ZodCheckLessThan | $ZodCheckGreaterThan | $ZodCheckMultipleOf | $ZodCheckNumberFormat | $ZodCheckBigIntFormat | $ZodCheckMaxSize | $ZodCheckMinSize | $ZodCheckSizeEquals | $ZodCheckMaxLength | $ZodCheckMinLength | $ZodCheckLengthEquals | $ZodCheckStringFormat | $ZodCheckProperty | $ZodCheckMimeType | $ZodCheckOverwrite;
+export type $ZodStringFormatChecks = $ZodCheckRegex | $ZodCheckLowerCase | $ZodCheckUpperCase | $ZodCheckIncludes | $ZodCheckStartsWith | $ZodCheckEndsWith | $ZodStringFormatTypes;
+//#endregion
+export { checks_d_exports };
+//# sourceMappingURL=checks.d.mts.map

package/dist/node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/checks.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checks.d.mts","names":["errors","errors.$ZodErrorMap","schemas","schemas.ParsePayload","errors.$ZodIssueBase","util","util.MaybeAsync","schemas.$ZodType","core","core.$constructor","util.Numeric","errors.$ZodIssueTooBig","errors.$ZodIssueTooSmall","errors.$ZodIssueNotMultipleOf","errors.$ZodIssueInvalidType","util.HasSize","util.HasLength","errors.$ZodIssueInvalidStringFormat","errors.$ZodIssue","schemas.$ZodShape","core.input","util.Widen","util.MimeTypes","schemas.File","errors.$ZodIssueInvalidValue","schemas.$ZodStringFormatTypes"],"sources":["../../../../../../../../../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/checks.d.cts"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/compile.d.mts

@@ -0,0 +1,67 @@
+import { SomeType } from "./schemas.mjs";
+import { core_d_exports, infer as output } from "./core.mjs";
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/compile.d.cts
+/** @internal Sentinel the compiled fast path returns when validation fails. */
+export declare const INVALID: unique symbol;
+/** @internal */
+export type INVALID = typeof INVALID;
+interface CompileFnOptions {
+  debug?: boolean | undefined;
+  /** Emit a validator instead of a parser: skip building the output value where nothing reads it. */
+  assertOnly?: boolean | undefined;
+}
+type CompiledFn<T> = ((input: unknown) => T | INVALID) & {
+  code?: string | undefined;
+  /** False when this function's INVALID does not strictly mean "the runtime would reject". */
+  definite?: boolean | undefined;
+};
+/** Raised when the schema contains async refinements or transforms. Surfaces only under `compile(schema, { strict: true })`. */
+export declare class ZodCompileAsyncError extends Error {
+  constructor(message?: string);
+}
+/**
+ * Raised when the schema contains a feature whose semantics the fast path
+ * can't fully model. Both the shim in `zod/compile` and the default
+ * `compile()` fall back to the runtime parser for that schema; only
+ * `compile(schema, { strict: true })` lets it surface.
+ */
+export declare class ZodCompileUnsupportedError extends Error {
+  /** Whether a container may absorb this refusal by running the child through the runtime (see `compileChild`). False when running only that node on the runtime is not equivalent to running the whole parse there — a runtime island gets no parse context, so a node that *consumes* issues rather than propagating them would finalize them against the wrong error map and still succeed. */
+  readonly islandable: boolean;
+  constructor(feature: string, islandable?: boolean);
+}
+export interface CompileOptions {
+  /** Throw the refusal instead of returning the schema uncompiled. */
+  strict?: boolean | undefined;
+}
+/**
+ * AOT-compile a Zod schema. Returns a clone whose `_zod.run` calls a generated
+ * fast path first and falls back to the original runtime parser on failure.
+ *
+ * - Forward direction only. Backward (encode), async, and `skipChecks` paths
+ *   bypass the fast path and use the runtime directly.
+ * - Never throws. A schema the fast path can't model is returned unchanged and
+ *   keeps using the runtime parser. Pass `{ strict: true }` to get the refusal
+ *   as a thrown `ZodCompileUnsupportedError` / `ZodCompileAsyncError` instead.
+ * - The original schema is unchanged. The clone shares children by reference.
+ */
+export declare function compile<T extends SomeType>(schema: T, options?: CompileOptions): T;
+/**
+ * Install an already-generated parser as a schema's fast path. Returns a clone; the original is
+ * unchanged.
+ *
+ * The parser takes the input and returns the parsed value, or `INVALID` to hand the parse to the
+ * runtime. It must be synchronous and forward-direction, and it must build fresh output rather than
+ * return its input — Zod cannot check either, and a wrong *success* is returned to the caller as-is.
+ *
+ * `compile()` is the ordinary entry point. This is for a build-time or native compiler that produces
+ * a parser where `new Function` is unavailable.
+ */
+export declare function withParser<T extends SomeType>(schema: T, parser: (input: unknown) => output<T> | INVALID): T;
+/**
+ * @internal Generate the standalone compiled function: a parser by default, a validator under
+ * `assertOnly`. Returns the parsed value, `true` where nothing reads the output, or `INVALID`. Consumers use `compile()`.
+ */
+export declare function compileFn<T extends SomeType>(schema: T, options?: CompileFnOptions): CompiledFn<output<T>>;
+//#endregion
+//# sourceMappingURL=compile.d.mts.map

package/dist/node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/compile.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.mts","names":["core","core.output"],"sources":["../../../../../../../../../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/compile.d.cts"],"x_google_ignoreList":[0],"mappings":";;;;qBAGqB;;YAET,iBAAiB;UACnB;EACN;;EAEA;;KAEC,WAAW,OAAO,mBAAmB,IAAI;EAC1C;;EAEA;;;qBAGiB,6BAA6B;EAC9C,YAAY;;;;;;;;qBAQK,mCAAmC;;WAE3C;EACT,YAAY,iBAAiB;;iBAEhB;;EAEb;;;;;;;;;;;;;wBAaoB,QAAQ,UAAU,UAAU,QAAQ,GAAG,UAAU,iBAAiB;;;;;;;;;;;;wBAYlE,WAAW,UAAU,UAAU,QAAQ,GAAG,SAAS,mBAAmBC,OAAY,KAAK,UAAU;;;;;wBAKjG,UAAU,UAAU,UAAU,QAAQ,GAAG,UAAU,mBAAmB,WAAWA,OAAY"}

package/dist/node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/core.d.mts

@@ -0,0 +1,85 @@
+import { Class, ProtoOf } from "./util.mjs";
+import { $ZodMemoizer, SomeType, schemas_d_exports } from "./schemas.mjs";
+import { $ZodErrorMap, errors_d_exports } from "./errors.mjs";
+declare namespace core_d_exports {
+  export { $ZodAsyncError, $ZodBranded, $ZodConfig, $ZodEncodeError, $ZodNarrow, $brand, $constructor, $constructorParams, NEVER, config, globalConfig, output as infer, input, output };
+}
+type ZodTrait = {
+  _zod: {
+    def: any;
+    [k: string]: any;
+  };
+};
+export interface $constructor<T extends ZodTrait, D = T["_zod"]["def"]> {
+  new (def: D): T;
+  init(inst: T, def: D): asserts inst is T;
+}
+export interface $constructorParams {
+  Parent?: typeof Class;
+}
+/** A special constant with type `never` */
+export declare const NEVER: never;
+export declare function $constructor<T extends ZodTrait, D = T["_zod"]["def"]>(name: string, initializer: (inst: T, def: D) => void,
+/** This trait's members, installed once on every prototype that composes it. They cannot be declared in the initializer above: that runs per instance, and the prototype is shared. */
+proto?: ProtoOf<T>, params?: $constructorParams): $constructor<T, D>;
+export declare const $brand: unique symbol;
+export type $brand<T extends string | number | symbol = string | number | symbol> = {
+  [$brand]: { [k in T]: true; };
+};
+export type $ZodBranded<T extends SomeType, Brand extends string | number | symbol, Dir extends "in" | "out" | "inout" = "out"> = T & (Dir extends "inout" ? {
+  _zod: {
+    input: input<T> & $brand<Brand>;
+    output: output<T> & $brand<Brand>;
+  };
+} : Dir extends "in" ? {
+  _zod: {
+    input: input<T> & $brand<Brand>;
+  };
+} : {
+  _zod: {
+    output: output<T> & $brand<Brand>;
+  };
+});
+export type $ZodNarrow<T extends SomeType, Out> = T & {
+  _zod: {
+    output: Out;
+  };
+};
+export declare class $ZodAsyncError extends Error {
+  constructor();
+}
+export declare class $ZodEncodeError extends Error {
+  constructor(name: string);
+}
+export type input<T> = T extends {
+  _zod: {
+    input: any;
+  };
+} ? T["_zod"]["input"] : unknown;
+export type output<T> = T extends {
+  _zod: {
+    output: any;
+  };
+} ? T["_zod"]["output"] : unknown;
+export interface $ZodConfig {
+  /** Custom error map. Overrides `config().localeError`. */
+  customError?: $ZodErrorMap | undefined;
+  /** Localized error map. Lowest priority. */
+  localeError?: $ZodErrorMap | undefined;
+  /** Disable JIT schema compilation. Useful in environments that disallow `eval`. */
+  jitless?: boolean | undefined;
+  /** Enables parsing input that contains reference cycles. Read when a schema is constructed. */
+  memoizer?: $ZodMemoizer | undefined;
+  /**
+   * Internal: post-processor invoked on every freshly-constructed schema
+   * instance, after init and deferred fns run. Set by `import "zod/compile"`
+   * to install AOT compilation. Not part of the public API.
+   * @internal
+   */
+  postProcessor?: ((inst: any) => void) | undefined;
+}
+export declare const globalConfig: $ZodConfig;
+export declare function config(newConfig?: Partial<$ZodConfig>): $ZodConfig;
+//#endregion
+export { core_d_exports, type output as infer };
+//# sourceMappingURL=core.d.mts.map

package/dist/node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/core.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.mts","names":["schemas","schemas.SomeType","errors","errors.$ZodErrorMap","schemas.$ZodMemoizer"],"sources":["../../../../../../../../../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/core.d.cts"],"x_google_ignoreList":[0],"mappings":";;;;;;KAGK;EACD;IACI;KACC;;;iBAGQ,aAAa,UAAU,UAAU,IAAI;OAC7C,KAAK,IAAI;EACd,KAAK,MAAM,GAAG,KAAK,YAAY,QAAQ;;iBAE1B;EACb,gBAAgB;;;qBAGC;wBACG,aAAa,UAAU,UAAU,IAAI,kBAAkB,cAAc,cAAc,MAAM,GAAG,KAAK,YAEzH;;AAAA,QAAQ,QAAQ,IAAI,SAAS,qBAAqB,aAAa,GAAG;qBAC7C;YACT,OAAO;GACd,YACI,KAAK;;YAGF,YAAY,UAAUC,UAAkB,wCAAwC,8CAA8C,KAAK;EAC3I;IACI,OAAO,MAAM,KAAK,OAAO;IACzB,QAAQ,OAAO,KAAK,OAAO;;IAE/B;EACA;IACI,OAAO,MAAM,KAAK,OAAO;;;EAG7B;IACI,QAAQ,OAAO,KAAK,OAAO;;;YAGvB,WAAW,UAAUA,UAAkB,OAAO;EACtD;IACI,QAAQ;;;qBAGK,uBAAuB;EACxC;;qBAEiB,wBAAwB;EACzC,YAAY;;YAEJ,MAAM,KAAK;EACnB;IACI;;IAEJ;YACQ,OAAO,KAAK;EACpB;IACI;;IAEJ;iBAEa;;EAEb,cAAcE;;EAEd,cAAcA;;EAEd;;EAEA,WAAWC;;;;;;;EAOX,kBAAkB;;qBAED,cAAc;wBACX,OAAO,YAAY,QAAQ,cAAc"}

package/dist/node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/doc.d.mts

@@ -0,0 +1,18 @@
+//#region ../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/doc.d.cts
+type ModeWriter = (doc: Doc, modes: {
+  execution: "sync" | "async";
+}) => void;
+export declare class Doc {
+  args: string[];
+  /** Bindings the compiled function closes over, by name. */
+  closed: Record<string, unknown>;
+  content: string[];
+  indent: number;
+  constructor(args?: string[], closed?: Record<string, unknown>);
+  indented(fn: (doc: Doc) => void): void;
+  write(fn: ModeWriter): void;
+  write(line: string): void;
+  compile(): any;
+}
+//#endregion
+//# sourceMappingURL=doc.d.mts.map

package/dist/node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/doc.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doc.d.mts","names":[],"sources":["../../../../../../../../../../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/doc.d.cts"],"x_google_ignoreList":[0],"mappings":";KAAK,cAAc,KAAK,KAAK;EACzB;;qBAEiB;EACjB;;EAEA,QAAQ;EACR;EACA;EACA,YAAY,iBAAiB,SAAS;EACtC,SAAS,KAAK,KAAK;EACnB,MAAM,IAAI;EACV,MAAM;EACN"}