unplugin-devpilot 0.0.0

package/dist/index-CL0Gw5-1.d.mts

@@ -0,0 +1,4130 @@
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/helpers/typeAliases.d.cts
+type Primitive$2 = string | number | symbol | bigint | boolean | null | undefined;
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/helpers/util.d.cts
+declare namespace util {
+  type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends (<V>() => V extends U ? 1 : 2) ? true : false;
+  export type isAny<T> = 0 extends 1 & T ? true : false;
+  export const assertEqual: <A, B>(_: AssertEqual<A, B>) => void;
+  export function assertIs<T>(_arg: T): void;
+  export function assertNever(_x: never): never;
+  export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+  export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
+  export type MakePartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+  export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
+  export type InexactPartial<T> = { [k in keyof T]?: T[k] | undefined };
+  export const arrayToEnum: <T extends string, U extends [T, ...T[]]>(items: U) => { [k in U[number]]: k };
+  export const getValidEnumValues: (obj: any) => any[];
+  export const objectValues: (obj: any) => any[];
+  export const objectKeys: ObjectConstructor["keys"];
+  export const find: <T>(arr: T[], checker: (arg: T) => any) => T | undefined;
+  export type identity<T> = objectUtil.identity<T>;
+  export type flatten<T> = objectUtil.flatten<T>;
+  export type noUndefined<T> = T extends undefined ? never : T;
+  export const isInteger: NumberConstructor["isInteger"];
+  export function joinValues<T extends any[]>(array: T, separator?: string): string;
+  export const jsonStringifyReplacer: (_: string, value: any) => any;
+  export {};
+}
+declare namespace objectUtil {
+  export type MergeShapes<U, V> = keyof U & keyof V extends never ? U & V : { [k in Exclude<keyof U, keyof V>]: U[k] } & V;
+  type optionalKeys<T extends object> = { [k in keyof T]: undefined extends T[k] ? k : never }[keyof T];
+  type requiredKeys<T extends object> = { [k in keyof T]: undefined extends T[k] ? never : k }[keyof T];
+  export type addQuestionMarks<T extends object, _O = any> = { [K in requiredKeys<T>]: T[K] } & { [K in optionalKeys<T>]?: T[K] } & { [k in keyof T]?: unknown };
+  export type identity<T> = T;
+  export type flatten<T> = identity<{ [k in keyof T]: T[k] }>;
+  export type noNeverKeys<T> = { [k in keyof T]: [T[k]] extends [never] ? never : k }[keyof T];
+  export type noNever<T> = identity<{ [k in noNeverKeys<T>]: k extends keyof T ? T[k] : never }>;
+  export const mergeShapes: <U, T>(first: U, second: T) => T & U;
+  export type extendShape<A extends object, B extends object> = 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] };
+  export {};
+}
+declare const ZodParsedType: {
+  string: "string";
+  nan: "nan";
+  number: "number";
+  integer: "integer";
+  float: "float";
+  boolean: "boolean";
+  date: "date";
+  bigint: "bigint";
+  symbol: "symbol";
+  function: "function";
+  undefined: "undefined";
+  null: "null";
+  array: "array";
+  object: "object";
+  unknown: "unknown";
+  promise: "promise";
+  void: "void";
+  never: "never";
+  map: "map";
+  set: "set";
+};
+type ZodParsedType = keyof typeof ZodParsedType;
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/ZodError.d.cts
+type allKeys<T> = T extends any ? keyof T : never;
+type typeToFlattenedError<T, U = string> = {
+  formErrors: U[];
+  fieldErrors: { [P in allKeys<T>]?: U[] };
+};
+declare const ZodIssueCode: {
+  custom: "custom";
+  invalid_type: "invalid_type";
+  too_big: "too_big";
+  too_small: "too_small";
+  not_multiple_of: "not_multiple_of";
+  unrecognized_keys: "unrecognized_keys";
+  invalid_union: "invalid_union";
+  invalid_literal: "invalid_literal";
+  invalid_union_discriminator: "invalid_union_discriminator";
+  invalid_enum_value: "invalid_enum_value";
+  invalid_arguments: "invalid_arguments";
+  invalid_return_type: "invalid_return_type";
+  invalid_date: "invalid_date";
+  invalid_string: "invalid_string";
+  invalid_intersection_types: "invalid_intersection_types";
+  not_finite: "not_finite";
+};
+type ZodIssueCode = keyof typeof ZodIssueCode;
+type ZodIssueBase = {
+  path: (string | number)[];
+  message?: string | undefined;
+};
+interface ZodInvalidTypeIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_type;
+  expected: ZodParsedType;
+  received: ZodParsedType;
+}
+interface ZodInvalidLiteralIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_literal;
+  expected: unknown;
+  received: unknown;
+}
+interface ZodUnrecognizedKeysIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.unrecognized_keys;
+  keys: string[];
+}
+interface ZodInvalidUnionIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_union;
+  unionErrors: ZodError$1[];
+}
+interface ZodInvalidUnionDiscriminatorIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_union_discriminator;
+  options: Primitive$2[];
+}
+interface ZodInvalidEnumValueIssue extends ZodIssueBase {
+  received: string | number;
+  code: typeof ZodIssueCode.invalid_enum_value;
+  options: (string | number)[];
+}
+interface ZodInvalidArgumentsIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_arguments;
+  argumentsError: ZodError$1;
+}
+interface ZodInvalidReturnTypeIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_return_type;
+  returnTypeError: ZodError$1;
+}
+interface ZodInvalidDateIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_date;
+}
+type StringValidation = "email" | "url" | "emoji" | "uuid" | "nanoid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "date" | "time" | "duration" | "ip" | "cidr" | "base64" | "jwt" | "base64url" | {
+  includes: string;
+  position?: number | undefined;
+} | {
+  startsWith: string;
+} | {
+  endsWith: string;
+};
+interface ZodInvalidStringIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_string;
+  validation: StringValidation;
+}
+interface ZodTooSmallIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.too_small;
+  minimum: number | bigint;
+  inclusive: boolean;
+  exact?: boolean;
+  type: "array" | "string" | "number" | "set" | "date" | "bigint";
+}
+interface ZodTooBigIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.too_big;
+  maximum: number | bigint;
+  inclusive: boolean;
+  exact?: boolean;
+  type: "array" | "string" | "number" | "set" | "date" | "bigint";
+}
+interface ZodInvalidIntersectionTypesIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_intersection_types;
+}
+interface ZodNotMultipleOfIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.not_multiple_of;
+  multipleOf: number | bigint;
+}
+interface ZodNotFiniteIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.not_finite;
+}
+interface ZodCustomIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.custom;
+  params?: {
+    [k: string]: any;
+  };
+}
+type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
+type ZodIssue = ZodIssueOptionalMessage & {
+  fatal?: boolean | undefined;
+  message: string;
+};
+type recursiveZodFormattedError<T> = T extends [any, ...any[]] ? { [K in keyof T]?: ZodFormattedError<T[K]> } : T extends any[] ? {
+  [k: number]: ZodFormattedError<T[number]>;
+} : T extends object ? { [K in keyof T]?: ZodFormattedError<T[K]> } : unknown;
+type ZodFormattedError<T, U = string> = {
+  _errors: U[];
+} & recursiveZodFormattedError<NonNullable<T>>;
+declare class ZodError$1<T = any> extends Error {
+  issues: ZodIssue[];
+  get errors(): ZodIssue[];
+  constructor(issues: ZodIssue[]);
+  format(): ZodFormattedError<T>;
+  format<U>(mapper: (issue: ZodIssue) => U): ZodFormattedError<T, U>;
+  static create: (issues: ZodIssue[]) => ZodError$1<any>;
+  static assert(value: unknown): asserts value is ZodError$1;
+  toString(): string;
+  get message(): string;
+  get isEmpty(): boolean;
+  addIssue: (sub: ZodIssue) => void;
+  addIssues: (subs?: ZodIssue[]) => void;
+  flatten(): typeToFlattenedError<T>;
+  flatten<U>(mapper?: (issue: ZodIssue) => U): typeToFlattenedError<T, U>;
+  get formErrors(): typeToFlattenedError<T, string>;
+}
+type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
+type IssueData = stripPath<ZodIssueOptionalMessage> & {
+  path?: (string | number)[];
+  fatal?: boolean | undefined;
+};
+type ErrorMapCtx = {
+  defaultError: string;
+  data: any;
+};
+type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
+  message: string;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/helpers/parseUtil.d.cts
+type ParseParams = {
+  path: (string | number)[];
+  errorMap: ZodErrorMap;
+  async: boolean;
+};
+type ParsePathComponent = string | number;
+type ParsePath = ParsePathComponent[];
+interface ParseContext$1 {
+  readonly common: {
+    readonly issues: ZodIssue[];
+    readonly contextualErrorMap?: ZodErrorMap | undefined;
+    readonly async: boolean;
+  };
+  readonly path: ParsePath;
+  readonly schemaErrorMap?: ZodErrorMap | undefined;
+  readonly parent: ParseContext$1 | null;
+  readonly data: any;
+  readonly parsedType: ZodParsedType;
+}
+type ParseInput = {
+  data: any;
+  path: (string | number)[];
+  parent: ParseContext$1;
+};
+declare class ParseStatus {
+  value: "aborted" | "dirty" | "valid";
+  dirty(): void;
+  abort(): void;
+  static mergeArray(status: ParseStatus, results: SyncParseReturnType<any>[]): SyncParseReturnType;
+  static mergeObjectAsync(status: ParseStatus, pairs: {
+    key: ParseReturnType<any>;
+    value: ParseReturnType<any>;
+  }[]): Promise<SyncParseReturnType<any>>;
+  static mergeObjectSync(status: ParseStatus, pairs: {
+    key: SyncParseReturnType<any>;
+    value: SyncParseReturnType<any>;
+    alwaysSet?: boolean;
+  }[]): SyncParseReturnType;
+}
+type INVALID = {
+  status: "aborted";
+};
+declare const INVALID: INVALID;
+type DIRTY<T> = {
+  status: "dirty";
+  value: T;
+};
+declare const DIRTY: <T>(value: T) => DIRTY<T>;
+type OK<T> = {
+  status: "valid";
+  value: T;
+};
+declare const OK: <T>(value: T) => OK<T>;
+type SyncParseReturnType<T = any> = OK<T> | DIRTY<T> | INVALID;
+type AsyncParseReturnType<T> = Promise<SyncParseReturnType<T>>;
+type ParseReturnType<T> = SyncParseReturnType<T> | AsyncParseReturnType<T>;
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/helpers/errorUtil.d.cts
+declare namespace errorUtil {
+  type ErrMessage = string | {
+    message?: string | undefined;
+  };
+  const errToObj: (message?: ErrMessage) => {
+    message?: string | undefined;
+  };
+  const toString: (message?: ErrMessage) => string | undefined;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/standard-schema.d.cts
+/**
+ * The Standard Schema interface.
+ */
+type 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.
+   */
+  export 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;
+    /**
+     * Validates unknown input values.
+     */
+    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+    /**
+     * Inferred types associated with the schema.
+     */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /**
+   * The result interface of the validate function.
+   */
+  export type Result<Output> = SuccessResult<Output> | FailureResult;
+  /**
+   * The result interface if validation succeeds.
+   */
+  export interface SuccessResult<Output> {
+    /**
+     * The typed output value.
+     */
+    readonly value: Output;
+    /**
+     * The non-existent issues.
+     */
+    readonly issues?: undefined;
+  }
+  /**
+   * The result interface if validation fails.
+   */
+  export interface FailureResult {
+    /**
+     * The issues of failed validation.
+     */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /**
+   * The issue interface of the failure output.
+   */
+  export 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.
+   */
+  export interface PathSegment {
+    /**
+     * The key representing a path segment.
+     */
+    readonly key: PropertyKey;
+  }
+  /**
+   * The Standard Schema types interface.
+   */
+  export 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 Schema.
+   */
+  export type InferInput<Schema extends StandardSchemaV1$1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /**
+   * Infers the output type of a Standard Schema.
+   */
+  export type InferOutput<Schema extends StandardSchemaV1$1> = NonNullable<Schema["~standard"]["types"]>["output"];
+  export {};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/types.d.cts
+interface RefinementCtx {
+  addIssue: (arg: IssueData) => void;
+  path: (string | number)[];
+}
+type ZodTypeAny = ZodType$1<any, any, any>;
+type TypeOf<T extends ZodType$1<any, any, any>> = T["_output"];
+type input$1<T extends ZodType$1<any, any, any>> = T["_input"];
+type output$1<T extends ZodType$1<any, any, any>> = T["_output"];
+type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;
+interface ZodTypeDef {
+  errorMap?: ZodErrorMap | undefined;
+  description?: string | undefined;
+}
+type RawCreateParams = {
+  errorMap?: ZodErrorMap | undefined;
+  invalid_type_error?: string | undefined;
+  required_error?: string | undefined;
+  message?: string | undefined;
+  description?: string | undefined;
+} | undefined;
+type SafeParseSuccess<Output> = {
+  success: true;
+  data: Output;
+  error?: never;
+};
+type SafeParseError<Input> = {
+  success: false;
+  error: ZodError$1<Input>;
+  data?: never;
+};
+type SafeParseReturnType<Input, Output> = SafeParseSuccess<Output> | SafeParseError<Input>;
+declare abstract class ZodType$1<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {
+  readonly _type: Output;
+  readonly _output: Output;
+  readonly _input: Input;
+  readonly _def: Def;
+  get description(): string | undefined;
+  "~standard": StandardSchemaV1$1.Props<Input, Output>;
+  abstract _parse(input: ParseInput): ParseReturnType<Output>;
+  _getType(input: ParseInput): string;
+  _getOrReturnCtx(input: ParseInput, ctx?: ParseContext$1 | undefined): ParseContext$1;
+  _processInputParams(input: ParseInput): {
+    status: ParseStatus;
+    ctx: ParseContext$1;
+  };
+  _parseSync(input: ParseInput): SyncParseReturnType<Output>;
+  _parseAsync(input: ParseInput): AsyncParseReturnType<Output>;
+  parse(data: unknown, params?: util.InexactPartial<ParseParams>): Output;
+  safeParse(data: unknown, params?: util.InexactPartial<ParseParams>): SafeParseReturnType<Input, Output>;
+  "~validate"(data: unknown): StandardSchemaV1$1.Result<Output> | Promise<StandardSchemaV1$1.Result<Output>>;
+  parseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<Output>;
+  safeParseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
+  /** Alias of safeParseAsync */
+  spa: (data: unknown, params?: util.InexactPartial<ParseParams>) => Promise<SafeParseReturnType<Input, Output>>;
+  refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, Input>;
+  refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, Output, Input>;
+  refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, RefinedOutput, Input>;
+  refinement(check: (arg: Output) => boolean, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, Output, Input>;
+  _refinement(refinement: RefinementEffect<Output>["refinement"]): ZodEffects<this, Output, Input>;
+  superRefine<RefinedOutput extends Output>(refinement: (arg: Output, ctx: RefinementCtx) => arg is RefinedOutput): ZodEffects<this, RefinedOutput, Input>;
+  superRefine(refinement: (arg: Output, ctx: RefinementCtx) => void): ZodEffects<this, Output, Input>;
+  superRefine(refinement: (arg: Output, ctx: RefinementCtx) => Promise<void>): ZodEffects<this, Output, Input>;
+  constructor(def: Def);
+  optional(): ZodOptional$1<this>;
+  nullable(): ZodNullable$1<this>;
+  nullish(): ZodOptional$1<ZodNullable$1<this>>;
+  array(): ZodArray$1<this>;
+  promise(): ZodPromise<this>;
+  or<T extends ZodTypeAny>(option: T): ZodUnion$1<[this, T]>;
+  and<T extends ZodTypeAny>(incoming: T): ZodIntersection$1<this, T>;
+  transform<NewOut>(transform: (arg: Output, ctx: RefinementCtx) => NewOut | Promise<NewOut>): ZodEffects<this, NewOut>;
+  default(def: util.noUndefined<Input>): ZodDefault$1<this>;
+  default(def: () => util.noUndefined<Input>): ZodDefault$1<this>;
+  brand<B extends string | number | symbol>(brand?: B): ZodBranded<this, B>;
+  catch(def: Output): ZodCatch$1<this>;
+  catch(def: (ctx: {
+    error: ZodError$1;
+    input: Input;
+  }) => Output): ZodCatch$1<this>;
+  describe(description: string): this;
+  pipe<T extends ZodTypeAny>(target: T): ZodPipeline<this, T>;
+  readonly(): ZodReadonly$1<this>;
+  isOptional(): boolean;
+  isNullable(): boolean;
+}
+interface ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  type: T;
+  typeName: ZodFirstPartyTypeKind.ZodArray;
+  exactLength: {
+    value: number;
+    message?: string | undefined;
+  } | null;
+  minLength: {
+    value: number;
+    message?: string | undefined;
+  } | null;
+  maxLength: {
+    value: number;
+    message?: string | undefined;
+  } | null;
+}
+type ArrayCardinality = "many" | "atleastone";
+type arrayOutputType<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> = Cardinality extends "atleastone" ? [T["_output"], ...T["_output"][]] : T["_output"][];
+declare class ZodArray$1<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> extends ZodType$1<arrayOutputType<T, Cardinality>, ZodArrayDef<T>, Cardinality extends "atleastone" ? [T["_input"], ...T["_input"][]] : T["_input"][]> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get element(): T;
+  min(minLength: number, message?: errorUtil.ErrMessage): this;
+  max(maxLength: number, message?: errorUtil.ErrMessage): this;
+  length(len: number, message?: errorUtil.ErrMessage): this;
+  nonempty(message?: errorUtil.ErrMessage): ZodArray$1<T, "atleastone">;
+  static create: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray$1<El>;
+}
+type ZodUnionOptions = Readonly<[ZodTypeAny, ...ZodTypeAny[]]>;
+interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>> extends ZodTypeDef {
+  options: T;
+  typeName: ZodFirstPartyTypeKind.ZodUnion;
+}
+declare class ZodUnion$1<T extends ZodUnionOptions> extends ZodType$1<T[number]["_output"], ZodUnionDef<T>, T[number]["_input"]> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get options(): T;
+  static create: <Options extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: Options, params?: RawCreateParams) => ZodUnion$1<Options>;
+}
+interface ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  left: T;
+  right: U;
+  typeName: ZodFirstPartyTypeKind.ZodIntersection;
+}
+declare class ZodIntersection$1<T extends ZodTypeAny, U extends ZodTypeAny> extends ZodType$1<T["_output"] & U["_output"], ZodIntersectionDef<T, U>, T["_input"] & U["_input"]> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: <TSchema extends ZodTypeAny, USchema extends ZodTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => ZodIntersection$1<TSchema, USchema>;
+}
+interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  type: T;
+  typeName: ZodFirstPartyTypeKind.ZodPromise;
+}
+declare class ZodPromise<T extends ZodTypeAny> extends ZodType$1<Promise<T["_output"]>, ZodPromiseDef<T>, Promise<T["_input"]>> {
+  unwrap(): T;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;
+}
+type RefinementEffect<T> = {
+  type: "refinement";
+  refinement: (arg: T, ctx: RefinementCtx) => any;
+};
+type TransformEffect<T> = {
+  type: "transform";
+  transform: (arg: T, ctx: RefinementCtx) => any;
+};
+type PreprocessEffect<T> = {
+  type: "preprocess";
+  transform: (arg: T, ctx: RefinementCtx) => any;
+};
+type Effect<T> = RefinementEffect<T> | TransformEffect<T> | PreprocessEffect<T>;
+interface ZodEffectsDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  schema: T;
+  typeName: ZodFirstPartyTypeKind.ZodEffects;
+  effect: Effect<any>;
+}
+declare class ZodEffects<T extends ZodTypeAny, Output = output$1<T>, Input = input$1<T>> extends ZodType$1<Output, ZodEffectsDef<T>, Input> {
+  innerType(): T;
+  sourceType(): T;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"]>;
+  static createWithPreprocess: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
+}
+interface ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  innerType: T;
+  typeName: ZodFirstPartyTypeKind.ZodOptional;
+}
+declare class ZodOptional$1<T extends ZodTypeAny> extends ZodType$1<T["_output"] | undefined, ZodOptionalDef<T>, T["_input"] | undefined> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  unwrap(): T;
+  static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodOptional$1<Inner>;
+}
+interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  innerType: T;
+  typeName: ZodFirstPartyTypeKind.ZodNullable;
+}
+declare class ZodNullable$1<T extends ZodTypeAny> extends ZodType$1<T["_output"] | null, ZodNullableDef<T>, T["_input"] | null> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  unwrap(): T;
+  static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodNullable$1<Inner>;
+}
+interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  innerType: T;
+  defaultValue: () => util.noUndefined<T["_input"]>;
+  typeName: ZodFirstPartyTypeKind.ZodDefault;
+}
+declare class ZodDefault$1<T extends ZodTypeAny> extends ZodType$1<util.noUndefined<T["_output"]>, ZodDefaultDef<T>, T["_input"] | undefined> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  removeDefault(): T;
+  static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
+    default: Inner["_input"] | (() => util.noUndefined<Inner["_input"]>);
+  }) => ZodDefault$1<Inner>;
+}
+interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  innerType: T;
+  catchValue: (ctx: {
+    error: ZodError$1;
+    input: unknown;
+  }) => T["_input"];
+  typeName: ZodFirstPartyTypeKind.ZodCatch;
+}
+declare class ZodCatch$1<T extends ZodTypeAny> extends ZodType$1<T["_output"], ZodCatchDef<T>, unknown> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  removeCatch(): T;
+  static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
+    catch: Inner["_output"] | (() => Inner["_output"]);
+  }) => ZodCatch$1<Inner>;
+}
+interface ZodBrandedDef<T extends ZodTypeAny> extends ZodTypeDef {
+  type: T;
+  typeName: ZodFirstPartyTypeKind.ZodBranded;
+}
+declare const BRAND: unique symbol;
+type BRAND<T extends string | number | symbol> = {
+  [BRAND]: { [k in T]: true };
+};
+declare class ZodBranded<T extends ZodTypeAny, B extends string | number | symbol> extends ZodType$1<T["_output"] & BRAND<B>, ZodBrandedDef<T>, T["_input"]> {
+  _parse(input: ParseInput): ParseReturnType<any>;
+  unwrap(): T;
+}
+interface ZodPipelineDef<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodTypeDef {
+  in: A;
+  out: B;
+  typeName: ZodFirstPartyTypeKind.ZodPipeline;
+}
+declare class ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodType$1<B["_output"], ZodPipelineDef<A, B>, A["_input"]> {
+  _parse(input: ParseInput): ParseReturnType<any>;
+  static create<ASchema extends ZodTypeAny, BSchema extends ZodTypeAny>(a: ASchema, b: BSchema): ZodPipeline<ASchema, BSchema>;
+}
+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>;
+interface ZodReadonlyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  innerType: T;
+  typeName: ZodFirstPartyTypeKind.ZodReadonly;
+}
+declare class ZodReadonly$1<T extends ZodTypeAny> extends ZodType$1<MakeReadonly$1<T["_output"]>, ZodReadonlyDef<T>, MakeReadonly$1<T["_input"]>> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodReadonly$1<Inner>;
+  unwrap(): T;
+}
+declare enum ZodFirstPartyTypeKind {
+  ZodString = "ZodString",
+  ZodNumber = "ZodNumber",
+  ZodNaN = "ZodNaN",
+  ZodBigInt = "ZodBigInt",
+  ZodBoolean = "ZodBoolean",
+  ZodDate = "ZodDate",
+  ZodSymbol = "ZodSymbol",
+  ZodUndefined = "ZodUndefined",
+  ZodNull = "ZodNull",
+  ZodAny = "ZodAny",
+  ZodUnknown = "ZodUnknown",
+  ZodNever = "ZodNever",
+  ZodVoid = "ZodVoid",
+  ZodArray = "ZodArray",
+  ZodObject = "ZodObject",
+  ZodUnion = "ZodUnion",
+  ZodDiscriminatedUnion = "ZodDiscriminatedUnion",
+  ZodIntersection = "ZodIntersection",
+  ZodTuple = "ZodTuple",
+  ZodRecord = "ZodRecord",
+  ZodMap = "ZodMap",
+  ZodSet = "ZodSet",
+  ZodFunction = "ZodFunction",
+  ZodLazy = "ZodLazy",
+  ZodLiteral = "ZodLiteral",
+  ZodEnum = "ZodEnum",
+  ZodEffects = "ZodEffects",
+  ZodNativeEnum = "ZodNativeEnum",
+  ZodOptional = "ZodOptional",
+  ZodNullable = "ZodNullable",
+  ZodDefault = "ZodDefault",
+  ZodCatch = "ZodCatch",
+  ZodPromise = "ZodPromise",
+  ZodBranded = "ZodBranded",
+  ZodPipeline = "ZodPipeline",
+  ZodReadonly = "ZodReadonly"
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/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.6/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.6/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.6/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.6/node_modules/zod/v4/core/util.d.cts
+type JWTAlgorithm = "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "EdDSA" | (string & {});
+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$1<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$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 = 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$1<{ [k in T]: k }>;
+type Literal = string | number | bigint | boolean | null | undefined;
+type Primitive$1 = string | number | symbol | bigint | boolean | null | undefined;
+type HasLength = {
+  length: number;
+};
+type Numeric = number | bigint | Date;
+type PropValues = Record<string, Set<Primitive$1>>;
+type PrimitiveSet = Set<Primitive$1>;
+type EmptyToNever<T> = keyof T extends never ? never : T;
+declare abstract class Class {
+  constructor(..._args: any[]);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/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.6/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 $ZodStringFormatDef<Format extends string = string> extends $ZodStringDef, $ZodCheckStringFormatDef<Format> {}
+interface $ZodStringFormatInternals<Format extends string = string> extends $ZodStringInternals<string>, $ZodCheckStringFormatInternals {
+  def: $ZodStringFormatDef<Format>;
+}
+interface $ZodStringFormat<Format extends string = string> extends $ZodType {
+  _zod: $ZodStringFormatInternals<Format>;
+}
+declare const $ZodStringFormat: $constructor<$ZodStringFormat>;
+interface $ZodGUIDInternals extends $ZodStringFormatInternals<"guid"> {}
+interface $ZodGUID extends $ZodType {
+  _zod: $ZodGUIDInternals;
+}
+declare const $ZodGUID: $constructor<$ZodGUID>;
+interface $ZodUUIDDef extends $ZodStringFormatDef<"uuid"> {
+  version?: "v1" | "v2" | "v3" | "v4" | "v5" | "v6" | "v7" | "v8";
+}
+interface $ZodUUIDInternals extends $ZodStringFormatInternals<"uuid"> {
+  def: $ZodUUIDDef;
+}
+interface $ZodUUID extends $ZodType {
+  _zod: $ZodUUIDInternals;
+}
+declare const $ZodUUID: $constructor<$ZodUUID>;
+interface $ZodEmailInternals extends $ZodStringFormatInternals<"email"> {}
+interface $ZodEmail extends $ZodType {
+  _zod: $ZodEmailInternals;
+}
+declare const $ZodEmail: $constructor<$ZodEmail>;
+interface $ZodURLDef extends $ZodStringFormatDef<"url"> {
+  hostname?: RegExp | undefined;
+  protocol?: RegExp | undefined;
+  normalize?: boolean | undefined;
+}
+interface $ZodURLInternals extends $ZodStringFormatInternals<"url"> {
+  def: $ZodURLDef;
+}
+interface $ZodURL extends $ZodType {
+  _zod: $ZodURLInternals;
+}
+declare const $ZodURL: $constructor<$ZodURL>;
+interface $ZodEmojiInternals extends $ZodStringFormatInternals<"emoji"> {}
+interface $ZodEmoji extends $ZodType {
+  _zod: $ZodEmojiInternals;
+}
+declare const $ZodEmoji: $constructor<$ZodEmoji>;
+interface $ZodNanoIDInternals extends $ZodStringFormatInternals<"nanoid"> {}
+interface $ZodNanoID extends $ZodType {
+  _zod: $ZodNanoIDInternals;
+}
+declare const $ZodNanoID: $constructor<$ZodNanoID>;
+interface $ZodCUIDInternals extends $ZodStringFormatInternals<"cuid"> {}
+interface $ZodCUID extends $ZodType {
+  _zod: $ZodCUIDInternals;
+}
+declare const $ZodCUID: $constructor<$ZodCUID>;
+interface $ZodCUID2Internals extends $ZodStringFormatInternals<"cuid2"> {}
+interface $ZodCUID2 extends $ZodType {
+  _zod: $ZodCUID2Internals;
+}
+declare const $ZodCUID2: $constructor<$ZodCUID2>;
+interface $ZodULIDInternals extends $ZodStringFormatInternals<"ulid"> {}
+interface $ZodULID extends $ZodType {
+  _zod: $ZodULIDInternals;
+}
+declare const $ZodULID: $constructor<$ZodULID>;
+interface $ZodXIDInternals extends $ZodStringFormatInternals<"xid"> {}
+interface $ZodXID extends $ZodType {
+  _zod: $ZodXIDInternals;
+}
+declare const $ZodXID: $constructor<$ZodXID>;
+interface $ZodKSUIDInternals extends $ZodStringFormatInternals<"ksuid"> {}
+interface $ZodKSUID extends $ZodType {
+  _zod: $ZodKSUIDInternals;
+}
+declare const $ZodKSUID: $constructor<$ZodKSUID>;
+interface $ZodISODateTimeDef extends $ZodStringFormatDef<"datetime"> {
+  precision: number | null;
+  offset: boolean;
+  local: boolean;
+}
+interface $ZodISODateTimeInternals extends $ZodStringFormatInternals {
+  def: $ZodISODateTimeDef;
+}
+interface $ZodISODateTime extends $ZodType {
+  _zod: $ZodISODateTimeInternals;
+}
+declare const $ZodISODateTime: $constructor<$ZodISODateTime>;
+interface $ZodISODateInternals extends $ZodStringFormatInternals<"date"> {}
+interface $ZodISODate extends $ZodType {
+  _zod: $ZodISODateInternals;
+}
+declare const $ZodISODate: $constructor<$ZodISODate>;
+interface $ZodISOTimeDef extends $ZodStringFormatDef<"time"> {
+  precision?: number | null;
+}
+interface $ZodISOTimeInternals extends $ZodStringFormatInternals<"time"> {
+  def: $ZodISOTimeDef;
+}
+interface $ZodISOTime extends $ZodType {
+  _zod: $ZodISOTimeInternals;
+}
+declare const $ZodISOTime: $constructor<$ZodISOTime>;
+interface $ZodISODurationInternals extends $ZodStringFormatInternals<"duration"> {}
+interface $ZodISODuration extends $ZodType {
+  _zod: $ZodISODurationInternals;
+}
+declare const $ZodISODuration: $constructor<$ZodISODuration>;
+interface $ZodIPv4Def extends $ZodStringFormatDef<"ipv4"> {
+  version?: "v4";
+}
+interface $ZodIPv4Internals extends $ZodStringFormatInternals<"ipv4"> {
+  def: $ZodIPv4Def;
+}
+interface $ZodIPv4 extends $ZodType {
+  _zod: $ZodIPv4Internals;
+}
+declare const $ZodIPv4: $constructor<$ZodIPv4>;
+interface $ZodIPv6Def extends $ZodStringFormatDef<"ipv6"> {
+  version?: "v6";
+}
+interface $ZodIPv6Internals extends $ZodStringFormatInternals<"ipv6"> {
+  def: $ZodIPv6Def;
+}
+interface $ZodIPv6 extends $ZodType {
+  _zod: $ZodIPv6Internals;
+}
+declare const $ZodIPv6: $constructor<$ZodIPv6>;
+interface $ZodCIDRv4Def extends $ZodStringFormatDef<"cidrv4"> {
+  version?: "v4";
+}
+interface $ZodCIDRv4Internals extends $ZodStringFormatInternals<"cidrv4"> {
+  def: $ZodCIDRv4Def;
+}
+interface $ZodCIDRv4 extends $ZodType {
+  _zod: $ZodCIDRv4Internals;
+}
+declare const $ZodCIDRv4: $constructor<$ZodCIDRv4>;
+interface $ZodCIDRv6Def extends $ZodStringFormatDef<"cidrv6"> {
+  version?: "v6";
+}
+interface $ZodCIDRv6Internals extends $ZodStringFormatInternals<"cidrv6"> {
+  def: $ZodCIDRv6Def;
+}
+interface $ZodCIDRv6 extends $ZodType {
+  _zod: $ZodCIDRv6Internals;
+}
+declare const $ZodCIDRv6: $constructor<$ZodCIDRv6>;
+interface $ZodBase64Internals extends $ZodStringFormatInternals<"base64"> {}
+interface $ZodBase64 extends $ZodType {
+  _zod: $ZodBase64Internals;
+}
+declare const $ZodBase64: $constructor<$ZodBase64>;
+interface $ZodBase64URLInternals extends $ZodStringFormatInternals<"base64url"> {}
+interface $ZodBase64URL extends $ZodType {
+  _zod: $ZodBase64URLInternals;
+}
+declare const $ZodBase64URL: $constructor<$ZodBase64URL>;
+interface $ZodE164Internals extends $ZodStringFormatInternals<"e164"> {}
+interface $ZodE164 extends $ZodType {
+  _zod: $ZodE164Internals;
+}
+declare const $ZodE164: $constructor<$ZodE164>;
+interface $ZodJWTDef extends $ZodStringFormatDef<"jwt"> {
+  alg?: JWTAlgorithm | undefined;
+}
+interface $ZodJWTInternals extends $ZodStringFormatInternals<"jwt"> {
+  def: $ZodJWTDef;
+}
+interface $ZodJWT extends $ZodType {
+  _zod: $ZodJWTInternals;
+}
+declare const $ZodJWT: $constructor<$ZodJWT>;
+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 $ZodDiscriminatedUnionDef<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodUnionDef<Options> {
+  discriminator: Disc;
+  unionFallback?: boolean;
+}
+interface $ZodDiscriminatedUnionInternals<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodUnionInternals<Options> {
+  def: $ZodDiscriminatedUnionDef<Options, Disc>;
+  propValues: PropValues;
+}
+interface $ZodDiscriminatedUnion<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodType {
+  _zod: $ZodDiscriminatedUnionInternals<Options, Disc>;
+}
+declare const $ZodDiscriminatedUnion: $constructor<$ZodDiscriminatedUnion>;
+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.6/node_modules/zod/v4/core/checks.d.cts
+interface $ZodCheckDef {
+  check: string;
+  error?: $ZodErrorMap<never> | undefined;
+  /** If true, no later checks will be executed if this check fails. Default `false`. */
+  abort?: boolean | undefined;
+  /** If provided, this check will only be executed if the function returns `true`. Defaults to `payload => z.util.isAborted(payload)`. */
+  when?: ((payload: ParsePayload) => boolean) | undefined;
+}
+interface $ZodCheckInternals<T> {
+  def: $ZodCheckDef;
+  /** The set of issues this check might throw. */
+  issc?: $ZodIssueBase;
+  check(payload: ParsePayload<T>): MaybeAsync<void>;
+  onattach: ((schema: $ZodType) => void)[];
+}
+interface $ZodCheck<in T = never> {
+  _zod: $ZodCheckInternals<T>;
+}
+declare const $ZodCheck: $constructor<$ZodCheck<any>>;
+interface $ZodCheckLessThanDef extends $ZodCheckDef {
+  check: "less_than";
+  value: Numeric;
+  inclusive: boolean;
+}
+interface $ZodCheckLessThanInternals<T extends Numeric = Numeric> extends $ZodCheckInternals<T> {
+  def: $ZodCheckLessThanDef;
+  issc: $ZodIssueTooBig<T>;
+}
+interface $ZodCheckLessThan<T extends Numeric = Numeric> extends $ZodCheck<T> {
+  _zod: $ZodCheckLessThanInternals<T>;
+}
+declare const $ZodCheckLessThan: $constructor<$ZodCheckLessThan>;
+interface $ZodCheckGreaterThanDef extends $ZodCheckDef {
+  check: "greater_than";
+  value: Numeric;
+  inclusive: boolean;
+}
+interface $ZodCheckGreaterThanInternals<T extends Numeric = Numeric> extends $ZodCheckInternals<T> {
+  def: $ZodCheckGreaterThanDef;
+  issc: $ZodIssueTooSmall<T>;
+}
+interface $ZodCheckGreaterThan<T extends Numeric = Numeric> extends $ZodCheck<T> {
+  _zod: $ZodCheckGreaterThanInternals<T>;
+}
+declare const $ZodCheckGreaterThan: $constructor<$ZodCheckGreaterThan>;
+interface $ZodCheckMultipleOfDef<T extends number | bigint = number | bigint> extends $ZodCheckDef {
+  check: "multiple_of";
+  value: T;
+}
+interface $ZodCheckMultipleOfInternals<T extends number | bigint = number | bigint> extends $ZodCheckInternals<T> {
+  def: $ZodCheckMultipleOfDef<T>;
+  issc: $ZodIssueNotMultipleOf;
+}
+interface $ZodCheckMultipleOf<T extends number | bigint = number | bigint> extends $ZodCheck<T> {
+  _zod: $ZodCheckMultipleOfInternals<T>;
+}
+declare const $ZodCheckMultipleOf: $constructor<$ZodCheckMultipleOf<number | bigint>>;
+type $ZodNumberFormats = "int32" | "uint32" | "float32" | "float64" | "safeint";
+interface $ZodCheckNumberFormatDef extends $ZodCheckDef {
+  check: "number_format";
+  format: $ZodNumberFormats;
+}
+interface $ZodCheckNumberFormatInternals extends $ZodCheckInternals<number> {
+  def: $ZodCheckNumberFormatDef;
+  issc: $ZodIssueInvalidType | $ZodIssueTooBig<"number"> | $ZodIssueTooSmall<"number">;
+}
+interface $ZodCheckNumberFormat extends $ZodCheck<number> {
+  _zod: $ZodCheckNumberFormatInternals;
+}
+declare const $ZodCheckNumberFormat: $constructor<$ZodCheckNumberFormat>;
+interface $ZodCheckMaxLengthDef extends $ZodCheckDef {
+  check: "max_length";
+  maximum: number;
+}
+interface $ZodCheckMaxLengthInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+  def: $ZodCheckMaxLengthDef;
+  issc: $ZodIssueTooBig<T>;
+}
+interface $ZodCheckMaxLength<T extends HasLength = HasLength> extends $ZodCheck<T> {
+  _zod: $ZodCheckMaxLengthInternals<T>;
+}
+declare const $ZodCheckMaxLength: $constructor<$ZodCheckMaxLength>;
+interface $ZodCheckMinLengthDef extends $ZodCheckDef {
+  check: "min_length";
+  minimum: number;
+}
+interface $ZodCheckMinLengthInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+  def: $ZodCheckMinLengthDef;
+  issc: $ZodIssueTooSmall<T>;
+}
+interface $ZodCheckMinLength<T extends HasLength = HasLength> extends $ZodCheck<T> {
+  _zod: $ZodCheckMinLengthInternals<T>;
+}
+declare const $ZodCheckMinLength: $constructor<$ZodCheckMinLength>;
+interface $ZodCheckLengthEqualsDef extends $ZodCheckDef {
+  check: "length_equals";
+  length: number;
+}
+interface $ZodCheckLengthEqualsInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+  def: $ZodCheckLengthEqualsDef;
+  issc: $ZodIssueTooBig<T> | $ZodIssueTooSmall<T>;
+}
+interface $ZodCheckLengthEquals<T extends HasLength = HasLength> extends $ZodCheck<T> {
+  _zod: $ZodCheckLengthEqualsInternals<T>;
+}
+declare const $ZodCheckLengthEquals: $constructor<$ZodCheckLengthEquals>;
+type $ZodStringFormats = "email" | "url" | "emoji" | "uuid" | "guid" | "nanoid" | "cuid" | "cuid2" | "ulid" | "xid" | "ksuid" | "datetime" | "date" | "time" | "duration" | "ipv4" | "ipv6" | "cidrv4" | "cidrv6" | "base64" | "base64url" | "json_string" | "e164" | "lowercase" | "uppercase" | "regex" | "jwt" | "starts_with" | "ends_with" | "includes";
+interface $ZodCheckStringFormatDef<Format extends string = string> extends $ZodCheckDef {
+  check: "string_format";
+  format: Format;
+  pattern?: RegExp | undefined;
+}
+interface $ZodCheckStringFormatInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckStringFormatDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckRegexDef extends $ZodCheckStringFormatDef {
+  format: "regex";
+  pattern: RegExp;
+}
+interface $ZodCheckRegexInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckRegexDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckRegex extends $ZodCheck<string> {
+  _zod: $ZodCheckRegexInternals;
+}
+declare const $ZodCheckRegex: $constructor<$ZodCheckRegex>;
+interface $ZodCheckLowerCaseDef extends $ZodCheckStringFormatDef<"lowercase"> {}
+interface $ZodCheckLowerCaseInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckLowerCaseDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckLowerCase extends $ZodCheck<string> {
+  _zod: $ZodCheckLowerCaseInternals;
+}
+declare const $ZodCheckLowerCase: $constructor<$ZodCheckLowerCase>;
+interface $ZodCheckUpperCaseDef extends $ZodCheckStringFormatDef<"uppercase"> {}
+interface $ZodCheckUpperCaseInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckUpperCaseDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckUpperCase extends $ZodCheck<string> {
+  _zod: $ZodCheckUpperCaseInternals;
+}
+declare const $ZodCheckUpperCase: $constructor<$ZodCheckUpperCase>;
+interface $ZodCheckIncludesDef extends $ZodCheckStringFormatDef<"includes"> {
+  includes: string;
+  position?: number | undefined;
+}
+interface $ZodCheckIncludesInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckIncludesDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckIncludes extends $ZodCheck<string> {
+  _zod: $ZodCheckIncludesInternals;
+}
+declare const $ZodCheckIncludes: $constructor<$ZodCheckIncludes>;
+interface $ZodCheckStartsWithDef extends $ZodCheckStringFormatDef<"starts_with"> {
+  prefix: string;
+}
+interface $ZodCheckStartsWithInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckStartsWithDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckStartsWith extends $ZodCheck<string> {
+  _zod: $ZodCheckStartsWithInternals;
+}
+declare const $ZodCheckStartsWith: $constructor<$ZodCheckStartsWith>;
+interface $ZodCheckEndsWithDef extends $ZodCheckStringFormatDef<"ends_with"> {
+  suffix: string;
+}
+interface $ZodCheckEndsWithInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckEndsWithDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckEndsWith extends $ZodCheckInternals<string> {
+  _zod: $ZodCheckEndsWithInternals;
+}
+declare const $ZodCheckEndsWith: $constructor<$ZodCheckEndsWith>;
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/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$1[];
+  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$1<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$1<{ [K in keyof T]?: $ZodFormattedError<T[K], U> }> : any;
+type $ZodFormattedError<T, U = string> = {
+  _errors: U[];
+} & Flatten$1<_ZodFormattedError<T, U>>;
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/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.6/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$1<Partial<EmptyToNever<Omit<T["_zod"]["def"], OmitKeys> & ([IssueTypes] extends [never] ? {} : {
+  error?: string | $ZodErrorMap<IssueTypes> | undefined; /** @deprecated This parameter is deprecated. Use `error` instead. */
+  message?: string | undefined;
+})>>>;
+type TypeParams<T extends $ZodType = $ZodType & {
+  _isst: never;
+}, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error"> = never> = Params<T, NonNullable<T["_zod"]["isst"]>, "type" | "checks" | "error" | AlsoOmit>;
+type CheckParams<T extends $ZodCheck = $ZodCheck, // & { _issc: never },
+AlsoOmit extends Exclude<keyof T["_zod"]["def"], "check" | "error"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "check" | "error" | AlsoOmit>;
+type CheckStringFormatParams<T extends $ZodStringFormat = $ZodStringFormat, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "coerce" | "checks" | "error" | "check" | "format"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "type" | "coerce" | "checks" | "error" | "check" | "format" | AlsoOmit>;
+type CheckTypeParams<T extends $ZodType & $ZodCheck = $ZodType & $ZodCheck, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error" | "check"> = never> = Params<T, NonNullable<T["_zod"]["isst"] | T["_zod"]["issc"]>, "type" | "checks" | "error" | "check" | AlsoOmit>;
+type $ZodCheckEmailParams = CheckStringFormatParams<$ZodEmail, "when">;
+type $ZodCheckGUIDParams = CheckStringFormatParams<$ZodGUID, "pattern" | "when">;
+type $ZodCheckUUIDParams = CheckStringFormatParams<$ZodUUID, "pattern" | "when">;
+type $ZodCheckURLParams = CheckStringFormatParams<$ZodURL, "when">;
+type $ZodCheckEmojiParams = CheckStringFormatParams<$ZodEmoji, "when">;
+type $ZodCheckNanoIDParams = CheckStringFormatParams<$ZodNanoID, "when">;
+type $ZodCheckCUIDParams = CheckStringFormatParams<$ZodCUID, "when">;
+type $ZodCheckCUID2Params = CheckStringFormatParams<$ZodCUID2, "when">;
+type $ZodCheckULIDParams = CheckStringFormatParams<$ZodULID, "when">;
+type $ZodCheckXIDParams = CheckStringFormatParams<$ZodXID, "when">;
+type $ZodCheckKSUIDParams = CheckStringFormatParams<$ZodKSUID, "when">;
+type $ZodCheckIPv4Params = CheckStringFormatParams<$ZodIPv4, "pattern" | "when" | "version">;
+type $ZodCheckIPv6Params = CheckStringFormatParams<$ZodIPv6, "pattern" | "when" | "version">;
+type $ZodCheckCIDRv4Params = CheckStringFormatParams<$ZodCIDRv4, "pattern" | "when">;
+type $ZodCheckCIDRv6Params = CheckStringFormatParams<$ZodCIDRv6, "pattern" | "when">;
+type $ZodCheckBase64Params = CheckStringFormatParams<$ZodBase64, "pattern" | "when">;
+type $ZodCheckBase64URLParams = CheckStringFormatParams<$ZodBase64URL, "pattern" | "when">;
+type $ZodCheckE164Params = CheckStringFormatParams<$ZodE164, "when">;
+type $ZodCheckJWTParams = CheckStringFormatParams<$ZodJWT, "pattern" | "when">;
+type $ZodCheckISODateTimeParams = CheckStringFormatParams<$ZodISODateTime, "pattern" | "when">;
+type $ZodCheckISODateParams = CheckStringFormatParams<$ZodISODate, "pattern" | "when">;
+type $ZodCheckISOTimeParams = CheckStringFormatParams<$ZodISOTime, "pattern" | "when">;
+type $ZodCheckISODurationParams = CheckStringFormatParams<$ZodISODuration, "when">;
+type $ZodCheckNumberFormatParams = CheckParams<$ZodCheckNumberFormat, "format" | "when">;
+type $ZodCheckLessThanParams = CheckParams<$ZodCheckLessThan, "inclusive" | "value" | "when">;
+type $ZodCheckGreaterThanParams = CheckParams<$ZodCheckGreaterThan, "inclusive" | "value" | "when">;
+type $ZodCheckMultipleOfParams = CheckParams<$ZodCheckMultipleOf, "value" | "when">;
+type $ZodCheckMaxLengthParams = CheckParams<$ZodCheckMaxLength, "maximum" | "when">;
+type $ZodCheckMinLengthParams = CheckParams<$ZodCheckMinLength, "minimum" | "when">;
+type $ZodCheckLengthEqualsParams = CheckParams<$ZodCheckLengthEquals, "length" | "when">;
+type $ZodCheckRegexParams = CheckParams<$ZodCheckRegex, "format" | "pattern" | "when">;
+type $ZodCheckLowerCaseParams = CheckParams<$ZodCheckLowerCase, "format" | "when">;
+type $ZodCheckUpperCaseParams = CheckParams<$ZodCheckUpperCase, "format" | "when">;
+type $ZodCheckIncludesParams = CheckParams<$ZodCheckIncludes, "includes" | "format" | "when" | "pattern">;
+type $ZodCheckStartsWithParams = CheckParams<$ZodCheckStartsWith, "prefix" | "format" | "when" | "pattern">;
+type $ZodCheckEndsWithParams = CheckParams<$ZodCheckEndsWith, "suffix" | "format" | "pattern" | "when">;
+type $ZodEnumParams = TypeParams<$ZodEnum, "entries">;
+type $ZodNonOptionalParams = TypeParams<$ZodNonOptional, "innerType">;
+type $ZodCustomParams = CheckTypeParams<$ZodCustom, "fn">;
+type $ZodSuperRefineIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
+type RawIssue<T extends $ZodIssueBase> = T extends any ? Flatten$1<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/@modelcontextprotocol+sdk@1.25.3_hono@4.11.7_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.d.ts
+type AnySchema = ZodTypeAny | $ZodType;
+type ZodRawShapeCompat = Record<string, AnySchema>;
+type SchemaOutput<S> = S extends ZodTypeAny ? TypeOf<S> : S extends $ZodType ? output<S> : never;
+/**
+ * Infers the output type from a ZodRawShapeCompat (raw shape object).
+ * Maps over each key in the shape and infers the output type from each schema.
+ */
+type ShapeOutput<Shape extends ZodRawShapeCompat> = { [K in keyof Shape]: SchemaOutput<Shape[K]> };
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/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.6/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.6/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 _ZodString<T extends $ZodStringInternals<unknown> = $ZodStringInternals<unknown>> extends _ZodType<T> {
+  format: string | null;
+  minLength: number | null;
+  maxLength: number | null;
+  regex(regex: RegExp, params?: string | $ZodCheckRegexParams): this;
+  includes(value: string, params?: string | $ZodCheckIncludesParams): this;
+  startsWith(value: string, params?: string | $ZodCheckStartsWithParams): this;
+  endsWith(value: string, params?: string | $ZodCheckEndsWithParams): this;
+  min(minLength: number, params?: string | $ZodCheckMinLengthParams): this;
+  max(maxLength: number, params?: string | $ZodCheckMaxLengthParams): this;
+  length(len: number, params?: string | $ZodCheckLengthEqualsParams): this;
+  nonempty(params?: string | $ZodCheckMinLengthParams): this;
+  lowercase(params?: string | $ZodCheckLowerCaseParams): this;
+  uppercase(params?: string | $ZodCheckUpperCaseParams): this;
+  trim(): this;
+  normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): this;
+  toLowerCase(): this;
+  toUpperCase(): this;
+  slugify(): this;
+}
+/** @internal */
+declare const _ZodString: $constructor<_ZodString>;
+interface ZodString extends _ZodString<$ZodStringInternals<string>> {
+  /** @deprecated Use `z.email()` instead. */
+  email(params?: string | $ZodCheckEmailParams): this;
+  /** @deprecated Use `z.url()` instead. */
+  url(params?: string | $ZodCheckURLParams): this;
+  /** @deprecated Use `z.jwt()` instead. */
+  jwt(params?: string | $ZodCheckJWTParams): this;
+  /** @deprecated Use `z.emoji()` instead. */
+  emoji(params?: string | $ZodCheckEmojiParams): this;
+  /** @deprecated Use `z.guid()` instead. */
+  guid(params?: string | $ZodCheckGUIDParams): this;
+  /** @deprecated Use `z.uuid()` instead. */
+  uuid(params?: string | $ZodCheckUUIDParams): this;
+  /** @deprecated Use `z.uuid()` instead. */
+  uuidv4(params?: string | $ZodCheckUUIDParams): this;
+  /** @deprecated Use `z.uuid()` instead. */
+  uuidv6(params?: string | $ZodCheckUUIDParams): this;
+  /** @deprecated Use `z.uuid()` instead. */
+  uuidv7(params?: string | $ZodCheckUUIDParams): this;
+  /** @deprecated Use `z.nanoid()` instead. */
+  nanoid(params?: string | $ZodCheckNanoIDParams): this;
+  /** @deprecated Use `z.guid()` instead. */
+  guid(params?: string | $ZodCheckGUIDParams): this;
+  /** @deprecated Use `z.cuid()` instead. */
+  cuid(params?: string | $ZodCheckCUIDParams): this;
+  /** @deprecated Use `z.cuid2()` instead. */
+  cuid2(params?: string | $ZodCheckCUID2Params): this;
+  /** @deprecated Use `z.ulid()` instead. */
+  ulid(params?: string | $ZodCheckULIDParams): this;
+  /** @deprecated Use `z.base64()` instead. */
+  base64(params?: string | $ZodCheckBase64Params): this;
+  /** @deprecated Use `z.base64url()` instead. */
+  base64url(params?: string | $ZodCheckBase64URLParams): this;
+  /** @deprecated Use `z.xid()` instead. */
+  xid(params?: string | $ZodCheckXIDParams): this;
+  /** @deprecated Use `z.ksuid()` instead. */
+  ksuid(params?: string | $ZodCheckKSUIDParams): this;
+  /** @deprecated Use `z.ipv4()` instead. */
+  ipv4(params?: string | $ZodCheckIPv4Params): this;
+  /** @deprecated Use `z.ipv6()` instead. */
+  ipv6(params?: string | $ZodCheckIPv6Params): this;
+  /** @deprecated Use `z.cidrv4()` instead. */
+  cidrv4(params?: string | $ZodCheckCIDRv4Params): this;
+  /** @deprecated Use `z.cidrv6()` instead. */
+  cidrv6(params?: string | $ZodCheckCIDRv6Params): this;
+  /** @deprecated Use `z.e164()` instead. */
+  e164(params?: string | $ZodCheckE164Params): this;
+  /** @deprecated Use `z.iso.datetime()` instead. */
+  datetime(params?: string | $ZodCheckISODateTimeParams): this;
+  /** @deprecated Use `z.iso.date()` instead. */
+  date(params?: string | $ZodCheckISODateParams): this;
+  /** @deprecated Use `z.iso.time()` instead. */
+  time(params?: string | $ZodCheckISOTimeParams): this;
+  /** @deprecated Use `z.iso.duration()` instead. */
+  duration(params?: string | $ZodCheckISODurationParams): this;
+}
+declare const ZodString: $constructor<ZodString>;
+interface ZodStringFormat<Format extends string = string> extends _ZodString<$ZodStringFormatInternals<Format>> {}
+declare const ZodStringFormat: $constructor<ZodStringFormat>;
+interface _ZodNumber<Internals extends $ZodNumberInternals = $ZodNumberInternals> extends _ZodType<Internals> {
+  gt(value: number, params?: string | $ZodCheckGreaterThanParams): this;
+  /** Identical to .min() */
+  gte(value: number, params?: string | $ZodCheckGreaterThanParams): this;
+  min(value: number, params?: string | $ZodCheckGreaterThanParams): this;
+  lt(value: number, params?: string | $ZodCheckLessThanParams): this;
+  /** Identical to .max() */
+  lte(value: number, params?: string | $ZodCheckLessThanParams): this;
+  max(value: number, params?: string | $ZodCheckLessThanParams): this;
+  /** Consider `z.int()` instead. This API is considered *legacy*; it will never be removed but a better alternative exists. */
+  int(params?: string | $ZodCheckNumberFormatParams): this;
+  /** @deprecated This is now identical to `.int()`. Only numbers in the safe integer range are accepted. */
+  safe(params?: string | $ZodCheckNumberFormatParams): this;
+  positive(params?: string | $ZodCheckGreaterThanParams): this;
+  nonnegative(params?: string | $ZodCheckGreaterThanParams): this;
+  negative(params?: string | $ZodCheckLessThanParams): this;
+  nonpositive(params?: string | $ZodCheckLessThanParams): this;
+  multipleOf(value: number, params?: string | $ZodCheckMultipleOfParams): this;
+  /** @deprecated Use `.multipleOf()` instead. */
+  step(value: number, params?: string | $ZodCheckMultipleOfParams): this;
+  /** @deprecated In v4 and later, z.number() does not allow infinite values by default. This is a no-op. */
+  finite(params?: unknown): this;
+  minValue: number | null;
+  maxValue: number | null;
+  /** @deprecated Check the `format` property instead.  */
+  isInt: boolean;
+  /** @deprecated Number schemas no longer accept infinite values, so this always returns `true`. */
+  isFinite: boolean;
+  format: string | null;
+}
+interface ZodNumber extends _ZodNumber<$ZodNumberInternals<number>> {}
+declare const ZodNumber: $constructor<ZodNumber>;
+interface _ZodBoolean<T extends $ZodBooleanInternals = $ZodBooleanInternals> extends _ZodType<T> {}
+interface ZodBoolean extends _ZodBoolean<$ZodBooleanInternals<boolean>> {}
+declare const ZodBoolean: $constructor<ZodBoolean>;
+interface ZodNull extends _ZodType<$ZodNullInternals> {}
+declare const ZodNull: $constructor<ZodNull>;
+interface ZodUnknown extends _ZodType<$ZodUnknownInternals> {}
+declare const ZodUnknown: $constructor<ZodUnknown>;
+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$1<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$1<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 ZodDiscriminatedUnion<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends ZodUnion<Options>, $ZodDiscriminatedUnion<Options, Disc> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  _zod: $ZodDiscriminatedUnionInternals<Options, Disc>;
+  def: $ZodDiscriminatedUnionDef<Options, Disc>;
+}
+declare const ZodDiscriminatedUnion: $constructor<ZodDiscriminatedUnion>;
+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 ZodRecord<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends _ZodType<$ZodRecordInternals<Key, Value>>, $ZodRecord<Key, Value> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  keyType: Key;
+  valueType: Value;
+}
+declare const ZodRecord: $constructor<ZodRecord>;
+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$1<Pick<T, U[number]>>>;
+  exclude<const U extends readonly (keyof T)[]>(values: U, params?: string | $ZodEnumParams): ZodEnum<Flatten$1<Omit<T, U[number]>>>;
+}
+declare const ZodEnum: $constructor<ZodEnum>;
+interface ZodLiteral<T extends Literal = Literal> extends _ZodType<$ZodLiteralInternals<T>>, $ZodLiteral<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  values: Set<T>;
+  /** @legacy Use `.values` instead. Accessing this property will throw an error if the literal accepts multiple values. */
+  value: T;
+}
+declare const ZodLiteral: $constructor<ZodLiteral>;
+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>;
+interface ZodCustom<O = unknown, I = unknown> extends _ZodType<$ZodCustomInternals<O, I>>, $ZodCustom<O, I> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
+declare const ZodCustom: $constructor<ZodCustom>;
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/iso.d.cts
+interface ZodISODateTime extends ZodStringFormat {
+  _zod: $ZodISODateTimeInternals;
+}
+declare const ZodISODateTime: $constructor<ZodISODateTime>;
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.3_hono@4.11.7_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/server/auth/types.d.ts
+/**
+ * Information about a validated access token, provided to request handlers.
+ */
+interface AuthInfo {
+  /**
+   * The access token.
+   */
+  token: string;
+  /**
+   * The client ID associated with this token.
+   */
+  clientId: string;
+  /**
+   * Scopes associated with this token.
+   */
+  scopes: string[];
+  /**
+   * When the token expires (in seconds since epoch).
+   */
+  expiresAt?: number;
+  /**
+   * The RFC 8707 resource server identifier for which this token is valid.
+   * If set, this MUST match the MCP server's resource identifier (minus hash fragment).
+   */
+  resource?: URL;
+  /**
+   * Additional data associated with the token.
+   * This field should be used for any additional data that needs to be attached to the auth info.
+   */
+  extra?: Record<string, unknown>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.3_hono@4.11.7_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/types.d.ts
+/**
+ * Task creation parameters, used to ask that the server create a task to represent a request.
+ */
+declare const TaskCreationParamsSchema: ZodObject<{
+  /**
+   * Time in milliseconds to keep task results available after completion.
+   * If null, the task has unlimited lifetime until manually cleaned up.
+   */
+  ttl: ZodOptional<ZodUnion<readonly [ZodNumber, ZodNull]>>;
+  /**
+   * Time in milliseconds to wait between task status requests.
+   */
+  pollInterval: ZodOptional<ZodNumber>;
+}, $loose>;
+/**
+ * Metadata for associating messages with a task.
+ * Include this in the `_meta` field under the key `io.modelcontextprotocol/related-task`.
+ */
+declare const RelatedTaskMetadataSchema: ZodObject<{
+  taskId: ZodString;
+}, $strip>;
+declare const RequestMetaSchema: ZodObject<{
+  /**
+   * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+   */
+  progressToken: ZodOptional<ZodUnion<readonly [ZodString, ZodNumber]>>;
+  /**
+   * If specified, this request is related to the provided task.
+   */
+  "io.modelcontextprotocol/related-task": ZodOptional<ZodObject<{
+    taskId: ZodString;
+  }, $strip>>;
+}, $loose>;
+/**
+ * Common params for any request.
+ */
+declare const RequestSchema: ZodObject<{
+  method: ZodString;
+  params: ZodOptional<ZodObject<{
+    _meta: ZodOptional<ZodObject<{
+      /**
+       * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+       */
+      progressToken: ZodOptional<ZodUnion<readonly [ZodString, ZodNumber]>>;
+      /**
+       * If specified, this request is related to the provided task.
+       */
+      "io.modelcontextprotocol/related-task": ZodOptional<ZodObject<{
+        taskId: ZodString;
+      }, $strip>>;
+    }, $loose>>;
+  }, $loose>>;
+}, $strip>;
+declare const NotificationSchema: ZodObject<{
+  method: ZodString;
+  params: ZodOptional<ZodObject<{
+    _meta: ZodOptional<ZodObject<{
+      /**
+       * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+       */
+      progressToken: ZodOptional<ZodUnion<readonly [ZodString, ZodNumber]>>;
+      /**
+       * If specified, this request is related to the provided task.
+       */
+      "io.modelcontextprotocol/related-task": ZodOptional<ZodObject<{
+        taskId: ZodString;
+      }, $strip>>;
+    }, $loose>>;
+  }, $loose>>;
+}, $strip>;
+declare const ResultSchema: ZodObject<{
+  /**
+   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
+   * for notes on _meta usage.
+   */
+  _meta: ZodOptional<ZodObject<{
+    /**
+     * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+     */
+    progressToken: ZodOptional<ZodUnion<readonly [ZodString, ZodNumber]>>;
+    /**
+     * If specified, this request is related to the provided task.
+     */
+    "io.modelcontextprotocol/related-task": ZodOptional<ZodObject<{
+      taskId: ZodString;
+    }, $strip>>;
+  }, $loose>>;
+}, $loose>;
+/**
+ * A uniquely identifying ID for a request in JSON-RPC.
+ */
+declare const RequestIdSchema: ZodUnion<readonly [ZodString, ZodNumber]>;
+declare const ProgressSchema: ZodObject<{
+  progress: ZodNumber;
+  total: ZodOptional<ZodNumber>;
+  message: ZodOptional<ZodString>;
+}, $strip>;
+/**
+ * A pollable state object associated with a request.
+ */
+declare const TaskSchema: ZodObject<{
+  taskId: ZodString;
+  status: ZodEnum<{
+    working: "working";
+    input_required: "input_required";
+    completed: "completed";
+    failed: "failed";
+    cancelled: "cancelled";
+  }>;
+  ttl: ZodUnion<readonly [ZodNumber, ZodNull]>;
+  createdAt: ZodString;
+  lastUpdatedAt: ZodString;
+  pollInterval: ZodOptional<ZodNumber>;
+  statusMessage: ZodOptional<ZodString>;
+}, $strip>;
+/**
+ * Additional properties describing a Tool to clients.
+ *
+ * NOTE: all properties in ToolAnnotations are **hints**.
+ * They are not guaranteed to provide a faithful description of
+ * tool behavior (including descriptive properties like `title`).
+ *
+ * Clients should never make tool use decisions based on ToolAnnotations
+ * received from untrusted servers.
+ */
+declare const ToolAnnotationsSchema: ZodObject<{
+  title: ZodOptional<ZodString>;
+  readOnlyHint: ZodOptional<ZodBoolean>;
+  destructiveHint: ZodOptional<ZodBoolean>;
+  idempotentHint: ZodOptional<ZodBoolean>;
+  openWorldHint: ZodOptional<ZodBoolean>;
+}, $strip>;
+/**
+ * The server's response to a tool call.
+ */
+declare const CallToolResultSchema: ZodObject<{
+  _meta: ZodOptional<ZodObject<{
+    /**
+     * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+     */
+    progressToken: ZodOptional<ZodUnion<readonly [ZodString, ZodNumber]>>;
+    /**
+     * If specified, this request is related to the provided task.
+     */
+    "io.modelcontextprotocol/related-task": ZodOptional<ZodObject<{
+      taskId: ZodString;
+    }, $strip>>;
+  }, $loose>>;
+  content: ZodDefault<ZodArray<ZodUnion<readonly [ZodObject<{
+    type: ZodLiteral<"text">;
+    text: ZodString;
+    annotations: ZodOptional<ZodObject<{
+      audience: ZodOptional<ZodArray<ZodEnum<{
+        user: "user";
+        assistant: "assistant";
+      }>>>;
+      priority: ZodOptional<ZodNumber>;
+      lastModified: ZodOptional<ZodISODateTime>;
+    }, $strip>>;
+    _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+  }, $strip>, ZodObject<{
+    type: ZodLiteral<"image">;
+    data: ZodString;
+    mimeType: ZodString;
+    annotations: ZodOptional<ZodObject<{
+      audience: ZodOptional<ZodArray<ZodEnum<{
+        user: "user";
+        assistant: "assistant";
+      }>>>;
+      priority: ZodOptional<ZodNumber>;
+      lastModified: ZodOptional<ZodISODateTime>;
+    }, $strip>>;
+    _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+  }, $strip>, ZodObject<{
+    type: ZodLiteral<"audio">;
+    data: ZodString;
+    mimeType: ZodString;
+    annotations: ZodOptional<ZodObject<{
+      audience: ZodOptional<ZodArray<ZodEnum<{
+        user: "user";
+        assistant: "assistant";
+      }>>>;
+      priority: ZodOptional<ZodNumber>;
+      lastModified: ZodOptional<ZodISODateTime>;
+    }, $strip>>;
+    _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+  }, $strip>, ZodObject<{
+    uri: ZodString;
+    description: ZodOptional<ZodString>;
+    mimeType: ZodOptional<ZodString>;
+    annotations: ZodOptional<ZodObject<{
+      audience: ZodOptional<ZodArray<ZodEnum<{
+        user: "user";
+        assistant: "assistant";
+      }>>>;
+      priority: ZodOptional<ZodNumber>;
+      lastModified: ZodOptional<ZodISODateTime>;
+    }, $strip>>;
+    _meta: ZodOptional<ZodObject<{}, $loose>>;
+    icons: ZodOptional<ZodArray<ZodObject<{
+      src: ZodString;
+      mimeType: ZodOptional<ZodString>;
+      sizes: ZodOptional<ZodArray<ZodString>>;
+      theme: ZodOptional<ZodEnum<{
+        light: "light";
+        dark: "dark";
+      }>>;
+    }, $strip>>>;
+    name: ZodString;
+    title: ZodOptional<ZodString>;
+    type: ZodLiteral<"resource_link">;
+  }, $strip>, ZodObject<{
+    type: ZodLiteral<"resource">;
+    resource: ZodUnion<readonly [ZodObject<{
+      uri: ZodString;
+      mimeType: ZodOptional<ZodString>;
+      _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+      text: ZodString;
+    }, $strip>, ZodObject<{
+      uri: ZodString;
+      mimeType: ZodOptional<ZodString>;
+      _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+      blob: ZodString;
+    }, $strip>]>;
+    annotations: ZodOptional<ZodObject<{
+      audience: ZodOptional<ZodArray<ZodEnum<{
+        user: "user";
+        assistant: "assistant";
+      }>>>;
+      priority: ZodOptional<ZodNumber>;
+      lastModified: ZodOptional<ZodISODateTime>;
+    }, $strip>>;
+    _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+  }, $strip>]>>>;
+  structuredContent: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+  isError: ZodOptional<ZodBoolean>;
+}, $loose>;
+declare const ServerRequestSchema: ZodUnion<readonly [ZodObject<{
+  method: ZodLiteral<"ping">;
+  params: ZodOptional<ZodObject<{
+    _meta: ZodOptional<ZodObject<{
+      /**
+       * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+       */
+      progressToken: ZodOptional<ZodUnion<readonly [ZodString, ZodNumber]>>;
+      /**
+       * If specified, this request is related to the provided task.
+       */
+      "io.modelcontextprotocol/related-task": ZodOptional<ZodObject<{
+        taskId: ZodString;
+      }, $strip>>;
+    }, $loose>>;
+  }, $strip>>;
+}, $strip>, ZodObject<{
+  method: ZodLiteral<"sampling/createMessage">;
+  params: ZodObject<{
+    _meta: ZodOptional<ZodObject<{
+      /**
+       * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+       */
+      progressToken: ZodOptional<ZodUnion<readonly [ZodString, ZodNumber]>>;
+      /**
+       * If specified, this request is related to the provided task.
+       */
+      "io.modelcontextprotocol/related-task": ZodOptional<ZodObject<{
+        taskId: ZodString;
+      }, $strip>>;
+    }, $loose>>;
+    task: ZodOptional<ZodObject<{
+      ttl: ZodOptional<ZodNumber>;
+    }, $strip>>;
+    messages: ZodArray<ZodObject<{
+      role: ZodEnum<{
+        user: "user";
+        assistant: "assistant";
+      }>;
+      content: ZodUnion<readonly [ZodDiscriminatedUnion<[ZodObject<{
+        type: ZodLiteral<"text">;
+        text: ZodString;
+        annotations: ZodOptional<ZodObject<{
+          audience: ZodOptional<ZodArray<ZodEnum<{
+            user: "user";
+            assistant: "assistant";
+          }>>>;
+          priority: ZodOptional<ZodNumber>;
+          lastModified: ZodOptional<ZodISODateTime>;
+        }, $strip>>;
+        _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+      }, $strip>, ZodObject<{
+        type: ZodLiteral<"image">;
+        data: ZodString;
+        mimeType: ZodString;
+        annotations: ZodOptional<ZodObject<{
+          audience: ZodOptional<ZodArray<ZodEnum<{
+            user: "user";
+            assistant: "assistant";
+          }>>>;
+          priority: ZodOptional<ZodNumber>;
+          lastModified: ZodOptional<ZodISODateTime>;
+        }, $strip>>;
+        _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+      }, $strip>, ZodObject<{
+        type: ZodLiteral<"audio">;
+        data: ZodString;
+        mimeType: ZodString;
+        annotations: ZodOptional<ZodObject<{
+          audience: ZodOptional<ZodArray<ZodEnum<{
+            user: "user";
+            assistant: "assistant";
+          }>>>;
+          priority: ZodOptional<ZodNumber>;
+          lastModified: ZodOptional<ZodISODateTime>;
+        }, $strip>>;
+        _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+      }, $strip>, ZodObject<{
+        type: ZodLiteral<"tool_use">;
+        name: ZodString;
+        id: ZodString;
+        input: ZodRecord<ZodString, ZodUnknown>;
+        _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+      }, $strip>, ZodObject<{
+        type: ZodLiteral<"tool_result">;
+        toolUseId: ZodString;
+        content: ZodDefault<ZodArray<ZodUnion<readonly [ZodObject<{
+          type: ZodLiteral<"text">;
+          text: ZodString;
+          annotations: ZodOptional<ZodObject<{
+            audience: ZodOptional<ZodArray<ZodEnum<{
+              user: "user";
+              assistant: "assistant";
+            }>>>;
+            priority: ZodOptional<ZodNumber>;
+            lastModified: ZodOptional<ZodISODateTime>;
+          }, $strip>>;
+          _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+        }, $strip>, ZodObject<{
+          type: ZodLiteral<"image">;
+          data: ZodString;
+          mimeType: ZodString;
+          annotations: ZodOptional<ZodObject<{
+            audience: ZodOptional<ZodArray<ZodEnum<{
+              user: "user";
+              assistant: "assistant";
+            }>>>;
+            priority: ZodOptional<ZodNumber>;
+            lastModified: ZodOptional<ZodISODateTime>;
+          }, $strip>>;
+          _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+        }, $strip>, ZodObject<{
+          type: ZodLiteral<"audio">;
+          data: ZodString;
+          mimeType: ZodString;
+          annotations: ZodOptional<ZodObject<{
+            audience: ZodOptional<ZodArray<ZodEnum<{
+              user: "user";
+              assistant: "assistant";
+            }>>>;
+            priority: ZodOptional<ZodNumber>;
+            lastModified: ZodOptional<ZodISODateTime>;
+          }, $strip>>;
+          _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+        }, $strip>, ZodObject<{
+          uri: ZodString;
+          description: ZodOptional<ZodString>;
+          mimeType: ZodOptional<ZodString>;
+          annotations: ZodOptional<ZodObject<{
+            audience: ZodOptional<ZodArray<ZodEnum<{
+              user: "user";
+              assistant: "assistant";
+            }>>>;
+            priority: ZodOptional<ZodNumber>;
+            lastModified: ZodOptional<ZodISODateTime>;
+          }, $strip>>;
+          _meta: ZodOptional<ZodObject<{}, $loose>>;
+          icons: ZodOptional<ZodArray<ZodObject<{
+            src: ZodString;
+            mimeType: ZodOptional<ZodString>;
+            sizes: ZodOptional<ZodArray<ZodString>>;
+            theme: ZodOptional<ZodEnum<{
+              light: "light";
+              dark: "dark";
+            }>>;
+          }, $strip>>>;
+          name: ZodString;
+          title: ZodOptional<ZodString>;
+          type: ZodLiteral<"resource_link">;
+        }, $strip>, ZodObject<{
+          type: ZodLiteral<"resource">;
+          resource: ZodUnion<readonly [ZodObject<{
+            uri: ZodString;
+            mimeType: ZodOptional<ZodString>;
+            _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+            text: ZodString;
+          }, $strip>, ZodObject<{
+            uri: ZodString;
+            mimeType: ZodOptional<ZodString>;
+            _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+            blob: ZodString;
+          }, $strip>]>;
+          annotations: ZodOptional<ZodObject<{
+            audience: ZodOptional<ZodArray<ZodEnum<{
+              user: "user";
+              assistant: "assistant";
+            }>>>;
+            priority: ZodOptional<ZodNumber>;
+            lastModified: ZodOptional<ZodISODateTime>;
+          }, $strip>>;
+          _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+        }, $strip>]>>>;
+        structuredContent: ZodOptional<ZodObject<{}, $loose>>;
+        isError: ZodOptional<ZodBoolean>;
+        _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+      }, $strip>]>, ZodArray<ZodDiscriminatedUnion<[ZodObject<{
+        type: ZodLiteral<"text">;
+        text: ZodString;
+        annotations: ZodOptional<ZodObject<{
+          audience: ZodOptional<ZodArray<ZodEnum<{
+            user: "user";
+            assistant: "assistant";
+          }>>>;
+          priority: ZodOptional<ZodNumber>;
+          lastModified: ZodOptional<ZodISODateTime>;
+        }, $strip>>;
+        _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+      }, $strip>, ZodObject<{
+        type: ZodLiteral<"image">;
+        data: ZodString;
+        mimeType: ZodString;
+        annotations: ZodOptional<ZodObject<{
+          audience: ZodOptional<ZodArray<ZodEnum<{
+            user: "user";
+            assistant: "assistant";
+          }>>>;
+          priority: ZodOptional<ZodNumber>;
+          lastModified: ZodOptional<ZodISODateTime>;
+        }, $strip>>;
+        _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+      }, $strip>, ZodObject<{
+        type: ZodLiteral<"audio">;
+        data: ZodString;
+        mimeType: ZodString;
+        annotations: ZodOptional<ZodObject<{
+          audience: ZodOptional<ZodArray<ZodEnum<{
+            user: "user";
+            assistant: "assistant";
+          }>>>;
+          priority: ZodOptional<ZodNumber>;
+          lastModified: ZodOptional<ZodISODateTime>;
+        }, $strip>>;
+        _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+      }, $strip>, ZodObject<{
+        type: ZodLiteral<"tool_use">;
+        name: ZodString;
+        id: ZodString;
+        input: ZodRecord<ZodString, ZodUnknown>;
+        _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+      }, $strip>, ZodObject<{
+        type: ZodLiteral<"tool_result">;
+        toolUseId: ZodString;
+        content: ZodDefault<ZodArray<ZodUnion<readonly [ZodObject<{
+          type: ZodLiteral<"text">;
+          text: ZodString;
+          annotations: ZodOptional<ZodObject<{
+            audience: ZodOptional<ZodArray<ZodEnum<{
+              user: "user";
+              assistant: "assistant";
+            }>>>;
+            priority: ZodOptional<ZodNumber>;
+            lastModified: ZodOptional<ZodISODateTime>;
+          }, $strip>>;
+          _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+        }, $strip>, ZodObject<{
+          type: ZodLiteral<"image">;
+          data: ZodString;
+          mimeType: ZodString;
+          annotations: ZodOptional<ZodObject<{
+            audience: ZodOptional<ZodArray<ZodEnum<{
+              user: "user";
+              assistant: "assistant";
+            }>>>;
+            priority: ZodOptional<ZodNumber>;
+            lastModified: ZodOptional<ZodISODateTime>;
+          }, $strip>>;
+          _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+        }, $strip>, ZodObject<{
+          type: ZodLiteral<"audio">;
+          data: ZodString;
+          mimeType: ZodString;
+          annotations: ZodOptional<ZodObject<{
+            audience: ZodOptional<ZodArray<ZodEnum<{
+              user: "user";
+              assistant: "assistant";
+            }>>>;
+            priority: ZodOptional<ZodNumber>;
+            lastModified: ZodOptional<ZodISODateTime>;
+          }, $strip>>;
+          _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+        }, $strip>, ZodObject<{
+          uri: ZodString;
+          description: ZodOptional<ZodString>;
+          mimeType: ZodOptional<ZodString>;
+          annotations: ZodOptional<ZodObject<{
+            audience: ZodOptional<ZodArray<ZodEnum<{
+              user: "user";
+              assistant: "assistant";
+            }>>>;
+            priority: ZodOptional<ZodNumber>;
+            lastModified: ZodOptional<ZodISODateTime>;
+          }, $strip>>;
+          _meta: ZodOptional<ZodObject<{}, $loose>>;
+          icons: ZodOptional<ZodArray<ZodObject<{
+            src: ZodString;
+            mimeType: ZodOptional<ZodString>;
+            sizes: ZodOptional<ZodArray<ZodString>>;
+            theme: ZodOptional<ZodEnum<{
+              light: "light";
+              dark: "dark";
+            }>>;
+          }, $strip>>>;
+          name: ZodString;
+          title: ZodOptional<ZodString>;
+          type: ZodLiteral<"resource_link">;
+        }, $strip>, ZodObject<{
+          type: ZodLiteral<"resource">;
+          resource: ZodUnion<readonly [ZodObject<{
+            uri: ZodString;
+            mimeType: ZodOptional<ZodString>;
+            _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+            text: ZodString;
+          }, $strip>, ZodObject<{
+            uri: ZodString;
+            mimeType: ZodOptional<ZodString>;
+            _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+            blob: ZodString;
+          }, $strip>]>;
+          annotations: ZodOptional<ZodObject<{
+            audience: ZodOptional<ZodArray<ZodEnum<{
+              user: "user";
+              assistant: "assistant";
+            }>>>;
+            priority: ZodOptional<ZodNumber>;
+            lastModified: ZodOptional<ZodISODateTime>;
+          }, $strip>>;
+          _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+        }, $strip>]>>>;
+        structuredContent: ZodOptional<ZodObject<{}, $loose>>;
+        isError: ZodOptional<ZodBoolean>;
+        _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+      }, $strip>]>>]>;
+      _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+    }, $strip>>;
+    modelPreferences: ZodOptional<ZodObject<{
+      hints: ZodOptional<ZodArray<ZodObject<{
+        name: ZodOptional<ZodString>;
+      }, $strip>>>;
+      costPriority: ZodOptional<ZodNumber>;
+      speedPriority: ZodOptional<ZodNumber>;
+      intelligencePriority: ZodOptional<ZodNumber>;
+    }, $strip>>;
+    systemPrompt: ZodOptional<ZodString>;
+    includeContext: ZodOptional<ZodEnum<{
+      none: "none";
+      thisServer: "thisServer";
+      allServers: "allServers";
+    }>>;
+    temperature: ZodOptional<ZodNumber>;
+    maxTokens: ZodNumber;
+    stopSequences: ZodOptional<ZodArray<ZodString>>;
+    metadata: ZodOptional<ZodCustom<object, object>>;
+    tools: ZodOptional<ZodArray<ZodObject<{
+      description: ZodOptional<ZodString>;
+      inputSchema: ZodObject<{
+        type: ZodLiteral<"object">;
+        properties: ZodOptional<ZodRecord<ZodString, ZodCustom<object, object>>>;
+        required: ZodOptional<ZodArray<ZodString>>;
+      }, $catchall<ZodUnknown>>;
+      outputSchema: ZodOptional<ZodObject<{
+        type: ZodLiteral<"object">;
+        properties: ZodOptional<ZodRecord<ZodString, ZodCustom<object, object>>>;
+        required: ZodOptional<ZodArray<ZodString>>;
+      }, $catchall<ZodUnknown>>>;
+      annotations: ZodOptional<ZodObject<{
+        title: ZodOptional<ZodString>;
+        readOnlyHint: ZodOptional<ZodBoolean>;
+        destructiveHint: ZodOptional<ZodBoolean>;
+        idempotentHint: ZodOptional<ZodBoolean>;
+        openWorldHint: ZodOptional<ZodBoolean>;
+      }, $strip>>;
+      execution: ZodOptional<ZodObject<{
+        taskSupport: ZodOptional<ZodEnum<{
+          optional: "optional";
+          required: "required";
+          forbidden: "forbidden";
+        }>>;
+      }, $strip>>;
+      _meta: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
+      icons: ZodOptional<ZodArray<ZodObject<{
+        src: ZodString;
+        mimeType: ZodOptional<ZodString>;
+        sizes: ZodOptional<ZodArray<ZodString>>;
+        theme: ZodOptional<ZodEnum<{
+          light: "light";
+          dark: "dark";
+        }>>;
+      }, $strip>>>;
+      name: ZodString;
+      title: ZodOptional<ZodString>;
+    }, $strip>>>;
+    toolChoice: ZodOptional<ZodObject<{
+      mode: ZodOptional<ZodEnum<{
+        required: "required";
+        auto: "auto";
+        none: "none";
+      }>>;
+    }, $strip>>;
+  }, $strip>;
+}, $strip>, ZodObject<{
+  method: ZodLiteral<"elicitation/create">;
+  params: ZodUnion<readonly [ZodObject<{
+    _meta: ZodOptional<ZodObject<{
+      /**
+       * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+       */
+      progressToken: ZodOptional<ZodUnion<readonly [ZodString, ZodNumber]>>;
+      /**
+       * If specified, this request is related to the provided task.
+       */
+      "io.modelcontextprotocol/related-task": ZodOptional<ZodObject<{
+        taskId: ZodString;
+      }, $strip>>;
+    }, $loose>>;
+    task: ZodOptional<ZodObject<{
+      ttl: ZodOptional<ZodNumber>;
+    }, $strip>>;
+    mode: ZodOptional<ZodLiteral<"form">>;
+    message: ZodString;
+    requestedSchema: ZodObject<{
+      type: ZodLiteral<"object">;
+      properties: ZodRecord<ZodString, ZodUnion<readonly [ZodUnion<readonly [ZodObject<{
+        type: ZodLiteral<"string">;
+        title: ZodOptional<ZodString>;
+        description: ZodOptional<ZodString>;
+        enum: ZodArray<ZodString>;
+        enumNames: ZodOptional<ZodArray<ZodString>>;
+        default: ZodOptional<ZodString>;
+      }, $strip>, ZodUnion<readonly [ZodObject<{
+        type: ZodLiteral<"string">;
+        title: ZodOptional<ZodString>;
+        description: ZodOptional<ZodString>;
+        enum: ZodArray<ZodString>;
+        default: ZodOptional<ZodString>;
+      }, $strip>, ZodObject<{
+        type: ZodLiteral<"string">;
+        title: ZodOptional<ZodString>;
+        description: ZodOptional<ZodString>;
+        oneOf: ZodArray<ZodObject<{
+          const: ZodString;
+          title: ZodString;
+        }, $strip>>;
+        default: ZodOptional<ZodString>;
+      }, $strip>]>, ZodUnion<readonly [ZodObject<{
+        type: ZodLiteral<"array">;
+        title: ZodOptional<ZodString>;
+        description: ZodOptional<ZodString>;
+        minItems: ZodOptional<ZodNumber>;
+        maxItems: ZodOptional<ZodNumber>;
+        items: ZodObject<{
+          type: ZodLiteral<"string">;
+          enum: ZodArray<ZodString>;
+        }, $strip>;
+        default: ZodOptional<ZodArray<ZodString>>;
+      }, $strip>, ZodObject<{
+        type: ZodLiteral<"array">;
+        title: ZodOptional<ZodString>;
+        description: ZodOptional<ZodString>;
+        minItems: ZodOptional<ZodNumber>;
+        maxItems: ZodOptional<ZodNumber>;
+        items: ZodObject<{
+          anyOf: ZodArray<ZodObject<{
+            const: ZodString;
+            title: ZodString;
+          }, $strip>>;
+        }, $strip>;
+        default: ZodOptional<ZodArray<ZodString>>;
+      }, $strip>]>]>, ZodObject<{
+        type: ZodLiteral<"boolean">;
+        title: ZodOptional<ZodString>;
+        description: ZodOptional<ZodString>;
+        default: ZodOptional<ZodBoolean>;
+      }, $strip>, ZodObject<{
+        type: ZodLiteral<"string">;
+        title: ZodOptional<ZodString>;
+        description: ZodOptional<ZodString>;
+        minLength: ZodOptional<ZodNumber>;
+        maxLength: ZodOptional<ZodNumber>;
+        format: ZodOptional<ZodEnum<{
+          date: "date";
+          uri: "uri";
+          email: "email";
+          "date-time": "date-time";
+        }>>;
+        default: ZodOptional<ZodString>;
+      }, $strip>, ZodObject<{
+        type: ZodEnum<{
+          number: "number";
+          integer: "integer";
+        }>;
+        title: ZodOptional<ZodString>;
+        description: ZodOptional<ZodString>;
+        minimum: ZodOptional<ZodNumber>;
+        maximum: ZodOptional<ZodNumber>;
+        default: ZodOptional<ZodNumber>;
+      }, $strip>]>>;
+      required: ZodOptional<ZodArray<ZodString>>;
+    }, $strip>;
+  }, $strip>, ZodObject<{
+    _meta: ZodOptional<ZodObject<{
+      /**
+       * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+       */
+      progressToken: ZodOptional<ZodUnion<readonly [ZodString, ZodNumber]>>;
+      /**
+       * If specified, this request is related to the provided task.
+       */
+      "io.modelcontextprotocol/related-task": ZodOptional<ZodObject<{
+        taskId: ZodString;
+      }, $strip>>;
+    }, $loose>>;
+    task: ZodOptional<ZodObject<{
+      ttl: ZodOptional<ZodNumber>;
+    }, $strip>>;
+    mode: ZodLiteral<"url">;
+    message: ZodString;
+    elicitationId: ZodString;
+    url: ZodString;
+  }, $strip>]>;
+}, $strip>, ZodObject<{
+  method: ZodLiteral<"roots/list">;
+  params: ZodOptional<ZodObject<{
+    _meta: ZodOptional<ZodObject<{
+      /**
+       * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+       */
+      progressToken: ZodOptional<ZodUnion<readonly [ZodString, ZodNumber]>>;
+      /**
+       * If specified, this request is related to the provided task.
+       */
+      "io.modelcontextprotocol/related-task": ZodOptional<ZodObject<{
+        taskId: ZodString;
+      }, $strip>>;
+    }, $loose>>;
+  }, $strip>>;
+}, $strip>, ZodObject<{
+  method: ZodLiteral<"tasks/get">;
+  params: ZodObject<{
+    _meta: ZodOptional<ZodObject<{
+      /**
+       * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+       */
+      progressToken: ZodOptional<ZodUnion<readonly [ZodString, ZodNumber]>>;
+      /**
+       * If specified, this request is related to the provided task.
+       */
+      "io.modelcontextprotocol/related-task": ZodOptional<ZodObject<{
+        taskId: ZodString;
+      }, $strip>>;
+    }, $loose>>;
+    taskId: ZodString;
+  }, $strip>;
+}, $strip>, ZodObject<{
+  method: ZodLiteral<"tasks/result">;
+  params: ZodObject<{
+    _meta: ZodOptional<ZodObject<{
+      /**
+       * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+       */
+      progressToken: ZodOptional<ZodUnion<readonly [ZodString, ZodNumber]>>;
+      /**
+       * If specified, this request is related to the provided task.
+       */
+      "io.modelcontextprotocol/related-task": ZodOptional<ZodObject<{
+        taskId: ZodString;
+      }, $strip>>;
+    }, $loose>>;
+    taskId: ZodString;
+  }, $strip>;
+}, $strip>, ZodObject<{
+  params: ZodOptional<ZodObject<{
+    _meta: ZodOptional<ZodObject<{
+      /**
+       * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+       */
+      progressToken: ZodOptional<ZodUnion<readonly [ZodString, ZodNumber]>>;
+      /**
+       * If specified, this request is related to the provided task.
+       */
+      "io.modelcontextprotocol/related-task": ZodOptional<ZodObject<{
+        taskId: ZodString;
+      }, $strip>>;
+    }, $loose>>;
+    cursor: ZodOptional<ZodString>;
+  }, $strip>>;
+  method: ZodLiteral<"tasks/list">;
+}, $strip>, ZodObject<{
+  method: ZodLiteral<"tasks/cancel">;
+  params: ZodObject<{
+    _meta: ZodOptional<ZodObject<{
+      /**
+       * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+       */
+      progressToken: ZodOptional<ZodUnion<readonly [ZodString, ZodNumber]>>;
+      /**
+       * If specified, this request is related to the provided task.
+       */
+      "io.modelcontextprotocol/related-task": ZodOptional<ZodObject<{
+        taskId: ZodString;
+      }, $strip>>;
+    }, $loose>>;
+    taskId: ZodString;
+  }, $strip>;
+}, $strip>]>;
+declare const ServerNotificationSchema: ZodUnion<readonly [ZodObject<{
+  method: ZodLiteral<"notifications/cancelled">;
+  params: ZodObject<{
+    _meta: ZodOptional<ZodObject<{
+      /**
+       * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+       */
+      progressToken: ZodOptional<ZodUnion<readonly [ZodString, ZodNumber]>>;
+      /**
+       * If specified, this request is related to the provided task.
+       */
+      "io.modelcontextprotocol/related-task": ZodOptional<ZodObject<{
+        taskId: ZodString;
+      }, $strip>>;
+    }, $loose>>;
+    requestId: ZodOptional<ZodUnion<readonly [ZodString, ZodNumber]>>;
+    reason: ZodOptional<ZodString>;
+  }, $strip>;
+}, $strip>, ZodObject<{
+  method: ZodLiteral<"notifications/progress">;
+  params: ZodObject<{
+    progressToken: ZodUnion<readonly [ZodString, ZodNumber]>;
+    progress: ZodNumber;
+    total: ZodOptional<ZodNumber>;
+    message: ZodOptional<ZodString>;
+    _meta: ZodOptional<ZodObject<{
+      /**
+       * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+       */
+      progressToken: ZodOptional<ZodUnion<readonly [ZodString, ZodNumber]>>;
+      /**
+       * If specified, this request is related to the provided task.
+       */
+      "io.modelcontextprotocol/related-task": ZodOptional<ZodObject<{
+        taskId: ZodString;
+      }, $strip>>;
+    }, $loose>>;
+  }, $strip>;
+}, $strip>, ZodObject<{
+  method: ZodLiteral<"notifications/message">;
+  params: ZodObject<{
+    _meta: ZodOptional<ZodObject<{
+      /**
+       * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+       */
+      progressToken: ZodOptional<ZodUnion<readonly [ZodString, ZodNumber]>>;
+      /**
+       * If specified, this request is related to the provided task.
+       */
+      "io.modelcontextprotocol/related-task": ZodOptional<ZodObject<{
+        taskId: ZodString;
+      }, $strip>>;
+    }, $loose>>;
+    level: ZodEnum<{
+      error: "error";
+      debug: "debug";
+      info: "info";
+      notice: "notice";
+      warning: "warning";
+      critical: "critical";
+      alert: "alert";
+      emergency: "emergency";
+    }>;
+    logger: ZodOptional<ZodString>;
+    data: ZodUnknown;
+  }, $strip>;
+}, $strip>, ZodObject<{
+  method: ZodLiteral<"notifications/resources/updated">;
+  params: ZodObject<{
+    _meta: ZodOptional<ZodObject<{
+      /**
+       * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+       */
+      progressToken: ZodOptional<ZodUnion<readonly [ZodString, ZodNumber]>>;
+      /**
+       * If specified, this request is related to the provided task.
+       */
+      "io.modelcontextprotocol/related-task": ZodOptional<ZodObject<{
+        taskId: ZodString;
+      }, $strip>>;
+    }, $loose>>;
+    uri: ZodString;
+  }, $strip>;
+}, $strip>, ZodObject<{
+  method: ZodLiteral<"notifications/resources/list_changed">;
+  params: ZodOptional<ZodObject<{
+    _meta: ZodOptional<ZodObject<{
+      /**
+       * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+       */
+      progressToken: ZodOptional<ZodUnion<readonly [ZodString, ZodNumber]>>;
+      /**
+       * If specified, this request is related to the provided task.
+       */
+      "io.modelcontextprotocol/related-task": ZodOptional<ZodObject<{
+        taskId: ZodString;
+      }, $strip>>;
+    }, $loose>>;
+  }, $strip>>;
+}, $strip>, ZodObject<{
+  method: ZodLiteral<"notifications/tools/list_changed">;
+  params: ZodOptional<ZodObject<{
+    _meta: ZodOptional<ZodObject<{
+      /**
+       * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+       */
+      progressToken: ZodOptional<ZodUnion<readonly [ZodString, ZodNumber]>>;
+      /**
+       * If specified, this request is related to the provided task.
+       */
+      "io.modelcontextprotocol/related-task": ZodOptional<ZodObject<{
+        taskId: ZodString;
+      }, $strip>>;
+    }, $loose>>;
+  }, $strip>>;
+}, $strip>, ZodObject<{
+  method: ZodLiteral<"notifications/prompts/list_changed">;
+  params: ZodOptional<ZodObject<{
+    _meta: ZodOptional<ZodObject<{
+      /**
+       * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+       */
+      progressToken: ZodOptional<ZodUnion<readonly [ZodString, ZodNumber]>>;
+      /**
+       * If specified, this request is related to the provided task.
+       */
+      "io.modelcontextprotocol/related-task": ZodOptional<ZodObject<{
+        taskId: ZodString;
+      }, $strip>>;
+    }, $loose>>;
+  }, $strip>>;
+}, $strip>, ZodObject<{
+  method: ZodLiteral<"notifications/tasks/status">;
+  params: ZodObject<{
+    _meta: ZodOptional<ZodObject<{
+      /**
+       * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+       */
+      progressToken: ZodOptional<ZodUnion<readonly [ZodString, ZodNumber]>>;
+      /**
+       * If specified, this request is related to the provided task.
+       */
+      "io.modelcontextprotocol/related-task": ZodOptional<ZodObject<{
+        taskId: ZodString;
+      }, $strip>>;
+    }, $loose>>;
+    taskId: ZodString;
+    status: ZodEnum<{
+      working: "working";
+      input_required: "input_required";
+      completed: "completed";
+      failed: "failed";
+      cancelled: "cancelled";
+    }>;
+    ttl: ZodUnion<readonly [ZodNumber, ZodNull]>;
+    createdAt: ZodString;
+    lastUpdatedAt: ZodString;
+    pollInterval: ZodOptional<ZodNumber>;
+    statusMessage: ZodOptional<ZodString>;
+  }, $strip>;
+}, $strip>, ZodObject<{
+  method: ZodLiteral<"notifications/elicitation/complete">;
+  params: ZodObject<{
+    _meta: ZodOptional<ZodObject<{
+      /**
+       * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+       */
+      progressToken: ZodOptional<ZodUnion<readonly [ZodString, ZodNumber]>>;
+      /**
+       * If specified, this request is related to the provided task.
+       */
+      "io.modelcontextprotocol/related-task": ZodOptional<ZodObject<{
+        taskId: ZodString;
+      }, $strip>>;
+    }, $loose>>;
+    elicitationId: ZodString;
+  }, $strip>;
+}, $strip>]>;
+type Primitive = string | number | boolean | bigint | null | undefined;
+type Flatten<T> = T extends Primitive ? T : T extends Array<infer U> ? Array<Flatten<U>> : T extends Set<infer U> ? Set<Flatten<U>> : T extends Map<infer K, infer V> ? Map<Flatten<K>, Flatten<V>> : T extends object ? { [K in keyof T]: Flatten<T[K]> } : T;
+type Infer<Schema extends ZodType> = Flatten<output<Schema>>;
+/**
+ * Headers that are compatible with both Node.js and the browser.
+ */
+type IsomorphicHeaders = Record<string, string | string[] | undefined>;
+/**
+ * Information about the incoming request.
+ */
+interface RequestInfo {
+  /**
+   * The headers of the request.
+   */
+  headers: IsomorphicHeaders;
+}
+type Request = Infer<typeof RequestSchema>;
+type RequestMeta = Infer<typeof RequestMetaSchema>;
+type Notification = Infer<typeof NotificationSchema>;
+type Result$1 = Infer<typeof ResultSchema>;
+type RequestId = Infer<typeof RequestIdSchema>;
+type Progress = Infer<typeof ProgressSchema>;
+type Task = Infer<typeof TaskSchema>;
+type TaskCreationParams = Infer<typeof TaskCreationParamsSchema>;
+type RelatedTaskMetadata = Infer<typeof RelatedTaskMetadataSchema>;
+type ToolAnnotations = Infer<typeof ToolAnnotationsSchema>;
+type CallToolResult = Infer<typeof CallToolResultSchema>;
+type ServerRequest = Infer<typeof ServerRequestSchema>;
+type ServerNotification = Infer<typeof ServerNotificationSchema>;
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.3_hono@4.11.7_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/transport.d.ts
+/**
+ * Options for sending a JSON-RPC message.
+ */
+type TransportSendOptions = {
+  /**
+   * If present, `relatedRequestId` is used to indicate to the transport which incoming request to associate this outgoing message with.
+   */
+  relatedRequestId?: RequestId;
+  /**
+   * The resumption token used to continue long-running requests that were interrupted.
+   *
+   * This allows clients to reconnect and continue from where they left off, if supported by the transport.
+   */
+  resumptionToken?: string;
+  /**
+   * A callback that is invoked when the resumption token changes, if supported by the transport.
+   *
+   * This allows clients to persist the latest token for potential reconnection.
+   */
+  onresumptiontoken?: (token: string) => void;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.3_hono@4.11.7_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.d.ts
+/**
+ * Task creation options.
+ * @experimental
+ */
+interface CreateTaskOptions {
+  /**
+   * Time in milliseconds to keep task results available after completion.
+   * If null, the task has unlimited lifetime until manually cleaned up.
+   */
+  ttl?: number | null;
+  /**
+   * Time in milliseconds to wait between task status requests.
+   */
+  pollInterval?: number;
+  /**
+   * Additional context to pass to the task store.
+   */
+  context?: Record<string, unknown>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.3_hono@4.11.7_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.d.ts
+/**
+ * Callback for progress notifications.
+ */
+type ProgressCallback = (progress: Progress) => void;
+/**
+ * Options that can be given per request.
+ */
+type RequestOptions = {
+  /**
+   * If set, requests progress notifications from the remote end (if supported). When progress notifications are received, this callback will be invoked.
+   *
+   * For task-augmented requests: progress notifications continue after CreateTaskResult is returned and stop automatically when the task reaches a terminal status.
+   */
+  onprogress?: ProgressCallback;
+  /**
+   * Can be used to cancel an in-flight request. This will cause an AbortError to be raised from request().
+   */
+  signal?: AbortSignal;
+  /**
+   * A timeout (in milliseconds) for this request. If exceeded, an McpError with code `RequestTimeout` will be raised from request().
+   *
+   * If not specified, `DEFAULT_REQUEST_TIMEOUT_MSEC` will be used as the timeout.
+   */
+  timeout?: number;
+  /**
+   * If true, receiving a progress notification will reset the request timeout.
+   * This is useful for long-running operations that send periodic progress updates.
+   * Default: false
+   */
+  resetTimeoutOnProgress?: boolean;
+  /**
+   * Maximum total time (in milliseconds) to wait for a response.
+   * If exceeded, an McpError with code `RequestTimeout` will be raised, regardless of progress notifications.
+   * If not specified, there is no maximum total timeout.
+   */
+  maxTotalTimeout?: number;
+  /**
+   * If provided, augments the request with task creation parameters to enable call-now, fetch-later execution patterns.
+   */
+  task?: TaskCreationParams;
+  /**
+   * If provided, associates this request with a related task.
+   */
+  relatedTask?: RelatedTaskMetadata;
+} & TransportSendOptions;
+/**
+ * Options that can be given per request.
+ */
+type TaskRequestOptions = Omit<RequestOptions, 'relatedTask'>;
+/**
+ * Request-scoped TaskStore interface.
+ */
+interface RequestTaskStore {
+  /**
+   * Creates a new task with the given creation parameters.
+   * The implementation generates a unique taskId and createdAt timestamp.
+   *
+   * @param taskParams - The task creation parameters from the request
+   * @returns The created task object
+   */
+  createTask(taskParams: CreateTaskOptions): Promise<Task>;
+  /**
+   * Gets the current status of a task.
+   *
+   * @param taskId - The task identifier
+   * @returns The task object
+   * @throws If the task does not exist
+   */
+  getTask(taskId: string): Promise<Task>;
+  /**
+   * Stores the result of a task and sets its final status.
+   *
+   * @param taskId - The task identifier
+   * @param status - The final status: 'completed' for success, 'failed' for errors
+   * @param result - The result to store
+   */
+  storeTaskResult(taskId: string, status: 'completed' | 'failed', result: Result$1): Promise<void>;
+  /**
+   * Retrieves the stored result of a task.
+   *
+   * @param taskId - The task identifier
+   * @returns The stored result
+   */
+  getTaskResult(taskId: string): Promise<Result$1>;
+  /**
+   * Updates a task's status (e.g., to 'cancelled', 'failed', 'completed').
+   *
+   * @param taskId - The task identifier
+   * @param status - The new status
+   * @param statusMessage - Optional diagnostic message for failed tasks or other status information
+   */
+  updateTaskStatus(taskId: string, status: Task['status'], statusMessage?: string): Promise<void>;
+  /**
+   * Lists tasks, optionally starting from a pagination cursor.
+   *
+   * @param cursor - Optional cursor for pagination
+   * @returns An object containing the tasks array and an optional nextCursor
+   */
+  listTasks(cursor?: string): Promise<{
+    tasks: Task[];
+    nextCursor?: string;
+  }>;
+}
+/**
+ * Extra data given to request handlers.
+ */
+type RequestHandlerExtra<SendRequestT extends Request, SendNotificationT extends Notification> = {
+  /**
+   * An abort signal used to communicate if the request was cancelled from the sender's side.
+   */
+  signal: AbortSignal;
+  /**
+   * Information about a validated access token, provided to request handlers.
+   */
+  authInfo?: AuthInfo;
+  /**
+   * The session ID from the transport, if available.
+   */
+  sessionId?: string;
+  /**
+   * Metadata from the original request.
+   */
+  _meta?: RequestMeta;
+  /**
+   * The JSON-RPC ID of the request being handled.
+   * This can be useful for tracking or logging purposes.
+   */
+  requestId: RequestId;
+  taskId?: string;
+  taskStore?: RequestTaskStore;
+  taskRequestedTtl?: number | null;
+  /**
+   * The original HTTP request.
+   */
+  requestInfo?: RequestInfo;
+  /**
+   * Sends a notification that relates to the current request being handled.
+   *
+   * This is used by certain transports to correctly associate related messages.
+   */
+  sendNotification: (notification: SendNotificationT) => Promise<void>;
+  /**
+   * Sends a request that relates to the current request being handled.
+   *
+   * This is used by certain transports to correctly associate related messages.
+   */
+  sendRequest: <U extends AnySchema>(request: SendRequestT, resultSchema: U, options?: TaskRequestOptions) => Promise<SchemaOutput<U>>;
+  /**
+   * Closes the SSE stream for this request, triggering client reconnection.
+   * Only available when using StreamableHTTPServerTransport with eventStore configured.
+   * Use this to implement polling behavior during long-running operations.
+   */
+  closeSSEStream?: () => void;
+  /**
+   * Closes the standalone GET SSE stream, triggering client reconnection.
+   * Only available when using StreamableHTTPServerTransport with eventStore configured.
+   * Use this to implement polling behavior for server-initiated notifications.
+   */
+  closeStandaloneSSEStream?: () => void;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.3_hono@4.11.7_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.d.ts
+type BaseToolCallback<SendResultT extends Result$1, Extra extends RequestHandlerExtra<ServerRequest, ServerNotification>, Args extends undefined | ZodRawShapeCompat | AnySchema> = Args extends ZodRawShapeCompat ? (args: ShapeOutput<Args>, extra: Extra) => SendResultT | Promise<SendResultT> : Args extends AnySchema ? (args: SchemaOutput<Args>, extra: Extra) => SendResultT | Promise<SendResultT> : (extra: Extra) => SendResultT | Promise<SendResultT>;
+/**
+ * Callback for a tool handler registered with Server.tool().
+ *
+ * Parameters will include tool arguments, if applicable, as well as other request handler context.
+ *
+ * The callback should return:
+ * - `structuredContent` if the tool has an outputSchema defined
+ * - `content` if the tool does not have an outputSchema
+ * - Both fields are optional but typically one should be provided
+ */
+type ToolCallback<Args extends undefined | ZodRawShapeCompat | AnySchema = undefined> = BaseToolCallback<CallToolResult, RequestHandlerExtra<ServerRequest, ServerNotification>, Args>;
+//#endregion
+//#region src/core/plugin/mcp.d.ts
+/** @internal */
+type McpToolRegister = <OutputArgs extends ZodRawShapeCompat | AnySchema, InputArgs extends undefined | ZodRawShapeCompat | AnySchema = undefined>() => ({
+  name: string;
+  config: {
+    title?: string;
+    description?: string;
+    inputSchema?: InputArgs;
+    outputSchema?: OutputArgs;
+    annotations?: ToolAnnotations;
+    _meta?: Record<string, unknown>;
+  };
+  cb: NoInfer<ToolCallback<InputArgs>>;
+});
+declare function defineMcpToolRegister<OutputArgs extends ZodRawShapeCompat | AnySchema, InputArgs extends undefined | ZodRawShapeCompat | AnySchema = undefined>(name: string, config: {
+  title?: string;
+  description?: string;
+  inputSchema?: InputArgs;
+  outputSchema?: OutputArgs;
+  annotations?: ToolAnnotations;
+  _meta?: Record<string, unknown>;
+}, cb: ToolCallback<InputArgs>): () => ({
+  name: string;
+  config: {
+    title?: string;
+    description?: string;
+    inputSchema?: InputArgs;
+    outputSchema?: OutputArgs;
+    annotations?: ToolAnnotations;
+    _meta?: Record<string, unknown>;
+  };
+  cb: ToolCallback<InputArgs>;
+});
+//#endregion
+//#region src/core/plugin/index.d.ts
+interface DevpilotPluginContext {
+  wsPort: number;
+}
+/**
+* Resolve the module path relative to the plugin to an absolute path
+* @param importMetaUrl - Pass in import.meta.url
+* @param relativePath - Path relative to the plugin
+* @example
+* ```ts
+* import { resolveClientModule } from 'unplugin-devpilot'
+*
+* export function myPlugin(): DevpilotPlugin {
+*   return {
+*     name: 'my-plugin',
+*     clientModule: resolveClientModule(import.meta.url, './client.mjs'),
+*   }
+* }
+* ```
+*/
+declare function resolveClientModule(importMetaUrl: string, relativePath: string): string;
+//#endregion
+export { defineMcpToolRegister as i, resolveClientModule as n, McpToolRegister as r, DevpilotPluginContext as t };