@plucky-ai/chat-sdk 0.6.0 → 0.7.0

package/dist/index.d.mts

@@ -0,0 +1,3873 @@
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/json-schema.d.cts
+type _JSONSchema$1 = boolean | JSONSchema$1;
+type JSONSchema$1 = {
+  [k: string]: unknown;
+  $schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#" | "http://json-schema.org/draft-04/schema#";
+  $id?: string;
+  $anchor?: string;
+  $ref?: string;
+  $dynamicRef?: string;
+  $dynamicAnchor?: string;
+  $vocabulary?: Record<string, boolean>;
+  $comment?: string;
+  $defs?: Record<string, JSONSchema$1>;
+  type?: "object" | "array" | "string" | "number" | "boolean" | "null" | "integer";
+  additionalItems?: _JSONSchema$1;
+  unevaluatedItems?: _JSONSchema$1;
+  prefixItems?: _JSONSchema$1[];
+  items?: _JSONSchema$1 | _JSONSchema$1[];
+  contains?: _JSONSchema$1;
+  additionalProperties?: _JSONSchema$1;
+  unevaluatedProperties?: _JSONSchema$1;
+  properties?: Record<string, _JSONSchema$1>;
+  patternProperties?: Record<string, _JSONSchema$1>;
+  dependentSchemas?: Record<string, _JSONSchema$1>;
+  propertyNames?: _JSONSchema$1;
+  if?: _JSONSchema$1;
+  then?: _JSONSchema$1;
+  else?: _JSONSchema$1;
+  allOf?: JSONSchema$1[];
+  anyOf?: JSONSchema$1[];
+  oneOf?: JSONSchema$1[];
+  not?: _JSONSchema$1;
+  multipleOf?: number;
+  maximum?: number;
+  exclusiveMaximum?: number | boolean;
+  minimum?: number;
+  exclusiveMinimum?: number | boolean;
+  maxLength?: number;
+  minLength?: number;
+  pattern?: string;
+  maxItems?: number;
+  minItems?: number;
+  uniqueItems?: boolean;
+  maxContains?: number;
+  minContains?: number;
+  maxProperties?: number;
+  minProperties?: number;
+  required?: string[];
+  dependentRequired?: Record<string, string[]>;
+  enum?: Array<string | number | boolean | null>;
+  const?: string | number | boolean | null;
+  id?: string;
+  title?: string;
+  description?: string;
+  default?: unknown;
+  deprecated?: boolean;
+  readOnly?: boolean;
+  writeOnly?: boolean;
+  nullable?: boolean;
+  examples?: unknown[];
+  format?: string;
+  contentMediaType?: string;
+  contentEncoding?: string;
+  contentSchema?: JSONSchema$1;
+  _prefault?: unknown;
+};
+type BaseSchema$1 = JSONSchema$1;
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/standard-schema.d.cts
+/** The Standard interface. */
+interface StandardTypedV1$1<Input = unknown, Output = Input> {
+  /** The Standard properties. */
+  readonly "~standard": StandardTypedV1$1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1$1 {
+  /** The Standard properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1$1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1$1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/** The Standard Schema interface. */
+interface StandardSchemaV1$1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1$1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1$1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1$1.Props<Input, Output> {
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown, options?: StandardSchemaV1$1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** The absence of issues indicates success. */
+    readonly issues?: undefined;
+  }
+  interface Options {
+    /** Implicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1$1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1$1> = StandardTypedV1$1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1$1> = StandardTypedV1$1.InferOutput<Schema>;
+}
+/** The Standard JSON Schema interface. */
+interface StandardJSONSchemaV1$1<Input = unknown, Output = Input> {
+  /** The Standard JSON Schema properties. */
+  readonly "~standard": StandardJSONSchemaV1$1.Props<Input, Output>;
+}
+declare namespace StandardJSONSchemaV1$1 {
+  /** The Standard JSON Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1$1.Props<Input, Output> {
+    /** Methods for generating the input/output JSON Schema. */
+    readonly jsonSchema: Converter;
+  }
+  /** The Standard JSON Schema converter interface. */
+  interface Converter {
+    /** Converts the input type to JSON Schema. May throw if conversion is not supported. */
+    readonly input: (options: StandardJSONSchemaV1$1.Options) => Record<string, unknown>;
+    /** Converts the output type to JSON Schema. May throw if conversion is not supported. */
+    readonly output: (options: StandardJSONSchemaV1$1.Options) => Record<string, unknown>;
+  }
+  /** The target version of the generated JSON Schema.
+   *
+   * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use.
+   *
+   * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
+   *
+   * All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
+   */
+  type Target = "draft-2020-12" | "draft-07" | "openapi-3.0" | ({} & string);
+  /** The options for the input/output methods. */
+  interface Options {
+    /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
+    readonly target: Target;
+    /** Implicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1$1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1$1> = StandardTypedV1$1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1$1> = StandardTypedV1$1.InferOutput<Schema>;
+}
+interface StandardSchemaWithJSONProps$1<Input = unknown, Output = Input> extends StandardSchemaV1$1.Props<Input, Output>, StandardJSONSchemaV1$1.Props<Input, Output> {}
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/registries.d.cts
+declare const $output$1: unique symbol;
+type $output$1 = typeof $output$1;
+declare const $input$1: unique symbol;
+type $input$1 = typeof $input$1;
+type $replace$1<Meta, S extends $ZodType$1> = Meta extends $output$1 ? output$1<S> : Meta extends $input$1 ? input$1<S> : Meta extends (infer M)[] ? $replace$1<M, S>[] : Meta extends ((...args: infer P) => infer R) ? (...args: { [K in keyof P]: $replace$1<P[K], S> }) => $replace$1<R, S> : Meta extends object ? { [K in keyof Meta]: $replace$1<Meta[K], S> } : Meta;
+type MetadataType$1 = object | undefined;
+declare class $ZodRegistry$1<Meta extends MetadataType$1 = MetadataType$1, Schema extends $ZodType$1 = $ZodType$1> {
+  _meta: Meta;
+  _schema: Schema;
+  _map: WeakMap<Schema, $replace$1<Meta, Schema>>;
+  _idmap: Map<string, Schema>;
+  add<S extends Schema>(schema: S, ..._meta: undefined extends Meta ? [$replace$1<Meta, S>?] : [$replace$1<Meta, S>]): this;
+  clear(): this;
+  remove(schema: Schema): this;
+  get<S extends Schema>(schema: S): $replace$1<Meta, S> | undefined;
+  has(schema: Schema): boolean;
+}
+interface JSONSchemaMeta$1 {
+  id?: string | undefined;
+  title?: string | undefined;
+  description?: string | undefined;
+  deprecated?: boolean | undefined;
+  [k: string]: unknown;
+}
+interface GlobalMeta$1 extends JSONSchemaMeta$1 {}
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/to-json-schema.d.cts
+type Processor$1<T extends $ZodType$1 = $ZodType$1> = (schema: T, ctx: ToJSONSchemaContext$1, json: BaseSchema$1, params: ProcessParams$1) => void;
+interface JSONSchemaGeneratorParams$1 {
+  processors: Record<string, Processor$1>;
+  /** A registry used to look up metadata for each schema. Any schema with an `id` property will be extracted as a $def.
+   *  @default globalRegistry */
+  metadata?: $ZodRegistry$1<Record<string, any>>;
+  /** The JSON Schema version to target.
+   * - `"draft-2020-12"` — Default. JSON Schema Draft 2020-12
+   * - `"draft-07"` — JSON Schema Draft 7
+   * - `"draft-04"` — JSON Schema Draft 4
+   * - `"openapi-3.0"` — OpenAPI 3.0 Schema Object */
+  target?: "draft-04" | "draft-07" | "draft-2020-12" | "openapi-3.0" | ({} & string) | undefined;
+  /** How to handle unrepresentable types.
+   * - `"throw"` — Default. Unrepresentable types throw an error
+   * - `"any"` — Unrepresentable types become `{}` */
+  unrepresentable?: "throw" | "any";
+  /** Arbitrary custom logic that can be used to modify the generated JSON Schema. */
+  override?: (ctx: {
+    zodSchema: $ZodTypes$1;
+    jsonSchema: BaseSchema$1;
+    path: (string | number)[];
+  }) => void;
+  /** Whether to extract the `"input"` or `"output"` type. Relevant to transforms, defaults, coerced primitives, etc.
+   * - `"output"` — Default. Convert the output schema.
+   * - `"input"` — Convert the input schema. */
+  io?: "input" | "output";
+  cycles?: "ref" | "throw";
+  reused?: "ref" | "inline";
+  external?: {
+    registry: $ZodRegistry$1<{
+      id?: string | undefined;
+    }>;
+    uri?: ((id: string) => string) | undefined;
+    defs: Record<string, BaseSchema$1>;
+  } | undefined;
+}
+/**
+ * Parameters for the toJSONSchema function.
+ */
+type ToJSONSchemaParams$1 = Omit<JSONSchemaGeneratorParams$1, "processors" | "external">;
+interface ProcessParams$1 {
+  schemaPath: $ZodType$1[];
+  path: (string | number)[];
+}
+interface Seen$1 {
+  /** JSON Schema result for this Zod schema */
+  schema: BaseSchema$1;
+  /** A cached version of the schema that doesn't get overwritten during ref resolution */
+  def?: BaseSchema$1;
+  defId?: string | undefined;
+  /** Number of times this schema was encountered during traversal */
+  count: number;
+  /** Cycle path */
+  cycle?: (string | number)[] | undefined;
+  isParent?: boolean | undefined;
+  /** Schema to inherit JSON Schema properties from (set by processor for wrappers) */
+  ref?: $ZodType$1 | null;
+  /** JSON Schema property path for this schema */
+  path?: (string | number)[] | undefined;
+}
+interface ToJSONSchemaContext$1 {
+  processors: Record<string, Processor$1>;
+  metadataRegistry: $ZodRegistry$1<Record<string, any>>;
+  target: "draft-04" | "draft-07" | "draft-2020-12" | "openapi-3.0" | ({} & string);
+  unrepresentable: "throw" | "any";
+  override: (ctx: {
+    zodSchema: $ZodType$1;
+    jsonSchema: BaseSchema$1;
+    path: (string | number)[];
+  }) => void;
+  io: "input" | "output";
+  counter: number;
+  seen: Map<$ZodType$1, Seen$1>;
+  cycles: "ref" | "throw";
+  reused: "ref" | "inline";
+  external?: {
+    registry: $ZodRegistry$1<{
+      id?: string | undefined;
+    }>;
+    uri?: ((id: string) => string) | undefined;
+    defs: Record<string, BaseSchema$1>;
+  } | undefined;
+}
+type ZodStandardSchemaWithJSON$3<T> = StandardSchemaWithJSONProps$1<input$1<T>, output$1<T>>;
+interface ZodStandardJSONSchemaPayload$1<T> extends BaseSchema$1 {
+  "~standard": ZodStandardSchemaWithJSON$3<T>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/util.d.cts
+type MimeTypes$1 = "application/json" | "application/xml" | "application/x-www-form-urlencoded" | "application/javascript" | "application/pdf" | "application/zip" | "application/vnd.ms-excel" | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "application/msword" | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/vnd.ms-powerpoint" | "application/vnd.openxmlformats-officedocument.presentationml.presentation" | "application/octet-stream" | "application/graphql" | "text/html" | "text/plain" | "text/css" | "text/javascript" | "text/csv" | "image/png" | "image/jpeg" | "image/gif" | "image/svg+xml" | "image/webp" | "audio/mpeg" | "audio/ogg" | "audio/wav" | "audio/webm" | "video/mp4" | "video/webm" | "video/ogg" | "font/woff" | "font/woff2" | "font/ttf" | "font/otf" | "multipart/form-data" | (string & {});
+type IsAny$1<T> = 0 extends 1 & T ? true : false;
+type Omit$2<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+type MakePartial$1<T, K extends keyof T> = Omit$2<T, K> & InexactPartial$1<Pick<T, K>>;
+type NoUndefined$1<T> = T extends undefined ? never : T;
+type LoosePartial$1<T extends object> = InexactPartial$1<T> & {
+  [k: string]: unknown;
+};
+type Mask$1<Keys extends PropertyKey> = { [K in Keys]?: true };
+type InexactPartial$1<T> = { [P in keyof T]?: T[P] | undefined };
+type BuiltIn$1 = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
+  readonly [Symbol.toStringTag]: string;
+} | Date | Error | Generator | Promise<unknown> | RegExp;
+type MakeReadonly$1<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn$1 ? T : Readonly<T>;
+type SomeObject$1 = Record<PropertyKey, any>;
+type Identity$1<T> = T;
+type Flatten$1<T> = Identity$1<{ [k in keyof T]: T[k] }>;
+type Prettify$1<T> = { [K in keyof T]: T[K] } & {};
+type Extend$1<A extends SomeObject$1, B extends SomeObject$1> = Flatten$1<keyof A & keyof B extends never ? A & B : { [K in keyof A as K extends keyof B ? never : K]: A[K] } & { [K in keyof B]: B[K] }>;
+type TupleItems$1 = ReadonlyArray<SomeType$1>;
+type AnyFunc$1 = (...args: any[]) => any;
+type MaybeAsync$1<T> = T | Promise<T>;
+type EnumValue$1 = string | number;
+type EnumLike$1 = Readonly<Record<string, EnumValue$1>>;
+type ToEnum$1<T extends EnumValue$1> = Flatten$1<{ [k in T]: k }>;
+type Literal$1 = string | number | bigint | boolean | null | undefined;
+type Primitive$1 = string | number | symbol | bigint | boolean | null | undefined;
+type HasLength$1 = {
+  length: number;
+};
+type PropValues$1 = Record<string, Set<Primitive$1>>;
+type PrimitiveSet$1 = Set<Primitive$1>;
+type EmptyToNever$1<T> = keyof T extends never ? never : T;
+declare abstract class Class$1 {
+  constructor(..._args: any[]);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/versions.d.cts
+declare const version$1: {
+  readonly major: 4;
+  readonly minor: 3;
+  readonly patch: number;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/schemas.d.cts
+interface ParseContext$1<T extends $ZodIssueBase$1 = never> {
+  /** Customize error messages. */
+  readonly error?: $ZodErrorMap$1<T>;
+  /** Include the `input` field in issue objects. Default `false`. */
+  readonly reportInput?: boolean;
+  /** Skip eval-based fast path. Default `false`. */
+  readonly jitless?: boolean;
+}
+/** @internal */
+interface ParseContextInternal$1<T extends $ZodIssueBase$1 = never> extends ParseContext$1<T> {
+  readonly async?: boolean | undefined;
+  readonly direction?: "forward" | "backward";
+  readonly skipChecks?: boolean;
+}
+interface ParsePayload$1<T = unknown> {
+  value: T;
+  issues: $ZodRawIssue$1[];
+  /** A may to mark a whole payload as aborted. Used in codecs/pipes. */
+  aborted?: boolean;
+}
+type CheckFn$1<T> = (input: ParsePayload$1<T>) => MaybeAsync$1<void>;
+interface $ZodTypeDef$1 {
+  type: "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "null" | "undefined" | "void" | "never" | "any" | "unknown" | "date" | "object" | "record" | "file" | "array" | "tuple" | "union" | "intersection" | "map" | "set" | "enum" | "literal" | "nullable" | "optional" | "nonoptional" | "success" | "transform" | "default" | "prefault" | "catch" | "nan" | "pipe" | "readonly" | "template_literal" | "promise" | "lazy" | "function" | "custom";
+  error?: $ZodErrorMap$1<never> | undefined;
+  checks?: $ZodCheck$1<never>[];
+}
+interface _$ZodTypeInternals$1 {
+  /** The `@zod/core` version of this schema */
+  version: typeof version$1;
+  /** Schema definition. */
+  def: $ZodTypeDef$1;
+  /** @internal Randomly generated ID for this schema. */
+  /** @internal List of deferred initializers. */
+  deferred: AnyFunc$1[] | undefined;
+  /** @internal Parses input and runs all checks (refinements). */
+  run(payload: ParsePayload$1<any>, ctx: ParseContextInternal$1): MaybeAsync$1<ParsePayload$1>;
+  /** @internal Parses input, doesn't run checks. */
+  parse(payload: ParsePayload$1<any>, ctx: ParseContextInternal$1): MaybeAsync$1<ParsePayload$1>;
+  /** @internal  Stores identifiers for the set of traits implemented by this schema. */
+  traits: Set<string>;
+  /** @internal Indicates that a schema output type should be considered optional inside objects.
+   * @default Required
+   */
+  /** @internal */
+  optin?: "optional" | undefined;
+  /** @internal */
+  optout?: "optional" | undefined;
+  /** @internal The set of literal values that will pass validation. Must be an exhaustive set. Used to determine optionality in z.record().
+   *
+   * Defined on: enum, const, literal, null, undefined
+   * Passthrough: optional, nullable, branded, default, catch, pipe
+   * Todo: unions?
+   */
+  values?: PrimitiveSet$1 | undefined;
+  /** Default value bubbled up from  */
+  /** @internal A set of literal discriminators used for the fast path in discriminated unions. */
+  propValues?: PropValues$1 | undefined;
+  /** @internal This flag indicates that a schema validation can be represented with a regular expression. Used to determine allowable schemas in z.templateLiteral(). */
+  pattern: RegExp | undefined;
+  /** @internal The constructor function of this schema. */
+  constr: new (def: any) => $ZodType$1;
+  /** @internal A catchall object for bag metadata related to this schema. Commonly modified by checks using `onattach`. */
+  bag: Record<string, unknown>;
+  /** @internal The set of issues this schema might throw during type checking. */
+  isst: $ZodIssueBase$1;
+  /** @internal Subject to change, not a public API. */
+  processJSONSchema?: ((ctx: ToJSONSchemaContext$1, json: BaseSchema$1, params: ProcessParams$1) => void) | undefined;
+  /** An optional method used to override `toJSONSchema` logic. */
+  toJSONSchema?: () => unknown;
+  /** @internal The parent of this schema. Only set during certain clone operations. */
+  parent?: $ZodType$1 | undefined;
+}
+/** @internal */
+interface $ZodTypeInternals$1<out O = unknown, out I = unknown> extends _$ZodTypeInternals$1 {
+  /** @internal The inferred output type */
+  output: O;
+  /** @internal The inferred input type */
+  input: I;
+}
+type $ZodStandardSchema$1<T> = StandardSchemaV1$1.Props<input$1<T>, output$1<T>>;
+type SomeType$1 = {
+  _zod: _$ZodTypeInternals$1;
+};
+interface $ZodType$1<O = unknown, I = unknown, Internals extends $ZodTypeInternals$1<O, I> = $ZodTypeInternals$1<O, I>> {
+  _zod: Internals;
+  "~standard": $ZodStandardSchema$1<this>;
+}
+interface _$ZodType$1<T extends $ZodTypeInternals$1 = $ZodTypeInternals$1> extends $ZodType$1<T["output"], T["input"], T> {}
+declare const $ZodType$1: $constructor$1<$ZodType$1>;
+interface $ZodStringDef$1 extends $ZodTypeDef$1 {
+  type: "string";
+  coerce?: boolean;
+  checks?: $ZodCheck$1<string>[];
+}
+interface $ZodStringInternals$1<Input> extends $ZodTypeInternals$1<string, Input> {
+  def: $ZodStringDef$1;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  pattern: RegExp;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  isst: $ZodIssueInvalidType$1;
+  bag: LoosePartial$1<{
+    minimum: number;
+    maximum: number;
+    patterns: Set<RegExp>;
+    format: string;
+    contentEncoding: string;
+  }>;
+}
+interface $ZodString$1<Input = unknown> extends _$ZodType$1<$ZodStringInternals$1<Input>> {}
+declare const $ZodString$1: $constructor$1<$ZodString$1>;
+interface $ZodNumberDef$1 extends $ZodTypeDef$1 {
+  type: "number";
+  coerce?: boolean;
+}
+interface $ZodNumberInternals$1<Input = unknown> extends $ZodTypeInternals$1<number, Input> {
+  def: $ZodNumberDef$1;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  pattern: RegExp;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  isst: $ZodIssueInvalidType$1;
+  bag: LoosePartial$1<{
+    minimum: number;
+    maximum: number;
+    exclusiveMinimum: number;
+    exclusiveMaximum: number;
+    format: string;
+    pattern: RegExp;
+  }>;
+}
+interface $ZodNumber$1<Input = unknown> extends $ZodType$1 {
+  _zod: $ZodNumberInternals$1<Input>;
+}
+declare const $ZodNumber$1: $constructor$1<$ZodNumber$1>;
+interface $ZodBooleanDef$1 extends $ZodTypeDef$1 {
+  type: "boolean";
+  coerce?: boolean;
+  checks?: $ZodCheck$1<boolean>[];
+}
+interface $ZodBooleanInternals$1<T = unknown> extends $ZodTypeInternals$1<boolean, T> {
+  pattern: RegExp;
+  def: $ZodBooleanDef$1;
+  isst: $ZodIssueInvalidType$1;
+}
+interface $ZodBoolean$1<T = unknown> extends $ZodType$1 {
+  _zod: $ZodBooleanInternals$1<T>;
+}
+declare const $ZodBoolean$1: $constructor$1<$ZodBoolean$1>;
+interface $ZodBigIntDef$1 extends $ZodTypeDef$1 {
+  type: "bigint";
+  coerce?: boolean;
+}
+interface $ZodBigIntInternals$1<T = unknown> extends $ZodTypeInternals$1<bigint, T> {
+  pattern: RegExp;
+  /** @internal Internal API, use with caution */
+  def: $ZodBigIntDef$1;
+  isst: $ZodIssueInvalidType$1;
+  bag: LoosePartial$1<{
+    minimum: bigint;
+    maximum: bigint;
+    format: string;
+  }>;
+}
+interface $ZodBigInt$1<T = unknown> extends $ZodType$1 {
+  _zod: $ZodBigIntInternals$1<T>;
+}
+declare const $ZodBigInt$1: $constructor$1<$ZodBigInt$1>;
+interface $ZodSymbolDef$1 extends $ZodTypeDef$1 {
+  type: "symbol";
+}
+interface $ZodSymbolInternals$1 extends $ZodTypeInternals$1<symbol, symbol> {
+  def: $ZodSymbolDef$1;
+  isst: $ZodIssueInvalidType$1;
+}
+interface $ZodSymbol$1 extends $ZodType$1 {
+  _zod: $ZodSymbolInternals$1;
+}
+declare const $ZodSymbol$1: $constructor$1<$ZodSymbol$1>;
+interface $ZodUndefinedDef$1 extends $ZodTypeDef$1 {
+  type: "undefined";
+}
+interface $ZodUndefinedInternals$1 extends $ZodTypeInternals$1<undefined, undefined> {
+  pattern: RegExp;
+  def: $ZodUndefinedDef$1;
+  values: PrimitiveSet$1;
+  isst: $ZodIssueInvalidType$1;
+}
+interface $ZodUndefined$1 extends $ZodType$1 {
+  _zod: $ZodUndefinedInternals$1;
+}
+declare const $ZodUndefined$1: $constructor$1<$ZodUndefined$1>;
+interface $ZodNullDef$1 extends $ZodTypeDef$1 {
+  type: "null";
+}
+interface $ZodNullInternals$1 extends $ZodTypeInternals$1<null, null> {
+  pattern: RegExp;
+  def: $ZodNullDef$1;
+  values: PrimitiveSet$1;
+  isst: $ZodIssueInvalidType$1;
+}
+interface $ZodNull$1 extends $ZodType$1 {
+  _zod: $ZodNullInternals$1;
+}
+declare const $ZodNull$1: $constructor$1<$ZodNull$1>;
+interface $ZodAnyDef$1 extends $ZodTypeDef$1 {
+  type: "any";
+}
+interface $ZodAnyInternals$1 extends $ZodTypeInternals$1<any, any> {
+  def: $ZodAnyDef$1;
+  isst: never;
+}
+interface $ZodAny$1 extends $ZodType$1 {
+  _zod: $ZodAnyInternals$1;
+}
+declare const $ZodAny$1: $constructor$1<$ZodAny$1>;
+interface $ZodUnknownDef$1 extends $ZodTypeDef$1 {
+  type: "unknown";
+}
+interface $ZodUnknownInternals$1 extends $ZodTypeInternals$1<unknown, unknown> {
+  def: $ZodUnknownDef$1;
+  isst: never;
+}
+interface $ZodUnknown$1 extends $ZodType$1 {
+  _zod: $ZodUnknownInternals$1;
+}
+declare const $ZodUnknown$1: $constructor$1<$ZodUnknown$1>;
+interface $ZodNeverDef$1 extends $ZodTypeDef$1 {
+  type: "never";
+}
+interface $ZodNeverInternals$1 extends $ZodTypeInternals$1<never, never> {
+  def: $ZodNeverDef$1;
+  isst: $ZodIssueInvalidType$1;
+}
+interface $ZodNever$1 extends $ZodType$1 {
+  _zod: $ZodNeverInternals$1;
+}
+declare const $ZodNever$1: $constructor$1<$ZodNever$1>;
+interface $ZodVoidDef$1 extends $ZodTypeDef$1 {
+  type: "void";
+}
+interface $ZodVoidInternals$1 extends $ZodTypeInternals$1<void, void> {
+  def: $ZodVoidDef$1;
+  isst: $ZodIssueInvalidType$1;
+}
+interface $ZodVoid$1 extends $ZodType$1 {
+  _zod: $ZodVoidInternals$1;
+}
+declare const $ZodVoid$1: $constructor$1<$ZodVoid$1>;
+interface $ZodDateDef$1 extends $ZodTypeDef$1 {
+  type: "date";
+  coerce?: boolean;
+}
+interface $ZodDateInternals$1<T = unknown> extends $ZodTypeInternals$1<Date, T> {
+  def: $ZodDateDef$1;
+  isst: $ZodIssueInvalidType$1;
+  bag: LoosePartial$1<{
+    minimum: Date;
+    maximum: Date;
+    format: string;
+  }>;
+}
+interface $ZodDate$1<T = unknown> extends $ZodType$1 {
+  _zod: $ZodDateInternals$1<T>;
+}
+declare const $ZodDate$1: $constructor$1<$ZodDate$1>;
+interface $ZodArrayDef$1<T extends SomeType$1 = $ZodType$1> extends $ZodTypeDef$1 {
+  type: "array";
+  element: T;
+}
+interface $ZodArrayInternals$1<T extends SomeType$1 = $ZodType$1> extends _$ZodTypeInternals$1 {
+  def: $ZodArrayDef$1<T>;
+  isst: $ZodIssueInvalidType$1;
+  output: output$1<T>[];
+  input: input$1<T>[];
+}
+interface $ZodArray$1<T extends SomeType$1 = $ZodType$1> extends $ZodType$1<any, any, $ZodArrayInternals$1<T>> {}
+declare const $ZodArray$1: $constructor$1<$ZodArray$1>;
+type OptionalOutSchema$1 = {
+  _zod: {
+    optout: "optional";
+  };
+};
+type OptionalInSchema$1 = {
+  _zod: {
+    optin: "optional";
+  };
+};
+type $InferObjectOutput$1<T extends $ZodLooseShape$1, Extra extends Record<string, unknown>> = string extends keyof T ? IsAny$1<T[keyof T]> extends true ? Record<string, unknown> : Record<string, output$1<T[keyof T]>> : keyof (T & Extra) extends never ? Record<string, never> : Prettify$1<{ -readonly [k in keyof T as T[k] extends OptionalOutSchema$1 ? never : k]: T[k]["_zod"]["output"] } & { -readonly [k in keyof T as T[k] extends OptionalOutSchema$1 ? k : never]?: T[k]["_zod"]["output"] } & Extra>;
+type $InferObjectInput$1<T extends $ZodLooseShape$1, Extra extends Record<string, unknown>> = string extends keyof T ? IsAny$1<T[keyof T]> extends true ? Record<string, unknown> : Record<string, input$1<T[keyof T]>> : keyof (T & Extra) extends never ? Record<string, never> : Prettify$1<{ -readonly [k in keyof T as T[k] extends OptionalInSchema$1 ? never : k]: T[k]["_zod"]["input"] } & { -readonly [k in keyof T as T[k] extends OptionalInSchema$1 ? k : never]?: T[k]["_zod"]["input"] } & Extra>;
+type $ZodObjectConfig$1 = {
+  out: Record<string, unknown>;
+  in: Record<string, unknown>;
+};
+type $loose$1 = {
+  out: Record<string, unknown>;
+  in: Record<string, unknown>;
+};
+type $strict$1 = {
+  out: {};
+  in: {};
+};
+type $strip$1 = {
+  out: {};
+  in: {};
+};
+type $catchall$1<T extends SomeType$1> = {
+  out: {
+    [k: string]: output$1<T>;
+  };
+  in: {
+    [k: string]: input$1<T>;
+  };
+};
+type $ZodShape$1 = Readonly<{
+  [k: string]: $ZodType$1;
+}>;
+interface $ZodObjectDef$1<Shape extends $ZodShape$1 = $ZodShape$1> extends $ZodTypeDef$1 {
+  type: "object";
+  shape: Shape;
+  catchall?: $ZodType$1 | undefined;
+}
+interface $ZodObjectInternals$1< /** @ts-ignore Cast variance */out Shape extends $ZodShape$1 = $ZodShape$1, out Config extends $ZodObjectConfig$1 = $ZodObjectConfig$1> extends _$ZodTypeInternals$1 {
+  def: $ZodObjectDef$1<Shape>;
+  config: Config;
+  isst: $ZodIssueInvalidType$1 | $ZodIssueUnrecognizedKeys$1;
+  propValues: PropValues$1;
+  output: $InferObjectOutput$1<Shape, Config["out"]>;
+  input: $InferObjectInput$1<Shape, Config["in"]>;
+  optin?: "optional" | undefined;
+  optout?: "optional" | undefined;
+}
+type $ZodLooseShape$1 = Record<string, any>;
+interface $ZodObject$1< /** @ts-ignore Cast variance */out Shape extends Readonly<$ZodShape$1> = Readonly<$ZodShape$1>, out Params extends $ZodObjectConfig$1 = $ZodObjectConfig$1> extends $ZodType$1<any, any, $ZodObjectInternals$1<Shape, Params>> {}
+declare const $ZodObject$1: $constructor$1<$ZodObject$1>;
+type $InferUnionOutput$1<T extends SomeType$1> = T extends any ? output$1<T> : never;
+type $InferUnionInput$1<T extends SomeType$1> = T extends any ? input$1<T> : never;
+interface $ZodUnionDef$1<Options extends readonly SomeType$1[] = readonly $ZodType$1[]> extends $ZodTypeDef$1 {
+  type: "union";
+  options: Options;
+  inclusive?: boolean;
+}
+type IsOptionalIn$1<T extends SomeType$1> = T extends OptionalInSchema$1 ? true : false;
+type IsOptionalOut$1<T extends SomeType$1> = T extends OptionalOutSchema$1 ? true : false;
+interface $ZodUnionInternals$1<T extends readonly SomeType$1[] = readonly $ZodType$1[]> extends _$ZodTypeInternals$1 {
+  def: $ZodUnionDef$1<T>;
+  isst: $ZodIssueInvalidUnion$1;
+  pattern: T[number]["_zod"]["pattern"];
+  values: T[number]["_zod"]["values"];
+  output: $InferUnionOutput$1<T[number]>;
+  input: $InferUnionInput$1<T[number]>;
+  optin: IsOptionalIn$1<T[number]> extends false ? "optional" | undefined : "optional";
+  optout: IsOptionalOut$1<T[number]> extends false ? "optional" | undefined : "optional";
+}
+interface $ZodUnion$1<T extends readonly SomeType$1[] = readonly $ZodType$1[]> extends $ZodType$1<any, any, $ZodUnionInternals$1<T>> {
+  _zod: $ZodUnionInternals$1<T>;
+}
+declare const $ZodUnion$1: $constructor$1<$ZodUnion$1>;
+interface $ZodIntersectionDef$1<Left extends SomeType$1 = $ZodType$1, Right extends SomeType$1 = $ZodType$1> extends $ZodTypeDef$1 {
+  type: "intersection";
+  left: Left;
+  right: Right;
+}
+interface $ZodIntersectionInternals$1<A extends SomeType$1 = $ZodType$1, B extends SomeType$1 = $ZodType$1> extends _$ZodTypeInternals$1 {
+  def: $ZodIntersectionDef$1<A, B>;
+  isst: never;
+  optin: A["_zod"]["optin"] | B["_zod"]["optin"];
+  optout: A["_zod"]["optout"] | B["_zod"]["optout"];
+  output: output$1<A> & output$1<B>;
+  input: input$1<A> & input$1<B>;
+}
+interface $ZodIntersection$1<A extends SomeType$1 = $ZodType$1, B extends SomeType$1 = $ZodType$1> extends $ZodType$1 {
+  _zod: $ZodIntersectionInternals$1<A, B>;
+}
+declare const $ZodIntersection$1: $constructor$1<$ZodIntersection$1>;
+interface $ZodTupleDef$1<T extends TupleItems$1 = readonly $ZodType$1[], Rest extends SomeType$1 | null = $ZodType$1 | null> extends $ZodTypeDef$1 {
+  type: "tuple";
+  items: T;
+  rest: Rest;
+}
+type $InferTupleInputType$1<T extends TupleItems$1, Rest extends SomeType$1 | null> = [...TupleInputTypeWithOptionals$1<T>, ...(Rest extends SomeType$1 ? input$1<Rest>[] : [])];
+type TupleInputTypeNoOptionals$1<T extends TupleItems$1> = { [k in keyof T]: input$1<T[k]> };
+type TupleInputTypeWithOptionals$1<T extends TupleItems$1> = T extends readonly [...infer Prefix extends SomeType$1[], infer Tail extends SomeType$1] ? Tail["_zod"]["optin"] extends "optional" ? [...TupleInputTypeWithOptionals$1<Prefix>, input$1<Tail>?] : TupleInputTypeNoOptionals$1<T> : [];
+type $InferTupleOutputType$1<T extends TupleItems$1, Rest extends SomeType$1 | null> = [...TupleOutputTypeWithOptionals$1<T>, ...(Rest extends SomeType$1 ? output$1<Rest>[] : [])];
+type TupleOutputTypeNoOptionals$1<T extends TupleItems$1> = { [k in keyof T]: output$1<T[k]> };
+type TupleOutputTypeWithOptionals$1<T extends TupleItems$1> = T extends readonly [...infer Prefix extends SomeType$1[], infer Tail extends SomeType$1] ? Tail["_zod"]["optout"] extends "optional" ? [...TupleOutputTypeWithOptionals$1<Prefix>, output$1<Tail>?] : TupleOutputTypeNoOptionals$1<T> : [];
+interface $ZodTupleInternals$1<T extends TupleItems$1 = readonly $ZodType$1[], Rest extends SomeType$1 | null = $ZodType$1 | null> extends _$ZodTypeInternals$1 {
+  def: $ZodTupleDef$1<T, Rest>;
+  isst: $ZodIssueInvalidType$1 | $ZodIssueTooBig$1<unknown[]> | $ZodIssueTooSmall$1<unknown[]>;
+  output: $InferTupleOutputType$1<T, Rest>;
+  input: $InferTupleInputType$1<T, Rest>;
+}
+interface $ZodTuple$1<T extends TupleItems$1 = readonly $ZodType$1[], Rest extends SomeType$1 | null = $ZodType$1 | null> extends $ZodType$1 {
+  _zod: $ZodTupleInternals$1<T, Rest>;
+}
+declare const $ZodTuple$1: $constructor$1<$ZodTuple$1>;
+type $ZodRecordKey$1 = $ZodType$1<string | number | symbol, unknown>;
+interface $ZodRecordDef$1<Key extends $ZodRecordKey$1 = $ZodRecordKey$1, Value extends SomeType$1 = $ZodType$1> extends $ZodTypeDef$1 {
+  type: "record";
+  keyType: Key;
+  valueType: Value;
+  /** @default "strict" - errors on keys not matching keyType. "loose" passes through non-matching keys unchanged. */
+  mode?: "strict" | "loose";
+}
+type $InferZodRecordOutput$1<Key extends $ZodRecordKey$1 = $ZodRecordKey$1, Value extends SomeType$1 = $ZodType$1> = Key extends $partial$1 ? Partial<Record<output$1<Key>, output$1<Value>>> : Record<output$1<Key>, output$1<Value>>;
+type $InferZodRecordInput$1<Key extends $ZodRecordKey$1 = $ZodRecordKey$1, Value extends SomeType$1 = $ZodType$1> = Key extends $partial$1 ? Partial<Record<input$1<Key> & PropertyKey, input$1<Value>>> : Record<input$1<Key> & PropertyKey, input$1<Value>>;
+interface $ZodRecordInternals$1<Key extends $ZodRecordKey$1 = $ZodRecordKey$1, Value extends SomeType$1 = $ZodType$1> extends $ZodTypeInternals$1<$InferZodRecordOutput$1<Key, Value>, $InferZodRecordInput$1<Key, Value>> {
+  def: $ZodRecordDef$1<Key, Value>;
+  isst: $ZodIssueInvalidType$1 | $ZodIssueInvalidKey$1<Record<PropertyKey, unknown>>;
+  optin?: "optional" | undefined;
+  optout?: "optional" | undefined;
+}
+type $partial$1 = {
+  "~~partial": true;
+};
+interface $ZodRecord$1<Key extends $ZodRecordKey$1 = $ZodRecordKey$1, Value extends SomeType$1 = $ZodType$1> extends $ZodType$1 {
+  _zod: $ZodRecordInternals$1<Key, Value>;
+}
+declare const $ZodRecord$1: $constructor$1<$ZodRecord$1>;
+interface $ZodMapDef$1<Key extends SomeType$1 = $ZodType$1, Value extends SomeType$1 = $ZodType$1> extends $ZodTypeDef$1 {
+  type: "map";
+  keyType: Key;
+  valueType: Value;
+}
+interface $ZodMapInternals$1<Key extends SomeType$1 = $ZodType$1, Value extends SomeType$1 = $ZodType$1> extends $ZodTypeInternals$1<Map<output$1<Key>, output$1<Value>>, Map<input$1<Key>, input$1<Value>>> {
+  def: $ZodMapDef$1<Key, Value>;
+  isst: $ZodIssueInvalidType$1 | $ZodIssueInvalidKey$1 | $ZodIssueInvalidElement$1<unknown>;
+  optin?: "optional" | undefined;
+  optout?: "optional" | undefined;
+}
+interface $ZodMap$1<Key extends SomeType$1 = $ZodType$1, Value extends SomeType$1 = $ZodType$1> extends $ZodType$1 {
+  _zod: $ZodMapInternals$1<Key, Value>;
+}
+declare const $ZodMap$1: $constructor$1<$ZodMap$1>;
+interface $ZodSetDef$1<T extends SomeType$1 = $ZodType$1> extends $ZodTypeDef$1 {
+  type: "set";
+  valueType: T;
+}
+interface $ZodSetInternals$1<T extends SomeType$1 = $ZodType$1> extends $ZodTypeInternals$1<Set<output$1<T>>, Set<input$1<T>>> {
+  def: $ZodSetDef$1<T>;
+  isst: $ZodIssueInvalidType$1;
+  optin?: "optional" | undefined;
+  optout?: "optional" | undefined;
+}
+interface $ZodSet$1<T extends SomeType$1 = $ZodType$1> extends $ZodType$1 {
+  _zod: $ZodSetInternals$1<T>;
+}
+declare const $ZodSet$1: $constructor$1<$ZodSet$1>;
+type $InferEnumOutput$1<T extends EnumLike$1> = T[keyof T] & {};
+type $InferEnumInput$1<T extends EnumLike$1> = T[keyof T] & {};
+interface $ZodEnumDef$1<T extends EnumLike$1 = EnumLike$1> extends $ZodTypeDef$1 {
+  type: "enum";
+  entries: T;
+}
+interface $ZodEnumInternals$1< /** @ts-ignore Cast variance */out T extends EnumLike$1 = EnumLike$1> extends $ZodTypeInternals$1<$InferEnumOutput$1<T>, $InferEnumInput$1<T>> {
+  def: $ZodEnumDef$1<T>;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  values: PrimitiveSet$1;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  pattern: RegExp;
+  isst: $ZodIssueInvalidValue$1;
+}
+interface $ZodEnum$1<T extends EnumLike$1 = EnumLike$1> extends $ZodType$1 {
+  _zod: $ZodEnumInternals$1<T>;
+}
+declare const $ZodEnum$1: $constructor$1<$ZodEnum$1>;
+interface $ZodLiteralDef$1<T extends Literal$1> extends $ZodTypeDef$1 {
+  type: "literal";
+  values: T[];
+}
+interface $ZodLiteralInternals$1<T extends Literal$1 = Literal$1> extends $ZodTypeInternals$1<T, T> {
+  def: $ZodLiteralDef$1<T>;
+  values: Set<T>;
+  pattern: RegExp;
+  isst: $ZodIssueInvalidValue$1;
+}
+interface $ZodLiteral$1<T extends Literal$1 = Literal$1> extends $ZodType$1 {
+  _zod: $ZodLiteralInternals$1<T>;
+}
+declare const $ZodLiteral$1: $constructor$1<$ZodLiteral$1>;
+type _File$1 = typeof globalThis extends {
+  File: infer F extends new (...args: any[]) => any;
+} ? InstanceType<F> : {};
+/** Do not reference this directly. */
+interface File$1 extends _File$1 {
+  readonly type: string;
+  readonly size: number;
+}
+interface $ZodFileDef$1 extends $ZodTypeDef$1 {
+  type: "file";
+}
+interface $ZodFileInternals$1 extends $ZodTypeInternals$1<File$1, File$1> {
+  def: $ZodFileDef$1;
+  isst: $ZodIssueInvalidType$1;
+  bag: LoosePartial$1<{
+    minimum: number;
+    maximum: number;
+    mime: MimeTypes$1[];
+  }>;
+}
+interface $ZodFile$1 extends $ZodType$1 {
+  _zod: $ZodFileInternals$1;
+}
+declare const $ZodFile$1: $constructor$1<$ZodFile$1>;
+interface $ZodTransformDef$1 extends $ZodTypeDef$1 {
+  type: "transform";
+  transform: (input: unknown, payload: ParsePayload$1<unknown>) => MaybeAsync$1<unknown>;
+}
+interface $ZodTransformInternals$1<O = unknown, I = unknown> extends $ZodTypeInternals$1<O, I> {
+  def: $ZodTransformDef$1;
+  isst: never;
+}
+interface $ZodTransform$1<O = unknown, I = unknown> extends $ZodType$1 {
+  _zod: $ZodTransformInternals$1<O, I>;
+}
+declare const $ZodTransform$1: $constructor$1<$ZodTransform$1>;
+interface $ZodOptionalDef$1<T extends SomeType$1 = $ZodType$1> extends $ZodTypeDef$1 {
+  type: "optional";
+  innerType: T;
+}
+interface $ZodOptionalInternals$1<T extends SomeType$1 = $ZodType$1> extends $ZodTypeInternals$1<output$1<T> | undefined, input$1<T> | undefined> {
+  def: $ZodOptionalDef$1<T>;
+  optin: "optional";
+  optout: "optional";
+  isst: never;
+  values: T["_zod"]["values"];
+  pattern: T["_zod"]["pattern"];
+}
+interface $ZodOptional$1<T extends SomeType$1 = $ZodType$1> extends $ZodType$1 {
+  _zod: $ZodOptionalInternals$1<T>;
+}
+declare const $ZodOptional$1: $constructor$1<$ZodOptional$1>;
+interface $ZodExactOptionalDef$1<T extends SomeType$1 = $ZodType$1> extends $ZodOptionalDef$1<T> {}
+interface $ZodExactOptionalInternals$1<T extends SomeType$1 = $ZodType$1> extends $ZodOptionalInternals$1<T> {
+  def: $ZodExactOptionalDef$1<T>;
+  output: output$1<T>;
+  input: input$1<T>;
+}
+interface $ZodExactOptional$1<T extends SomeType$1 = $ZodType$1> extends $ZodType$1 {
+  _zod: $ZodExactOptionalInternals$1<T>;
+}
+declare const $ZodExactOptional$1: $constructor$1<$ZodExactOptional$1>;
+interface $ZodNullableDef$1<T extends SomeType$1 = $ZodType$1> extends $ZodTypeDef$1 {
+  type: "nullable";
+  innerType: T;
+}
+interface $ZodNullableInternals$1<T extends SomeType$1 = $ZodType$1> extends $ZodTypeInternals$1<output$1<T> | null, input$1<T> | null> {
+  def: $ZodNullableDef$1<T>;
+  optin: T["_zod"]["optin"];
+  optout: T["_zod"]["optout"];
+  isst: never;
+  values: T["_zod"]["values"];
+  pattern: T["_zod"]["pattern"];
+}
+interface $ZodNullable$1<T extends SomeType$1 = $ZodType$1> extends $ZodType$1 {
+  _zod: $ZodNullableInternals$1<T>;
+}
+declare const $ZodNullable$1: $constructor$1<$ZodNullable$1>;
+interface $ZodDefaultDef$1<T extends SomeType$1 = $ZodType$1> extends $ZodTypeDef$1 {
+  type: "default";
+  innerType: T;
+  /** The default value. May be a getter. */
+  defaultValue: NoUndefined$1<output$1<T>>;
+}
+interface $ZodDefaultInternals$1<T extends SomeType$1 = $ZodType$1> extends $ZodTypeInternals$1<NoUndefined$1<output$1<T>>, input$1<T> | undefined> {
+  def: $ZodDefaultDef$1<T>;
+  optin: "optional";
+  optout?: "optional" | undefined;
+  isst: never;
+  values: T["_zod"]["values"];
+}
+interface $ZodDefault$1<T extends SomeType$1 = $ZodType$1> extends $ZodType$1 {
+  _zod: $ZodDefaultInternals$1<T>;
+}
+declare const $ZodDefault$1: $constructor$1<$ZodDefault$1>;
+interface $ZodPrefaultDef$1<T extends SomeType$1 = $ZodType$1> extends $ZodTypeDef$1 {
+  type: "prefault";
+  innerType: T;
+  /** The default value. May be a getter. */
+  defaultValue: input$1<T>;
+}
+interface $ZodPrefaultInternals$1<T extends SomeType$1 = $ZodType$1> extends $ZodTypeInternals$1<NoUndefined$1<output$1<T>>, input$1<T> | undefined> {
+  def: $ZodPrefaultDef$1<T>;
+  optin: "optional";
+  optout?: "optional" | undefined;
+  isst: never;
+  values: T["_zod"]["values"];
+}
+interface $ZodPrefault$1<T extends SomeType$1 = $ZodType$1> extends $ZodType$1 {
+  _zod: $ZodPrefaultInternals$1<T>;
+}
+declare const $ZodPrefault$1: $constructor$1<$ZodPrefault$1>;
+interface $ZodNonOptionalDef$1<T extends SomeType$1 = $ZodType$1> extends $ZodTypeDef$1 {
+  type: "nonoptional";
+  innerType: T;
+}
+interface $ZodNonOptionalInternals$1<T extends SomeType$1 = $ZodType$1> extends $ZodTypeInternals$1<NoUndefined$1<output$1<T>>, NoUndefined$1<input$1<T>>> {
+  def: $ZodNonOptionalDef$1<T>;
+  isst: $ZodIssueInvalidType$1;
+  values: T["_zod"]["values"];
+  optin: "optional" | undefined;
+  optout: "optional" | undefined;
+}
+interface $ZodNonOptional$1<T extends SomeType$1 = $ZodType$1> extends $ZodType$1 {
+  _zod: $ZodNonOptionalInternals$1<T>;
+}
+declare const $ZodNonOptional$1: $constructor$1<$ZodNonOptional$1>;
+interface $ZodSuccessDef$1<T extends SomeType$1 = $ZodType$1> extends $ZodTypeDef$1 {
+  type: "success";
+  innerType: T;
+}
+interface $ZodSuccessInternals$1<T extends SomeType$1 = $ZodType$1> extends $ZodTypeInternals$1<boolean, input$1<T>> {
+  def: $ZodSuccessDef$1<T>;
+  isst: never;
+  optin: T["_zod"]["optin"];
+  optout: "optional" | undefined;
+}
+interface $ZodSuccess$1<T extends SomeType$1 = $ZodType$1> extends $ZodType$1 {
+  _zod: $ZodSuccessInternals$1<T>;
+}
+declare const $ZodSuccess$1: $constructor$1<$ZodSuccess$1>;
+interface $ZodCatchCtx$1 extends ParsePayload$1 {
+  /** @deprecated Use `ctx.issues` */
+  error: {
+    issues: $ZodIssue$1[];
+  };
+  /** @deprecated Use `ctx.value` */
+  input: unknown;
+}
+interface $ZodCatchDef$1<T extends SomeType$1 = $ZodType$1> extends $ZodTypeDef$1 {
+  type: "catch";
+  innerType: T;
+  catchValue: (ctx: $ZodCatchCtx$1) => unknown;
+}
+interface $ZodCatchInternals$1<T extends SomeType$1 = $ZodType$1> extends $ZodTypeInternals$1<output$1<T>, input$1<T>> {
+  def: $ZodCatchDef$1<T>;
+  optin: T["_zod"]["optin"];
+  optout: T["_zod"]["optout"];
+  isst: never;
+  values: T["_zod"]["values"];
+}
+interface $ZodCatch$1<T extends SomeType$1 = $ZodType$1> extends $ZodType$1 {
+  _zod: $ZodCatchInternals$1<T>;
+}
+declare const $ZodCatch$1: $constructor$1<$ZodCatch$1>;
+interface $ZodNaNDef$1 extends $ZodTypeDef$1 {
+  type: "nan";
+}
+interface $ZodNaNInternals$1 extends $ZodTypeInternals$1<number, number> {
+  def: $ZodNaNDef$1;
+  isst: $ZodIssueInvalidType$1;
+}
+interface $ZodNaN$1 extends $ZodType$1 {
+  _zod: $ZodNaNInternals$1;
+}
+declare const $ZodNaN$1: $constructor$1<$ZodNaN$1>;
+interface $ZodPipeDef$1<A extends SomeType$1 = $ZodType$1, B extends SomeType$1 = $ZodType$1> extends $ZodTypeDef$1 {
+  type: "pipe";
+  in: A;
+  out: B;
+  /** Only defined inside $ZodCodec instances. */
+  transform?: (value: output$1<A>, payload: ParsePayload$1<output$1<A>>) => MaybeAsync$1<input$1<B>>;
+  /** Only defined inside $ZodCodec instances. */
+  reverseTransform?: (value: input$1<B>, payload: ParsePayload$1<input$1<B>>) => MaybeAsync$1<output$1<A>>;
+}
+interface $ZodPipeInternals$1<A extends SomeType$1 = $ZodType$1, B extends SomeType$1 = $ZodType$1> extends $ZodTypeInternals$1<output$1<B>, input$1<A>> {
+  def: $ZodPipeDef$1<A, B>;
+  isst: never;
+  values: A["_zod"]["values"];
+  optin: A["_zod"]["optin"];
+  optout: B["_zod"]["optout"];
+  propValues: A["_zod"]["propValues"];
+}
+interface $ZodPipe$1<A extends SomeType$1 = $ZodType$1, B extends SomeType$1 = $ZodType$1> extends $ZodType$1 {
+  _zod: $ZodPipeInternals$1<A, B>;
+}
+declare const $ZodPipe$1: $constructor$1<$ZodPipe$1>;
+interface $ZodReadonlyDef$1<T extends SomeType$1 = $ZodType$1> extends $ZodTypeDef$1 {
+  type: "readonly";
+  innerType: T;
+}
+interface $ZodReadonlyInternals$1<T extends SomeType$1 = $ZodType$1> extends $ZodTypeInternals$1<MakeReadonly$1<output$1<T>>, MakeReadonly$1<input$1<T>>> {
+  def: $ZodReadonlyDef$1<T>;
+  optin: T["_zod"]["optin"];
+  optout: T["_zod"]["optout"];
+  isst: never;
+  propValues: T["_zod"]["propValues"];
+  values: T["_zod"]["values"];
+}
+interface $ZodReadonly$1<T extends SomeType$1 = $ZodType$1> extends $ZodType$1 {
+  _zod: $ZodReadonlyInternals$1<T>;
+}
+declare const $ZodReadonly$1: $constructor$1<$ZodReadonly$1>;
+interface $ZodTemplateLiteralDef$1 extends $ZodTypeDef$1 {
+  type: "template_literal";
+  parts: $ZodTemplateLiteralPart$1[];
+  format?: string | undefined;
+}
+interface $ZodTemplateLiteralInternals$1<Template extends string = string> extends $ZodTypeInternals$1<Template, Template> {
+  pattern: RegExp;
+  def: $ZodTemplateLiteralDef$1;
+  isst: $ZodIssueInvalidType$1;
+}
+interface $ZodTemplateLiteral$1<Template extends string = string> extends $ZodType$1 {
+  _zod: $ZodTemplateLiteralInternals$1<Template>;
+}
+type LiteralPart$1 = Exclude<Literal$1, symbol>;
+interface SchemaPartInternals$1 extends $ZodTypeInternals$1<LiteralPart$1, LiteralPart$1> {
+  pattern: RegExp;
+}
+interface SchemaPart$1 extends $ZodType$1 {
+  _zod: SchemaPartInternals$1;
+}
+type $ZodTemplateLiteralPart$1 = LiteralPart$1 | SchemaPart$1;
+declare const $ZodTemplateLiteral$1: $constructor$1<$ZodTemplateLiteral$1>;
+type $ZodFunctionArgs$1 = $ZodType$1<unknown[], unknown[]>;
+type $ZodFunctionIn$1 = $ZodFunctionArgs$1;
+type $ZodFunctionOut$1 = $ZodType$1;
+type $InferInnerFunctionType$1<Args extends $ZodFunctionIn$1, Returns extends $ZodFunctionOut$1> = (...args: $ZodFunctionIn$1 extends Args ? never[] : output$1<Args>) => input$1<Returns>;
+type $InferInnerFunctionTypeAsync$1<Args extends $ZodFunctionIn$1, Returns extends $ZodFunctionOut$1> = (...args: $ZodFunctionIn$1 extends Args ? never[] : output$1<Args>) => MaybeAsync$1<input$1<Returns>>;
+type $InferOuterFunctionType$1<Args extends $ZodFunctionIn$1, Returns extends $ZodFunctionOut$1> = (...args: $ZodFunctionIn$1 extends Args ? never[] : input$1<Args>) => output$1<Returns>;
+type $InferOuterFunctionTypeAsync$1<Args extends $ZodFunctionIn$1, Returns extends $ZodFunctionOut$1> = (...args: $ZodFunctionIn$1 extends Args ? never[] : input$1<Args>) => Promise<output$1<Returns>>;
+interface $ZodFunctionDef$1<In extends $ZodFunctionIn$1 = $ZodFunctionIn$1, Out extends $ZodFunctionOut$1 = $ZodFunctionOut$1> extends $ZodTypeDef$1 {
+  type: "function";
+  input: In;
+  output: Out;
+}
+interface $ZodFunctionInternals$1<Args extends $ZodFunctionIn$1, Returns extends $ZodFunctionOut$1> extends $ZodTypeInternals$1<$InferOuterFunctionType$1<Args, Returns>, $InferInnerFunctionType$1<Args, Returns>> {
+  def: $ZodFunctionDef$1<Args, Returns>;
+  isst: $ZodIssueInvalidType$1;
+}
+interface $ZodFunction$1<Args extends $ZodFunctionIn$1 = $ZodFunctionIn$1, Returns extends $ZodFunctionOut$1 = $ZodFunctionOut$1> extends $ZodType$1<any, any, $ZodFunctionInternals$1<Args, Returns>> {
+  /** @deprecated */
+  _def: $ZodFunctionDef$1<Args, Returns>;
+  _input: $InferInnerFunctionType$1<Args, Returns>;
+  _output: $InferOuterFunctionType$1<Args, Returns>;
+  implement<F extends $InferInnerFunctionType$1<Args, Returns>>(func: F): (...args: Parameters<this["_output"]>) => ReturnType<F> extends ReturnType<this["_output"]> ? ReturnType<F> : ReturnType<this["_output"]>;
+  implementAsync<F extends $InferInnerFunctionTypeAsync$1<Args, Returns>>(func: F): F extends $InferOuterFunctionTypeAsync$1<Args, Returns> ? F : $InferOuterFunctionTypeAsync$1<Args, Returns>;
+  input<const Items extends TupleItems$1, const Rest extends $ZodFunctionOut$1 = $ZodFunctionOut$1>(args: Items, rest?: Rest): $ZodFunction$1<$ZodTuple$1<Items, Rest>, Returns>;
+  input<NewArgs extends $ZodFunctionIn$1>(args: NewArgs): $ZodFunction$1<NewArgs, Returns>;
+  input(...args: any[]): $ZodFunction$1<any, Returns>;
+  output<NewReturns extends $ZodType$1>(output: NewReturns): $ZodFunction$1<Args, NewReturns>;
+}
+declare const $ZodFunction$1: $constructor$1<$ZodFunction$1>;
+interface $ZodPromiseDef$1<T extends SomeType$1 = $ZodType$1> extends $ZodTypeDef$1 {
+  type: "promise";
+  innerType: T;
+}
+interface $ZodPromiseInternals$1<T extends SomeType$1 = $ZodType$1> extends $ZodTypeInternals$1<Promise<output$1<T>>, MaybeAsync$1<input$1<T>>> {
+  def: $ZodPromiseDef$1<T>;
+  isst: never;
+}
+interface $ZodPromise$1<T extends SomeType$1 = $ZodType$1> extends $ZodType$1 {
+  _zod: $ZodPromiseInternals$1<T>;
+}
+declare const $ZodPromise$1: $constructor$1<$ZodPromise$1>;
+interface $ZodLazyDef$1<T extends SomeType$1 = $ZodType$1> extends $ZodTypeDef$1 {
+  type: "lazy";
+  getter: () => T;
+}
+interface $ZodLazyInternals$1<T extends SomeType$1 = $ZodType$1> extends $ZodTypeInternals$1<output$1<T>, input$1<T>> {
+  def: $ZodLazyDef$1<T>;
+  isst: never;
+  /** Auto-cached way to retrieve the inner schema */
+  innerType: T;
+  pattern: T["_zod"]["pattern"];
+  propValues: T["_zod"]["propValues"];
+  optin: T["_zod"]["optin"];
+  optout: T["_zod"]["optout"];
+}
+interface $ZodLazy$1<T extends SomeType$1 = $ZodType$1> extends $ZodType$1 {
+  _zod: $ZodLazyInternals$1<T>;
+}
+declare const $ZodLazy$1: $constructor$1<$ZodLazy$1>;
+interface $ZodCustomDef$1<O = unknown> extends $ZodTypeDef$1, $ZodCheckDef$1 {
+  type: "custom";
+  check: "custom";
+  path?: PropertyKey[] | undefined;
+  error?: $ZodErrorMap$1 | undefined;
+  params?: Record<string, any> | undefined;
+  fn: (arg: O) => unknown;
+}
+interface $ZodCustomInternals$1<O = unknown, I = unknown> extends $ZodTypeInternals$1<O, I>, $ZodCheckInternals$1<O> {
+  def: $ZodCustomDef$1;
+  issc: $ZodIssue$1;
+  isst: never;
+  bag: LoosePartial$1<{
+    Class: typeof Class$1;
+  }>;
+}
+interface $ZodCustom$1<O = unknown, I = unknown> extends $ZodType$1 {
+  _zod: $ZodCustomInternals$1<O, I>;
+}
+declare const $ZodCustom$1: $constructor$1<$ZodCustom$1>;
+type $ZodTypes$1 = $ZodString$1 | $ZodNumber$1 | $ZodBigInt$1 | $ZodBoolean$1 | $ZodDate$1 | $ZodSymbol$1 | $ZodUndefined$1 | $ZodNullable$1 | $ZodNull$1 | $ZodAny$1 | $ZodUnknown$1 | $ZodNever$1 | $ZodVoid$1 | $ZodArray$1 | $ZodObject$1 | $ZodUnion$1 | $ZodIntersection$1 | $ZodTuple$1 | $ZodRecord$1 | $ZodMap$1 | $ZodSet$1 | $ZodLiteral$1 | $ZodEnum$1 | $ZodFunction$1 | $ZodPromise$1 | $ZodLazy$1 | $ZodOptional$1 | $ZodDefault$1 | $ZodPrefault$1 | $ZodTemplateLiteral$1 | $ZodCustom$1 | $ZodTransform$1 | $ZodNonOptional$1 | $ZodReadonly$1 | $ZodNaN$1 | $ZodPipe$1 | $ZodSuccess$1 | $ZodCatch$1 | $ZodFile$1;
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/checks.d.cts
+interface $ZodCheckDef$1 {
+  check: string;
+  error?: $ZodErrorMap$1<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$1) => boolean) | undefined;
+}
+interface $ZodCheckInternals$1<T> {
+  def: $ZodCheckDef$1;
+  /** The set of issues this check might throw. */
+  issc?: $ZodIssueBase$1;
+  check(payload: ParsePayload$1<T>): MaybeAsync$1<void>;
+  onattach: ((schema: $ZodType$1) => void)[];
+}
+interface $ZodCheck$1<in T = never> {
+  _zod: $ZodCheckInternals$1<T>;
+}
+declare const $ZodCheck$1: $constructor$1<$ZodCheck$1<any>>;
+interface $ZodCheckMaxLengthDef$1 extends $ZodCheckDef$1 {
+  check: "max_length";
+  maximum: number;
+}
+interface $ZodCheckMaxLengthInternals$1<T extends HasLength$1 = HasLength$1> extends $ZodCheckInternals$1<T> {
+  def: $ZodCheckMaxLengthDef$1;
+  issc: $ZodIssueTooBig$1<T>;
+}
+interface $ZodCheckMaxLength$1<T extends HasLength$1 = HasLength$1> extends $ZodCheck$1<T> {
+  _zod: $ZodCheckMaxLengthInternals$1<T>;
+}
+declare const $ZodCheckMaxLength$1: $constructor$1<$ZodCheckMaxLength$1>;
+interface $ZodCheckMinLengthDef$1 extends $ZodCheckDef$1 {
+  check: "min_length";
+  minimum: number;
+}
+interface $ZodCheckMinLengthInternals$1<T extends HasLength$1 = HasLength$1> extends $ZodCheckInternals$1<T> {
+  def: $ZodCheckMinLengthDef$1;
+  issc: $ZodIssueTooSmall$1<T>;
+}
+interface $ZodCheckMinLength$1<T extends HasLength$1 = HasLength$1> extends $ZodCheck$1<T> {
+  _zod: $ZodCheckMinLengthInternals$1<T>;
+}
+declare const $ZodCheckMinLength$1: $constructor$1<$ZodCheckMinLength$1>;
+interface $ZodCheckLengthEqualsDef$1 extends $ZodCheckDef$1 {
+  check: "length_equals";
+  length: number;
+}
+interface $ZodCheckLengthEqualsInternals$1<T extends HasLength$1 = HasLength$1> extends $ZodCheckInternals$1<T> {
+  def: $ZodCheckLengthEqualsDef$1;
+  issc: $ZodIssueTooBig$1<T> | $ZodIssueTooSmall$1<T>;
+}
+interface $ZodCheckLengthEquals$1<T extends HasLength$1 = HasLength$1> extends $ZodCheck$1<T> {
+  _zod: $ZodCheckLengthEqualsInternals$1<T>;
+}
+declare const $ZodCheckLengthEquals$1: $constructor$1<$ZodCheckLengthEquals$1>;
+type $ZodStringFormats$1 = "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";
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/errors.d.cts
+interface $ZodIssueBase$1 {
+  readonly code?: string;
+  readonly input?: unknown;
+  readonly path: PropertyKey[];
+  readonly message: string;
+}
+type $ZodInvalidTypeExpected$1 = "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "undefined" | "null" | "never" | "void" | "date" | "array" | "object" | "tuple" | "record" | "map" | "set" | "file" | "nonoptional" | "nan" | "function" | (string & {});
+interface $ZodIssueInvalidType$1<Input = unknown> extends $ZodIssueBase$1 {
+  readonly code: "invalid_type";
+  readonly expected: $ZodInvalidTypeExpected$1;
+  readonly input?: Input;
+}
+interface $ZodIssueTooBig$1<Input = unknown> extends $ZodIssueBase$1 {
+  readonly code: "too_big";
+  readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
+  readonly maximum: number | bigint;
+  readonly inclusive?: boolean;
+  readonly exact?: boolean;
+  readonly input?: Input;
+}
+interface $ZodIssueTooSmall$1<Input = unknown> extends $ZodIssueBase$1 {
+  readonly code: "too_small";
+  readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
+  readonly minimum: number | bigint;
+  /** True if the allowable range includes the minimum */
+  readonly inclusive?: boolean;
+  /** True if the allowed value is fixed (e.g.` z.length(5)`), not a range (`z.minLength(5)`) */
+  readonly exact?: boolean;
+  readonly input?: Input;
+}
+interface $ZodIssueInvalidStringFormat$1 extends $ZodIssueBase$1 {
+  readonly code: "invalid_format";
+  readonly format: $ZodStringFormats$1 | (string & {});
+  readonly pattern?: string;
+  readonly input?: string;
+}
+interface $ZodIssueNotMultipleOf$1<Input extends number | bigint = number | bigint> extends $ZodIssueBase$1 {
+  readonly code: "not_multiple_of";
+  readonly divisor: number;
+  readonly input?: Input;
+}
+interface $ZodIssueUnrecognizedKeys$1 extends $ZodIssueBase$1 {
+  readonly code: "unrecognized_keys";
+  readonly keys: string[];
+  readonly input?: Record<string, unknown>;
+}
+interface $ZodIssueInvalidUnionNoMatch$1 extends $ZodIssueBase$1 {
+  readonly code: "invalid_union";
+  readonly errors: $ZodIssue$1[][];
+  readonly input?: unknown;
+  readonly discriminator?: string | undefined;
+  readonly inclusive?: true;
+}
+interface $ZodIssueInvalidUnionMultipleMatch$1 extends $ZodIssueBase$1 {
+  readonly code: "invalid_union";
+  readonly errors: [];
+  readonly input?: unknown;
+  readonly discriminator?: string | undefined;
+  readonly inclusive: false;
+}
+type $ZodIssueInvalidUnion$1 = $ZodIssueInvalidUnionNoMatch$1 | $ZodIssueInvalidUnionMultipleMatch$1;
+interface $ZodIssueInvalidKey$1<Input = unknown> extends $ZodIssueBase$1 {
+  readonly code: "invalid_key";
+  readonly origin: "map" | "record";
+  readonly issues: $ZodIssue$1[];
+  readonly input?: Input;
+}
+interface $ZodIssueInvalidElement$1<Input = unknown> extends $ZodIssueBase$1 {
+  readonly code: "invalid_element";
+  readonly origin: "map" | "set";
+  readonly key: unknown;
+  readonly issues: $ZodIssue$1[];
+  readonly input?: Input;
+}
+interface $ZodIssueInvalidValue$1<Input = unknown> extends $ZodIssueBase$1 {
+  readonly code: "invalid_value";
+  readonly values: Primitive$1[];
+  readonly input?: Input;
+}
+interface $ZodIssueCustom$1 extends $ZodIssueBase$1 {
+  readonly code: "custom";
+  readonly params?: Record<string, any> | undefined;
+  readonly input?: unknown;
+}
+type $ZodIssue$1 = $ZodIssueInvalidType$1 | $ZodIssueTooBig$1 | $ZodIssueTooSmall$1 | $ZodIssueInvalidStringFormat$1 | $ZodIssueNotMultipleOf$1 | $ZodIssueUnrecognizedKeys$1 | $ZodIssueInvalidUnion$1 | $ZodIssueInvalidKey$1 | $ZodIssueInvalidElement$1 | $ZodIssueInvalidValue$1 | $ZodIssueCustom$1;
+type $ZodInternalIssue$1<T extends $ZodIssueBase$1 = $ZodIssue$1> = T extends any ? RawIssue$3<T> : never;
+type RawIssue$3<T extends $ZodIssueBase$1> = T extends any ? Flatten$1<MakePartial$1<T, "message" | "path"> & {
+  /** The input data */readonly input: unknown; /** The schema or check that originated this issue. */
+  readonly inst?: $ZodType$1 | $ZodCheck$1; /** If `true`, Zod will continue executing checks/refinements after this issue. */
+  readonly continue?: boolean | undefined;
+} & Record<string, unknown>> : never;
+type $ZodRawIssue$1<T extends $ZodIssueBase$1 = $ZodIssue$1> = $ZodInternalIssue$1<T>;
+interface $ZodErrorMap$1<T extends $ZodIssueBase$1 = $ZodIssue$1> {
+  (issue: $ZodRawIssue$1<T>): {
+    message: string;
+  } | string | undefined | null;
+}
+interface $ZodError$1<T = unknown> extends Error {
+  type: T;
+  issues: $ZodIssue$1[];
+  _zod: {
+    output: T;
+    def: $ZodIssue$1[];
+  };
+  stack?: string;
+  name: string;
+}
+declare const $ZodError$1: $constructor$1<$ZodError$1>;
+type $ZodFlattenedError$1<T, U = string> = _FlattenedError$1<T, U>;
+type _FlattenedError$1<T, U = string> = {
+  formErrors: U[];
+  fieldErrors: { [P in keyof T]?: U[] };
+};
+type _ZodFormattedError$1<T, U = string> = T extends [any, ...any[]] ? { [K in keyof T]?: $ZodFormattedError$1<T[K], U> } : T extends any[] ? {
+  [k: number]: $ZodFormattedError$1<T[number], U>;
+} : T extends object ? Flatten$1<{ [K in keyof T]?: $ZodFormattedError$1<T[K], U> }> : any;
+type $ZodFormattedError$1<T, U = string> = {
+  _errors: U[];
+} & Flatten$1<_ZodFormattedError$1<T, U>>;
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/core.d.cts
+type ZodTrait$1 = {
+  _zod: {
+    def: any;
+    [k: string]: any;
+  };
+};
+interface $constructor$1<T extends ZodTrait$1, D = T["_zod"]["def"]> {
+  new (def: D): T;
+  init(inst: T, def: D): asserts inst is T;
+}
+declare function $constructor$1<T extends ZodTrait$1, D = T["_zod"]["def"]>(name: string, initializer: (inst: T, def: D) => void, params?: {
+  Parent?: typeof Class$1;
+}): $constructor$1<T, D>;
+declare const $brand$1: unique symbol;
+type $brand$1<T extends string | number | symbol = string | number | symbol> = {
+  [$brand$1]: { [k in T]: true };
+};
+type $ZodBranded$1<T extends SomeType$1, Brand extends string | number | symbol, Dir extends "in" | "out" | "inout" = "out"> = T & (Dir extends "inout" ? {
+  _zod: {
+    input: input$1<T> & $brand$1<Brand>;
+    output: output$1<T> & $brand$1<Brand>;
+  };
+} : Dir extends "in" ? {
+  _zod: {
+    input: input$1<T> & $brand$1<Brand>;
+  };
+} : {
+  _zod: {
+    output: output$1<T> & $brand$1<Brand>;
+  };
+});
+type input$1<T> = T extends {
+  _zod: {
+    input: any;
+  };
+} ? T["_zod"]["input"] : unknown;
+type output$1<T> = T extends {
+  _zod: {
+    output: any;
+  };
+} ? T["_zod"]["output"] : unknown;
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/api.d.cts
+type Params$1<T extends $ZodType$1 | $ZodCheck$1, IssueTypes extends $ZodIssueBase$1, OmitKeys extends keyof T["_zod"]["def"] = never> = Flatten$1<Partial<EmptyToNever$1<Omit<T["_zod"]["def"], OmitKeys> & ([IssueTypes] extends [never] ? {} : {
+  error?: string | $ZodErrorMap$1<IssueTypes> | undefined; /** @deprecated This parameter is deprecated. Use `error` instead. */
+  message?: string | undefined;
+})>>>;
+type TypeParams$1<T extends $ZodType$1 = $ZodType$1 & {
+  _isst: never;
+}, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error"> = never> = Params$1<T, NonNullable<T["_zod"]["isst"]>, "type" | "checks" | "error" | AlsoOmit>;
+type CheckParams$1<T extends $ZodCheck$1 = $ZodCheck$1, // & { _issc: never },
+AlsoOmit extends Exclude<keyof T["_zod"]["def"], "check" | "error"> = never> = Params$1<T, NonNullable<T["_zod"]["issc"]>, "check" | "error" | AlsoOmit>;
+type CheckTypeParams$1<T extends $ZodType$1 & $ZodCheck$1 = $ZodType$1 & $ZodCheck$1, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error" | "check"> = never> = Params$1<T, NonNullable<T["_zod"]["isst"] | T["_zod"]["issc"]>, "type" | "checks" | "error" | "check" | AlsoOmit>;
+type $ZodCheckMaxLengthParams$1 = CheckParams$1<$ZodCheckMaxLength$1, "maximum" | "when">;
+type $ZodCheckMinLengthParams$1 = CheckParams$1<$ZodCheckMinLength$1, "minimum" | "when">;
+type $ZodCheckLengthEqualsParams$1 = CheckParams$1<$ZodCheckLengthEquals$1, "length" | "when">;
+type $ZodEnumParams$1 = TypeParams$1<$ZodEnum$1, "entries">;
+type $ZodNonOptionalParams$1 = TypeParams$1<$ZodNonOptional$1, "innerType">;
+type $ZodCustomParams$1 = CheckTypeParams$1<$ZodCustom$1, "fn">;
+type $ZodSuperRefineIssue$1<T extends $ZodIssueBase$1 = $ZodIssue$1> = T extends any ? RawIssue$2<T> : never;
+type RawIssue$2<T extends $ZodIssueBase$1> = T extends any ? Flatten$1<MakePartial$1<T, "message" | "path"> & {
+  /** The schema or check that originated this issue. */readonly inst?: $ZodType$1 | $ZodCheck$1; /** If `true`, Zod will execute subsequent checks/refinements instead of immediately aborting */
+  readonly continue?: boolean | undefined;
+} & Record<string, unknown>> : never;
+interface $RefinementCtx$1<T = unknown> extends ParsePayload$1<T> {
+  addIssue(arg: string | $ZodSuperRefineIssue$1): void;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/classic/errors.d.cts
+/** An Error-like class used to store Zod validation issues.  */
+interface ZodError$1<T = unknown> extends $ZodError$1<T> {
+  /** @deprecated Use the `z.treeifyError(err)` function instead. */
+  format(): $ZodFormattedError$1<T>;
+  format<U>(mapper: (issue: $ZodIssue$1) => U): $ZodFormattedError$1<T, U>;
+  /** @deprecated Use the `z.treeifyError(err)` function instead. */
+  flatten(): $ZodFlattenedError$1<T>;
+  flatten<U>(mapper: (issue: $ZodIssue$1) => U): $ZodFlattenedError$1<T, U>;
+  /** @deprecated Push directly to `.issues` instead. */
+  addIssue(issue: $ZodIssue$1): void;
+  /** @deprecated Push directly to `.issues` instead. */
+  addIssues(issues: $ZodIssue$1[]): void;
+  /** @deprecated Check `err.issues.length === 0` instead. */
+  isEmpty: boolean;
+}
+declare const ZodError$1: $constructor$1<ZodError$1>;
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/classic/parse.d.cts
+type ZodSafeParseResult$1<T> = ZodSafeParseSuccess$1<T> | ZodSafeParseError$1<T>;
+type ZodSafeParseSuccess$1<T> = {
+  success: true;
+  data: T;
+  error?: never;
+};
+type ZodSafeParseError$1<T> = {
+  success: false;
+  data?: never;
+  error: ZodError$1<T>;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/classic/schemas.d.cts
+type ZodStandardSchemaWithJSON$2<T> = StandardSchemaWithJSONProps$1<input$1<T>, output$1<T>>;
+interface ZodType$1<out Output = unknown, out Input = unknown, out Internals extends $ZodTypeInternals$1<Output, Input> = $ZodTypeInternals$1<Output, Input>> extends $ZodType$1<Output, Input, Internals> {
+  def: Internals["def"];
+  type: Internals["def"]["type"];
+  /** @deprecated Use `.def` instead. */
+  _def: Internals["def"];
+  /** @deprecated Use `z.output<typeof schema>` instead. */
+  _output: Internals["output"];
+  /** @deprecated Use `z.input<typeof schema>` instead. */
+  _input: Internals["input"];
+  "~standard": ZodStandardSchemaWithJSON$2<this>;
+  /** Converts this schema to a JSON Schema representation. */
+  toJSONSchema(params?: ToJSONSchemaParams$1): ZodStandardJSONSchemaPayload$1<this>;
+  check(...checks: (CheckFn$1<output$1<this>> | $ZodCheck$1<output$1<this>>)[]): this;
+  with(...checks: (CheckFn$1<output$1<this>> | $ZodCheck$1<output$1<this>>)[]): this;
+  clone(def?: Internals["def"], params?: {
+    parent: boolean;
+  }): this;
+  register<R extends $ZodRegistry$1>(registry: R, ...meta: this extends R["_schema"] ? undefined extends R["_meta"] ? [$replace$1<R["_meta"], this>?] : [$replace$1<R["_meta"], this>] : ["Incompatible schema"]): this;
+  brand<T extends PropertyKey = PropertyKey, Dir extends "in" | "out" | "inout" = "out">(value?: T): PropertyKey extends T ? this : $ZodBranded$1<this, T, Dir>;
+  parse(data: unknown, params?: ParseContext$1<$ZodIssue$1>): output$1<this>;
+  safeParse(data: unknown, params?: ParseContext$1<$ZodIssue$1>): ZodSafeParseResult$1<output$1<this>>;
+  parseAsync(data: unknown, params?: ParseContext$1<$ZodIssue$1>): Promise<output$1<this>>;
+  safeParseAsync(data: unknown, params?: ParseContext$1<$ZodIssue$1>): Promise<ZodSafeParseResult$1<output$1<this>>>;
+  spa: (data: unknown, params?: ParseContext$1<$ZodIssue$1>) => Promise<ZodSafeParseResult$1<output$1<this>>>;
+  encode(data: output$1<this>, params?: ParseContext$1<$ZodIssue$1>): input$1<this>;
+  decode(data: input$1<this>, params?: ParseContext$1<$ZodIssue$1>): output$1<this>;
+  encodeAsync(data: output$1<this>, params?: ParseContext$1<$ZodIssue$1>): Promise<input$1<this>>;
+  decodeAsync(data: input$1<this>, params?: ParseContext$1<$ZodIssue$1>): Promise<output$1<this>>;
+  safeEncode(data: output$1<this>, params?: ParseContext$1<$ZodIssue$1>): ZodSafeParseResult$1<input$1<this>>;
+  safeDecode(data: input$1<this>, params?: ParseContext$1<$ZodIssue$1>): ZodSafeParseResult$1<output$1<this>>;
+  safeEncodeAsync(data: output$1<this>, params?: ParseContext$1<$ZodIssue$1>): Promise<ZodSafeParseResult$1<input$1<this>>>;
+  safeDecodeAsync(data: input$1<this>, params?: ParseContext$1<$ZodIssue$1>): Promise<ZodSafeParseResult$1<output$1<this>>>;
+  refine<Ch extends (arg: output$1<this>) => unknown | Promise<unknown>>(check: Ch, params?: string | $ZodCustomParams$1): Ch extends ((arg: any) => arg is infer R) ? this & ZodType$1<R, input$1<this>> : this;
+  superRefine(refinement: (arg: output$1<this>, ctx: $RefinementCtx$1<output$1<this>>) => void | Promise<void>): this;
+  overwrite(fn: (x: output$1<this>) => output$1<this>): this;
+  optional(): ZodOptional$1<this>;
+  exactOptional(): ZodExactOptional$1<this>;
+  nonoptional(params?: string | $ZodNonOptionalParams$1): ZodNonOptional$1<this>;
+  nullable(): ZodNullable$1<this>;
+  nullish(): ZodOptional$1<ZodNullable$1<this>>;
+  default(def: NoUndefined$1<output$1<this>>): ZodDefault$1<this>;
+  default(def: () => NoUndefined$1<output$1<this>>): ZodDefault$1<this>;
+  prefault(def: () => input$1<this>): ZodPrefault$1<this>;
+  prefault(def: input$1<this>): ZodPrefault$1<this>;
+  array(): ZodArray$1<this>;
+  or<T extends SomeType$1>(option: T): ZodUnion$1<[this, T]>;
+  and<T extends SomeType$1>(incoming: T): ZodIntersection$1<this, T>;
+  transform<NewOut>(transform: (arg: output$1<this>, ctx: $RefinementCtx$1<output$1<this>>) => NewOut | Promise<NewOut>): ZodPipe$1<this, ZodTransform$1<Awaited<NewOut>, output$1<this>>>;
+  catch(def: output$1<this>): ZodCatch$1<this>;
+  catch(def: (ctx: $ZodCatchCtx$1) => output$1<this>): ZodCatch$1<this>;
+  pipe<T extends $ZodType$1<any, output$1<this>>>(target: T | $ZodType$1<any, output$1<this>>): ZodPipe$1<this, T>;
+  readonly(): ZodReadonly$1<this>;
+  /** Returns a new instance that has been registered in `z.globalRegistry` with the specified description */
+  describe(description: string): this;
+  description?: string;
+  /** Returns the metadata associated with this instance in `z.globalRegistry` */
+  meta(): $replace$1<GlobalMeta$1, this> | undefined;
+  /** Returns a new instance that has been registered in `z.globalRegistry` with the specified metadata */
+  meta(data: $replace$1<GlobalMeta$1, this>): this;
+  /** @deprecated Try safe-parsing `undefined` (this is what `isOptional` does internally):
+   *
+   * ```ts
+   * const schema = z.string().optional();
+   * const isOptional = schema.safeParse(undefined).success; // true
+   * ```
+   */
+  isOptional(): boolean;
+  /**
+   * @deprecated Try safe-parsing `null` (this is what `isNullable` does internally):
+   *
+   * ```ts
+   * const schema = z.string().nullable();
+   * const isNullable = schema.safeParse(null).success; // true
+   * ```
+   */
+  isNullable(): boolean;
+  apply<T>(fn: (schema: this) => T): T;
+}
+interface _ZodType$1<out Internals extends $ZodTypeInternals$1 = $ZodTypeInternals$1> extends ZodType$1<any, any, Internals> {}
+declare const ZodType$1: $constructor$1<ZodType$1>;
+interface ZodArray$1<T extends SomeType$1 = $ZodType$1> extends _ZodType$1<$ZodArrayInternals$1<T>>, $ZodArray$1<T> {
+  element: T;
+  min(minLength: number, params?: string | $ZodCheckMinLengthParams$1): this;
+  nonempty(params?: string | $ZodCheckMinLengthParams$1): this;
+  max(maxLength: number, params?: string | $ZodCheckMaxLengthParams$1): this;
+  length(len: number, params?: string | $ZodCheckLengthEqualsParams$1): this;
+  unwrap(): T;
+  "~standard": ZodStandardSchemaWithJSON$2<this>;
+}
+declare const ZodArray$1: $constructor$1<ZodArray$1>;
+type SafeExtendShape$1<Base extends $ZodShape$1, Ext extends $ZodLooseShape$1> = { [K in keyof Ext]: K extends keyof Base ? output$1<Ext[K]> extends output$1<Base[K]> ? input$1<Ext[K]> extends input$1<Base[K]> ? Ext[K] : never : never : Ext[K] };
+interface ZodObject$1< /** @ts-ignore Cast variance */out Shape extends $ZodShape$1 = $ZodLooseShape$1, out Config extends $ZodObjectConfig$1 = $strip$1> extends _ZodType$1<$ZodObjectInternals$1<Shape, Config>>, $ZodObject$1<Shape, Config> {
+  "~standard": ZodStandardSchemaWithJSON$2<this>;
+  shape: Shape;
+  keyof(): ZodEnum$1<ToEnum$1<keyof Shape & string>>;
+  /** Define a schema to validate all unrecognized keys. This overrides the existing strict/loose behavior. */
+  catchall<T extends SomeType$1>(schema: T): ZodObject$1<Shape, $catchall$1<T>>;
+  /** @deprecated Use `z.looseObject()` or `.loose()` instead. */
+  passthrough(): ZodObject$1<Shape, $loose$1>;
+  /** Consider `z.looseObject(A.shape)` instead */
+  loose(): ZodObject$1<Shape, $loose$1>;
+  /** Consider `z.strictObject(A.shape)` instead */
+  strict(): ZodObject$1<Shape, $strict$1>;
+  /** This is the default behavior. This method call is likely unnecessary. */
+  strip(): ZodObject$1<Shape, $strip$1>;
+  extend<U extends $ZodLooseShape$1>(shape: U): ZodObject$1<Extend$1<Shape, U>, Config>;
+  safeExtend<U extends $ZodLooseShape$1>(shape: SafeExtendShape$1<Shape, U> & Partial<Record<keyof Shape, SomeType$1>>): ZodObject$1<Extend$1<Shape, U>, Config>;
+  /**
+   * @deprecated Use [`A.extend(B.shape)`](https://zod.dev/api?id=extend) instead.
+   */
+  merge<U extends ZodObject$1>(other: U): ZodObject$1<Extend$1<Shape, U["shape"]>, U["_zod"]["config"]>;
+  pick<M extends Mask$1<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject$1<Flatten$1<Pick<Shape, Extract<keyof Shape, keyof M>>>, Config>;
+  omit<M extends Mask$1<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject$1<Flatten$1<Omit<Shape, Extract<keyof Shape, keyof M>>>, Config>;
+  partial(): ZodObject$1<{ [k in keyof Shape]: ZodOptional$1<Shape[k]> }, Config>;
+  partial<M extends Mask$1<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject$1<{ [k in keyof Shape]: k extends keyof M ? ZodOptional$1<Shape[k]> : Shape[k] }, Config>;
+  required(): ZodObject$1<{ [k in keyof Shape]: ZodNonOptional$1<Shape[k]> }, Config>;
+  required<M extends Mask$1<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject$1<{ [k in keyof Shape]: k extends keyof M ? ZodNonOptional$1<Shape[k]> : Shape[k] }, Config>;
+}
+declare const ZodObject$1: $constructor$1<ZodObject$1>;
+interface ZodUnion$1<T extends readonly SomeType$1[] = readonly $ZodType$1[]> extends _ZodType$1<$ZodUnionInternals$1<T>>, $ZodUnion$1<T> {
+  "~standard": ZodStandardSchemaWithJSON$2<this>;
+  options: T;
+}
+declare const ZodUnion$1: $constructor$1<ZodUnion$1>;
+interface ZodIntersection$1<A extends SomeType$1 = $ZodType$1, B extends SomeType$1 = $ZodType$1> extends _ZodType$1<$ZodIntersectionInternals$1<A, B>>, $ZodIntersection$1<A, B> {
+  "~standard": ZodStandardSchemaWithJSON$2<this>;
+}
+declare const ZodIntersection$1: $constructor$1<ZodIntersection$1>;
+interface ZodEnum$1< /** @ts-ignore Cast variance */out T extends EnumLike$1 = EnumLike$1> extends _ZodType$1<$ZodEnumInternals$1<T>>, $ZodEnum$1<T> {
+  "~standard": ZodStandardSchemaWithJSON$2<this>;
+  enum: T;
+  options: Array<T[keyof T]>;
+  extract<const U extends readonly (keyof T)[]>(values: U, params?: string | $ZodEnumParams$1): ZodEnum$1<Flatten$1<Pick<T, U[number]>>>;
+  exclude<const U extends readonly (keyof T)[]>(values: U, params?: string | $ZodEnumParams$1): ZodEnum$1<Flatten$1<Omit<T, U[number]>>>;
+}
+declare const ZodEnum$1: $constructor$1<ZodEnum$1>;
+interface ZodTransform$1<O = unknown, I = unknown> extends _ZodType$1<$ZodTransformInternals$1<O, I>>, $ZodTransform$1<O, I> {
+  "~standard": ZodStandardSchemaWithJSON$2<this>;
+}
+declare const ZodTransform$1: $constructor$1<ZodTransform$1>;
+interface ZodOptional$1<T extends SomeType$1 = $ZodType$1> extends _ZodType$1<$ZodOptionalInternals$1<T>>, $ZodOptional$1<T> {
+  "~standard": ZodStandardSchemaWithJSON$2<this>;
+  unwrap(): T;
+}
+declare const ZodOptional$1: $constructor$1<ZodOptional$1>;
+interface ZodExactOptional$1<T extends SomeType$1 = $ZodType$1> extends _ZodType$1<$ZodExactOptionalInternals$1<T>>, $ZodExactOptional$1<T> {
+  "~standard": ZodStandardSchemaWithJSON$2<this>;
+  unwrap(): T;
+}
+declare const ZodExactOptional$1: $constructor$1<ZodExactOptional$1>;
+interface ZodNullable$1<T extends SomeType$1 = $ZodType$1> extends _ZodType$1<$ZodNullableInternals$1<T>>, $ZodNullable$1<T> {
+  "~standard": ZodStandardSchemaWithJSON$2<this>;
+  unwrap(): T;
+}
+declare const ZodNullable$1: $constructor$1<ZodNullable$1>;
+interface ZodDefault$1<T extends SomeType$1 = $ZodType$1> extends _ZodType$1<$ZodDefaultInternals$1<T>>, $ZodDefault$1<T> {
+  "~standard": ZodStandardSchemaWithJSON$2<this>;
+  unwrap(): T;
+  /** @deprecated Use `.unwrap()` instead. */
+  removeDefault(): T;
+}
+declare const ZodDefault$1: $constructor$1<ZodDefault$1>;
+interface ZodPrefault$1<T extends SomeType$1 = $ZodType$1> extends _ZodType$1<$ZodPrefaultInternals$1<T>>, $ZodPrefault$1<T> {
+  "~standard": ZodStandardSchemaWithJSON$2<this>;
+  unwrap(): T;
+}
+declare const ZodPrefault$1: $constructor$1<ZodPrefault$1>;
+interface ZodNonOptional$1<T extends SomeType$1 = $ZodType$1> extends _ZodType$1<$ZodNonOptionalInternals$1<T>>, $ZodNonOptional$1<T> {
+  "~standard": ZodStandardSchemaWithJSON$2<this>;
+  unwrap(): T;
+}
+declare const ZodNonOptional$1: $constructor$1<ZodNonOptional$1>;
+interface ZodCatch$1<T extends SomeType$1 = $ZodType$1> extends _ZodType$1<$ZodCatchInternals$1<T>>, $ZodCatch$1<T> {
+  "~standard": ZodStandardSchemaWithJSON$2<this>;
+  unwrap(): T;
+  /** @deprecated Use `.unwrap()` instead. */
+  removeCatch(): T;
+}
+declare const ZodCatch$1: $constructor$1<ZodCatch$1>;
+interface ZodPipe$1<A extends SomeType$1 = $ZodType$1, B extends SomeType$1 = $ZodType$1> extends _ZodType$1<$ZodPipeInternals$1<A, B>>, $ZodPipe$1<A, B> {
+  "~standard": ZodStandardSchemaWithJSON$2<this>;
+  in: A;
+  out: B;
+}
+declare const ZodPipe$1: $constructor$1<ZodPipe$1>;
+interface ZodReadonly$1<T extends SomeType$1 = $ZodType$1> extends _ZodType$1<$ZodReadonlyInternals$1<T>>, $ZodReadonly$1<T> {
+  "~standard": ZodStandardSchemaWithJSON$2<this>;
+  unwrap(): T;
+}
+declare const ZodReadonly$1: $constructor$1<ZodReadonly$1>;
+//#endregion
+//#region ../loader-types/dist/index.d.mts
+//#region src/index.d.ts
+/**
+ * Configuration options for initializing the Plucky chat widget.
+ *
+ * Pass this object to {@link Plucky} (chat-sdk) or {@link useChat} (React)
+ * to embed the widget on the page.
+ *
+ * @example
+ * ```ts
+ * Plucky({
+ *   appId: 'my-app-id',
+ *   baseUrl: 'https://widget.plucky.ai',
+ *   user: { id: 'user-123', name: 'Jane Doe', email: 'jane@example.com' },
+ *   mode: 'push',
+ *   autoOpen: false,
+ * })
+ * ```
+ */
+type PluckySettingsParams = {
+  /**
+   * Base URL of the Plucky widget server (e.g., `'https://widget.plucky.ai'`).
+   * The loader script and widget iframe are served from this origin.
+   */
+  baseUrl: string;
+  /**
+   * Unique identifier for your Plucky app, obtained from the Plucky dashboard.
+   */
+  appId: string;
+  /**
+   * Optional user identification and metadata. When provided, the widget
+   * associates conversations with this user and displays their name/email
+   * in the dashboard.
+   *
+   * @example
+   * ```ts
+   * user: {
+   *   id: 'user-123',
+   *   name: 'Jane Doe',
+   *   email: 'jane@example.com',
+   *   createdAt: '2024-01-15T00:00:00Z',
+   *   metadata: { plan: 'pro', company: 'Acme' },
+   * }
+   * ```
+   */
+  user?: {
+    /** Unique identifier for the user in your system. */id: string; /** Display name shown in the Plucky dashboard. */
+    name?: string; /** Email address shown in the Plucky dashboard. */
+    email?: string;
+    /**
+     * ISO 8601 timestamp of when the user was created in your system.
+     * Used for analytics and segmentation in the dashboard.
+     */
+    createdAt?: string;
+    /**
+     * Arbitrary key-value metadata attached to the user.
+     * Visible in the Plucky dashboard and can be used for filtering.
+     */
+    metadata?: Record<string, any>;
+  };
+  /**
+   * Built-in system tools to enable for the AI assistant.
+   *
+   * @example
+   * ```ts
+   * systemTools: { readPage: true }
+   * ```
+   */
+  systemTools?: {
+    /**
+     * When `true`, enables the `readPage` system tool that allows the AI
+     * assistant to read the content of the current page. Defaults to `false`.
+     */
+    readPage?: boolean;
+  };
+  /**
+   * Display mode for the widget.
+   * - `'push'` (default) — fixed sidebar that pushes page content.
+   * - `'overlay'` — fixed sidebar that overlays page content.
+   * - `'inline'` — widget is mounted inside a container element specified by {@link containerId}.
+   */
+  mode?: 'push' | 'overlay' | 'inline';
+  /**
+   * The `id` of the container element to mount the widget into.
+   * Required when `mode` is `'inline'`. The element must exist in the DOM
+   * before calling init / mounting the widget.
+   */
+  containerId?: string;
+  /**
+   * Whether to auto-open the widget when it loads. Defaults to `true`.
+   * Set to `false` to start with the widget closed.
+   */
+  autoOpen?: boolean;
+  /**
+   * Whether to show a floating trigger button in the bottom-right corner.
+   * When clicked, the trigger button toggles the widget open/closed.
+   * Defaults to `false`.
+   */
+  triggerButton?: boolean;
+  /**
+   * URL patterns the widget should be **visible** on.
+   * Uses Chrome-style match patterns (e.g. `'https://*.example.com/app/*'`).
+   * When omitted or empty, every page is included by default.
+   * If a URL matches both `include` and `exclude`, `exclude` wins.
+   */
+  include?: string[];
+  /**
+   * URL patterns the widget should be **hidden** on.
+   * Uses Chrome-style match patterns (e.g. `'https://example.com/login'`).
+   * Takes priority over `include` — if a URL matches both, it is excluded.
+   * The widget stays mounted but is hidden on excluded pages.
+   */
+  exclude?: string[];
+};
+/**
+ * Serializable subset of a tool definition sent across the iframe boundary.
+ * This does not include the callback — only metadata used by the widget
+ * to display tool information and validate inputs.
+ *
+ * @see {@link ToolConfig} for the full tool definition including the callback.
+ */
+interface SimpleToolConfig$1 {
+  /** Unique name for the tool (e.g., `'getWeather'`). Must be unique across all registered tools. */
+  name: string;
+  /** Human-readable description of what the tool does. Shown to the AI assistant to help it decide when to use the tool. */
+  description: string;
+  /**
+   * Text displayed in the chat while the tool is executing.
+   * Set to `null` to suppress the loading indicator entirely.
+   * @default undefined (uses the widget's default loading text)
+   */
+  defaultLoadingText?: string | null;
+  /**
+   * Text displayed in the chat after the tool completes successfully.
+   * Set to `null` to suppress the success message entirely.
+   * Can be overridden per-invocation by returning `{ content, successText }` from the callback.
+   * @default undefined (uses the widget's default success text)
+   */
+  defaultSuccessText?: string | null;
+  /**
+   * JSON Schema or Zod object schema describing the tool's expected input.
+   * When a Zod schema is provided, it is automatically converted to JSON Schema
+   * before being sent to the AI model.
+   *
+   * @example
+   * ```ts
+   * import { z } from 'zod'
+   *
+   * inputSchema: z.object({
+   *   city: z.string().describe('City name to look up'),
+   *   units: z.enum(['celsius', 'fahrenheit']).optional(),
+   * })
+   * ```
+   */
+  inputSchema?: ZodObject$1 | Record<string, unknown>;
+}
+type InferToolInput<T extends ZodObject$1<any> | Record<string, unknown> | undefined> = T extends ZodObject$1<any> ? output$1<T> : Record<string, unknown>;
+/**
+ * Return type for a tool callback. Either a plain string (used as the tool
+ * result content) or an object with `content` and an optional `successText`
+ * override.
+ *
+ * @example
+ * ```ts
+ * // Simple string result
+ * cb: async ({ city }) => `The weather in ${city} is sunny.`
+ *
+ * // Object result with custom success text
+ * cb: async ({ city }) => ({
+ *   content: JSON.stringify({ temp: 72, condition: 'sunny' }),
+ *   successText: `Fetched weather for ${city}`,
+ * })
+ * ```
+ */
+type ToolCallbackResult = string | {
+  /** The content returned to the AI assistant as the tool result. */content: string; /** Optional override for the success text displayed in the chat UI after the tool completes. */
+  successText?: string;
+};
+/**
+ * Full tool definition including the callback function.
+ *
+ * Register tools with {@link addTools} (chat-sdk) or {@link useTools} (React)
+ * to let the AI assistant invoke custom functions on the host page.
+ *
+ * @typeParam TInputSchema - The type of the input schema (Zod object or plain JSON Schema).
+ *   When a Zod schema is provided, the callback `input` parameter is automatically
+ *   inferred from it.
+ *
+ * @example
+ * ```ts
+ * import { z } from 'zod'
+ *
+ * const weatherTool: ToolConfig = {
+ *   name: 'getWeather',
+ *   description: 'Fetches current weather for a city',
+ *   inputSchema: z.object({
+ *     city: z.string().describe('City name'),
+ *   }),
+ *   cb: async ({ city }) => `The weather in ${city} is sunny.`,
+ * }
+ * ```
+ */
+interface ToolConfig<TInputSchema extends ZodObject$1<any> | Record<string, unknown> | undefined = any> extends Omit<SimpleToolConfig$1, 'inputSchema'> {
+  /**
+   * JSON Schema or Zod object schema describing the tool's expected input.
+   * When a Zod schema is provided, the `cb` parameter type is automatically inferred.
+   */
+  inputSchema?: TInputSchema;
+  /**
+   * Callback executed when the AI assistant invokes this tool.
+   * Receives the parsed input (typed from `inputSchema` if using Zod) and
+   * must return a {@link ToolCallbackResult}.
+   *
+   * @param input - The input arguments passed by the AI assistant, validated against `inputSchema`.
+   * @returns The tool result — either a string or `{ content, successText }`.
+   */
+  cb?: (input: InferToolInput<TInputSchema>) => Promise<ToolCallbackResult> | ToolCallbackResult;
+}
+/**
+ * Settings that can be updated after the widget has been initialized.
+ * Passed to {@link updateSettings} to modify user information at runtime.
+ */
+interface PluckyUpdateSettingsParams {
+  /** Updated user identification and metadata. Only provided fields are merged. */
+  user?: PluckySettingsParams['user'];
+}
+/**
+ * Maps every postMessage `type` string to its payload type.
+ *
+ * Both the loader (host-side transport) and the widget (IframeCommunicator)
+ * derive their typed `send` / `on` signatures from this interface.
+ * Adding a new message here automatically requires typed handling on both sides.
+ */
+//#endregion
+//#region ../loader/dist/load.d.ts
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/json-schema.d.cts
+type _JSONSchema = boolean | JSONSchema;
+type JSONSchema = {
+  [k: string]: unknown;
+  $schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#" | "http://json-schema.org/draft-04/schema#";
+  $id?: string;
+  $anchor?: string;
+  $ref?: string;
+  $dynamicRef?: string;
+  $dynamicAnchor?: string;
+  $vocabulary?: Record<string, boolean>;
+  $comment?: string;
+  $defs?: Record<string, JSONSchema>;
+  type?: "object" | "array" | "string" | "number" | "boolean" | "null" | "integer";
+  additionalItems?: _JSONSchema;
+  unevaluatedItems?: _JSONSchema;
+  prefixItems?: _JSONSchema[];
+  items?: _JSONSchema | _JSONSchema[];
+  contains?: _JSONSchema;
+  additionalProperties?: _JSONSchema;
+  unevaluatedProperties?: _JSONSchema;
+  properties?: Record<string, _JSONSchema>;
+  patternProperties?: Record<string, _JSONSchema>;
+  dependentSchemas?: Record<string, _JSONSchema>;
+  propertyNames?: _JSONSchema;
+  if?: _JSONSchema;
+  then?: _JSONSchema;
+  else?: _JSONSchema;
+  allOf?: JSONSchema[];
+  anyOf?: JSONSchema[];
+  oneOf?: JSONSchema[];
+  not?: _JSONSchema;
+  multipleOf?: number;
+  maximum?: number;
+  exclusiveMaximum?: number | boolean;
+  minimum?: number;
+  exclusiveMinimum?: number | boolean;
+  maxLength?: number;
+  minLength?: number;
+  pattern?: string;
+  maxItems?: number;
+  minItems?: number;
+  uniqueItems?: boolean;
+  maxContains?: number;
+  minContains?: number;
+  maxProperties?: number;
+  minProperties?: number;
+  required?: string[];
+  dependentRequired?: Record<string, string[]>;
+  enum?: Array<string | number | boolean | null>;
+  const?: string | number | boolean | null;
+  id?: string;
+  title?: string;
+  description?: string;
+  default?: unknown;
+  deprecated?: boolean;
+  readOnly?: boolean;
+  writeOnly?: boolean;
+  nullable?: boolean;
+  examples?: unknown[];
+  format?: string;
+  contentMediaType?: string;
+  contentEncoding?: string;
+  contentSchema?: JSONSchema;
+  _prefault?: unknown;
+};
+type BaseSchema = JSONSchema; //#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/standard-schema.d.cts
+/** The Standard interface. */
+interface StandardTypedV1<Input = unknown, Output = Input> {
+  /** The Standard properties. */
+  readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+  /** The Standard properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** The absence of issues indicates success. */
+    readonly issues?: undefined;
+  }
+  interface Options {
+    /** Implicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+/** The Standard JSON Schema interface. */
+interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard JSON Schema properties. */
+  readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardJSONSchemaV1 {
+  /** The Standard JSON Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Methods for generating the input/output JSON Schema. */
+    readonly jsonSchema: Converter;
+  }
+  /** The Standard JSON Schema converter interface. */
+  interface Converter {
+    /** Converts the input type to JSON Schema. May throw if conversion is not supported. */
+    readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+    /** Converts the output type to JSON Schema. May throw if conversion is not supported. */
+    readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+  }
+  /** The target version of the generated JSON Schema.
+   *
+   * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use.
+   *
+   * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
+   *
+   * All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
+   */
+  type Target = "draft-2020-12" | "draft-07" | "openapi-3.0" | ({} & string);
+  /** The options for the input/output methods. */
+  interface Options {
+    /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
+    readonly target: Target;
+    /** Implicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+interface StandardSchemaWithJSONProps<Input = unknown, Output = Input> extends StandardSchemaV1.Props<Input, Output>, StandardJSONSchemaV1.Props<Input, Output> {} //#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/registries.d.cts
+declare const $output: unique symbol;
+type $output = typeof $output;
+declare const $input: unique symbol;
+type $input = typeof $input;
+type $replace<Meta, S extends $ZodType> = Meta extends $output ? output<S> : Meta extends $input ? input<S> : Meta extends (infer M)[] ? $replace<M, S>[] : Meta extends ((...args: infer P) => infer R) ? (...args: { [K in keyof P]: $replace<P[K], S> }) => $replace<R, S> : Meta extends object ? { [K in keyof Meta]: $replace<Meta[K], S> } : Meta;
+type MetadataType = object | undefined;
+declare class $ZodRegistry<Meta extends MetadataType = MetadataType, Schema extends $ZodType = $ZodType> {
+  _meta: Meta;
+  _schema: Schema;
+  _map: WeakMap<Schema, $replace<Meta, Schema>>;
+  _idmap: Map<string, Schema>;
+  add<S extends Schema>(schema: S, ..._meta: undefined extends Meta ? [$replace<Meta, S>?] : [$replace<Meta, S>]): this;
+  clear(): this;
+  remove(schema: Schema): this;
+  get<S extends Schema>(schema: S): $replace<Meta, S> | undefined;
+  has(schema: Schema): boolean;
+}
+interface JSONSchemaMeta {
+  id?: string | undefined;
+  title?: string | undefined;
+  description?: string | undefined;
+  deprecated?: boolean | undefined;
+  [k: string]: unknown;
+}
+interface GlobalMeta extends JSONSchemaMeta {} //#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/to-json-schema.d.cts
+type Processor<T extends $ZodType = $ZodType> = (schema: T, ctx: ToJSONSchemaContext, json: BaseSchema, params: ProcessParams) => void;
+interface JSONSchemaGeneratorParams {
+  processors: Record<string, Processor>;
+  /** A registry used to look up metadata for each schema. Any schema with an `id` property will be extracted as a $def.
+   *  @default globalRegistry */
+  metadata?: $ZodRegistry<Record<string, any>>;
+  /** The JSON Schema version to target.
+   * - `"draft-2020-12"` — Default. JSON Schema Draft 2020-12
+   * - `"draft-07"` — JSON Schema Draft 7
+   * - `"draft-04"` — JSON Schema Draft 4
+   * - `"openapi-3.0"` — OpenAPI 3.0 Schema Object */
+  target?: "draft-04" | "draft-07" | "draft-2020-12" | "openapi-3.0" | ({} & string) | undefined;
+  /** How to handle unrepresentable types.
+   * - `"throw"` — Default. Unrepresentable types throw an error
+   * - `"any"` — Unrepresentable types become `{}` */
+  unrepresentable?: "throw" | "any";
+  /** Arbitrary custom logic that can be used to modify the generated JSON Schema. */
+  override?: (ctx: {
+    zodSchema: $ZodTypes;
+    jsonSchema: BaseSchema;
+    path: (string | number)[];
+  }) => void;
+  /** Whether to extract the `"input"` or `"output"` type. Relevant to transforms, defaults, coerced primitives, etc.
+   * - `"output"` — Default. Convert the output schema.
+   * - `"input"` — Convert the input schema. */
+  io?: "input" | "output";
+  cycles?: "ref" | "throw";
+  reused?: "ref" | "inline";
+  external?: {
+    registry: $ZodRegistry<{
+      id?: string | undefined;
+    }>;
+    uri?: ((id: string) => string) | undefined;
+    defs: Record<string, BaseSchema>;
+  } | undefined;
+}
+/**
+ * Parameters for the toJSONSchema function.
+ */
+type ToJSONSchemaParams = Omit<JSONSchemaGeneratorParams, "processors" | "external">;
+interface ProcessParams {
+  schemaPath: $ZodType[];
+  path: (string | number)[];
+}
+interface Seen {
+  /** JSON Schema result for this Zod schema */
+  schema: BaseSchema;
+  /** A cached version of the schema that doesn't get overwritten during ref resolution */
+  def?: BaseSchema;
+  defId?: string | undefined;
+  /** Number of times this schema was encountered during traversal */
+  count: number;
+  /** Cycle path */
+  cycle?: (string | number)[] | undefined;
+  isParent?: boolean | undefined;
+  /** Schema to inherit JSON Schema properties from (set by processor for wrappers) */
+  ref?: $ZodType | null;
+  /** JSON Schema property path for this schema */
+  path?: (string | number)[] | undefined;
+}
+interface ToJSONSchemaContext {
+  processors: Record<string, Processor>;
+  metadataRegistry: $ZodRegistry<Record<string, any>>;
+  target: "draft-04" | "draft-07" | "draft-2020-12" | "openapi-3.0" | ({} & string);
+  unrepresentable: "throw" | "any";
+  override: (ctx: {
+    zodSchema: $ZodType;
+    jsonSchema: BaseSchema;
+    path: (string | number)[];
+  }) => void;
+  io: "input" | "output";
+  counter: number;
+  seen: Map<$ZodType, Seen>;
+  cycles: "ref" | "throw";
+  reused: "ref" | "inline";
+  external?: {
+    registry: $ZodRegistry<{
+      id?: string | undefined;
+    }>;
+    uri?: ((id: string) => string) | undefined;
+    defs: Record<string, BaseSchema>;
+  } | undefined;
+}
+type ZodStandardSchemaWithJSON$1<T> = StandardSchemaWithJSONProps<input<T>, output<T>>;
+interface ZodStandardJSONSchemaPayload<T> extends BaseSchema {
+  "~standard": ZodStandardSchemaWithJSON$1<T>;
+} //#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/util.d.cts
+type MimeTypes = "application/json" | "application/xml" | "application/x-www-form-urlencoded" | "application/javascript" | "application/pdf" | "application/zip" | "application/vnd.ms-excel" | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "application/msword" | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/vnd.ms-powerpoint" | "application/vnd.openxmlformats-officedocument.presentationml.presentation" | "application/octet-stream" | "application/graphql" | "text/html" | "text/plain" | "text/css" | "text/javascript" | "text/csv" | "image/png" | "image/jpeg" | "image/gif" | "image/svg+xml" | "image/webp" | "audio/mpeg" | "audio/ogg" | "audio/wav" | "audio/webm" | "video/mp4" | "video/webm" | "video/ogg" | "font/woff" | "font/woff2" | "font/ttf" | "font/otf" | "multipart/form-data" | (string & {});
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type Omit$1<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+type MakePartial<T, K extends keyof T> = Omit$1<T, K> & InexactPartial<Pick<T, K>>;
+type NoUndefined<T> = T extends undefined ? never : T;
+type LoosePartial<T extends object> = InexactPartial<T> & {
+  [k: string]: unknown;
+};
+type Mask<Keys extends PropertyKey> = { [K in Keys]?: true };
+type InexactPartial<T> = { [P in keyof T]?: T[P] | undefined };
+type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
+  readonly [Symbol.toStringTag]: string;
+} | Date | Error | Generator | Promise<unknown> | RegExp;
+type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;
+type SomeObject = Record<PropertyKey, any>;
+type Identity<T> = T;
+type Flatten<T> = Identity<{ [k in keyof T]: T[k] }>;
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+type Extend<A extends SomeObject, B extends SomeObject> = Flatten<keyof A & keyof B extends never ? A & B : { [K in keyof A as K extends keyof B ? never : K]: A[K] } & { [K in keyof B]: B[K] }>;
+type TupleItems = ReadonlyArray<SomeType>;
+type AnyFunc = (...args: any[]) => any;
+type MaybeAsync<T> = T | Promise<T>;
+type EnumValue = string | number;
+type EnumLike = Readonly<Record<string, EnumValue>>;
+type ToEnum<T extends EnumValue> = Flatten<{ [k in T]: k }>;
+type Literal = string | number | bigint | boolean | null | undefined;
+type Primitive = string | number | symbol | bigint | boolean | null | undefined;
+type HasLength = {
+  length: number;
+};
+type PropValues = Record<string, Set<Primitive>>;
+type PrimitiveSet = Set<Primitive>;
+type EmptyToNever<T> = keyof T extends never ? never : T;
+declare abstract class Class {
+  constructor(..._args: any[]);
+} //#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/versions.d.cts
+declare const version: {
+  readonly major: 4;
+  readonly minor: 3;
+  readonly patch: number;
+}; //#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/schemas.d.cts
+interface ParseContext<T extends $ZodIssueBase = never> {
+  /** Customize error messages. */
+  readonly error?: $ZodErrorMap<T>;
+  /** Include the `input` field in issue objects. Default `false`. */
+  readonly reportInput?: boolean;
+  /** Skip eval-based fast path. Default `false`. */
+  readonly jitless?: boolean;
+}
+/** @internal */
+interface ParseContextInternal<T extends $ZodIssueBase = never> extends ParseContext<T> {
+  readonly async?: boolean | undefined;
+  readonly direction?: "forward" | "backward";
+  readonly skipChecks?: boolean;
+}
+interface ParsePayload<T = unknown> {
+  value: T;
+  issues: $ZodRawIssue[];
+  /** A may to mark a whole payload as aborted. Used in codecs/pipes. */
+  aborted?: boolean;
+}
+type CheckFn<T> = (input: ParsePayload<T>) => MaybeAsync<void>;
+interface $ZodTypeDef {
+  type: "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "null" | "undefined" | "void" | "never" | "any" | "unknown" | "date" | "object" | "record" | "file" | "array" | "tuple" | "union" | "intersection" | "map" | "set" | "enum" | "literal" | "nullable" | "optional" | "nonoptional" | "success" | "transform" | "default" | "prefault" | "catch" | "nan" | "pipe" | "readonly" | "template_literal" | "promise" | "lazy" | "function" | "custom";
+  error?: $ZodErrorMap<never> | undefined;
+  checks?: $ZodCheck<never>[];
+}
+interface _$ZodTypeInternals {
+  /** The `@zod/core` version of this schema */
+  version: typeof version;
+  /** Schema definition. */
+  def: $ZodTypeDef;
+  /** @internal Randomly generated ID for this schema. */
+  /** @internal List of deferred initializers. */
+  deferred: AnyFunc[] | undefined;
+  /** @internal Parses input and runs all checks (refinements). */
+  run(payload: ParsePayload<any>, ctx: ParseContextInternal): MaybeAsync<ParsePayload>;
+  /** @internal Parses input, doesn't run checks. */
+  parse(payload: ParsePayload<any>, ctx: ParseContextInternal): MaybeAsync<ParsePayload>;
+  /** @internal  Stores identifiers for the set of traits implemented by this schema. */
+  traits: Set<string>;
+  /** @internal Indicates that a schema output type should be considered optional inside objects.
+   * @default Required
+   */
+  /** @internal */
+  optin?: "optional" | undefined;
+  /** @internal */
+  optout?: "optional" | undefined;
+  /** @internal The set of literal values that will pass validation. Must be an exhaustive set. Used to determine optionality in z.record().
+   *
+   * Defined on: enum, const, literal, null, undefined
+   * Passthrough: optional, nullable, branded, default, catch, pipe
+   * Todo: unions?
+   */
+  values?: PrimitiveSet | undefined;
+  /** Default value bubbled up from  */
+  /** @internal A set of literal discriminators used for the fast path in discriminated unions. */
+  propValues?: PropValues | undefined;
+  /** @internal This flag indicates that a schema validation can be represented with a regular expression. Used to determine allowable schemas in z.templateLiteral(). */
+  pattern: RegExp | undefined;
+  /** @internal The constructor function of this schema. */
+  constr: new (def: any) => $ZodType;
+  /** @internal A catchall object for bag metadata related to this schema. Commonly modified by checks using `onattach`. */
+  bag: Record<string, unknown>;
+  /** @internal The set of issues this schema might throw during type checking. */
+  isst: $ZodIssueBase;
+  /** @internal Subject to change, not a public API. */
+  processJSONSchema?: ((ctx: ToJSONSchemaContext, json: BaseSchema, params: ProcessParams) => void) | undefined;
+  /** An optional method used to override `toJSONSchema` logic. */
+  toJSONSchema?: () => unknown;
+  /** @internal The parent of this schema. Only set during certain clone operations. */
+  parent?: $ZodType | undefined;
+}
+/** @internal */
+interface $ZodTypeInternals<out O = unknown, out I = unknown> extends _$ZodTypeInternals {
+  /** @internal The inferred output type */
+  output: O;
+  /** @internal The inferred input type */
+  input: I;
+}
+type $ZodStandardSchema<T> = StandardSchemaV1.Props<input<T>, output<T>>;
+type SomeType = {
+  _zod: _$ZodTypeInternals;
+};
+interface $ZodType<O = unknown, I = unknown, Internals extends $ZodTypeInternals<O, I> = $ZodTypeInternals<O, I>> {
+  _zod: Internals;
+  "~standard": $ZodStandardSchema<this>;
+}
+interface _$ZodType<T extends $ZodTypeInternals = $ZodTypeInternals> extends $ZodType<T["output"], T["input"], T> {}
+declare const $ZodType: $constructor<$ZodType>;
+interface $ZodStringDef extends $ZodTypeDef {
+  type: "string";
+  coerce?: boolean;
+  checks?: $ZodCheck<string>[];
+}
+interface $ZodStringInternals<Input> extends $ZodTypeInternals<string, Input> {
+  def: $ZodStringDef;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  pattern: RegExp;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  isst: $ZodIssueInvalidType;
+  bag: LoosePartial<{
+    minimum: number;
+    maximum: number;
+    patterns: Set<RegExp>;
+    format: string;
+    contentEncoding: string;
+  }>;
+}
+interface $ZodString<Input = unknown> extends _$ZodType<$ZodStringInternals<Input>> {}
+declare const $ZodString: $constructor<$ZodString>;
+interface $ZodNumberDef extends $ZodTypeDef {
+  type: "number";
+  coerce?: boolean;
+}
+interface $ZodNumberInternals<Input = unknown> extends $ZodTypeInternals<number, Input> {
+  def: $ZodNumberDef;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  pattern: RegExp;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  isst: $ZodIssueInvalidType;
+  bag: LoosePartial<{
+    minimum: number;
+    maximum: number;
+    exclusiveMinimum: number;
+    exclusiveMaximum: number;
+    format: string;
+    pattern: RegExp;
+  }>;
+}
+interface $ZodNumber<Input = unknown> extends $ZodType {
+  _zod: $ZodNumberInternals<Input>;
+}
+declare const $ZodNumber: $constructor<$ZodNumber>;
+interface $ZodBooleanDef extends $ZodTypeDef {
+  type: "boolean";
+  coerce?: boolean;
+  checks?: $ZodCheck<boolean>[];
+}
+interface $ZodBooleanInternals<T = unknown> extends $ZodTypeInternals<boolean, T> {
+  pattern: RegExp;
+  def: $ZodBooleanDef;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodBoolean<T = unknown> extends $ZodType {
+  _zod: $ZodBooleanInternals<T>;
+}
+declare const $ZodBoolean: $constructor<$ZodBoolean>;
+interface $ZodBigIntDef extends $ZodTypeDef {
+  type: "bigint";
+  coerce?: boolean;
+}
+interface $ZodBigIntInternals<T = unknown> extends $ZodTypeInternals<bigint, T> {
+  pattern: RegExp;
+  /** @internal Internal API, use with caution */
+  def: $ZodBigIntDef;
+  isst: $ZodIssueInvalidType;
+  bag: LoosePartial<{
+    minimum: bigint;
+    maximum: bigint;
+    format: string;
+  }>;
+}
+interface $ZodBigInt<T = unknown> extends $ZodType {
+  _zod: $ZodBigIntInternals<T>;
+}
+declare const $ZodBigInt: $constructor<$ZodBigInt>;
+interface $ZodSymbolDef extends $ZodTypeDef {
+  type: "symbol";
+}
+interface $ZodSymbolInternals extends $ZodTypeInternals<symbol, symbol> {
+  def: $ZodSymbolDef;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodSymbol extends $ZodType {
+  _zod: $ZodSymbolInternals;
+}
+declare const $ZodSymbol: $constructor<$ZodSymbol>;
+interface $ZodUndefinedDef extends $ZodTypeDef {
+  type: "undefined";
+}
+interface $ZodUndefinedInternals extends $ZodTypeInternals<undefined, undefined> {
+  pattern: RegExp;
+  def: $ZodUndefinedDef;
+  values: PrimitiveSet;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodUndefined extends $ZodType {
+  _zod: $ZodUndefinedInternals;
+}
+declare const $ZodUndefined: $constructor<$ZodUndefined>;
+interface $ZodNullDef extends $ZodTypeDef {
+  type: "null";
+}
+interface $ZodNullInternals extends $ZodTypeInternals<null, null> {
+  pattern: RegExp;
+  def: $ZodNullDef;
+  values: PrimitiveSet;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodNull extends $ZodType {
+  _zod: $ZodNullInternals;
+}
+declare const $ZodNull: $constructor<$ZodNull>;
+interface $ZodAnyDef extends $ZodTypeDef {
+  type: "any";
+}
+interface $ZodAnyInternals extends $ZodTypeInternals<any, any> {
+  def: $ZodAnyDef;
+  isst: never;
+}
+interface $ZodAny extends $ZodType {
+  _zod: $ZodAnyInternals;
+}
+declare const $ZodAny: $constructor<$ZodAny>;
+interface $ZodUnknownDef extends $ZodTypeDef {
+  type: "unknown";
+}
+interface $ZodUnknownInternals extends $ZodTypeInternals<unknown, unknown> {
+  def: $ZodUnknownDef;
+  isst: never;
+}
+interface $ZodUnknown extends $ZodType {
+  _zod: $ZodUnknownInternals;
+}
+declare const $ZodUnknown: $constructor<$ZodUnknown>;
+interface $ZodNeverDef extends $ZodTypeDef {
+  type: "never";
+}
+interface $ZodNeverInternals extends $ZodTypeInternals<never, never> {
+  def: $ZodNeverDef;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodNever extends $ZodType {
+  _zod: $ZodNeverInternals;
+}
+declare const $ZodNever: $constructor<$ZodNever>;
+interface $ZodVoidDef extends $ZodTypeDef {
+  type: "void";
+}
+interface $ZodVoidInternals extends $ZodTypeInternals<void, void> {
+  def: $ZodVoidDef;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodVoid extends $ZodType {
+  _zod: $ZodVoidInternals;
+}
+declare const $ZodVoid: $constructor<$ZodVoid>;
+interface $ZodDateDef extends $ZodTypeDef {
+  type: "date";
+  coerce?: boolean;
+}
+interface $ZodDateInternals<T = unknown> extends $ZodTypeInternals<Date, T> {
+  def: $ZodDateDef;
+  isst: $ZodIssueInvalidType;
+  bag: LoosePartial<{
+    minimum: Date;
+    maximum: Date;
+    format: string;
+  }>;
+}
+interface $ZodDate<T = unknown> extends $ZodType {
+  _zod: $ZodDateInternals<T>;
+}
+declare const $ZodDate: $constructor<$ZodDate>;
+interface $ZodArrayDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "array";
+  element: T;
+}
+interface $ZodArrayInternals<T extends SomeType = $ZodType> extends _$ZodTypeInternals {
+  def: $ZodArrayDef<T>;
+  isst: $ZodIssueInvalidType;
+  output: output<T>[];
+  input: input<T>[];
+}
+interface $ZodArray<T extends SomeType = $ZodType> extends $ZodType<any, any, $ZodArrayInternals<T>> {}
+declare const $ZodArray: $constructor<$ZodArray>;
+type OptionalOutSchema = {
+  _zod: {
+    optout: "optional";
+  };
+};
+type OptionalInSchema = {
+  _zod: {
+    optin: "optional";
+  };
+};
+type $InferObjectOutput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? IsAny<T[keyof T]> extends true ? Record<string, unknown> : Record<string, output<T[keyof T]>> : keyof (T & Extra) extends never ? Record<string, never> : Prettify<{ -readonly [k in keyof T as T[k] extends OptionalOutSchema ? never : k]: T[k]["_zod"]["output"] } & { -readonly [k in keyof T as T[k] extends OptionalOutSchema ? k : never]?: T[k]["_zod"]["output"] } & Extra>;
+type $InferObjectInput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? IsAny<T[keyof T]> extends true ? Record<string, unknown> : Record<string, input<T[keyof T]>> : keyof (T & Extra) extends never ? Record<string, never> : Prettify<{ -readonly [k in keyof T as T[k] extends OptionalInSchema ? never : k]: T[k]["_zod"]["input"] } & { -readonly [k in keyof T as T[k] extends OptionalInSchema ? k : never]?: T[k]["_zod"]["input"] } & Extra>;
+type $ZodObjectConfig = {
+  out: Record<string, unknown>;
+  in: Record<string, unknown>;
+};
+type $loose = {
+  out: Record<string, unknown>;
+  in: Record<string, unknown>;
+};
+type $strict = {
+  out: {};
+  in: {};
+};
+type $strip = {
+  out: {};
+  in: {};
+};
+type $catchall<T extends SomeType> = {
+  out: {
+    [k: string]: output<T>;
+  };
+  in: {
+    [k: string]: input<T>;
+  };
+};
+type $ZodShape = Readonly<{
+  [k: string]: $ZodType;
+}>;
+interface $ZodObjectDef<Shape extends $ZodShape = $ZodShape> extends $ZodTypeDef {
+  type: "object";
+  shape: Shape;
+  catchall?: $ZodType | undefined;
+}
+interface $ZodObjectInternals< /** @ts-ignore Cast variance */out Shape extends $ZodShape = $ZodShape, out Config extends $ZodObjectConfig = $ZodObjectConfig> extends _$ZodTypeInternals {
+  def: $ZodObjectDef<Shape>;
+  config: Config;
+  isst: $ZodIssueInvalidType | $ZodIssueUnrecognizedKeys;
+  propValues: PropValues;
+  output: $InferObjectOutput<Shape, Config["out"]>;
+  input: $InferObjectInput<Shape, Config["in"]>;
+  optin?: "optional" | undefined;
+  optout?: "optional" | undefined;
+}
+type $ZodLooseShape = Record<string, any>;
+interface $ZodObject< /** @ts-ignore Cast variance */out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Params extends $ZodObjectConfig = $ZodObjectConfig> extends $ZodType<any, any, $ZodObjectInternals<Shape, Params>> {}
+declare const $ZodObject: $constructor<$ZodObject>;
+type $InferUnionOutput<T extends SomeType> = T extends any ? output<T> : never;
+type $InferUnionInput<T extends SomeType> = T extends any ? input<T> : never;
+interface $ZodUnionDef<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodTypeDef {
+  type: "union";
+  options: Options;
+  inclusive?: boolean;
+}
+type IsOptionalIn<T extends SomeType> = T extends OptionalInSchema ? true : false;
+type IsOptionalOut<T extends SomeType> = T extends OptionalOutSchema ? true : false;
+interface $ZodUnionInternals<T extends readonly SomeType[] = readonly $ZodType[]> extends _$ZodTypeInternals {
+  def: $ZodUnionDef<T>;
+  isst: $ZodIssueInvalidUnion;
+  pattern: T[number]["_zod"]["pattern"];
+  values: T[number]["_zod"]["values"];
+  output: $InferUnionOutput<T[number]>;
+  input: $InferUnionInput<T[number]>;
+  optin: IsOptionalIn<T[number]> extends false ? "optional" | undefined : "optional";
+  optout: IsOptionalOut<T[number]> extends false ? "optional" | undefined : "optional";
+}
+interface $ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType<any, any, $ZodUnionInternals<T>> {
+  _zod: $ZodUnionInternals<T>;
+}
+declare const $ZodUnion: $constructor<$ZodUnion>;
+interface $ZodIntersectionDef<Left extends SomeType = $ZodType, Right extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "intersection";
+  left: Left;
+  right: Right;
+}
+interface $ZodIntersectionInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _$ZodTypeInternals {
+  def: $ZodIntersectionDef<A, B>;
+  isst: never;
+  optin: A["_zod"]["optin"] | B["_zod"]["optin"];
+  optout: A["_zod"]["optout"] | B["_zod"]["optout"];
+  output: output<A> & output<B>;
+  input: input<A> & input<B>;
+}
+interface $ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodIntersectionInternals<A, B>;
+}
+declare const $ZodIntersection: $constructor<$ZodIntersection>;
+interface $ZodTupleDef<T extends TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends $ZodTypeDef {
+  type: "tuple";
+  items: T;
+  rest: Rest;
+}
+type $InferTupleInputType<T extends TupleItems, Rest extends SomeType | null> = [...TupleInputTypeWithOptionals<T>, ...(Rest extends SomeType ? input<Rest>[] : [])];
+type TupleInputTypeNoOptionals<T extends TupleItems> = { [k in keyof T]: input<T[k]> };
+type TupleInputTypeWithOptionals<T extends TupleItems> = T extends readonly [...infer Prefix extends SomeType[], infer Tail extends SomeType] ? Tail["_zod"]["optin"] extends "optional" ? [...TupleInputTypeWithOptionals<Prefix>, input<Tail>?] : TupleInputTypeNoOptionals<T> : [];
+type $InferTupleOutputType<T extends TupleItems, Rest extends SomeType | null> = [...TupleOutputTypeWithOptionals<T>, ...(Rest extends SomeType ? output<Rest>[] : [])];
+type TupleOutputTypeNoOptionals<T extends TupleItems> = { [k in keyof T]: output<T[k]> };
+type TupleOutputTypeWithOptionals<T extends TupleItems> = T extends readonly [...infer Prefix extends SomeType[], infer Tail extends SomeType] ? Tail["_zod"]["optout"] extends "optional" ? [...TupleOutputTypeWithOptionals<Prefix>, output<Tail>?] : TupleOutputTypeNoOptionals<T> : [];
+interface $ZodTupleInternals<T extends TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends _$ZodTypeInternals {
+  def: $ZodTupleDef<T, Rest>;
+  isst: $ZodIssueInvalidType | $ZodIssueTooBig<unknown[]> | $ZodIssueTooSmall<unknown[]>;
+  output: $InferTupleOutputType<T, Rest>;
+  input: $InferTupleInputType<T, Rest>;
+}
+interface $ZodTuple<T extends TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends $ZodType {
+  _zod: $ZodTupleInternals<T, Rest>;
+}
+declare const $ZodTuple: $constructor<$ZodTuple>;
+type $ZodRecordKey = $ZodType<string | number | symbol, unknown>;
+interface $ZodRecordDef<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "record";
+  keyType: Key;
+  valueType: Value;
+  /** @default "strict" - errors on keys not matching keyType. "loose" passes through non-matching keys unchanged. */
+  mode?: "strict" | "loose";
+}
+type $InferZodRecordOutput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<output<Key>, output<Value>>> : Record<output<Key>, output<Value>>;
+type $InferZodRecordInput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<input<Key> & PropertyKey, input<Value>>> : Record<input<Key> & PropertyKey, input<Value>>;
+interface $ZodRecordInternals<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeInternals<$InferZodRecordOutput<Key, Value>, $InferZodRecordInput<Key, Value>> {
+  def: $ZodRecordDef<Key, Value>;
+  isst: $ZodIssueInvalidType | $ZodIssueInvalidKey<Record<PropertyKey, unknown>>;
+  optin?: "optional" | undefined;
+  optout?: "optional" | undefined;
+}
+type $partial = {
+  "~~partial": true;
+};
+interface $ZodRecord<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodRecordInternals<Key, Value>;
+}
+declare const $ZodRecord: $constructor<$ZodRecord>;
+interface $ZodMapDef<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "map";
+  keyType: Key;
+  valueType: Value;
+}
+interface $ZodMapInternals<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodTypeInternals<Map<output<Key>, output<Value>>, Map<input<Key>, input<Value>>> {
+  def: $ZodMapDef<Key, Value>;
+  isst: $ZodIssueInvalidType | $ZodIssueInvalidKey | $ZodIssueInvalidElement<unknown>;
+  optin?: "optional" | undefined;
+  optout?: "optional" | undefined;
+}
+interface $ZodMap<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodMapInternals<Key, Value>;
+}
+declare const $ZodMap: $constructor<$ZodMap>;
+interface $ZodSetDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "set";
+  valueType: T;
+}
+interface $ZodSetInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<Set<output<T>>, Set<input<T>>> {
+  def: $ZodSetDef<T>;
+  isst: $ZodIssueInvalidType;
+  optin?: "optional" | undefined;
+  optout?: "optional" | undefined;
+}
+interface $ZodSet<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodSetInternals<T>;
+}
+declare const $ZodSet: $constructor<$ZodSet>;
+type $InferEnumOutput<T extends EnumLike> = T[keyof T] & {};
+type $InferEnumInput<T extends EnumLike> = T[keyof T] & {};
+interface $ZodEnumDef<T extends EnumLike = EnumLike> extends $ZodTypeDef {
+  type: "enum";
+  entries: T;
+}
+interface $ZodEnumInternals< /** @ts-ignore Cast variance */out T extends EnumLike = EnumLike> extends $ZodTypeInternals<$InferEnumOutput<T>, $InferEnumInput<T>> {
+  def: $ZodEnumDef<T>;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  values: PrimitiveSet;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  pattern: RegExp;
+  isst: $ZodIssueInvalidValue;
+}
+interface $ZodEnum<T extends EnumLike = EnumLike> extends $ZodType {
+  _zod: $ZodEnumInternals<T>;
+}
+declare const $ZodEnum: $constructor<$ZodEnum>;
+interface $ZodLiteralDef<T extends Literal> extends $ZodTypeDef {
+  type: "literal";
+  values: T[];
+}
+interface $ZodLiteralInternals<T extends Literal = Literal> extends $ZodTypeInternals<T, T> {
+  def: $ZodLiteralDef<T>;
+  values: Set<T>;
+  pattern: RegExp;
+  isst: $ZodIssueInvalidValue;
+}
+interface $ZodLiteral<T extends Literal = Literal> extends $ZodType {
+  _zod: $ZodLiteralInternals<T>;
+}
+declare const $ZodLiteral: $constructor<$ZodLiteral>;
+type _File = typeof globalThis extends {
+  File: infer F extends new (...args: any[]) => any;
+} ? InstanceType<F> : {};
+/** Do not reference this directly. */
+interface File extends _File {
+  readonly type: string;
+  readonly size: number;
+}
+interface $ZodFileDef extends $ZodTypeDef {
+  type: "file";
+}
+interface $ZodFileInternals extends $ZodTypeInternals<File, File> {
+  def: $ZodFileDef;
+  isst: $ZodIssueInvalidType;
+  bag: LoosePartial<{
+    minimum: number;
+    maximum: number;
+    mime: MimeTypes[];
+  }>;
+}
+interface $ZodFile extends $ZodType {
+  _zod: $ZodFileInternals;
+}
+declare const $ZodFile: $constructor<$ZodFile>;
+interface $ZodTransformDef extends $ZodTypeDef {
+  type: "transform";
+  transform: (input: unknown, payload: ParsePayload<unknown>) => MaybeAsync<unknown>;
+}
+interface $ZodTransformInternals<O = unknown, I = unknown> extends $ZodTypeInternals<O, I> {
+  def: $ZodTransformDef;
+  isst: never;
+}
+interface $ZodTransform<O = unknown, I = unknown> extends $ZodType {
+  _zod: $ZodTransformInternals<O, I>;
+}
+declare const $ZodTransform: $constructor<$ZodTransform>;
+interface $ZodOptionalDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "optional";
+  innerType: T;
+}
+interface $ZodOptionalInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T> | undefined, input<T> | undefined> {
+  def: $ZodOptionalDef<T>;
+  optin: "optional";
+  optout: "optional";
+  isst: never;
+  values: T["_zod"]["values"];
+  pattern: T["_zod"]["pattern"];
+}
+interface $ZodOptional<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodOptionalInternals<T>;
+}
+declare const $ZodOptional: $constructor<$ZodOptional>;
+interface $ZodExactOptionalDef<T extends SomeType = $ZodType> extends $ZodOptionalDef<T> {}
+interface $ZodExactOptionalInternals<T extends SomeType = $ZodType> extends $ZodOptionalInternals<T> {
+  def: $ZodExactOptionalDef<T>;
+  output: output<T>;
+  input: input<T>;
+}
+interface $ZodExactOptional<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodExactOptionalInternals<T>;
+}
+declare const $ZodExactOptional: $constructor<$ZodExactOptional>;
+interface $ZodNullableDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "nullable";
+  innerType: T;
+}
+interface $ZodNullableInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T> | null, input<T> | null> {
+  def: $ZodNullableDef<T>;
+  optin: T["_zod"]["optin"];
+  optout: T["_zod"]["optout"];
+  isst: never;
+  values: T["_zod"]["values"];
+  pattern: T["_zod"]["pattern"];
+}
+interface $ZodNullable<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodNullableInternals<T>;
+}
+declare const $ZodNullable: $constructor<$ZodNullable>;
+interface $ZodDefaultDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "default";
+  innerType: T;
+  /** The default value. May be a getter. */
+  defaultValue: NoUndefined<output<T>>;
+}
+interface $ZodDefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T>>, input<T> | undefined> {
+  def: $ZodDefaultDef<T>;
+  optin: "optional";
+  optout?: "optional" | undefined;
+  isst: never;
+  values: T["_zod"]["values"];
+}
+interface $ZodDefault<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodDefaultInternals<T>;
+}
+declare const $ZodDefault: $constructor<$ZodDefault>;
+interface $ZodPrefaultDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "prefault";
+  innerType: T;
+  /** The default value. May be a getter. */
+  defaultValue: input<T>;
+}
+interface $ZodPrefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T>>, input<T> | undefined> {
+  def: $ZodPrefaultDef<T>;
+  optin: "optional";
+  optout?: "optional" | undefined;
+  isst: never;
+  values: T["_zod"]["values"];
+}
+interface $ZodPrefault<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodPrefaultInternals<T>;
+}
+declare const $ZodPrefault: $constructor<$ZodPrefault>;
+interface $ZodNonOptionalDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "nonoptional";
+  innerType: T;
+}
+interface $ZodNonOptionalInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T>>, NoUndefined<input<T>>> {
+  def: $ZodNonOptionalDef<T>;
+  isst: $ZodIssueInvalidType;
+  values: T["_zod"]["values"];
+  optin: "optional" | undefined;
+  optout: "optional" | undefined;
+}
+interface $ZodNonOptional<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodNonOptionalInternals<T>;
+}
+declare const $ZodNonOptional: $constructor<$ZodNonOptional>;
+interface $ZodSuccessDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "success";
+  innerType: T;
+}
+interface $ZodSuccessInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<boolean, input<T>> {
+  def: $ZodSuccessDef<T>;
+  isst: never;
+  optin: T["_zod"]["optin"];
+  optout: "optional" | undefined;
+}
+interface $ZodSuccess<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodSuccessInternals<T>;
+}
+declare const $ZodSuccess: $constructor<$ZodSuccess>;
+interface $ZodCatchCtx extends ParsePayload {
+  /** @deprecated Use `ctx.issues` */
+  error: {
+    issues: $ZodIssue[];
+  };
+  /** @deprecated Use `ctx.value` */
+  input: unknown;
+}
+interface $ZodCatchDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "catch";
+  innerType: T;
+  catchValue: (ctx: $ZodCatchCtx) => unknown;
+}
+interface $ZodCatchInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T>, input<T>> {
+  def: $ZodCatchDef<T>;
+  optin: T["_zod"]["optin"];
+  optout: T["_zod"]["optout"];
+  isst: never;
+  values: T["_zod"]["values"];
+}
+interface $ZodCatch<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodCatchInternals<T>;
+}
+declare const $ZodCatch: $constructor<$ZodCatch>;
+interface $ZodNaNDef extends $ZodTypeDef {
+  type: "nan";
+}
+interface $ZodNaNInternals extends $ZodTypeInternals<number, number> {
+  def: $ZodNaNDef;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodNaN extends $ZodType {
+  _zod: $ZodNaNInternals;
+}
+declare const $ZodNaN: $constructor<$ZodNaN>;
+interface $ZodPipeDef<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "pipe";
+  in: A;
+  out: B;
+  /** Only defined inside $ZodCodec instances. */
+  transform?: (value: output<A>, payload: ParsePayload<output<A>>) => MaybeAsync<input<B>>;
+  /** Only defined inside $ZodCodec instances. */
+  reverseTransform?: (value: input<B>, payload: ParsePayload<input<B>>) => MaybeAsync<output<A>>;
+}
+interface $ZodPipeInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<output<B>, input<A>> {
+  def: $ZodPipeDef<A, B>;
+  isst: never;
+  values: A["_zod"]["values"];
+  optin: A["_zod"]["optin"];
+  optout: B["_zod"]["optout"];
+  propValues: A["_zod"]["propValues"];
+}
+interface $ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodPipeInternals<A, B>;
+}
+declare const $ZodPipe: $constructor<$ZodPipe>;
+interface $ZodReadonlyDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "readonly";
+  innerType: T;
+}
+interface $ZodReadonlyInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<MakeReadonly<output<T>>, MakeReadonly<input<T>>> {
+  def: $ZodReadonlyDef<T>;
+  optin: T["_zod"]["optin"];
+  optout: T["_zod"]["optout"];
+  isst: never;
+  propValues: T["_zod"]["propValues"];
+  values: T["_zod"]["values"];
+}
+interface $ZodReadonly<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodReadonlyInternals<T>;
+}
+declare const $ZodReadonly: $constructor<$ZodReadonly>;
+interface $ZodTemplateLiteralDef extends $ZodTypeDef {
+  type: "template_literal";
+  parts: $ZodTemplateLiteralPart[];
+  format?: string | undefined;
+}
+interface $ZodTemplateLiteralInternals<Template extends string = string> extends $ZodTypeInternals<Template, Template> {
+  pattern: RegExp;
+  def: $ZodTemplateLiteralDef;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodTemplateLiteral<Template extends string = string> extends $ZodType {
+  _zod: $ZodTemplateLiteralInternals<Template>;
+}
+type LiteralPart = Exclude<Literal, symbol>;
+interface SchemaPartInternals extends $ZodTypeInternals<LiteralPart, LiteralPart> {
+  pattern: RegExp;
+}
+interface SchemaPart extends $ZodType {
+  _zod: SchemaPartInternals;
+}
+type $ZodTemplateLiteralPart = LiteralPart | SchemaPart;
+declare const $ZodTemplateLiteral: $constructor<$ZodTemplateLiteral>;
+type $ZodFunctionArgs = $ZodType<unknown[], unknown[]>;
+type $ZodFunctionIn = $ZodFunctionArgs;
+type $ZodFunctionOut = $ZodType;
+type $InferInnerFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : output<Args>) => input<Returns>;
+type $InferInnerFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : output<Args>) => MaybeAsync<input<Returns>>;
+type $InferOuterFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : input<Args>) => output<Returns>;
+type $InferOuterFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : input<Args>) => Promise<output<Returns>>;
+interface $ZodFunctionDef<In extends $ZodFunctionIn = $ZodFunctionIn, Out extends $ZodFunctionOut = $ZodFunctionOut> extends $ZodTypeDef {
+  type: "function";
+  input: In;
+  output: Out;
+}
+interface $ZodFunctionInternals<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> extends $ZodTypeInternals<$InferOuterFunctionType<Args, Returns>, $InferInnerFunctionType<Args, Returns>> {
+  def: $ZodFunctionDef<Args, Returns>;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodFunction<Args extends $ZodFunctionIn = $ZodFunctionIn, Returns extends $ZodFunctionOut = $ZodFunctionOut> extends $ZodType<any, any, $ZodFunctionInternals<Args, Returns>> {
+  /** @deprecated */
+  _def: $ZodFunctionDef<Args, Returns>;
+  _input: $InferInnerFunctionType<Args, Returns>;
+  _output: $InferOuterFunctionType<Args, Returns>;
+  implement<F extends $InferInnerFunctionType<Args, Returns>>(func: F): (...args: Parameters<this["_output"]>) => ReturnType<F> extends ReturnType<this["_output"]> ? ReturnType<F> : ReturnType<this["_output"]>;
+  implementAsync<F extends $InferInnerFunctionTypeAsync<Args, Returns>>(func: F): F extends $InferOuterFunctionTypeAsync<Args, Returns> ? F : $InferOuterFunctionTypeAsync<Args, Returns>;
+  input<const Items extends TupleItems, const Rest extends $ZodFunctionOut = $ZodFunctionOut>(args: Items, rest?: Rest): $ZodFunction<$ZodTuple<Items, Rest>, Returns>;
+  input<NewArgs extends $ZodFunctionIn>(args: NewArgs): $ZodFunction<NewArgs, Returns>;
+  input(...args: any[]): $ZodFunction<any, Returns>;
+  output<NewReturns extends $ZodType>(output: NewReturns): $ZodFunction<Args, NewReturns>;
+}
+declare const $ZodFunction: $constructor<$ZodFunction>;
+interface $ZodPromiseDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "promise";
+  innerType: T;
+}
+interface $ZodPromiseInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<Promise<output<T>>, MaybeAsync<input<T>>> {
+  def: $ZodPromiseDef<T>;
+  isst: never;
+}
+interface $ZodPromise<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodPromiseInternals<T>;
+}
+declare const $ZodPromise: $constructor<$ZodPromise>;
+interface $ZodLazyDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "lazy";
+  getter: () => T;
+}
+interface $ZodLazyInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T>, input<T>> {
+  def: $ZodLazyDef<T>;
+  isst: never;
+  /** Auto-cached way to retrieve the inner schema */
+  innerType: T;
+  pattern: T["_zod"]["pattern"];
+  propValues: T["_zod"]["propValues"];
+  optin: T["_zod"]["optin"];
+  optout: T["_zod"]["optout"];
+}
+interface $ZodLazy<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodLazyInternals<T>;
+}
+declare const $ZodLazy: $constructor<$ZodLazy>;
+interface $ZodCustomDef<O = unknown> extends $ZodTypeDef, $ZodCheckDef {
+  type: "custom";
+  check: "custom";
+  path?: PropertyKey[] | undefined;
+  error?: $ZodErrorMap | undefined;
+  params?: Record<string, any> | undefined;
+  fn: (arg: O) => unknown;
+}
+interface $ZodCustomInternals<O = unknown, I = unknown> extends $ZodTypeInternals<O, I>, $ZodCheckInternals<O> {
+  def: $ZodCustomDef;
+  issc: $ZodIssue;
+  isst: never;
+  bag: LoosePartial<{
+    Class: typeof Class;
+  }>;
+}
+interface $ZodCustom<O = unknown, I = unknown> extends $ZodType {
+  _zod: $ZodCustomInternals<O, I>;
+}
+declare const $ZodCustom: $constructor<$ZodCustom>;
+type $ZodTypes = $ZodString | $ZodNumber | $ZodBigInt | $ZodBoolean | $ZodDate | $ZodSymbol | $ZodUndefined | $ZodNullable | $ZodNull | $ZodAny | $ZodUnknown | $ZodNever | $ZodVoid | $ZodArray | $ZodObject | $ZodUnion | $ZodIntersection | $ZodTuple | $ZodRecord | $ZodMap | $ZodSet | $ZodLiteral | $ZodEnum | $ZodFunction | $ZodPromise | $ZodLazy | $ZodOptional | $ZodDefault | $ZodPrefault | $ZodTemplateLiteral | $ZodCustom | $ZodTransform | $ZodNonOptional | $ZodReadonly | $ZodNaN | $ZodPipe | $ZodSuccess | $ZodCatch | $ZodFile; //#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.5/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 $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"; //#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/core/errors.d.cts
+interface $ZodIssueBase {
+  readonly code?: string;
+  readonly input?: unknown;
+  readonly path: PropertyKey[];
+  readonly message: string;
+}
+type $ZodInvalidTypeExpected = "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "undefined" | "null" | "never" | "void" | "date" | "array" | "object" | "tuple" | "record" | "map" | "set" | "file" | "nonoptional" | "nan" | "function" | (string & {});
+interface $ZodIssueInvalidType<Input = unknown> extends $ZodIssueBase {
+  readonly code: "invalid_type";
+  readonly expected: $ZodInvalidTypeExpected;
+  readonly input?: Input;
+}
+interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
+  readonly code: "too_big";
+  readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
+  readonly maximum: number | bigint;
+  readonly inclusive?: boolean;
+  readonly exact?: boolean;
+  readonly input?: Input;
+}
+interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {
+  readonly code: "too_small";
+  readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
+  readonly minimum: number | bigint;
+  /** True if the allowable range includes the minimum */
+  readonly inclusive?: boolean;
+  /** True if the allowed value is fixed (e.g.` z.length(5)`), not a range (`z.minLength(5)`) */
+  readonly exact?: boolean;
+  readonly input?: Input;
+}
+interface $ZodIssueInvalidStringFormat extends $ZodIssueBase {
+  readonly code: "invalid_format";
+  readonly format: $ZodStringFormats | (string & {});
+  readonly pattern?: string;
+  readonly input?: string;
+}
+interface $ZodIssueNotMultipleOf<Input extends number | bigint = number | bigint> extends $ZodIssueBase {
+  readonly code: "not_multiple_of";
+  readonly divisor: number;
+  readonly input?: Input;
+}
+interface $ZodIssueUnrecognizedKeys extends $ZodIssueBase {
+  readonly code: "unrecognized_keys";
+  readonly keys: string[];
+  readonly input?: Record<string, unknown>;
+}
+interface $ZodIssueInvalidUnionNoMatch extends $ZodIssueBase {
+  readonly code: "invalid_union";
+  readonly errors: $ZodIssue[][];
+  readonly input?: unknown;
+  readonly discriminator?: string | undefined;
+  readonly inclusive?: true;
+}
+interface $ZodIssueInvalidUnionMultipleMatch extends $ZodIssueBase {
+  readonly code: "invalid_union";
+  readonly errors: [];
+  readonly input?: unknown;
+  readonly discriminator?: string | undefined;
+  readonly inclusive: false;
+}
+type $ZodIssueInvalidUnion = $ZodIssueInvalidUnionNoMatch | $ZodIssueInvalidUnionMultipleMatch;
+interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
+  readonly code: "invalid_key";
+  readonly origin: "map" | "record";
+  readonly issues: $ZodIssue[];
+  readonly input?: Input;
+}
+interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase {
+  readonly code: "invalid_element";
+  readonly origin: "map" | "set";
+  readonly key: unknown;
+  readonly issues: $ZodIssue[];
+  readonly input?: Input;
+}
+interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {
+  readonly code: "invalid_value";
+  readonly values: Primitive[];
+  readonly input?: Input;
+}
+interface $ZodIssueCustom extends $ZodIssueBase {
+  readonly code: "custom";
+  readonly params?: Record<string, any> | undefined;
+  readonly input?: unknown;
+}
+type $ZodIssue = $ZodIssueInvalidType | $ZodIssueTooBig | $ZodIssueTooSmall | $ZodIssueInvalidStringFormat | $ZodIssueNotMultipleOf | $ZodIssueUnrecognizedKeys | $ZodIssueInvalidUnion | $ZodIssueInvalidKey | $ZodIssueInvalidElement | $ZodIssueInvalidValue | $ZodIssueCustom;
+type $ZodInternalIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue$1<T> : never;
+type RawIssue$1<T extends $ZodIssueBase> = T extends any ? Flatten<MakePartial<T, "message" | "path"> & {
+  /** The input data */readonly input: unknown; /** The schema or check that originated this issue. */
+  readonly inst?: $ZodType | $ZodCheck; /** If `true`, Zod will continue executing checks/refinements after this issue. */
+  readonly continue?: boolean | undefined;
+} & Record<string, unknown>> : never;
+type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = $ZodInternalIssue<T>;
+interface $ZodErrorMap<T extends $ZodIssueBase = $ZodIssue> {
+  (issue: $ZodRawIssue<T>): {
+    message: string;
+  } | string | undefined | null;
+}
+interface $ZodError<T = unknown> extends Error {
+  type: T;
+  issues: $ZodIssue[];
+  _zod: {
+    output: T;
+    def: $ZodIssue[];
+  };
+  stack?: string;
+  name: string;
+}
+declare const $ZodError: $constructor<$ZodError>;
+type $ZodFlattenedError<T, U = string> = _FlattenedError<T, U>;
+type _FlattenedError<T, U = string> = {
+  formErrors: U[];
+  fieldErrors: { [P in keyof T]?: U[] };
+};
+type _ZodFormattedError<T, U = string> = T extends [any, ...any[]] ? { [K in keyof T]?: $ZodFormattedError<T[K], U> } : T extends any[] ? {
+  [k: number]: $ZodFormattedError<T[number], U>;
+} : T extends object ? Flatten<{ [K in keyof T]?: $ZodFormattedError<T[K], U> }> : any;
+type $ZodFormattedError<T, U = string> = {
+  _errors: U[];
+} & Flatten<_ZodFormattedError<T, U>>; //#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.5/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, 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>;
+  };
+});
+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
+//#region ../../node_modules/.pnpm/zod@4.3.5/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 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 $ZodCheckMaxLengthParams = CheckParams<$ZodCheckMaxLength, "maximum" | "when">;
+type $ZodCheckMinLengthParams = CheckParams<$ZodCheckMinLength, "minimum" | "when">;
+type $ZodCheckLengthEqualsParams = CheckParams<$ZodCheckLengthEquals, "length" | "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
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/classic/errors.d.cts
+/** An Error-like class used to store Zod validation issues.  */
+interface ZodError<T = unknown> extends $ZodError<T> {
+  /** @deprecated Use the `z.treeifyError(err)` function instead. */
+  format(): $ZodFormattedError<T>;
+  format<U>(mapper: (issue: $ZodIssue) => U): $ZodFormattedError<T, U>;
+  /** @deprecated Use the `z.treeifyError(err)` function instead. */
+  flatten(): $ZodFlattenedError<T>;
+  flatten<U>(mapper: (issue: $ZodIssue) => U): $ZodFlattenedError<T, U>;
+  /** @deprecated Push directly to `.issues` instead. */
+  addIssue(issue: $ZodIssue): void;
+  /** @deprecated Push directly to `.issues` instead. */
+  addIssues(issues: $ZodIssue[]): void;
+  /** @deprecated Check `err.issues.length === 0` instead. */
+  isEmpty: boolean;
+}
+declare const ZodError: $constructor<ZodError>; //#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/classic/parse.d.cts
+type ZodSafeParseResult<T> = ZodSafeParseSuccess<T> | ZodSafeParseError<T>;
+type ZodSafeParseSuccess<T> = {
+  success: true;
+  data: T;
+  error?: never;
+};
+type ZodSafeParseError<T> = {
+  success: false;
+  data?: never;
+  error: ZodError<T>;
+}; //#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.5/node_modules/zod/v4/classic/schemas.d.cts
+type ZodStandardSchemaWithJSON<T> = StandardSchemaWithJSONProps<input<T>, output<T>>;
+interface ZodType<out Output = unknown, out Input = unknown, out Internals extends $ZodTypeInternals<Output, Input> = $ZodTypeInternals<Output, Input>> extends $ZodType<Output, Input, Internals> {
+  def: Internals["def"];
+  type: Internals["def"]["type"];
+  /** @deprecated Use `.def` instead. */
+  _def: Internals["def"];
+  /** @deprecated Use `z.output<typeof schema>` instead. */
+  _output: Internals["output"];
+  /** @deprecated Use `z.input<typeof schema>` instead. */
+  _input: Internals["input"];
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  /** Converts this schema to a JSON Schema representation. */
+  toJSONSchema(params?: ToJSONSchemaParams): ZodStandardJSONSchemaPayload<this>;
+  check(...checks: (CheckFn<output<this>> | $ZodCheck<output<this>>)[]): this;
+  with(...checks: (CheckFn<output<this>> | $ZodCheck<output<this>>)[]): this;
+  clone(def?: Internals["def"], params?: {
+    parent: boolean;
+  }): this;
+  register<R extends $ZodRegistry>(registry: R, ...meta: this extends R["_schema"] ? undefined extends R["_meta"] ? [$replace<R["_meta"], this>?] : [$replace<R["_meta"], this>] : ["Incompatible schema"]): this;
+  brand<T extends PropertyKey = PropertyKey, Dir extends "in" | "out" | "inout" = "out">(value?: T): PropertyKey extends T ? this : $ZodBranded<this, T, Dir>;
+  parse(data: unknown, params?: ParseContext<$ZodIssue>): output<this>;
+  safeParse(data: unknown, params?: ParseContext<$ZodIssue>): ZodSafeParseResult<output<this>>;
+  parseAsync(data: unknown, params?: ParseContext<$ZodIssue>): Promise<output<this>>;
+  safeParseAsync(data: unknown, params?: ParseContext<$ZodIssue>): Promise<ZodSafeParseResult<output<this>>>;
+  spa: (data: unknown, params?: ParseContext<$ZodIssue>) => Promise<ZodSafeParseResult<output<this>>>;
+  encode(data: output<this>, params?: ParseContext<$ZodIssue>): input<this>;
+  decode(data: input<this>, params?: ParseContext<$ZodIssue>): output<this>;
+  encodeAsync(data: output<this>, params?: ParseContext<$ZodIssue>): Promise<input<this>>;
+  decodeAsync(data: input<this>, params?: ParseContext<$ZodIssue>): Promise<output<this>>;
+  safeEncode(data: output<this>, params?: ParseContext<$ZodIssue>): ZodSafeParseResult<input<this>>;
+  safeDecode(data: input<this>, params?: ParseContext<$ZodIssue>): ZodSafeParseResult<output<this>>;
+  safeEncodeAsync(data: output<this>, params?: ParseContext<$ZodIssue>): Promise<ZodSafeParseResult<input<this>>>;
+  safeDecodeAsync(data: input<this>, params?: ParseContext<$ZodIssue>): Promise<ZodSafeParseResult<output<this>>>;
+  refine<Ch extends (arg: output<this>) => unknown | Promise<unknown>>(check: Ch, params?: string | $ZodCustomParams): Ch extends ((arg: any) => arg is infer R) ? this & ZodType<R, input<this>> : this;
+  superRefine(refinement: (arg: output<this>, ctx: $RefinementCtx<output<this>>) => void | Promise<void>): this;
+  overwrite(fn: (x: output<this>) => output<this>): this;
+  optional(): ZodOptional<this>;
+  exactOptional(): ZodExactOptional<this>;
+  nonoptional(params?: string | $ZodNonOptionalParams): ZodNonOptional<this>;
+  nullable(): ZodNullable<this>;
+  nullish(): ZodOptional<ZodNullable<this>>;
+  default(def: NoUndefined<output<this>>): ZodDefault<this>;
+  default(def: () => NoUndefined<output<this>>): ZodDefault<this>;
+  prefault(def: () => input<this>): ZodPrefault<this>;
+  prefault(def: input<this>): ZodPrefault<this>;
+  array(): ZodArray<this>;
+  or<T extends SomeType>(option: T): ZodUnion<[this, T]>;
+  and<T extends SomeType>(incoming: T): ZodIntersection<this, T>;
+  transform<NewOut>(transform: (arg: output<this>, ctx: $RefinementCtx<output<this>>) => NewOut | Promise<NewOut>): ZodPipe<this, ZodTransform<Awaited<NewOut>, output<this>>>;
+  catch(def: output<this>): ZodCatch<this>;
+  catch(def: (ctx: $ZodCatchCtx) => output<this>): ZodCatch<this>;
+  pipe<T extends $ZodType<any, output<this>>>(target: T | $ZodType<any, output<this>>): ZodPipe<this, T>;
+  readonly(): ZodReadonly<this>;
+  /** Returns a new instance that has been registered in `z.globalRegistry` with the specified description */
+  describe(description: string): this;
+  description?: string;
+  /** Returns the metadata associated with this instance in `z.globalRegistry` */
+  meta(): $replace<GlobalMeta, this> | undefined;
+  /** Returns a new instance that has been registered in `z.globalRegistry` with the specified metadata */
+  meta(data: $replace<GlobalMeta, this>): this;
+  /** @deprecated Try safe-parsing `undefined` (this is what `isOptional` does internally):
+   *
+   * ```ts
+   * const schema = z.string().optional();
+   * const isOptional = schema.safeParse(undefined).success; // true
+   * ```
+   */
+  isOptional(): boolean;
+  /**
+   * @deprecated Try safe-parsing `null` (this is what `isNullable` does internally):
+   *
+   * ```ts
+   * const schema = z.string().nullable();
+   * const isNullable = schema.safeParse(null).success; // true
+   * ```
+   */
+  isNullable(): boolean;
+  apply<T>(fn: (schema: this) => T): T;
+}
+interface _ZodType<out Internals extends $ZodTypeInternals = $ZodTypeInternals> extends ZodType<any, any, Internals> {}
+declare const ZodType: $constructor<ZodType>;
+interface ZodArray<T extends SomeType = $ZodType> extends _ZodType<$ZodArrayInternals<T>>, $ZodArray<T> {
+  element: T;
+  min(minLength: number, params?: string | $ZodCheckMinLengthParams): this;
+  nonempty(params?: string | $ZodCheckMinLengthParams): this;
+  max(maxLength: number, params?: string | $ZodCheckMaxLengthParams): this;
+  length(len: number, params?: string | $ZodCheckLengthEqualsParams): this;
+  unwrap(): T;
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
+declare const ZodArray: $constructor<ZodArray>;
+type SafeExtendShape<Base extends $ZodShape, Ext extends $ZodLooseShape> = { [K in keyof Ext]: K extends keyof Base ? output<Ext[K]> extends output<Base[K]> ? input<Ext[K]> extends input<Base[K]> ? Ext[K] : never : never : Ext[K] };
+interface ZodObject< /** @ts-ignore Cast variance */out Shape extends $ZodShape = $ZodLooseShape, out Config extends $ZodObjectConfig = $strip> extends _ZodType<$ZodObjectInternals<Shape, Config>>, $ZodObject<Shape, Config> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  shape: Shape;
+  keyof(): ZodEnum<ToEnum<keyof Shape & string>>;
+  /** Define a schema to validate all unrecognized keys. This overrides the existing strict/loose behavior. */
+  catchall<T extends SomeType>(schema: T): ZodObject<Shape, $catchall<T>>;
+  /** @deprecated Use `z.looseObject()` or `.loose()` instead. */
+  passthrough(): ZodObject<Shape, $loose>;
+  /** Consider `z.looseObject(A.shape)` instead */
+  loose(): ZodObject<Shape, $loose>;
+  /** Consider `z.strictObject(A.shape)` instead */
+  strict(): ZodObject<Shape, $strict>;
+  /** This is the default behavior. This method call is likely unnecessary. */
+  strip(): ZodObject<Shape, $strip>;
+  extend<U extends $ZodLooseShape>(shape: U): ZodObject<Extend<Shape, U>, Config>;
+  safeExtend<U extends $ZodLooseShape>(shape: SafeExtendShape<Shape, U> & Partial<Record<keyof Shape, SomeType>>): ZodObject<Extend<Shape, U>, Config>;
+  /**
+   * @deprecated Use [`A.extend(B.shape)`](https://zod.dev/api?id=extend) instead.
+   */
+  merge<U extends ZodObject>(other: U): ZodObject<Extend<Shape, U["shape"]>, U["_zod"]["config"]>;
+  pick<M extends Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, Config>;
+  omit<M extends Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>, Config>;
+  partial(): ZodObject<{ [k in keyof Shape]: ZodOptional<Shape[k]> }, Config>;
+  partial<M extends Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<{ [k in keyof Shape]: k extends keyof M ? ZodOptional<Shape[k]> : Shape[k] }, Config>;
+  required(): ZodObject<{ [k in keyof Shape]: ZodNonOptional<Shape[k]> }, Config>;
+  required<M extends Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<{ [k in keyof Shape]: k extends keyof M ? ZodNonOptional<Shape[k]> : Shape[k] }, Config>;
+}
+declare const ZodObject: $constructor<ZodObject>;
+interface ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends _ZodType<$ZodUnionInternals<T>>, $ZodUnion<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  options: T;
+}
+declare const ZodUnion: $constructor<ZodUnion>;
+interface ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodIntersectionInternals<A, B>>, $ZodIntersection<A, B> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
+declare const ZodIntersection: $constructor<ZodIntersection>;
+interface ZodEnum< /** @ts-ignore Cast variance */out T extends EnumLike = EnumLike> extends _ZodType<$ZodEnumInternals<T>>, $ZodEnum<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  enum: T;
+  options: Array<T[keyof T]>;
+  extract<const U extends readonly (keyof T)[]>(values: U, params?: string | $ZodEnumParams): ZodEnum<Flatten<Pick<T, U[number]>>>;
+  exclude<const U extends readonly (keyof T)[]>(values: U, params?: string | $ZodEnumParams): ZodEnum<Flatten<Omit<T, U[number]>>>;
+}
+declare const ZodEnum: $constructor<ZodEnum>;
+interface ZodTransform<O = unknown, I = unknown> extends _ZodType<$ZodTransformInternals<O, I>>, $ZodTransform<O, I> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
+declare const ZodTransform: $constructor<ZodTransform>;
+interface ZodOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodOptionalInternals<T>>, $ZodOptional<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodOptional: $constructor<ZodOptional>;
+interface ZodExactOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodExactOptionalInternals<T>>, $ZodExactOptional<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodExactOptional: $constructor<ZodExactOptional>;
+interface ZodNullable<T extends SomeType = $ZodType> extends _ZodType<$ZodNullableInternals<T>>, $ZodNullable<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodNullable: $constructor<ZodNullable>;
+interface ZodDefault<T extends SomeType = $ZodType> extends _ZodType<$ZodDefaultInternals<T>>, $ZodDefault<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+  /** @deprecated Use `.unwrap()` instead. */
+  removeDefault(): T;
+}
+declare const ZodDefault: $constructor<ZodDefault>;
+interface ZodPrefault<T extends SomeType = $ZodType> extends _ZodType<$ZodPrefaultInternals<T>>, $ZodPrefault<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodPrefault: $constructor<ZodPrefault>;
+interface ZodNonOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodNonOptionalInternals<T>>, $ZodNonOptional<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodNonOptional: $constructor<ZodNonOptional>;
+interface ZodCatch<T extends SomeType = $ZodType> extends _ZodType<$ZodCatchInternals<T>>, $ZodCatch<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+  /** @deprecated Use `.unwrap()` instead. */
+  removeCatch(): T;
+}
+declare const ZodCatch: $constructor<ZodCatch>;
+interface ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodPipeInternals<A, B>>, $ZodPipe<A, B> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  in: A;
+  out: B;
+}
+declare const ZodPipe: $constructor<ZodPipe>;
+interface ZodReadonly<T extends SomeType = $ZodType> extends _ZodType<$ZodReadonlyInternals<T>>, $ZodReadonly<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodReadonly: $constructor<ZodReadonly>; //#endregion
+//#region ../loader-types/dist/index.d.mts
+//#region src/index.d.ts
+/**
+ * Configuration options for initializing the Plucky chat widget.
+ *
+ * Pass this object to {@link Plucky} (chat-sdk) or {@link useChat} (React)
+ * to embed the widget on the page.
+ *
+ * @example
+ * ```ts
+ * Plucky({
+ *   appId: 'my-app-id',
+ *   baseUrl: 'https://widget.plucky.ai',
+ *   user: { id: 'user-123', name: 'Jane Doe', email: 'jane@example.com' },
+ *   mode: 'push',
+ *   autoOpen: false,
+ * })
+ * ```
+ */
+/**
+ * Serializable subset of a tool definition sent across the iframe boundary.
+ * This does not include the callback — only metadata used by the widget
+ * to display tool information and validate inputs.
+ *
+ * @see {@link ToolConfig} for the full tool definition including the callback.
+ */
+interface SimpleToolConfig {
+  /** Unique name for the tool (e.g., `'getWeather'`). Must be unique across all registered tools. */
+  name: string;
+  /** Human-readable description of what the tool does. Shown to the AI assistant to help it decide when to use the tool. */
+  description: string;
+  /**
+   * Text displayed in the chat while the tool is executing.
+   * Set to `null` to suppress the loading indicator entirely.
+   * @default undefined (uses the widget's default loading text)
+   */
+  defaultLoadingText?: string | null;
+  /**
+   * Text displayed in the chat after the tool completes successfully.
+   * Set to `null` to suppress the success message entirely.
+   * Can be overridden per-invocation by returning `{ content, successText }` from the callback.
+   * @default undefined (uses the widget's default success text)
+   */
+  defaultSuccessText?: string | null;
+  /**
+   * JSON Schema or Zod object schema describing the tool's expected input.
+   * When a Zod schema is provided, it is automatically converted to JSON Schema
+   * before being sent to the AI model.
+   *
+   * @example
+   * ```ts
+   * import { z } from 'zod'
+   *
+   * inputSchema: z.object({
+   *   city: z.string().describe('City name to look up'),
+   *   units: z.enum(['celsius', 'fahrenheit']).optional(),
+   * })
+   * ```
+   */
+  inputSchema?: ZodObject | Record<string, unknown>;
+}
+/**
+ * Maps every postMessage `type` string to its payload type.
+ *
+ * Both the loader (host-side transport) and the widget (IframeCommunicator)
+ * derive their typed `send` / `on` signatures from this interface.
+ * Adding a new message here automatically requires typed handling on both sides.
+ */
+interface FrameMessageMap {
+  PLUCKY_LOAD_CONFIG: {
+    appId: string;
+    user: Record<string, unknown>;
+    mode: string;
+    sessionToken?: string;
+    tools: SimpleToolConfig[];
+    tags: string[];
+  };
+  PLUCKY_SEND_MESSAGE: {
+    content: string | unknown[];
+    createChat: boolean;
+    chatId?: string;
+  };
+  PLUCKY_SET_INPUT: {
+    input: string;
+    createChat: boolean;
+  };
+  PLUCKY_FOCUS_INPUT: void;
+  PLUCKY_SET_MOBILE: {
+    isMobile: boolean;
+  };
+  PLUCKY_SESSION_REQUEST: {
+    reason?: string;
+  };
+  PLUCKY_TOOL_CONFIG_UPDATED: {
+    tools: SimpleToolConfig[];
+  };
+  PLUCKY_WIDGET_MOUNTED: void;
+  PLUCKY_SESSION_LOADED: void;
+  PLUCKY_SESSION_UPDATED: {
+    token: string;
+  };
+  PLUCKY_CLOSE: void;
+  PLUCKY_SET_WIDTH: number;
+  PLUCKY_SWITCH_MODE: {
+    mode: string;
+  };
+  PLUCKY_RESPONSE_RECEIVED: {
+    messages: unknown[];
+    chatId: string;
+  };
+  PLUCKY_CONFIG_LOADED: void;
+  PLUCKY_TOOL_CALL: unknown;
+  PLUCKY_SET_FULLSCREEN: {
+    fullscreen: boolean;
+  };
+  PLUCKY_VISIBILITY: 'visible' | 'hidden';
+}
+/** Every postMessage type string used across the frame boundary. */
+type FrameMessageType = keyof FrameMessageMap;
+/** Extract the payload type for a given message type. */
+/**
+ * Every command that can be dispatched via `Plucky(action, payload)`.
+ * Add new commands here — TypeScript will enforce that handlers and
+ * SDK wrappers stay in sync.
+ */
+//#endregion
+//#region src/Plucky.d.ts
+/**
+ * Initializes the Plucky chat widget on the page.
+ *
+ * Injects a settings script and loader bootstrap script into `<head>`.
+ * On subsequent calls the function is a no-op — the widget can only be
+ * attached once per page lifecycle. To re-initialize after removal,
+ * call {@link unmount} first.
+ *
+ * @param options - Widget configuration. Required fields:
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `appId` | `string` | **(required)** Your Plucky app ID from the dashboard. |
+ * | `baseUrl` | `string` | **(required)** Widget server origin (e.g., `'https://widget.plucky.ai'`). |
+ * | `user` | `object` | Identify the current user (`{ id, name?, email?, createdAt?, metadata? }`). |
+ * | `user.id` | `string` | Unique user identifier in your system. |
+ * | `user.name` | `string` | Display name shown in the dashboard. |
+ * | `user.email` | `string` | Email shown in the dashboard. |
+ * | `user.createdAt` | `string` | ISO 8601 timestamp of user creation. |
+ * | `user.metadata` | `Record<string, any>` | Arbitrary key-value pairs for segmentation. |
+ * | `systemTools` | `object` | Built-in tools to enable (e.g., `{ readPage: true }`). |
+ * | `mode` | `'push' \| 'overlay' \| 'inline'` | Display mode. Default: `'push'`. |
+ * | `containerId` | `string` | Container element ID — required when `mode` is `'inline'`. |
+ * | `autoOpen` | `boolean` | Auto-open on load. Default: `true`. |
+ * | `triggerButton` | `boolean` | Show floating trigger button. Default: `false`. |
+ *
+ * @example
+ * ```ts
+ * import { Plucky } from '@plucky-ai/chat-sdk'
+ *
+ * Plucky({
+ *   appId: 'your-app-id',
+ *   baseUrl: 'https://widget.plucky.ai',
+ *   user: { id: 'user-123', name: 'Jane' },
+ * })
+ * ```
+ *
+ * @example Inline mode
+ * ```ts
+ * Plucky({
+ *   appId: 'your-app-id',
+ *   baseUrl: 'https://widget.plucky.ai',
+ *   mode: 'inline',
+ *   containerId: 'chat-container',
+ *   autoOpen: true,
+ * })
+ * ```
+ */
+declare function Plucky(options: PluckySettingsParams): void;
+//#endregion
+//#region src/index.d.ts
+/**
+ * Opens the chat widget.
+ *
+ * If the widget is already open this is a no-op.
+ *
+ * @example
+ * ```ts
+ * open()
+ * ```
+ */
+declare const open: () => void;
+/**
+ * Closes the chat widget.
+ *
+ * If the widget is already closed this is a no-op.
+ *
+ * @example
+ * ```ts
+ * close()
+ * ```
+ */
+declare const close: () => void;
+/**
+ * Toggles the chat widget between open and closed states.
+ *
+ * @example
+ * ```ts
+ * toggle()
+ * ```
+ */
+declare const toggle: () => void;
+/**
+ * Sends a message in the chat on behalf of the user.
+ *
+ * @param payload - The message payload.
+ * @param payload.content - The text content of the message to send.
+ * @param payload.createChat - When `true`, creates a new chat session before sending.
+ *
+ * @example
+ * ```ts
+ * sendMessage({ content: 'Hello!', createChat: true })
+ * ```
+ */
+declare const sendMessage: (payload: {
+  content: string;
+  createChat?: boolean;
+}) => void;
+/**
+ * Sets the content of the chat input field without sending it.
+ *
+ * Useful for pre-filling a prompt that the user can review before submitting.
+ *
+ * @param payload - The input payload.
+ * @param payload.content - The text to place in the input field.
+ * @param payload.createChat - When `true`, creates a new chat session if one doesn't exist.
+ *
+ * @example
+ * ```ts
+ * setInput({ content: 'Draft message...' })
+ * ```
+ */
+declare const setInput: (payload: {
+  content: string;
+  createChat?: boolean;
+}) => void;
+/**
+ * Registers one or more custom tools that the AI assistant can invoke.
+ *
+ * Each tool specifies a name, description, optional Zod/JSON input schema,
+ * and a callback that is executed when the assistant calls the tool.
+ * Tools persist until explicitly removed with {@link removeTools} or
+ * the widget is {@link unmount | unmounted}.
+ *
+ * @param tools - Array of {@link ToolConfig} objects. Each tool object accepts:
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `name` | `string` | **(required)** Unique tool name (e.g., `'getWeather'`). |
+ * | `description` | `string` | **(required)** Tells the AI when to use this tool. |
+ * | `inputSchema` | `ZodObject \| Record<string, unknown>` | Zod or JSON Schema describing expected input. |
+ * | `cb` | `(input) => string \| { content, successText? }` | Callback invoked when the AI calls the tool. May be async. |
+ * | `defaultLoadingText` | `string \| null` | Text shown while the tool runs. `null` hides it. |
+ * | `defaultSuccessText` | `string \| null` | Text shown on completion. `null` hides it. |
+ *
+ * @example Basic tool without a schema
+ * ```ts
+ * addTools([
+ *   {
+ *     name: 'getWeather',
+ *     description: 'Fetches current weather for a city',
+ *     cb: async ({ city }) => `The weather in ${city} is sunny.`,
+ *   },
+ * ])
+ * ```
+ *
+ * @example Tool with a Zod input schema
+ * ```ts
+ * import { z } from 'zod'
+ *
+ * addTools([
+ *   {
+ *     name: 'getWeather',
+ *     description: 'Fetches current weather for a city',
+ *     inputSchema: z.object({
+ *       city: z.string().describe('City name to look up'),
+ *       units: z.enum(['celsius', 'fahrenheit']).optional(),
+ *     }),
+ *     cb: async ({ city, units }) => {
+ *       const data = await fetchWeather(city, units)
+ *       return { content: JSON.stringify(data), successText: `Weather for ${city}` }
+ *     },
+ *   },
+ * ])
+ * ```
+ */
+declare const addTools: (payload: ToolConfig<any>[]) => void;
+/**
+ * Removes previously registered tools by name.
+ *
+ * @param names - Array of tool name strings to unregister.
+ *
+ * @example
+ * ```ts
+ * removeTools(['getWeather'])
+ * ```
+ */
+declare const removeTools: (payload: string[]) => void;
+/**
+ * Sets the width of the chat widget sidebar in pixels.
+ *
+ * @param width - Width in pixels.
+ *
+ * @example
+ * ```ts
+ * setWidth(500)
+ * ```
+ */
+declare const setWidth: (payload: number) => void;
+/**
+ * Shows the floating trigger button in the bottom-right corner of the page.
+ *
+ * The trigger button allows users to toggle the widget open/closed.
+ *
+ * @example
+ * ```ts
+ * showTriggerButton()
+ * ```
+ */
+declare const showTriggerButton: () => void;
+/**
+ * Hides the floating trigger button.
+ *
+ * @example
+ * ```ts
+ * hideTriggerButton()
+ * ```
+ */
+declare const hideTriggerButton: () => void;
+/**
+ * Unmounts the Plucky widget and removes it from the DOM entirely.
+ *
+ * After calling this, the widget must be re-initialized with {@link Plucky}
+ * to appear again.
+ *
+ * @example
+ * ```ts
+ * unmount()
+ * ```
+ */
+declare const unmount: () => void;
+/**
+ * Updates widget settings after initialization (e.g., user information).
+ *
+ * Only fields present in the payload are updated; omitted fields remain unchanged.
+ *
+ * @param settings - Partial settings to merge.
+ * @param settings.user - Updated user identification and metadata.
+ *
+ * @example
+ * ```ts
+ * updateSettings({ user: { id: 'user-456', name: 'Jane' } })
+ * ```
+ */
+declare const updateSettings: (payload: PluckyUpdateSettingsParams) => void;
+/**
+ * Enables or disables fullscreen mode for the chat widget.
+ *
+ * @param fullscreen - `true` to enter fullscreen, `false` to exit.
+ *
+ * @example
+ * ```ts
+ * setFullscreen(true)
+ * ```
+ */
+declare function setFullscreen(fullscreen: boolean): void;
+/**
+ * Subscribes to a widget event.
+ *
+ * Events are emitted by the widget iframe and forwarded to the host page.
+ * Use {@link removeEventListener} with the same `event` and `listener`
+ * reference to unsubscribe.
+ *
+ * @param event - The event name to listen for (e.g., `'PLUCKY_RESPONSE_RECEIVED'`).
+ * @param listener - Callback invoked with the event payload.
+ *
+ * @example
+ * ```ts
+ * const onResponse = (payload) => console.log('Response:', payload)
+ * addEventListener('PLUCKY_RESPONSE_RECEIVED', onResponse)
+ * ```
+ */
+declare function addEventListener(event: string, listener: (payload: unknown) => void): void;
+/**
+ * Removes a previously registered event listener.
+ *
+ * The `event` and `listener` arguments must match those passed to
+ * {@link addEventListener}.
+ *
+ * @param event - The event name to stop listening for.
+ * @param listener - The exact listener function reference to remove.
+ *
+ * @example
+ * ```ts
+ * removeEventListener('PLUCKY_RESPONSE_RECEIVED', onResponse)
+ * ```
+ */
+declare function removeEventListener(event: string, listener: (payload: unknown) => void): void;
+/**
+ * Returns whether the widget has finished loading and is ready to
+ * accept commands.
+ *
+ * @returns `true` if the widget is initialized and responsive, `false` otherwise.
+ *
+ * @example
+ * ```ts
+ * if (isReady()) {
+ *   sendMessage({ content: 'Hi!' })
+ * }
+ * ```
+ */
+declare function isReady(): boolean;
+//#endregion
+export { type FrameMessageType as MessageType, Plucky, type ToolConfig, addEventListener, addTools, close, hideTriggerButton, isReady, open, removeEventListener, removeTools, sendMessage, setFullscreen, setInput, setWidth, showTriggerButton, toggle, unmount, updateSettings };
+//# sourceMappingURL=index.d.mts.map