open-tag 0.0.1 → 0.0.2

package/dist/index.d.mts

@@ -0,0 +1,4661 @@
+//#region ../../node_modules/.pnpm/zod@4.5.4/node_modules/zod/v4/core/json-schema.d.cts
+type _JSONSchema = boolean | JSONSchema;
+type SchemaType = "object" | "array" | "string" | "number" | "boolean" | "null" | "integer";
+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?: SchemaType | SchemaType[];
+  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.5.4/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.5.4/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.5.4/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;
+/**
+ * Called for each schema that has no JSON Schema equivalent. Return a JSON Schema to use in its
+ * place, `"any"` to fall back to the `unrepresentable: "any"` behavior, or `"throw"`/`undefined` to
+ * throw the default error. Throwing from the handler propagates, so custom errors work too.
+ */
+type UnrepresentableHandler<T extends $ZodType = $ZodType> = (ctx: {
+  zodSchema: T;
+  path: (string | number)[];
+  /** The error Zod would throw. Distinguishes sites that share a `zodSchema`, e.g. an `undefined`
+   *  vs a `bigint` member of the same literal. */
+  message: string;
+}) => BaseSchema | "throw" | "any" | undefined;
+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 `{}`
+   * - A function — called once per unrepresentable schema; see {@link UnrepresentableHandler}. */
+  unrepresentable?: "throw" | "any" | UnrepresentableHandler<$ZodTypes>;
+  /** 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" | UnrepresentableHandler;
+  override: (ctx: {
+    zodSchema: $ZodType;
+    jsonSchema: BaseSchema;
+    path: (string | number)[];
+  }) => void;
+  io: "input" | "output";
+  counter: number;
+  seen: Map<$ZodType, Seen>;
+  /** Registry conversions share one `seen` map across every emitted schema. These hold the
+   * `external` the whole-map passes below last ran for, so the passes are not repeated once per
+   * schema — and still re-run if the map grows or `external` is swapped. `sharedEmitDoneFor`
+   * covers both passes in `finalize`: the ref flattening and the `$defs` build.
+   *
+   * The passes are valid only while nothing they read has changed, so both are cleared in
+   * `process()` when the map grows, and in `JSONSchemaGenerator.emit()`, which can also change
+   * the `cycles` and `reused` they branch on.
+   *
+   * One case is deliberately not covered: an `override` callback that writes to
+   * `metadataRegistry` mid-conversion. It runs inside `finalize`, so a registry conversion has
+   * nowhere left to clear the guards, and later schemas keep the ids the first pass saw. That
+   * output was never coherent — before this, whether a shared subschema was inlined or extracted
+   * depended on which registry entry happened to be emitted when the callback fired. */
+  sharedDefsExtractedFor?: ToJSONSchemaContext["external"];
+  sharedEmitDoneFor?: ToJSONSchemaContext["external"];
+  cycles: "ref" | "throw";
+  reused: "ref" | "inline";
+  /** The `allOf` array of each intersection encountered during traversal, innermost first. `finalize` folds every emitted object holding one; see `foldIntersection`. */
+  intersections: BaseSchema[][];
+  /** Rewrites a processor deferred to `finalize`, where the flatten has resolved every ref and the union branches are in place. */
+  deferred: (() => void)[];
+  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.5.4/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 Writeable<T> = { -readonly [P in keyof T]: T[P]; } & {};
+type InexactPartial<T> = { [P in keyof T]?: T[P] | undefined; };
+type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
+  readonly [Symbol.toStringTag]: string;
+} | Date | Error | Generator | Promise<unknown> | RegExp;
+type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;
+type SomeObject = Record<PropertyKey, any>;
+type Identity<T> = T;
+type Flatten<T> = Identity<{ [k in keyof T]: T[k]; }>;
+type Prettify<T> = { [K in keyof T]: T[K]; } & {};
+type Extend<A extends SomeObject, B extends SomeObject> = Flatten<keyof A & keyof B extends never ? A & B : { [K in keyof A as K extends keyof B ? never : K]: A[K]; } & { [K in keyof B]: B[K]; }>;
+type TupleItems = ReadonlyArray<SomeType>;
+type AnyFunc = (...args: any[]) => any;
+type MaybeAsync<T> = T | Promise<T>;
+type EnumValue = string | number;
+type EnumLike = Readonly<Record<string, EnumValue>>;
+type ToEnum<T extends EnumValue> = Flatten<{ [k in T]: k; }>;
+type Literal = string | number | bigint | boolean | null | undefined;
+type Primitive = string | number | symbol | bigint | boolean | null | undefined;
+type HasLength = {
+  length: number;
+};
+type Numeric = number | bigint | Date;
+type PropValues = Record<string, Set<Primitive>>;
+type PrimitiveSet = Set<Primitive>;
+type EmptyToNever<T> = keyof T extends never ? never : T;
+declare abstract class Class {
+  constructor(..._args: any[]);
+}
+/** A trait's prototype members: a partial view of its own interface, with `this` typed as the instance. */
+type ProtoOf<T> = { [K in keyof T]?: (T[K] extends ((...args: infer A) => infer R) ? (...args: A) => R : T[K]) | undefined; } & ThisType<T>;
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.5.4/node_modules/zod/v4/core/versions.d.cts
+declare const version: {
+  readonly major: 4;
+  readonly minor: 5;
+  readonly patch: number;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.5.4/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 way to mark a whole payload as aborted. Used in codecs/pipes. */
+  aborted?: boolean;
+  /** @internal Set when the value came from a repeat visit to a node still being
+   * parsed. Its checks run on the node itself, against the finished value. */
+  memo?: boolean | undefined;
+}
+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 Three rungs, each strictly stronger than the last:
+   *   undefined    — required; the container may not omit this slot
+   *   "optional"   — the container may omit it; nothing is supplied in its place
+   *   "defaulted"  — the container may omit it AND this schema substitutes a value
+   * Consumers asking "may the slot be absent?" test `!== undefined`.
+   * $ZodOptional asks the stronger question and tests `=== "defaulted"`. */
+  optin?: "optional" | "defaulted" | undefined;
+  /** @internal */
+  optout?: "optional" | undefined;
+  /** @internal The set of literal values that will pass validation. Must be an exhaustive set. Used to determine optionality in z.record().
+   *
+   * 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;
+    /** the pattern admits strings its `format` keyword forbids, so `toJSONSchema` must not emit it */
+    laxFormat: boolean;
+  }>;
+}
+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 $ZodNanoIDDef extends $ZodStringFormatDef<"nanoid"> {
+  length?: number | undefined;
+}
+interface $ZodNanoIDInternals extends $ZodStringFormatInternals<"nanoid"> {
+  def: $ZodNanoIDDef;
+}
+interface $ZodNanoID extends $ZodType {
+  _zod: $ZodNanoIDInternals;
+}
+declare const $ZodNanoID: $constructor<$ZodNanoID>;
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link $ZodCUID2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+interface $ZodCUIDInternals extends $ZodStringFormatInternals<"cuid"> {}
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link $ZodCUID2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+interface $ZodCUID extends $ZodType {
+  _zod: $ZodCUIDInternals;
+}
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link $ZodCUID2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+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" | "defaulted";
+  };
+};
+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" | "defaulted" | undefined : "optional" | "defaulted";
+  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;
+  bag: LoosePartial<{
+    optionsMap: Map<Primitive, $ZodType>;
+  }>;
+}
+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" | "defaulted" ? [...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";
+  partial?: boolean;
+}
+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>>> : [Value] extends [OptionalInSchema] ? 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" | "defaulted";
+  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: "defaulted";
+  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: "defaulted";
+  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.5.4/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, the check runs only when this returns `true`. By default, it is skipped if prior parsing produced aborting issues. */
+  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<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodCheckDef {
+  check: "number_format";
+  format: Format;
+}
+interface $ZodCheckNumberFormatInternals<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodCheckInternals<number> {
+  def: $ZodCheckNumberFormatDef<Format>;
+  issc: $ZodIssueInvalidType | $ZodIssueTooBig<"number"> | $ZodIssueTooSmall<"number">;
+}
+interface $ZodCheckNumberFormat<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodCheck<number> {
+  _zod: $ZodCheckNumberFormatInternals<Format>;
+}
+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" | "credit_card" | "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.5.4/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 options?: Primitive[];
+  readonly inclusive?: true;
+}
+interface $ZodIssueInvalidUnionMultipleMatch extends $ZodIssueBase {
+  readonly code: "invalid_union";
+  readonly errors: [];
+  readonly input?: unknown;
+  readonly discriminator?: string | undefined;
+  readonly inclusive: false;
+  /** Indices of the options that matched */
+  readonly matches: number[];
+}
+type $ZodIssueInvalidUnion = $ZodIssueInvalidUnionNoMatch | $ZodIssueInvalidUnionMultipleMatch;
+interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
+  readonly code: "invalid_key";
+  readonly origin: "map" | "record";
+  readonly issues: $ZodIssue[];
+  readonly input?: Input;
+}
+interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase {
+  readonly code: "invalid_element";
+  readonly origin: "map" | "set";
+  readonly key: unknown;
+  readonly issues: $ZodIssue[];
+  readonly input?: Input;
+}
+interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {
+  readonly code: "invalid_value";
+  readonly values: Primitive[];
+  readonly input?: Input;
+}
+interface $ZodIssueCustom extends $ZodIssueBase {
+  readonly code: "custom";
+  readonly params?: Record<string, any> | undefined;
+  readonly input?: unknown;
+}
+type $ZodIssue = $ZodIssueInvalidType | $ZodIssueTooBig | $ZodIssueTooSmall | $ZodIssueInvalidStringFormat | $ZodIssueNotMultipleOf | $ZodIssueUnrecognizedKeys | $ZodIssueInvalidUnion | $ZodIssueInvalidKey | $ZodIssueInvalidElement | $ZodIssueInvalidValue | $ZodIssueCustom;
+type $ZodInternalIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue$1<T> : never;
+type RawIssue$1<T extends $ZodIssueBase> = T extends any ? Flatten<MakePartial<T, "message" | "path"> & {
+  /** The input data */
+  readonly input: unknown;
+  /** The schema or check that originated this issue. */
+  readonly inst?: $ZodType | $ZodCheck;
+  /** The schema that owns the issue. Equal to `inst` when a schema originated the issue, and the schema the check was attached to when a check did. */
+  readonly schema?: $ZodType | undefined;
+  /** If `true`, Zod will continue executing checks/refinements after this issue. */
+  readonly continue?: boolean | undefined;
+} & Record<string, unknown>> : never;
+type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = $ZodInternalIssue<T>;
+interface $ZodErrorMap<T extends $ZodIssueBase = $ZodIssue> {
+  (issue: $ZodRawIssue<T>): {
+    message: string;
+  } | string | undefined | null;
+}
+interface $ZodError<T = unknown> extends Error {
+  type: T;
+  issues: $ZodIssue[];
+  _zod: {
+    output: T;
+    def: $ZodIssue[];
+  };
+  stack?: string;
+  name: string;
+}
+declare const $ZodError: $constructor<$ZodError>;
+type $ZodFlattenedError<T, U = string> = _FlattenedError<T, U>;
+type _FlattenedError<T, U = string> = {
+  formErrors: U[];
+  fieldErrors: { [P in keyof T]?: U[]; };
+};
+type _ZodFormattedError<T, U = string> = T extends [any, ...any[]] ? { [K in keyof T]?: $ZodFormattedError<T[K], U>; } : T extends any[] ? {
+  [k: number]: $ZodFormattedError<T[number], U>;
+} : T extends object ? Flatten<{ [K in keyof T]?: $ZodFormattedError<T[K], U>; }> : any;
+type $ZodFormattedError<T, U = string> = {
+  _errors: U[];
+} & Flatten<_ZodFormattedError<T, U>>;
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.5.4/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;
+}
+interface $constructorParams {
+  Parent?: typeof Class;
+}
+declare function $constructor<T extends ZodTrait, D = T["_zod"]["def"]>(name: string, initializer: (inst: T, def: D) => void,
+/** This trait's members, installed once on every prototype that composes it. They cannot be declared in the initializer above: that runs per instance, and the prototype is shared. */
+proto?: ProtoOf<T>, params?: $constructorParams): $constructor<T, D>;
+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.5.4/node_modules/zod/v4/core/api.d.cts
+type Params<T extends $ZodType | $ZodCheck, IssueTypes extends $ZodIssueBase, OmitKeys extends keyof T["_zod"]["def"] = never> = Flatten<Partial<EmptyToNever<Omit<T["_zod"]["def"], OmitKeys> & ([IssueTypes] extends [never] ? {} : {
+  error?: string | $ZodErrorMap<IssueTypes> | undefined;
+  /** @deprecated This parameter is deprecated. Use `error` instead. */
+  message?: string | undefined;
+})>>>;
+type TypeParams<T extends $ZodType = $ZodType & {
+  _isst: never;
+}, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error"> = never> = Params<T, NonNullable<T["_zod"]["isst"]>, "type" | "checks" | "error" | AlsoOmit>;
+type CheckParams<T extends $ZodCheck = $ZodCheck // & { _issc: never },
+, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "check" | "error"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "check" | "error" | AlsoOmit>;
+type CheckStringFormatParams<T extends $ZodStringFormat = $ZodStringFormat, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "coerce" | "checks" | "error" | "check" | "format"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "type" | "coerce" | "checks" | "error" | "check" | "format" | AlsoOmit>;
+type CheckTypeParams<T extends $ZodType & $ZodCheck = $ZodType & $ZodCheck, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error" | "check"> = never> = Params<T, NonNullable<T["_zod"]["isst"] | T["_zod"]["issc"]>, "type" | "checks" | "error" | "check" | AlsoOmit>;
+type $ZodCheckEmailParams = CheckStringFormatParams<$ZodEmail, "when">;
+type $ZodCheckGUIDParams = CheckStringFormatParams<$ZodGUID, "pattern" | "when">;
+type $ZodCheckUUIDParams = CheckStringFormatParams<$ZodUUID, "pattern" | "when">;
+type $ZodCheckURLParams = CheckStringFormatParams<$ZodURL, "when">;
+type $ZodCheckEmojiParams = CheckStringFormatParams<$ZodEmoji, "when">;
+type $ZodCheckNanoIDParams = CheckStringFormatParams<$ZodNanoID, "when" | "pattern">;
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link _cuid2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+type $ZodCheckCUIDParams = CheckStringFormatParams<$ZodCUID, "when">;
+type $ZodCheckCUID2Params = CheckStringFormatParams<$ZodCUID2, "when">;
+type $ZodCheckULIDParams = CheckStringFormatParams<$ZodULID, "when">;
+type $ZodCheckXIDParams = CheckStringFormatParams<$ZodXID, "when">;
+type $ZodCheckKSUIDParams = CheckStringFormatParams<$ZodKSUID, "when">;
+type $ZodCheckIPv4Params = CheckStringFormatParams<$ZodIPv4, "pattern" | "when" | "version">;
+type $ZodCheckIPv6Params = CheckStringFormatParams<$ZodIPv6, "pattern" | "when" | "version">;
+type $ZodCheckCIDRv4Params = CheckStringFormatParams<$ZodCIDRv4, "pattern" | "when">;
+type $ZodCheckCIDRv6Params = CheckStringFormatParams<$ZodCIDRv6, "pattern" | "when">;
+type $ZodCheckBase64Params = CheckStringFormatParams<$ZodBase64, "pattern" | "when">;
+type $ZodCheckBase64URLParams = CheckStringFormatParams<$ZodBase64URL, "pattern" | "when">;
+type $ZodCheckE164Params = CheckStringFormatParams<$ZodE164, "when">;
+type $ZodCheckJWTParams = CheckStringFormatParams<$ZodJWT, "pattern" | "when">;
+type $ZodCheckISODateTimeParams = CheckStringFormatParams<$ZodISODateTime, "pattern" | "when">;
+type $ZodCheckISODateParams = CheckStringFormatParams<$ZodISODate, "pattern" | "when">;
+type $ZodCheckISOTimeParams = CheckStringFormatParams<$ZodISOTime, "pattern" | "when">;
+type $ZodCheckISODurationParams = CheckStringFormatParams<$ZodISODuration, "when">;
+type $ZodCheckNumberFormatParams = CheckParams<$ZodCheckNumberFormat, "format" | "when">;
+type $ZodCheckLessThanParams = CheckParams<$ZodCheckLessThan, "inclusive" | "value" | "when">;
+type $ZodCheckGreaterThanParams = CheckParams<$ZodCheckGreaterThan, "inclusive" | "value" | "when">;
+type $ZodCheckMultipleOfParams = CheckParams<$ZodCheckMultipleOf, "value" | "when">;
+type $ZodCheckMaxLengthParams = CheckParams<$ZodCheckMaxLength, "maximum" | "when">;
+type $ZodCheckMinLengthParams = CheckParams<$ZodCheckMinLength, "minimum" | "when">;
+type $ZodCheckLengthEqualsParams = CheckParams<$ZodCheckLengthEquals, "length" | "when">;
+type $ZodCheckRegexParams = CheckParams<$ZodCheckRegex, "format" | "pattern" | "when">;
+type $ZodCheckLowerCaseParams = CheckParams<$ZodCheckLowerCase, "format" | "when">;
+type $ZodCheckUpperCaseParams = CheckParams<$ZodCheckUpperCase, "format" | "when">;
+type $ZodCheckIncludesParams = CheckParams<$ZodCheckIncludes, "includes" | "format" | "when" | "pattern">;
+type $ZodCheckStartsWithParams = CheckParams<$ZodCheckStartsWith, "prefix" | "format" | "when" | "pattern">;
+type $ZodCheckEndsWithParams = CheckParams<$ZodCheckEndsWith, "suffix" | "format" | "pattern" | "when">;
+type $ZodEnumParams = TypeParams<$ZodEnum, "entries">;
+type $ZodNonOptionalParams = TypeParams<$ZodNonOptional, "innerType">;
+type $ZodCustomParams = CheckTypeParams<$ZodCustom, "fn">;
+type $ZodSuperRefineIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
+type RawIssue<T extends $ZodIssueBase> = T extends any ? Flatten<MakePartial<T, "message" | "path"> & {
+  /** The schema or check that originated this issue. */
+  readonly inst?: $ZodType | $ZodCheck;
+  /** If `true`, Zod will execute subsequent checks/refinements instead of immediately aborting */
+  readonly continue?: boolean | undefined;
+} & Record<string, unknown>> : never;
+interface $RefinementCtx<T = unknown> extends ParsePayload<T> {
+  addIssue(arg: string | $ZodSuperRefineIssue): void;
+}
+interface $ZodSuperRefineParams {
+  /** If provided, the refinement runs only when this returns `true`. By default, it is skipped if prior parsing produced aborting issues. */
+  when?: ((payload: ParsePayload) => boolean) | undefined;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.5.4/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.5.4/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.5.4/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>, params?: $ZodSuperRefineParams): 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, TArgs extends unknown[] = []>(fn: (schema: this, ...args: TArgs) => T, ...args: TArgs): 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 CUID v1 is deprecated by its authors due to information leakage
+   * (timestamps embedded in the id). Use `z.cuid2()` instead.
+   * See https://github.com/paralleldrive/cuid.
+   */
+  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 _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, Writeable<U>>, Config>;
+  safeExtend<U extends $ZodLooseShape>(shape: SafeExtendShape<Shape, U> & Partial<Record<keyof Shape, SomeType>>): ZodObject<Extend<Shape, Writeable<U>>, Config>;
+  /**
+   * @deprecated Use [`A.extend(B.shape)`](https://zod.dev/api?id=extend) instead.
+   */
+  merge<U extends ZodObject>(other: U): ZodObject<Extend<Shape, U["shape"]>, U["_zod"]["config"]>;
+  pick<M extends Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, Config>;
+  omit<M extends Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>, Config>;
+  partial(): ZodObject<{ -readonly [k in keyof Shape]: ZodOptional<Shape[k]>; }, Config>;
+  partial<M extends Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<{ -readonly [k in keyof Shape]: k extends keyof M ? ZodOptional<Shape[k]> : Shape[k]; }, Config>;
+  exactPartial(): ZodObject<{ -readonly [k in keyof Shape]: ZodExactOptional<Shape[k]>; }, Config>;
+  exactPartial<M extends Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<{ -readonly [k in keyof Shape]: k extends keyof M ? ZodExactOptional<Shape[k]> : Shape[k]; }, Config>;
+  required(): ZodObject<{ -readonly [k in keyof Shape]: ZodNonOptional<Shape[k]>; }, Config>;
+  required<M extends Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<{ -readonly [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 ZodEnum<
+/** @ts-ignore Cast variance */
+out T extends EnumLike = EnumLike> extends _ZodType<$ZodEnumInternals<T>>, $ZodEnum<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  enum: T;
+  options: Array<T[keyof T]>;
+  extract<const U extends readonly (keyof T)[]>(values: U, params?: string | $ZodEnumParams): ZodEnum<Flatten<Pick<T, U[number]>>>;
+  exclude<const U extends readonly (keyof T)[]>(values: U, params?: string | $ZodEnumParams): ZodEnum<Flatten<Omit<T, U[number]>>>;
+}
+declare const ZodEnum: $constructor<ZodEnum>;
+interface 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>;
+//#endregion
+//#region ../../packages/shared/dist/task-Dg5NQU3r.d.mts
+declare const AccountComputerSummarySchema: ZodObject<{
+  computerId: ZodString;
+  displayName: ZodString;
+  platform: ZodEnum<{
+    darwin: "darwin";
+    linux: "linux";
+    win32: "win32";
+  }>;
+  connectionStatus: ZodEnum<{
+    offline: "offline";
+    online: "online";
+  }>;
+  providerReadiness: ZodOptional<ZodArray<ZodObject<{
+    provider: ZodEnum<{
+      "claude-code": "claude-code";
+      codex: "codex";
+    }>;
+    status: ZodEnum<{
+      checking: "checking";
+      install: "install";
+      ready: "ready";
+      "sign-in": "sign-in";
+      unavailable: "unavailable";
+    }>;
+    observedAt: ZodNullable<ZodString>;
+  }, $strict>>>;
+  imCliReadiness: ZodOptional<ZodArray<ZodObject<{
+    provider: ZodEnum<{
+      feishu: "feishu";
+      slack: "slack";
+    }>;
+    status: ZodEnum<{
+      checking: "checking";
+      install: "install";
+      ready: "ready";
+      unavailable: "unavailable";
+    }>;
+    observedAt: ZodNullable<ZodString>;
+  }, $strict>>>;
+  connectedAt: ZodNullable<ZodString>;
+  lastSeenAt: ZodNullable<ZodString>;
+  observedAt: ZodString;
+  createdAt: ZodString;
+  agentIds: ZodArray<ZodString>;
+}, $strict>;
+declare const ListAccountComputersResponseSchema: ZodObject<{
+  computers: ZodArray<ZodObject<{
+    computerId: ZodString;
+    displayName: ZodString;
+    platform: ZodEnum<{
+      darwin: "darwin";
+      linux: "linux";
+      win32: "win32";
+    }>;
+    connectionStatus: ZodEnum<{
+      offline: "offline";
+      online: "online";
+    }>;
+    providerReadiness: ZodOptional<ZodArray<ZodObject<{
+      provider: ZodEnum<{
+        "claude-code": "claude-code";
+        codex: "codex";
+      }>;
+      status: ZodEnum<{
+        checking: "checking";
+        install: "install";
+        ready: "ready";
+        "sign-in": "sign-in";
+        unavailable: "unavailable";
+      }>;
+      observedAt: ZodNullable<ZodString>;
+    }, $strict>>>;
+    imCliReadiness: ZodOptional<ZodArray<ZodObject<{
+      provider: ZodEnum<{
+        feishu: "feishu";
+        slack: "slack";
+      }>;
+      status: ZodEnum<{
+        checking: "checking";
+        install: "install";
+        ready: "ready";
+        unavailable: "unavailable";
+      }>;
+      observedAt: ZodNullable<ZodString>;
+    }, $strict>>>;
+    connectedAt: ZodNullable<ZodString>;
+    lastSeenAt: ZodNullable<ZodString>;
+    observedAt: ZodString;
+    createdAt: ZodString;
+    agentIds: ZodArray<ZodString>;
+  }, $strict>>;
+}, $strict>;
+type AccountComputerSummary = output<typeof AccountComputerSummarySchema>;
+type ListAccountComputersResponse = output<typeof ListAccountComputersResponseSchema>;
+declare const AgentUsageWindowDaysSchema: ZodUnion<readonly [ZodLiteral<1>, ZodLiteral<7>, ZodLiteral<30>, ZodLiteral<90>]>;
+declare const AgentDetailSchema: ZodObject<{
+  id: ZodString;
+  name: ZodString;
+  displayName: ZodString;
+  runtimeProvider: ZodEnum<{
+    "claude-code": "claude-code";
+    codex: "codex";
+  }>;
+  receiveMode: ZodEnum<{
+    all_message: "all_message";
+    mention_only: "mention_only";
+  }>;
+  status: ZodEnum<{
+    active: "active";
+    suspended: "suspended";
+  }>;
+  createdAt: ZodString;
+  updatedAt: ZodString;
+  createdBy: ZodObject<{
+    userId: ZodString;
+    displayName: ZodString;
+  }, $strict>;
+  computer: ZodNullable<ZodObject<{
+    computerId: ZodString;
+    displayName: ZodString;
+    platform: ZodEnum<{
+      darwin: "darwin";
+      linux: "linux";
+      win32: "win32";
+    }>;
+  }, $strict>>;
+  requiresComputerRebind: ZodOptional<ZodBoolean>;
+  activity: ZodDiscriminatedUnion<[ZodObject<{
+    state: ZodLiteral<"idle">;
+  }, $strict>, ZodObject<{
+    state: ZodLiteral<"unknown">;
+  }, $strict>, ZodObject<{
+    state: ZodLiteral<"working">;
+    startedAt: ZodString;
+  }, $strict>], "state">;
+}, $strict>;
+declare const AgentUsageDetailSchema: ZodObject<{
+  inputTokens: ZodNumber;
+  cachedInputTokens: ZodNumber;
+  outputTokens: ZodNumber;
+  tokens: ZodNumber;
+  windowDays: ZodUnion<readonly [ZodLiteral<1>, ZodLiteral<7>, ZodLiteral<30>, ZodLiteral<90>]>;
+  startedAt: ZodString;
+  endedAt: ZodString;
+  tasks: ZodNumber;
+  measuredTasks: ZodNumber;
+  failed: ZodNumber;
+  daily: ZodArray<ZodObject<{
+    inputTokens: ZodNumber;
+    cachedInputTokens: ZodNumber;
+    outputTokens: ZodNumber;
+    tokens: ZodNumber;
+    date: ZodString;
+    tasks: ZodNumber;
+    measuredTasks: ZodNumber;
+  }, $strict>>;
+}, $strict>;
+declare const AgentAdminConfigSchema: ZodObject<{
+  id: ZodString;
+  name: ZodString;
+  displayName: ZodString;
+  runtimeProvider: ZodEnum<{
+    "claude-code": "claude-code";
+    codex: "codex";
+  }>;
+  receiveMode: ZodEnum<{
+    all_message: "all_message";
+    mention_only: "mention_only";
+  }>;
+  status: ZodEnum<{
+    active: "active";
+    suspended: "suspended";
+  }>;
+  createdAt: ZodString;
+  updatedAt: ZodString;
+  createdByUserId: ZodString;
+  computerId: ZodNullable<ZodString>;
+  revision: ZodNumber;
+  runtimeConfig: ZodObject<{
+    revision: ZodNumber;
+    model: ZodNullable<ZodString>;
+    reasoningEffort: ZodNullable<ZodString>;
+    instructions: ZodString;
+    maxDurationMs: ZodNullable<ZodNumber>;
+  }, $strict>;
+}, $strict>;
+declare const CreateAgentRequestSchema: ZodObject<{
+  creationIntentId: ZodOptional<ZodString>;
+  name: ZodString;
+  displayName: ZodString;
+  runtimeProvider: ZodEnum<{
+    "claude-code": "claude-code";
+    codex: "codex";
+  }>;
+  computerId: ZodOptional<ZodString>;
+  runtimeConfig: ZodOptional<ZodObject<{
+    model: ZodOptional<ZodNullable<ZodString>>;
+    reasoningEffort: ZodOptional<ZodNullable<ZodString>>;
+    instructions: ZodOptional<ZodString>;
+    maxDurationMs: ZodOptional<ZodNullable<ZodNumber>>;
+  }, $strict>>;
+}, $strict>;
+declare const UpdateAgentRequestSchema: ZodObject<{
+  expectedRevision: ZodNumber;
+  displayName: ZodOptional<ZodString>;
+  receiveMode: ZodOptional<ZodEnum<{
+    all_message: "all_message";
+    mention_only: "mention_only";
+  }>>;
+  runtimeConfig: ZodOptional<ZodObject<{
+    model: ZodOptional<ZodNullable<ZodString>>;
+    reasoningEffort: ZodOptional<ZodNullable<ZodString>>;
+    instructions: ZodOptional<ZodString>;
+    maxDurationMs: ZodOptional<ZodNullable<ZodNumber>>;
+  }, $strict>>;
+}, $strict>;
+declare const ListAgentsResponseSchema: ZodObject<{
+  agents: ZodArray<ZodObject<{
+    id: ZodString;
+    name: ZodString;
+    displayName: ZodString;
+    runtimeProvider: ZodEnum<{
+      "claude-code": "claude-code";
+      codex: "codex";
+    }>;
+    receiveMode: ZodEnum<{
+      all_message: "all_message";
+      mention_only: "mention_only";
+    }>;
+    status: ZodEnum<{
+      active: "active";
+      suspended: "suspended";
+    }>;
+    createdAt: ZodString;
+    updatedAt: ZodString;
+    createdBy: ZodObject<{
+      userId: ZodString;
+      displayName: ZodString;
+    }, $strict>;
+    computer: ZodNullable<ZodObject<{
+      computerId: ZodString;
+      displayName: ZodString;
+      platform: ZodEnum<{
+        darwin: "darwin";
+        linux: "linux";
+        win32: "win32";
+      }>;
+    }, $strict>>;
+    requiresComputerRebind: ZodOptional<ZodBoolean>;
+    activity: ZodDiscriminatedUnion<[ZodObject<{
+      state: ZodLiteral<"idle">;
+    }, $strict>, ZodObject<{
+      state: ZodLiteral<"unknown">;
+    }, $strict>, ZodObject<{
+      state: ZodLiteral<"working">;
+      startedAt: ZodString;
+    }, $strict>], "state">;
+    usage: ZodObject<{
+      windowDays: ZodLiteral<30>;
+      tasks: ZodNumber;
+      failed: ZodNumber;
+      tokens: ZodNumber;
+    }, $strict>;
+  }, $strict>>;
+}, $strict>;
+declare const AgentRuntimeTestRequestSchema: ZodObject<{
+  expectedRevision: ZodNumber;
+  expectedRuntimeConfigRevision: ZodNumber;
+}, $strict>;
+declare const AgentRuntimeTestResponseSchema: ZodDiscriminatedUnion<[ZodObject<{
+  status: ZodLiteral<"passed">;
+}, $strict>, ZodObject<{
+  status: ZodLiteral<"failed">;
+  code: ZodEnum<{
+    busy: "busy";
+    cancelled: "cancelled";
+    capability_missing: "capability_missing";
+    computer_unavailable: "computer_unavailable";
+    interaction_or_tool: "interaction_or_tool";
+    provider_failed: "provider_failed";
+    provider_start_failed: "provider_start_failed";
+    stale_configuration: "stale_configuration";
+    timeout: "timeout";
+  }>;
+}, $strict>], "status">;
+type AgentDetail = output<typeof AgentDetailSchema>;
+type AgentUsageWindowDays = output<typeof AgentUsageWindowDaysSchema>;
+type AgentUsageDetail = output<typeof AgentUsageDetailSchema>;
+type AgentAdminConfig = output<typeof AgentAdminConfigSchema>;
+type CreateAgentRequest = output<typeof CreateAgentRequestSchema>;
+type UpdateAgentRequest = output<typeof UpdateAgentRequestSchema>;
+type ListAgentsResponse = output<typeof ListAgentsResponseSchema>;
+type AgentRuntimeTestRequest = output<typeof AgentRuntimeTestRequestSchema>;
+type AgentRuntimeTestResponse = output<typeof AgentRuntimeTestResponseSchema>;
+declare const ImCliProviderSchema: ZodEnum<{
+  feishu: "feishu";
+  slack: "slack";
+}>;
+/**
+ * Exchange identifies the local installation, not an existing Computer. The Server decides create vs
+ * repair only from the one-time code: create always allocates a new Computer, and repair names its
+ * target Computer when the code is issued.
+ */
+declare const ComputerConnectCodeExchangeRequestSchema: ZodObject<{
+  code: ZodString;
+  installationId: ZodString;
+  displayName: ZodString;
+  platform: ZodEnum<{
+    darwin: "darwin";
+    linux: "linux";
+    win32: "win32";
+  }>;
+  arch: ZodString;
+  clientVersion: ZodString;
+}, $strict>;
+declare const ComputerConnectCodeExchangeResponseSchema: ZodObject<{
+  agentId: ZodOptional<ZodString>;
+  runtimeProvider: ZodOptional<ZodEnum<{
+    "claude-code": "claude-code";
+    codex: "codex";
+  }>>;
+  computerId: ZodString;
+  installationId: ZodString;
+  machineToken: ZodString;
+}, $strict>;
+declare const ComputerConnectCodeIssueResponseSchema: ZodObject<{
+  connectCodeId: ZodString;
+  bootstrapCommand: ZodString;
+  expiresIn: ZodNumber;
+  issuedAt: ZodString;
+  mode: ZodOptional<ZodEnum<{
+    create: "create";
+    repair: "repair";
+  }>>;
+}, $strict>;
+declare const ComputerConnectCodeStatusSchema: ZodDiscriminatedUnion<[ZodObject<{
+  connectCodeId: ZodString;
+  computerId: ZodNull;
+  redeemedAt: ZodNull;
+  state: ZodLiteral<"pending">;
+}, $strict>, ZodObject<{
+  connectCodeId: ZodString;
+  computerId: ZodNull;
+  redeemedAt: ZodNull;
+  state: ZodLiteral<"expired">;
+}, $strict>, ZodObject<{
+  connectCodeId: ZodString;
+  computerId: ZodNull;
+  redeemedAt: ZodNull;
+  state: ZodLiteral<"revoked">;
+}, $strict>, ZodObject<{
+  connectCodeId: ZodString;
+  state: ZodLiteral<"redeemed">;
+  computerId: ZodString;
+  redeemedAt: ZodString;
+}, $strict>], "state">;
+type ComputerConnectCodeExchangeRequest = output<typeof ComputerConnectCodeExchangeRequestSchema>;
+type ComputerConnectCodeExchangeResponse = output<typeof ComputerConnectCodeExchangeResponseSchema>;
+type ComputerConnectCodeIssueResponse = output<typeof ComputerConnectCodeIssueResponseSchema>;
+type ComputerConnectCodeStatus = output<typeof ComputerConnectCodeStatusSchema>;
+type ImCliProvider = output<typeof ImCliProviderSchema>;
+declare const ConnectCodeExchangeResponseSchema: ZodObject<{
+  accessToken: ZodString;
+  refreshToken: ZodString;
+  tokenType: ZodLiteral<"Bearer">;
+  expiresIn: ZodNumber;
+}, $strict>;
+declare const RefreshTokenResponseSchema: ZodObject<{
+  accessToken: ZodString;
+  refreshToken: ZodString;
+  tokenType: ZodLiteral<"Bearer">;
+  expiresIn: ZodNumber;
+}, $strict>;
+/**
+ * Authentication proves Account identity only. `setupCompletedAt` is durable Account state from
+ * `users.setup_completed_at`; it is never derived from Agents, Workspaces, or grants.
+ */
+declare const MeResponseSchema: ZodObject<{
+  user: ZodObject<{
+    id: ZodString;
+    email: ZodString;
+    displayName: ZodString;
+  }, $strict>;
+  setupCompletedAt: ZodNullable<ZodString>;
+}, $strict>;
+type ConnectCodeExchangeResponse = output<typeof ConnectCodeExchangeResponseSchema>;
+type RefreshTokenResponse = output<typeof RefreshTokenResponseSchema>;
+type MeResponse = output<typeof MeResponseSchema>;
+//#endregion
+//#region src/health.d.ts
+declare const ServerHealthSchema: ZodObject<{
+  status: ZodLiteral<"ok">;
+  service: ZodLiteral<"opentag-server">;
+}, $strict>;
+type ServerHealth = output<typeof ServerHealthSchema>;
+declare const ImBindingSummarySchema: ZodObject<{
+  id: ZodString;
+  agentId: ZodString;
+  provider: ZodEnum<{
+    feishu: "feishu";
+    slack: "slack";
+  }>;
+  bindingState: ZodEnum<{
+    active: "active";
+    disabled: "disabled";
+    error: "error";
+    provisioning: "provisioning";
+    reauthorization_required: "reauthorization_required";
+  }>;
+  bot: ZodObject<{
+    displayName: ZodNullable<ZodString>;
+    avatarUrl: ZodNullable<ZodString>;
+  }, $strict>;
+  receiveMode: ZodEnum<{
+    all_message: "all_message";
+    mention_only: "mention_only";
+  }>;
+  lastInboundAt: ZodNullable<ZodString>;
+  lastValidatedAt: ZodNullable<ZodString>;
+  lastRuntimeObservationAt: ZodNullable<ZodString>;
+}, $strict>;
+declare const ImBindingAdminDetailSchema: ZodObject<{
+  id: ZodString;
+  agentId: ZodString;
+  provider: ZodEnum<{
+    feishu: "feishu";
+    slack: "slack";
+  }>;
+  bindingState: ZodEnum<{
+    active: "active";
+    disabled: "disabled";
+    error: "error";
+    provisioning: "provisioning";
+    reauthorization_required: "reauthorization_required";
+  }>;
+  bot: ZodObject<{
+    displayName: ZodNullable<ZodString>;
+    avatarUrl: ZodNullable<ZodString>;
+  }, $strict>;
+  receiveMode: ZodEnum<{
+    all_message: "all_message";
+    mention_only: "mention_only";
+  }>;
+  lastInboundAt: ZodNullable<ZodString>;
+  lastValidatedAt: ZodNullable<ZodString>;
+  lastRuntimeObservationAt: ZodNullable<ZodString>;
+  identity: ZodDiscriminatedUnion<[ZodObject<{
+    provider: ZodLiteral<"feishu">;
+    appId: ZodString;
+    teamId: ZodNullable<ZodString>;
+    botOpenId: ZodString;
+    teamBrand: ZodNullable<ZodString>;
+  }, $strict>, ZodObject<{
+    provider: ZodLiteral<"slack">;
+    appId: ZodString;
+    teamId: ZodString;
+    enterpriseId: ZodNullable<ZodString>;
+    botUserId: ZodString;
+    appIdEvidence: ZodLiteral<"configured">;
+  }, $strict>], "provider">;
+  credentialGeneration: ZodNumber;
+  grantedCapabilities: ZodArray<ZodString>;
+  reauthorizationRequired: ZodBoolean;
+  lastErrorCode: ZodNullable<ZodString>;
+}, $strict>;
+declare const FeishuSetupAttemptSchema: ZodObject<{
+  id: ZodString;
+  agentId: ZodString;
+  intent: ZodEnum<{
+    create: "create";
+    reauthorize: "reauthorize";
+    replace: "replace";
+  }>;
+  state: ZodEnum<{
+    awaiting_user: "awaiting_user";
+    canceled: "canceled";
+    expired: "expired";
+    failed: "failed";
+    succeeded: "succeeded";
+    validating: "validating";
+  }>;
+  qrUrl: ZodNullable<ZodString>;
+  expiresAt: ZodString;
+  errorCode: ZodNullable<ZodString>;
+  completedAt: ZodNullable<ZodString>;
+  createdAt: ZodString;
+}, $strict>;
+declare const StartSlackOAuthRequestSchema: ZodObject<{
+  intent: ZodEnum<{
+    create: "create";
+    reauthorize: "reauthorize";
+  }>;
+  returnSurface: ZodOptional<ZodEnum<{
+    "agent-messaging-settings": "agent-messaging-settings";
+    "agent-setup": "agent-setup";
+  }>>;
+  expectedMessaging: ZodOptional<ZodDiscriminatedUnion<[ZodObject<{
+    kind: ZodLiteral<"unbound">;
+  }, $strict>, ZodObject<{
+    kind: ZodLiteral<"bound">;
+    provider: ZodEnum<{
+      feishu: "feishu";
+      slack: "slack";
+    }>;
+    bindingId: ZodString;
+    credentialGeneration: ZodNumber;
+  }, $strict>], "kind">>;
+}, $strict>;
+declare const StartSlackOAuthResponseSchema: ZodObject<{
+  authorizationUrl: ZodString;
+  expiresAt: ZodString;
+}, $strict>;
+declare const ImBindingDiagnosticsSchema: ZodObject<{
+  imBindingId: ZodString;
+  provider: ZodEnum<{
+    feishu: "feishu";
+    slack: "slack";
+  }>;
+  ready: ZodBoolean;
+  agentRuntimeReadiness: ZodEnum<{
+    checking: "checking";
+    install: "install";
+    ready: "ready";
+    "sign-in": "sign-in";
+    unavailable: "unavailable";
+  }>;
+  providerCliReadiness: ZodEnum<{
+    checking: "checking";
+    install: "install";
+    ready: "ready";
+    unavailable: "unavailable";
+  }>;
+  credentialExecutionReadiness: ZodEnum<{
+    checking: "checking";
+    needs_attention: "needs_attention";
+    ready: "ready";
+    retrying: "retrying";
+    unconfirmed: "unconfirmed";
+  }>;
+  credentialExecutionReason: ZodOptional<ZodEnum<{
+    credential_rejected: "credential_rejected";
+    identity_mismatch: "identity_mismatch";
+    provider_unreachable: "provider_unreachable";
+    rate_limited: "rate_limited";
+    scope_missing: "scope_missing";
+    upgrade_required: "upgrade_required";
+  }>>;
+  credentialGeneration: ZodNumber;
+  credentialStatus: ZodEnum<{
+    invalid: "invalid";
+    valid: "valid";
+  }>;
+  requiredCapabilities: ZodArray<ZodString>;
+  grantedCapabilities: ZodArray<ZodString>;
+  missingCapabilities: ZodArray<ZodString>;
+  reauthorizationRequired: ZodBoolean;
+  slackAppId: ZodNullable<ZodObject<{
+    value: ZodString;
+    evidence: ZodLiteral<"configured">;
+    ingressMatchRequired: ZodLiteral<true>;
+  }, $strict>>;
+  slackIdentityClosure: ZodNullable<ZodObject<{
+    status: ZodEnum<{
+      pending: "pending";
+      verified: "verified";
+    }>;
+    verifiedAt: ZodNullable<ZodString>;
+  }, $strict>>;
+  connection: ZodNullable<ZodObject<{
+    state: ZodEnum<{
+      connected: "connected";
+      disconnected: "disconnected";
+    }>;
+    observedAt: ZodString;
+  }, $strip>>;
+  lastInboundAt: ZodNullable<ZodString>;
+  lastValidatedAt: ZodNullable<ZodString>;
+  lastRuntimeObservationAt: ZodNullable<ZodString>;
+  lastErrorCode: ZodNullable<ZodString>;
+}, $strict>;
+type ImBindingSummary = output<typeof ImBindingSummarySchema>;
+type ImBindingAdminDetail = output<typeof ImBindingAdminDetailSchema>;
+type FeishuSetupAttempt = output<typeof FeishuSetupAttemptSchema>;
+type StartSlackOAuthRequest = output<typeof StartSlackOAuthRequestSchema>;
+type StartSlackOAuthResponse = output<typeof StartSlackOAuthResponseSchema>;
+type ImBindingDiagnostics = output<typeof ImBindingDiagnosticsSchema>;
+declare const RuntimeDurableWorkKindSchema: ZodEnum<{
+  "session-message": "session-message";
+  "turn-report": "turn-report";
+}>;
+declare const RuntimeDurableWorkRecordSchema: ZodObject<{
+  attempts: ZodNumber;
+  acceptedAt: ZodNumber;
+  key: ZodString;
+  kind: ZodEnum<{
+    "session-message": "session-message";
+    "turn-report": "turn-report";
+  }>;
+  lastError: ZodOptional<ZodObject<{
+    category: ZodString;
+    code: ZodString;
+    message: ZodString;
+    phase: ZodString;
+    requestId: ZodString;
+    retryability: ZodEnum<{
+      retryable: "retryable";
+      terminal: "terminal";
+    }>;
+  }, $strict>>;
+  nextAttemptAt: ZodOptional<ZodNumber>;
+  payload: ZodUnknown;
+  status: ZodEnum<{
+    accepted: "accepted";
+    "dead-letter": "dead-letter";
+    failed: "failed";
+    retryable: "retryable";
+    running: "running";
+    succeeded: "succeeded";
+  }>;
+  updatedAt: ZodNumber;
+}, $strict>;
+type RuntimeDurableWorkKind = output<typeof RuntimeDurableWorkKindSchema>;
+type RuntimeDurableWorkRecord = output<typeof RuntimeDurableWorkRecordSchema>;
+/** The stable high-level class used for operational routing and dashboards. */
+declare const StructuredErrorCategorySchema: ZodEnum<{
+  auth: "auth";
+  authorization: "authorization";
+  cancelled: "cancelled";
+  configuration: "configuration";
+  conflict: "conflict";
+  dependency: "dependency";
+  internal: "internal";
+  not_found: "not_found";
+  protocol: "protocol";
+  rate_limit: "rate_limit";
+  timeout: "timeout";
+  unavailable: "unavailable";
+  validation: "validation";
+}>;
+/** The safe retry policy for a failure. Retries must still respect operation idempotency. */
+declare const ErrorRetryabilitySchema: ZodEnum<{
+  after_auth: "after_auth";
+  backoff: "backoff";
+  immediate: "immediate";
+  never: "never";
+}>;
+/** The lifecycle boundary at which an error was observed. */
+declare const StructuredErrorPhaseSchema: ZodEnum<{
+  authentication: "authentication";
+  authorization: "authorization";
+  configuration: "configuration";
+  dispatch: "dispatch";
+  persistence: "persistence";
+  provider: "provider";
+  request: "request";
+  scheduler: "scheduler";
+  serialization: "serialization";
+  shutdown: "shutdown";
+  socket: "socket";
+  startup: "startup";
+  transport: "transport";
+  unknown: "unknown";
+  validation: "validation";
+  worker: "worker";
+}>;
+type StructuredErrorCauseInput = {
+  code?: string;
+  category?: StructuredErrorCategory;
+  retryability?: ErrorRetryability;
+  phase?: StructuredErrorPhase;
+  message: string;
+  cause?: StructuredErrorCauseInput;
+};
+declare const StructuredErrorSchema: ZodObject<{
+  code: ZodString;
+  category: ZodEnum<{
+    auth: "auth";
+    authorization: "authorization";
+    cancelled: "cancelled";
+    configuration: "configuration";
+    conflict: "conflict";
+    dependency: "dependency";
+    internal: "internal";
+    not_found: "not_found";
+    protocol: "protocol";
+    rate_limit: "rate_limit";
+    timeout: "timeout";
+    unavailable: "unavailable";
+    validation: "validation";
+  }>;
+  retryability: ZodEnum<{
+    after_auth: "after_auth";
+    backoff: "backoff";
+    immediate: "immediate";
+    never: "never";
+  }>;
+  phase: ZodEnum<{
+    authentication: "authentication";
+    authorization: "authorization";
+    configuration: "configuration";
+    dispatch: "dispatch";
+    persistence: "persistence";
+    provider: "provider";
+    request: "request";
+    scheduler: "scheduler";
+    serialization: "serialization";
+    shutdown: "shutdown";
+    socket: "socket";
+    startup: "startup";
+    transport: "transport";
+    unknown: "unknown";
+    validation: "validation";
+    worker: "worker";
+  }>;
+  requestId: ZodOptional<ZodString>;
+  message: ZodString;
+  cause: ZodOptional<ZodType<StructuredErrorCauseInput, unknown, $ZodTypeInternals<StructuredErrorCauseInput, unknown>>>;
+}, $strict>;
+type StructuredErrorCategory = output<typeof StructuredErrorCategorySchema>;
+type ErrorRetryability = output<typeof ErrorRetryabilitySchema>;
+type StructuredErrorPhase = output<typeof StructuredErrorPhaseSchema>;
+type StructuredError = output<typeof StructuredErrorSchema>;
+//#endregion
+//#region ../../packages/shared/dist/index.d.mts
+//#region src/channel-name.d.ts
+/**
+ * Release channel names. Kept free of Node.js imports so browser bundles and protocol schemas can
+ * reference channels without pulling in `node:os`/`node:path`.
+ */
+declare const ChannelNameSchema: ZodEnum<{
+  dev: "dev";
+  prod: "prod";
+  staging: "staging";
+}>;
+type ChannelName = output<typeof ChannelNameSchema>;
+//#endregion
+//#region src/channel.d.ts
+declare const ServiceIdSchema: ZodString;
+type ServiceId = output<typeof ServiceIdSchema>;
+interface ChannelConfig {
+  binName: string;
+  channel: ChannelName;
+  defaultHome: string;
+  defaultServerUrl?: string;
+  displayName: string;
+  packageName: string;
+  serviceId: ServiceId;
+}
+declare const SessionCliCreateRequestSchema: ZodObject<{
+  messageId: ZodString;
+  message: ZodString;
+  model: ZodOptional<ZodString>;
+  reasoningEffort: ZodOptional<ZodString>;
+  maxDurationMs: ZodOptional<ZodNumber>;
+}, $strict>;
+declare const SessionCliSendRequestSchema: ZodObject<{
+  messageId: ZodString;
+  targetSessionId: ZodString;
+  message: ZodString;
+}, $strict>;
+declare const SessionCliCommandResponseSchema: ZodObject<{
+  messageId: ZodString;
+  status: ZodEnum<{
+    accepted: "accepted";
+    rejected: "rejected";
+    unknown: "unknown";
+    unreachable: "unreachable";
+  }>;
+  sessionId: ZodOptional<ZodString>;
+  code: ZodOptional<ZodString>;
+}, $strict>;
+declare const SessionCliListQuerySchema: ZodObject<{
+  recursive: ZodDefault<ZodBoolean>;
+  limit: ZodDefault<ZodNumber>;
+  cursor: ZodOptional<ZodString>;
+  since: ZodOptional<ZodString>;
+}, $strict>;
+declare const SessionCliListResponseSchema: ZodObject<{
+  items: ZodArray<ZodObject<{
+    sessionId: ZodString;
+    parentSessionId: ZodString;
+    createdAt: ZodString;
+    lastMessageAt: ZodString;
+    lastDeliveryOutcome: ZodEnum<{
+      accepted: "accepted";
+      rejected: "rejected";
+      unknown: "unknown";
+      unreachable: "unreachable";
+    }>;
+    taskPreview: ZodString;
+  }, $strict>>;
+  nextCursor: ZodOptional<ZodString>;
+}, $strict>;
+type SessionCliCreateRequest = output<typeof SessionCliCreateRequestSchema>;
+type SessionCliSendRequest = output<typeof SessionCliSendRequestSchema>;
+type SessionCliCommandResponse = output<typeof SessionCliCommandResponseSchema>;
+type SessionCliListQuery = output<typeof SessionCliListQuerySchema>;
+type SessionCliListResponse = output<typeof SessionCliListResponseSchema>;
+//#endregion
+//#region ../../packages/client/dist/index.d.mts
+interface RequestOptions {
+  signal?: AbortSignal;
+  timeoutMs?: number;
+  requestId?: string;
+}
+interface OpenTagApiConstructorOptions {
+  fetchImpl?: typeof fetch;
+  timeoutMs?: number;
+}
+declare class OpenTagApi {
+  #private;
+  constructor(serverUrl: string, fetchOrOptions?: typeof fetch | OpenTagApiConstructorOptions, options?: OpenTagApiConstructorOptions);
+  exchangeConnectCode(code: string, expectedUserId?: string, options?: RequestOptions): Promise<ConnectCodeExchangeResponse>;
+  exchangeComputerConnectCode(input: ComputerConnectCodeExchangeRequest, options?: RequestOptions): Promise<ComputerConnectCodeExchangeResponse>;
+  refresh(refreshToken: string, options?: RequestOptions): Promise<RefreshTokenResponse>;
+  me(accessToken: string, options?: RequestOptions): Promise<MeResponse>;
+  issueComputerConnectCode(accessToken: string, options?: RequestOptions): Promise<ComputerConnectCodeIssueResponse>;
+  getComputerConnectCodeStatus(accessToken: string, connectCodeId: string, options?: RequestOptions): Promise<ComputerConnectCodeStatus>;
+  listAccountComputers(accessToken: string, options?: RequestOptions): Promise<ListAccountComputersResponse>;
+  createAgent(accessToken: string, input: CreateAgentRequest, options?: RequestOptions): Promise<AgentAdminConfig>;
+  listAgents(accessToken: string, options?: RequestOptions): Promise<ListAgentsResponse>;
+  getAgent(accessToken: string, agentId: string, options?: RequestOptions): Promise<AgentDetail>;
+  getAgentUsage(accessToken: string, agentId: string, windowDays: AgentUsageWindowDays, options?: RequestOptions): Promise<AgentUsageDetail>;
+  getAgentConfig(accessToken: string, agentId: string, options?: RequestOptions): Promise<AgentAdminConfig>;
+  testAgentRuntime(accessToken: string, agentId: string, input: AgentRuntimeTestRequest, options?: RequestOptions): Promise<AgentRuntimeTestResponse>;
+  rebindAgentComputer(accessToken: string, agentId: string, computerId: string): Promise<AgentAdminConfig>;
+  updateAgent(accessToken: string, agentId: string, input: UpdateAgentRequest, options?: RequestOptions): Promise<AgentAdminConfig>;
+  suspendAgent(accessToken: string, agentId: string, options?: RequestOptions): Promise<AgentAdminConfig>;
+  reactivateAgent(accessToken: string, agentId: string, options?: RequestOptions): Promise<AgentAdminConfig>;
+  deleteAgent(accessToken: string, agentId: string, options?: RequestOptions): Promise<void>;
+  getAgentImBinding(accessToken: string, agentId: string, options?: RequestOptions): Promise<ImBindingSummary | undefined>;
+  getAgentImBindingConfig(accessToken: string, agentId: string, options?: RequestOptions): Promise<ImBindingAdminDetail | undefined>;
+  createFeishuSetupAttempt(accessToken: string, agentId: string, intent?: "create" | "reauthorize" | "replace", options?: RequestOptions): Promise<FeishuSetupAttempt>;
+  getFeishuSetupAttempt(accessToken: string, attemptId: string, options?: RequestOptions): Promise<FeishuSetupAttempt>;
+  cancelFeishuSetupAttempt(accessToken: string, attemptId: string, options?: RequestOptions): Promise<FeishuSetupAttempt>;
+  startSlackOAuth(accessToken: string, agentId: string, input: StartSlackOAuthRequest, options?: RequestOptions): Promise<StartSlackOAuthResponse>;
+  getImBindingDiagnostics(accessToken: string, imBindingId: string, options?: RequestOptions): Promise<ImBindingDiagnostics>;
+  disableImBinding(accessToken: string, imBindingId: string, options?: RequestOptions): Promise<void>;
+  openImResource(machineToken: string, imMessageId: string, ordinal: number, scope: {
+    sessionId: string;
+    instanceId: string;
+    placementGeneration: number;
+  }, options?: RequestOptions): Promise<Response>;
+  listRuntimeDurableWork(machineToken: string, kind: RuntimeDurableWorkKind, options?: RequestOptions): Promise<RuntimeDurableWorkRecord[]>;
+  writeRuntimeDurableWork(machineToken: string, record: RuntimeDurableWorkRecord, options?: RequestOptions): Promise<void>;
+  createInternalSession(proof: string, input: SessionCliCreateRequest, options?: RequestOptions): Promise<SessionCliCommandResponse>;
+  sendSessionMessage(proof: string, input: SessionCliSendRequest, options?: RequestOptions): Promise<SessionCliCommandResponse>;
+  listInternalSessions(proof: string, input: SessionCliListQuery, options?: RequestOptions): Promise<SessionCliListResponse>;
+}
+//#endregion
+//#region src/auth/credentials.d.ts
+interface StoredCredentials {
+  accessToken: string;
+  accessTokenExpiresAt: string;
+  refreshToken: string;
+  serverUrl: string;
+}
+//#endregion
+//#region src/auth/machine-credentials.d.ts
+interface MachineComputerCredential {
+  computerId: string;
+  installationId: string;
+  machineToken: string;
+  serverUrl: string;
+}
+interface StoredMachineCredentials {
+  version: 3;
+  computer: MachineComputerCredential;
+}
+//#endregion
+//#region src/observability/logger.d.ts
+type ClientLogBindings = Readonly<Record<string, unknown>>;
+interface ClientLogger {
+  child(bindings: ClientLogBindings): ClientLogger;
+  debug(fields: ClientLogBindings, message: string): void;
+  error(fields: ClientLogBindings, message: string): void;
+  info(fields: ClientLogBindings, message: string): void;
+  warn(fields: ClientLogBindings, message: string): void;
+}
+//#endregion
+//#region src/runtime/agent-runtime-installation.d.ts
+type AgentRuntimeExecutableSource = "explicit" | "caller-path" | "well-known" | "login-shell" | "version-manager" | "desktop-app";
+type AgentRuntimeCliInstallation = {
+  provider: "codex" | "claude-code";
+  displayName: string;
+  status: "installed";
+  path: string;
+  source: AgentRuntimeExecutableSource;
+} | {
+  provider: "codex" | "claude-code";
+  displayName: string;
+  status: "not-installed";
+} | {
+  provider: "codex" | "claude-code";
+  displayName: string;
+  status: "unknown";
+  detail: string;
+};
+//#endregion
+//#region src/runtime/computer-identity.d.ts
+interface ComputerIdentity {
+  version: 2;
+  computerId: string;
+  serverUrl: string;
+}
+//#endregion
+//#region src/runtime/provider-cli/types.d.ts
+/**
+ * A managed Provider CLI is either Feishu/Lark (`lark-cli`) or Slack (`slack`).
+ * The provider identifier reuses the canonical IM provider vocabulary.
+ */
+type ProviderCliProvider = ImCliProvider;
+type ProviderCliTrust = "catalog-verified" | "compatible-unverified";
+/** Local Provider CLI state machine from the management design; `checking` is an in-flight observation. */
+type ProviderCliLocalState = "checking" | "absent" | "ready" | "unavailable";
+/**
+ * Stable local diagnostic codes. These stay local to the machine; only the coarse
+ * readiness mapping may ever leave the device.
+ */
+type ProviderCliDiagnosticCode = "not_installed" | "global_bin_unavailable" | "launcher_invalid" | "global_command_shadowed" | "external_path_invalid" | "external_not_detected" | "external_candidate_changed" | "external_candidate_unverified" | "artifact_drifted" | "integrity_failed" | "version_incompatible" | "probe_failed" | "install_incomplete" | "credential_unavailable" | "unsupported_platform" | "operation_in_progress" | "selection_invalid";
+/** Warning codes that never downgrade readiness on their own. */
+type ProviderCliWarningCode = "global_command_shadowed" | "global_path_not_configured" | "external_candidate_unverified";
+interface ProviderCliDiagnostic {
+  readonly code: ProviderCliDiagnosticCode;
+  readonly remediation?: string;
+}
+interface ProviderCliWarning {
+  readonly code: ProviderCliWarningCode;
+  readonly remediation?: string;
+}
+interface ProviderCliSelectionSummary {
+  readonly kind: "managed" | "external";
+  readonly path: string;
+  readonly version: string;
+  readonly trust: ProviderCliTrust;
+  readonly generation: number;
+}
+/** Read-only inspection result for one provider. */
+interface ProviderCliInspection {
+  readonly provider: ProviderCliProvider;
+  readonly state: Exclude<ProviderCliLocalState, "checking">;
+  readonly readiness: "ready" | "install" | "unavailable";
+  readonly selection?: ProviderCliSelectionSummary;
+  readonly fingerprint?: string;
+  readonly launcher: {
+    readonly path: string;
+    readonly status: "valid" | "missing" | "invalid" | "mismatch";
+  };
+  readonly globalCommand: {
+    readonly active: boolean;
+    readonly path?: string;
+    readonly resolvedPath?: string;
+  };
+  readonly warnings: readonly ProviderCliWarning[];
+  readonly diagnostic?: ProviderCliDiagnostic;
+}
+type ProviderCliEnsureAction = "noop" | "selected-existing" | "installed-managed" | "failed";
+type ProviderCliPhase = "detect" | "select" | "managed-install" | "verify";
+interface ProviderCliPhaseRecord {
+  readonly phase: ProviderCliPhase;
+  readonly status: "started" | "completed" | "failed";
+  /** Bounded single-line human detail; never carries credentials or raw child-process output. */
+  readonly detail?: string;
+}
+interface ProviderCliCandidateReport {
+  readonly path: string;
+  readonly version?: string;
+  readonly trust?: ProviderCliTrust;
+  readonly disposition: "selected" | "ignored";
+  readonly reason: string;
+}
+/** Stable ensure result shape; the `--json` document serializes this verbatim per provider. */
+interface ProviderCliEnsureResult {
+  readonly ok: boolean;
+  readonly provider: ProviderCliProvider;
+  readonly action: ProviderCliEnsureAction;
+  readonly phases: readonly ProviderCliPhaseRecord[];
+  readonly selected?: {
+    readonly path: string;
+    readonly version: string;
+    readonly source: string;
+    readonly trust: ProviderCliTrust;
+  };
+  readonly candidates: readonly ProviderCliCandidateReport[];
+  readonly readiness: "ready" | "unavailable";
+  readonly globalCommand: {
+    readonly active: boolean;
+    readonly path?: string;
+    readonly resolvedPath?: string;
+  };
+  readonly warnings: readonly ProviderCliWarning[];
+  readonly diagnostic?: ProviderCliDiagnostic;
+  readonly dryRun?: boolean;
+}
+//#endregion
+//#region src/runtime/provider-cli/catalog.d.ts
+/**
+ * Reviewed Provider CLI catalog.
+ *
+ * The catalog is the only source of managed-install truth: version, platform asset,
+ * digests, size bounds, probe contract, and license are reviewed static data that ship
+ * in an OpenTag release. Nothing here is fetched from a mutable remote `latest`
+ * manifest. Probe contracts run without credentials and never call a provider API.
+ *
+ * Current entries were reviewed on 2026-08-30:
+ * - lark-cli v1.0.92 archive digests match the upstream-published `checksums.txt` from
+ *   https://github.com/larksuite/cli/releases/tag/v1.0.92; executable digests were
+ *   computed from those verified archives.
+ * - Slack CLI v4.7.0 archives were downloaded from the official
+ *   https://downloads.slack-edge.com/slack-cli/ prefix (Slack publishes no checksum
+ *   file); digests were computed from those archives.
+ */
+interface ProviderCliProbeContract {
+  /** Arguments that print the version, e.g. `["--version"]` or `["version"]`. */
+  readonly versionArgs: readonly string[];
+  /** Arguments proving the required command surface, e.g. `["im", "--help"]`. */
+  readonly surfaceArgs: readonly string[];
+  /** RegExp source whose first capture group is the semantic version. */
+  readonly versionPattern: string;
+  readonly timeoutMs: number;
+  readonly maxOutputBytes: number;
+}
+interface ProviderCliCatalogArtifact {
+  readonly platform: "darwin" | "linux";
+  readonly arch: "arm64" | "x64";
+  readonly archiveType: "tar.gz";
+  /** Official artifact URL; the reviewed catalog is the trust root for this location. */
+  readonly url: string;
+  /** SHA-256 of the archive. */
+  readonly sha256: string;
+  /** Exact archive size; doubles as the bounded download limit. */
+  readonly archiveBytes: number;
+  /** Hard cap on the decompressed archive stream (decompression-bomb guard). */
+  readonly maxExtractedBytes: number;
+  /** Expected executable member path inside the archive (and below the version dir). */
+  readonly executablePath: string;
+  /** SHA-256 of the extracted executable; also the external `catalog-verified` trust digest. */
+  readonly executableSha256: string;
+  readonly executableBytes: number;
+}
+interface ProviderCliCatalogEntry {
+  readonly provider: ProviderCliProvider;
+  /** Native command name visible to users and Agents. */
+  readonly command: "lark-cli" | "slack";
+  readonly displayName: string;
+  /** Exact version a managed install publishes. */
+  readonly version: string;
+  /** Semver range an external candidate must satisfy to be compatible. */
+  readonly compatibility: string;
+  readonly probes: ProviderCliProbeContract;
+  /** Update-check suppression applied by the launcher for managed targets only. */
+  readonly managedEnvironment: Readonly<Record<string, string>>;
+  /** Global flags the launcher prepends for managed targets only. */
+  readonly managedArguments: readonly string[];
+  readonly license: {
+    readonly name: string;
+    readonly copyright: string;
+    readonly notices: string;
+  };
+  readonly artifacts: readonly ProviderCliCatalogArtifact[];
+}
+//#endregion
+//#region src/runtime/integration-cli-installation.d.ts
+type IntegrationCliId = "feishu" | "slack";
+type IntegrationCliInstallation = {
+  cli: IntegrationCliId;
+  displayName: string;
+  status: "installed";
+  path: string;
+  source: AgentRuntimeExecutableSource;
+} | {
+  cli: IntegrationCliId;
+  displayName: string;
+  status: "not-installed";
+} | {
+  cli: IntegrationCliId;
+  displayName: string;
+  status: "unknown";
+  detail: string;
+};
+//#endregion
+//#region src/runtime/local-computer-configuration.d.ts
+type LocalConfigurationStatus = "valid" | "missing" | "invalid";
+interface LocalComputerConfigurationInspection {
+  identity: {
+    status: LocalConfigurationStatus;
+    value?: ComputerIdentity;
+    detail?: string;
+  };
+  credentials: {
+    status: LocalConfigurationStatus;
+    value?: StoredMachineCredentials;
+    detail?: string;
+  };
+  binding: {
+    status: LocalConfigurationStatus;
+    credentialCount: number;
+    serverUrl?: string;
+    detail?: string;
+  };
+}
+//#endregion
+//#region src/runtime/provider-cli/probe.d.ts
+/** Injectable bounded child-process runner; the default never uses a shell. */
+type ProviderCliExecFile = (file: string, args: readonly string[], options: {
+  env: NodeJS.ProcessEnv;
+  timeout: number;
+  maxBuffer: number;
+  windowsHide: boolean;
+}) => Promise<{
+  stdout: string;
+  stderr: string;
+}>;
+//#endregion
+//#region src/runtime/provider-cli/detector.d.ts
+/**
+ * User-facing external detection: one bounded, read-only scan of exact provider command
+ * names in the invoking CLI process's PATH. It never scans version managers or home
+ * trees, never starts a login shell, and never touches credentials or provider APIs.
+ */
+interface ProviderCliCandidate {
+  /** Ephemeral identity valid only for this detection pass. */
+  readonly id: string;
+  readonly provider: ProviderCliProvider;
+  readonly kind: "external" | "managed";
+  /** Canonical realpath of the exact executable this candidate would run. */
+  readonly path: string;
+  /** PATH directory that contributed the candidate, or `selection`. */
+  readonly sourceDir: string;
+  readonly version: string;
+  readonly trust: ProviderCliTrust;
+  readonly fingerprint: string;
+  /** Managed archive digest when the candidate is a managed artifact. */
+  readonly managedDigest?: string;
+  /** Effective PATH order index; candidates not on PATH sort last. */
+  readonly pathRank: number;
+  /** True when the candidate is the current persisted selection. */
+  readonly incumbent: boolean;
+}
+/** Bounded artifact download; the default implementation follows redirects off the reviewed URL. */
+type ProviderCliFetcher = (options: {
+  url: string;
+  maxBytes: number;
+  timeoutMs: number;
+}) => Promise<Uint8Array>;
+type ProviderCliPhaseEvent = ProviderCliPhaseRecord & {
+  readonly provider: ProviderCliProvider;
+};
+//#endregion
+//#region src/core/command/policy.d.ts
+/** Process exit values shared by every user-facing CLI command. */
+declare const EXIT_CODES$1: {
+  readonly success: 0;
+  readonly failure: 1;
+  readonly usage: 2;
+  readonly serviceUnavailable: 3;
+  readonly interrupted: 130;
+};
+type CommandExitCode = (typeof EXIT_CODES$1)[keyof typeof EXIT_CODES$1];
+type CommandErrorCategory = StructuredError["category"];
+type CommandRetryability = ErrorRetryability;
+type CommandPhase = StructuredError["phase"];
+type CommandErrorCodeFields = {
+  code: string;
+  category: CommandErrorCategory;
+};
+type CommandErrorRetryFields = {
+  retryability: CommandRetryability;
+  phase: CommandPhase;
+};
+type CommandErrorRequiredFields = CommandErrorCodeFields & CommandErrorRetryFields;
+type CommandErrorFields = CommandErrorRequiredFields & {
+  requestId?: string;
+};
+/** Structured, transport-neutral CLI failure metadata. The Error message is the human detail. */
+declare class CommandError$1 extends Error {
+  readonly code: string;
+  readonly category: CommandErrorCategory;
+  readonly retryability: CommandRetryability;
+  readonly phase: CommandPhase;
+  readonly requestId?: string;
+  readonly structuredError: StructuredError;
+  constructor(fields: CommandErrorFields, message: string, options?: ErrorOptions);
+  toStructuredError(): StructuredError;
+}
+type SuccessCommandResult<T> = {
+  ok: true;
+  value: T;
+  exitCode: typeof EXIT_CODES$1.success;
+};
+type FailureCommandResultBase<T> = {
+  ok: false;
+  error: CommandError$1;
+  value?: T;
+};
+type FailureCommandResult<T> = FailureCommandResultBase<T> & {
+  exitCode: Exclude<CommandExitCode, 0>;
+};
+type CommandResult<T> = SuccessCommandResult<T> | FailureCommandResult<T>;
+type CommandFormatValueOptions<T> = {
+  formatValue?: (value: T) => string;
+};
+type CommandFormatWriterOptions = {
+  stdout?: (chunk: string) => void;
+  stderr?: (chunk: string) => void;
+};
+type CommandFormatOptions<T> = CommandFormatValueOptions<T> & CommandFormatWriterOptions;
+type CommandPresentationOptions<T> = {
+  json?: boolean;
+} & CommandFormatOptions<T>;
+type CommandExecutionOptions<T> = CommandPresentationOptions<T> & {
+  logger?: ClientLogger;
+  phase?: CommandPhase;
+};
+/** Convert errors from Commander, Zod, the API, and Node into one local contract. */
+declare function toCommandError$1(error: unknown, phase?: CommandPhase): CommandError$1;
+/** Present a result once. Human successes use stdout; all failures use redacted stderr. */
+declare function presentCommand$1<T>(result: CommandResult<T>, options?: CommandPresentationOptions<T>): CommandExitCode;
+/** Run an operation through the shared result and presentation path. */
+declare function executeCommand$1<T>(operation: () => Promise<T>, options?: CommandExecutionOptions<T>): Promise<CommandExitCode>;
+declare function commandExitCode$1(error: CommandError$1): Exclude<CommandExitCode, typeof EXIT_CODES$1.success>;
+//#endregion
+//#region src/build-info.d.ts
+declare const CHANNEL: ChannelName;
+declare const CLI_PACKAGE_NAME: string;
+declare const CLI_VERSION: string;
+//#endregion
+//#region ../../node_modules/.pnpm/commander@15.0.0/node_modules/commander/typings/index.d.ts
+// Type definitions for commander
+// Original definitions by: Alan Agius <https://github.com/alan-agius4>, Marcelo Dezem <https://github.com/mdezem>, vvakame <https://github.com/vvakame>, Jules Randolph <https://github.com/sveinburne>
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// This is a trick to encourage editor to suggest the known literals while still
+// allowing any BaseType value.
+// References:
+// - https://github.com/microsoft/TypeScript/issues/29729
+// - https://github.com/sindresorhus/type-fest/blob/main/source/literal-union.d.ts
+// - https://github.com/sindresorhus/type-fest/blob/main/source/primitive.d.ts
+type LiteralUnion<LiteralType, BaseType extends string | number> = LiteralType | (BaseType & Record<never, never>);
+declare class CommanderError extends Error {
+  code: string;
+  exitCode: number;
+  message: string;
+  nestedError?: string;
+  /**
+   * Constructs the CommanderError class
+   * @param exitCode - suggested exit code which could be used with process.exit
+   * @param code - an id string representing the error
+   * @param message - human-readable description of the error
+   */
+  constructor(exitCode: number, code: string, message: string);
+}
+interface ErrorOptions$1 {
+  // optional parameter for error()
+  /** an id string representing the error */
+  code?: string;
+  /** suggested exit code which could be used with process.exit */
+  exitCode?: number;
+}
+declare class Argument {
+  description: string;
+  required: boolean;
+  variadic: boolean;
+  defaultValue?: any;
+  defaultValueDescription?: string;
+  parseArg?: <T>(value: string, previous: T) => T;
+  argChoices?: string[];
+  /**
+   * Initialize a new command argument with the given name and description.
+   * The default is that the argument is required, and you can explicitly
+   * indicate this with <> around the name. Put [] around the name for an optional argument.
+   */
+  constructor(arg: string, description?: string);
+  /**
+   * Return argument name.
+   */
+  name(): string;
+  /**
+   * Set the default value, and optionally supply the description to be displayed in the help.
+   */
+  default(value: unknown, description?: string): this;
+  /**
+   * Set the custom handler for processing CLI command arguments into argument values.
+   */
+  argParser<T>(fn: (value: string, previous: T) => T): this;
+  /**
+   * Only allow argument value to be one of choices.
+   */
+  choices(values: readonly string[]): this;
+  /**
+   * Make argument required.
+   */
+  argRequired(): this;
+  /**
+   * Make argument optional.
+   */
+  argOptional(): this;
+}
+declare class Option {
+  flags: string;
+  description: string;
+  required: boolean; // A value must be supplied when the option is specified.
+  optional: boolean; // A value is optional when the option is specified.
+  variadic: boolean;
+  mandatory: boolean; // The option must have a value after parsing, which usually means it must be specified on command line.
+  short?: string;
+  long?: string;
+  negate: boolean;
+  defaultValue?: any;
+  defaultValueDescription?: string;
+  presetArg?: unknown;
+  envVar?: string;
+  parseArg?: <T>(value: string, previous: T) => T;
+  hidden: boolean;
+  argChoices?: string[];
+  helpGroupHeading?: string;
+  constructor(flags: string, description?: string);
+  /**
+   * Set the default value, and optionally supply the description to be displayed in the help.
+   */
+  default(value: unknown, description?: string): this;
+  /**
+   * Preset to use when option used without option-argument, especially optional but also boolean and negated.
+   * The custom processing (parseArg) is called.
+   *
+   * @example
+   * ```ts
+   * new Option('--color').default('GREYSCALE').preset('RGB');
+   * new Option('--donate [amount]').preset('20').argParser(parseFloat);
+   * ```
+   */
+  preset(arg: unknown): this;
+  /**
+   * Add option name(s) that conflict with this option.
+   * An error will be displayed if conflicting options are found during parsing.
+   *
+   * @example
+   * ```ts
+   * new Option('--rgb').conflicts('cmyk');
+   * new Option('--js').conflicts(['ts', 'jsx']);
+   * ```
+   */
+  conflicts(names: string | string[]): this;
+  /**
+   * Specify implied option values for when this option is set and the implied options are not.
+   *
+   * The custom processing (parseArg) is not called on the implied values.
+   *
+   * @example
+   * program
+   *   .addOption(new Option('--log', 'write logging information to file'))
+   *   .addOption(new Option('--trace', 'log extra details').implies({ log: 'trace.txt' }));
+   */
+  implies(optionValues: OptionValues): this;
+  /**
+   * Set environment variable to check for option value.
+   *
+   * An environment variables is only used if when processed the current option value is
+   * undefined, or the source of the current value is 'default' or 'config' or 'env'.
+   */
+  env(name: string): this;
+  /**
+   * Set the custom handler for processing CLI option arguments into option values.
+   */
+  argParser<T>(fn: (value: string, previous: T) => T): this;
+  /**
+   * Whether the option is mandatory and must have a value after parsing.
+   */
+  makeOptionMandatory(mandatory?: boolean): this;
+  /**
+   * Hide option in help.
+   */
+  hideHelp(hide?: boolean): this;
+  /**
+   * Only allow option value to be one of choices.
+   */
+  choices(values: readonly string[]): this;
+  /**
+   * Return option name.
+   */
+  name(): string;
+  /**
+   * Return option name, in a camelcase format that can be used
+   * as an object attribute key.
+   */
+  attributeName(): string;
+  /**
+   * Set the help group heading.
+   */
+  helpGroup(heading: string): this;
+  /**
+   * Return whether a boolean option.
+   *
+   * Options are one of boolean, negated, required argument, or optional argument.
+   */
+  isBoolean(): boolean;
+}
+declare class Help {
+  /** output helpWidth, long lines are wrapped to fit */
+  helpWidth?: number;
+  minWidthToWrap: number;
+  sortSubcommands: boolean;
+  sortOptions: boolean;
+  showGlobalOptions: boolean;
+  constructor();
+  /*
+   * prepareContext is called by Commander after applying overrides from `Command.configureHelp()`
+   * and just before calling `formatHelp()`.
+   *
+   * Commander just uses the helpWidth and the others are provided for subclasses.
+   */
+  prepareContext(contextOptions: {
+    error?: boolean;
+    helpWidth?: number;
+    outputHasColors?: boolean;
+  }): void;
+  /** Get the command term to show in the list of subcommands. */
+  subcommandTerm(cmd: Command): string;
+  /** Get the command summary to show in the list of subcommands. */
+  subcommandDescription(cmd: Command): string;
+  /** Get the option term to show in the list of options. */
+  optionTerm(option: Option): string;
+  /** Get the option description to show in the list of options. */
+  optionDescription(option: Option): string;
+  /** Get the argument term to show in the list of arguments. */
+  argumentTerm(argument: Argument): string;
+  /** Get the argument description to show in the list of arguments. */
+  argumentDescription(argument: Argument): string;
+  /** Get the command usage to be displayed at the top of the built-in help. */
+  commandUsage(cmd: Command): string;
+  /** Get the description for the command. */
+  commandDescription(cmd: Command): string;
+  /** Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one. */
+  visibleCommands(cmd: Command): Command[];
+  /** Get an array of the visible options. Includes a placeholder for the implicit help option, if there is one. */
+  visibleOptions(cmd: Command): Option[];
+  /** Get an array of the visible global options. (Not including help.) */
+  visibleGlobalOptions(cmd: Command): Option[];
+  /** Get an array of the arguments which have descriptions. */
+  visibleArguments(cmd: Command): Argument[];
+  /** Get the longest command term length. */
+  longestSubcommandTermLength(cmd: Command, helper: Help): number;
+  /** Get the longest option term length. */
+  longestOptionTermLength(cmd: Command, helper: Help): number;
+  /** Get the longest global option term length. */
+  longestGlobalOptionTermLength(cmd: Command, helper: Help): number;
+  /** Get the longest argument term length. */
+  longestArgumentTermLength(cmd: Command, helper: Help): number;
+  /** Return display width of string, ignoring ANSI escape sequences. Used in padding and wrapping calculations. */
+  displayWidth(str: string): number;
+  /** Style the titles. Called with 'Usage:', 'Options:', etc. */
+  styleTitle(title: string): string;
+  /** Usage: <str> */
+  styleUsage(str: string): string;
+  /** Style for command name in usage string.  */
+  styleCommandText(str: string): string;
+  styleCommandDescription(str: string): string;
+  styleOptionDescription(str: string): string;
+  styleSubcommandDescription(str: string): string;
+  styleArgumentDescription(str: string): string;
+  /** Base style used by descriptions. */
+  styleDescriptionText(str: string): string;
+  styleOptionTerm(str: string): string;
+  styleSubcommandTerm(str: string): string;
+  styleArgumentTerm(str: string): string;
+  /** Base style used in terms and usage for options. */
+  styleOptionText(str: string): string;
+  /** Base style used in terms and usage for subcommands. */
+  styleSubcommandText(str: string): string;
+  /** Base style used in terms and usage for arguments. */
+  styleArgumentText(str: string): string;
+  /** Calculate the pad width from the maximum term length. */
+  padWidth(cmd: Command, helper: Help): number;
+  /**
+   * Wrap a string at whitespace, preserving existing line breaks.
+   * Wrapping is skipped if the width is less than `minWidthToWrap`.
+   */
+  boxWrap(str: string, width: number): string;
+  /** Detect manually wrapped and indented strings by checking for line break followed by whitespace. */
+  preformatted(str: string): boolean;
+  /**
+   * Format the "item", which consists of a term and description. Pad the term and wrap the description, indenting the following lines.
+   *
+   * So "TTT", 5, "DDD DDDD DD DDD" might be formatted for this.helpWidth=17 like so:
+   *   TTT    DDD DDDD
+   *          DD DDD
+   */
+  formatItem(term: string, termWidth: number, description: string, helper: Help): string;
+  /**
+   * Format a list of items, given a heading and an array of formatted items.
+   */
+  formatItemList(heading: string, items: string[], helper: Help): string[];
+  /**
+   * Group items by their help group heading.
+   */
+  groupItems<T extends Command | Option>(unsortedItems: T[], visibleItems: T[], getGroup: (item: T) => string): Map<string, T[]>;
+  /** Generate the built-in help text. */
+  formatHelp(cmd: Command, helper: Help): string;
+}
+type HelpConfiguration = Partial<Help>;
+interface ParseOptions {
+  from: 'node' | 'electron' | 'user';
+}
+interface HelpContext {
+  // optional parameter for .help() and .outputHelp()
+  error: boolean;
+}
+interface AddHelpTextContext {
+  // passed to text function used with .addHelpText()
+  error: boolean;
+  command: Command;
+}
+interface OutputConfiguration {
+  writeOut?(str: string): void;
+  writeErr?(str: string): void;
+  outputError?(str: string, write: (str: string) => void): void;
+  getOutHelpWidth?(): number;
+  getErrHelpWidth?(): number;
+  getOutHasColors?(): boolean;
+  getErrHasColors?(): boolean;
+  stripColor?(str: string): string;
+}
+type AddHelpTextPosition = 'beforeAll' | 'before' | 'after' | 'afterAll';
+type HookEvent = 'preSubcommand' | 'preAction' | 'postAction';
+// The source is a string so author can define their own too.
+type OptionValueSource = LiteralUnion<'default' | 'config' | 'env' | 'cli' | 'implied', string> | undefined;
+type OptionValues = Record<string, any>;
+declare class Command {
+  args: string[];
+  processedArgs: any[];
+  readonly commands: readonly Command[];
+  readonly options: readonly Option[];
+  readonly registeredArguments: readonly Argument[];
+  parent: Command | null;
+  constructor(name?: string);
+  /**
+   * Set the program version to `str`.
+   *
+   * This method auto-registers the "-V, --version" flag
+   * which will print the version number when passed.
+   *
+   * You can optionally supply the  flags and description to override the defaults.
+   */
+  version(str: string, flags?: string, description?: string): this;
+  /**
+   * Get the program version.
+   */
+  version(): string | undefined;
+  /**
+   * Define a command, implemented using an action handler.
+   *
+   * @remarks
+   * The command description is supplied using `.description`, not as a parameter to `.command`.
+   *
+   * @example
+   * ```ts
+   * program
+   *   .command('clone <source> [destination]')
+   *   .description('clone a repository into a newly created directory')
+   *   .action((source, destination) => {
+   *     console.log('clone command called');
+   *   });
+   * ```
+   *
+   * @param nameAndArgs - command name and arguments, args are  `<required>` or `[optional]` and last may also be `variadic...`
+   * @param opts - configuration options
+   * @returns new command
+   */
+  command(nameAndArgs: string, opts?: CommandOptions): ReturnType<this['createCommand']>;
+  /**
+   * Define a command, implemented in a separate executable file.
+   *
+   * @remarks
+   * The command description is supplied as the second parameter to `.command`.
+   *
+   * @example
+   * ```ts
+   *  program
+   *    .command('start <service>', 'start named service')
+   *    .command('stop [service]', 'stop named service, or all if no name supplied');
+   * ```
+   *
+   * @param nameAndArgs - command name and arguments, args are  `<required>` or `[optional]` and last may also be `variadic...`
+   * @param description - description of executable command
+   * @param opts - configuration options
+   * @returns `this` command for chaining
+   */
+  command(nameAndArgs: string, description: string, opts?: ExecutableCommandOptions): this;
+  /**
+   * Factory routine to create a new unattached command.
+   *
+   * See .command() for creating an attached subcommand, which uses this routine to
+   * create the command. You can override createCommand to customise subcommands.
+   */
+  createCommand(name?: string): Command;
+  /**
+   * Add a prepared subcommand.
+   *
+   * See .command() for creating an attached subcommand which inherits settings from its parent.
+   *
+   * @returns `this` command for chaining
+   */
+  addCommand(cmd: Command, opts?: CommandOptions): this;
+  /**
+   * Factory routine to create a new unattached argument.
+   *
+   * See .argument() for creating an attached argument, which uses this routine to
+   * create the argument. You can override createArgument to return a custom argument.
+   */
+  createArgument(name: string, description?: string): Argument;
+  /**
+   * Define argument syntax for command.
+   *
+   * The default is that the argument is required, and you can explicitly
+   * indicate this with <> around the name. Put [] around the name for an optional argument.
+   *
+   * @example
+   * ```
+   * program.argument('<input-file>');
+   * program.argument('[output-file]');
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  argument<T>(flags: string, description: string, parseArg: (value: string, previous: T) => T, defaultValue?: T): this;
+  argument(name: string, description?: string, defaultValue?: unknown): this;
+  /**
+   * Define argument syntax for command, adding a prepared argument.
+   *
+   * @returns `this` command for chaining
+   */
+  addArgument(arg: Argument): this;
+  /**
+   * Define argument syntax for command, adding multiple at once (without descriptions).
+   *
+   * See also .argument().
+   *
+   * @example
+   * ```
+   * program.arguments('<cmd> [env]');
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  arguments(names: string): this;
+  /**
+   * Customise or override default help command. By default a help command is automatically added if your command has subcommands.
+   *
+   * @example
+   * ```ts
+   * program.helpCommand('help [cmd]');
+   * program.helpCommand('help [cmd]', 'show help');
+   * program.helpCommand(false); // suppress default help command
+   * program.helpCommand(true); // add help command even if no subcommands
+   * ```
+   */
+  helpCommand(nameAndArgs: string, description?: string): this;
+  helpCommand(enable: boolean): this;
+  /**
+   * Add prepared custom help command.
+   */
+  addHelpCommand(cmd: Command): this;
+  /** @deprecated since v12, instead use helpCommand */
+  addHelpCommand(nameAndArgs: string, description?: string): this;
+  /** @deprecated since v12, instead use helpCommand */
+  addHelpCommand(enable?: boolean): this;
+  /**
+   * Add hook for life cycle event.
+   */
+  hook(event: HookEvent, listener: (thisCommand: Command, actionCommand: Command) => void | Promise<void>): this;
+  /**
+   * Register callback to use as replacement for calling process.exit.
+   */
+  exitOverride(callback?: (err: CommanderError) => never | void): this;
+  /**
+   * Display error message and exit (or call exitOverride).
+   */
+  error(message: string, errorOptions?: ErrorOptions$1): never;
+  /**
+   * You can customise the help with a subclass of Help by overriding createHelp,
+   * or by overriding Help properties using configureHelp().
+   */
+  createHelp(): Help;
+  /**
+   * You can customise the help by overriding Help properties using configureHelp(),
+   * or with a subclass of Help by overriding createHelp().
+   */
+  configureHelp(configuration: HelpConfiguration): this;
+  /** Get configuration */
+  configureHelp(): HelpConfiguration;
+  /**
+   * The default output goes to stdout and stderr. You can customise this for special
+   * applications. You can also customise the display of errors by overriding outputError.
+   *
+   * The configuration properties are all functions:
+   * ```
+   * // functions to change where being written, stdout and stderr
+   * writeOut(str)
+   * writeErr(str)
+   * // matching functions to specify width for wrapping help
+   * getOutHelpWidth()
+   * getErrHelpWidth()
+   * // functions based on what is being written out
+   * outputError(str, write) // used for displaying errors, and not used for displaying help
+   * ```
+   */
+  configureOutput(configuration: OutputConfiguration): this;
+  /** Get configuration */
+  configureOutput(): OutputConfiguration;
+  /**
+   * Copy settings that are useful to have in common across root command and subcommands.
+   *
+   * (Used internally when adding a command using `.command()` so subcommands inherit parent settings.)
+   */
+  copyInheritedSettings(sourceCommand: Command): this;
+  /**
+   * Display the help or a custom message after an error occurs.
+   */
+  showHelpAfterError(displayHelp?: boolean | string): this;
+  /**
+   * Display suggestion of similar commands for unknown commands, or options for unknown options.
+   */
+  showSuggestionAfterError(displaySuggestion?: boolean): this;
+  /**
+   * Register callback `fn` for the command.
+   *
+   * @example
+   * ```
+   * program
+   *   .command('serve')
+   *   .description('start service')
+   *   .action(function() {
+   *     // do work here
+   *   });
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  action(fn: (this: this, ...args: any[]) => void | Promise<void>): this;
+  /**
+   * Define option with `flags`, `description`, and optional argument parsing function or `defaultValue` or both.
+   *
+   * The `flags` string contains the short and/or long flags, separated by comma, a pipe or space. A required
+   * option-argument is indicated by `<>` and an optional option-argument by `[]`.
+   *
+   * See the README for more details, and see also addOption() and requiredOption().
+   *
+   * @example
+   *
+   * ```js
+   * program
+   *     .option('-p, --pepper', 'add pepper')
+   *     .option('--pt, --pizza-type <TYPE>', 'type of pizza') // required option-argument
+   *     .option('-c, --cheese [CHEESE]', 'add extra cheese', 'mozzarella') // optional option-argument with default
+   *     .option('-t, --tip <VALUE>', 'add tip to purchase cost', parseFloat) // custom parse function
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  option(flags: string, description?: string, defaultValue?: string | boolean | string[]): this;
+  option<T>(flags: string, description: string, parseArg: (value: string, previous: T) => T, defaultValue?: T): this;
+  /** @deprecated since v7, instead use choices or a custom function */
+  option(flags: string, description: string, regexp: RegExp, defaultValue?: string | boolean | string[]): this;
+  /**
+   * Define a required option, which must have a value after parsing. This usually means
+   * the option must be specified on the command line. (Otherwise the same as .option().)
+   *
+   * The `flags` string contains the short and/or long flags, separated by comma, a pipe or space.
+   */
+  requiredOption(flags: string, description?: string, defaultValue?: string | boolean | string[]): this;
+  requiredOption<T>(flags: string, description: string, parseArg: (value: string, previous: T) => T, defaultValue?: T): this;
+  /** @deprecated since v7, instead use choices or a custom function */
+  requiredOption(flags: string, description: string, regexp: RegExp, defaultValue?: string | boolean | string[]): this;
+  /**
+   * Factory routine to create a new unattached option.
+   *
+   * See .option() for creating an attached option, which uses this routine to
+   * create the option. You can override createOption to return a custom option.
+   */
+  createOption(flags: string, description?: string): Option;
+  /**
+   * Add a prepared Option.
+   *
+   * See .option() and .requiredOption() for creating and attaching an option in a single call.
+   */
+  addOption(option: Option): this;
+  /**
+   * Whether to store option values as properties on command object,
+   * or store separately (specify false). In both cases the option values can be accessed using .opts().
+   *
+   * @returns `this` command for chaining
+   */
+  storeOptionsAsProperties<T extends OptionValues>(): this & T;
+  storeOptionsAsProperties<T extends OptionValues>(storeAsProperties: true): this & T;
+  storeOptionsAsProperties(storeAsProperties?: boolean): this;
+  /**
+   * Retrieve option value.
+   */
+  getOptionValue(key: string): any;
+  /**
+   * Store option value.
+   */
+  setOptionValue(key: string, value: unknown): this;
+  /**
+   * Store option value and where the value came from.
+   */
+  setOptionValueWithSource(key: string, value: unknown, source: OptionValueSource): this;
+  /**
+   * Get source of option value.
+   */
+  getOptionValueSource(key: string): OptionValueSource | undefined;
+  /**
+   * Get source of option value. See also .optsWithGlobals().
+   */
+  getOptionValueSourceWithGlobals(key: string): OptionValueSource | undefined;
+  /**
+   * Alter parsing of short flags with optional values.
+   *
+   * @example
+   * ```
+   * // for `.option('-f,--flag [value]'):
+   * .combineFlagAndOptionalValue(true)  // `-f80` is treated like `--flag=80`, this is the default behaviour
+   * .combineFlagAndOptionalValue(false) // `-fb` is treated like `-f -b`
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  combineFlagAndOptionalValue(combine?: boolean): this;
+  /**
+   * Allow unknown options on the command line.
+   *
+   * @returns `this` command for chaining
+   */
+  allowUnknownOption(allowUnknown?: boolean): this;
+  /**
+   * Allow excess command-arguments on the command line. Pass false to make excess arguments an error.
+   *
+   * @returns `this` command for chaining
+   */
+  allowExcessArguments(allowExcess?: boolean): this;
+  /**
+   * Enable positional options. Positional means global options are specified before subcommands which lets
+   * subcommands reuse the same option names, and also enables subcommands to turn on passThroughOptions.
+   *
+   * The default behaviour is non-positional and global options may appear anywhere on the command line.
+   *
+   * @returns `this` command for chaining
+   */
+  enablePositionalOptions(positional?: boolean): this;
+  /**
+   * Pass through options that come after command-arguments rather than treat them as command-options,
+   * so actual command-options come before command-arguments. Turning this on for a subcommand requires
+   * positional options to have been enabled on the program (parent commands).
+   *
+   * The default behaviour is non-positional and options may appear before or after command-arguments.
+   *
+   * @returns `this` command for chaining
+   */
+  passThroughOptions(passThrough?: boolean): this;
+  /**
+   * Parse `argv`, setting options and invoking commands when defined.
+   *
+   * Use parseAsync instead of parse if any of your action handlers are async.
+   *
+   * Call with no parameters to parse `process.argv`. Detects Electron and special node options like `node --eval`. Easy mode!
+   *
+   * Or call with an array of strings to parse, and optionally where the user arguments start by specifying where the arguments are `from`:
+   * - `'node'`: default, `argv[0]` is the application and `argv[1]` is the script being run, with user arguments after that
+   * - `'electron'`: `argv[0]` is the application and `argv[1]` varies depending on whether the electron application is packaged
+   * - `'user'`: just user arguments
+   *
+   * @example
+   * ```
+   * program.parse(); // parse process.argv and auto-detect electron and special node flags
+   * program.parse(process.argv); // assume argv[0] is app and argv[1] is script
+   * program.parse(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  parse(argv?: readonly string[], parseOptions?: ParseOptions): this;
+  /**
+   * Parse `argv`, setting options and invoking commands when defined.
+   *
+   * Call with no parameters to parse `process.argv`. Detects Electron and special node options like `node --eval`. Easy mode!
+   *
+   * Or call with an array of strings to parse, and optionally where the user arguments start by specifying where the arguments are `from`:
+   * - `'node'`: default, `argv[0]` is the application and `argv[1]` is the script being run, with user arguments after that
+   * - `'electron'`: `argv[0]` is the application and `argv[1]` varies depending on whether the electron application is packaged
+   * - `'user'`: just user arguments
+   *
+   * @example
+   * ```
+   * await program.parseAsync(); // parse process.argv and auto-detect electron and special node flags
+   * await program.parseAsync(process.argv); // assume argv[0] is app and argv[1] is script
+   * await program.parseAsync(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
+   * ```
+   *
+   * @returns Promise
+   */
+  parseAsync(argv?: readonly string[], parseOptions?: ParseOptions): Promise<this>;
+  /**
+   * Called the first time parse is called to save state and allow a restore before subsequent calls to parse.
+   * Not usually called directly, but available for subclasses to save their custom state.
+   *
+   * This is called in a lazy way. Only commands used in parsing chain will have state saved.
+   */
+  saveStateBeforeParse(): void;
+  /**
+   * Restore state before parse for calls after the first.
+   * Not usually called directly, but available for subclasses to save their custom state.
+   *
+   * This is called in a lazy way. Only commands used in parsing chain will have state restored.
+   */
+  restoreStateBeforeParse(): void;
+  /**
+   * Parse options from `argv` removing known options,
+   * and return argv split into operands and unknown arguments.
+   *
+   * Side effects: modifies command by storing options. Does not reset state if called again.
+   *
+   *     argv => operands, unknown
+   *     --known kkk op => [op], []
+   *     op --known kkk => [op], []
+   *     sub --unknown uuu op => [sub], [--unknown uuu op]
+   *     sub -- --unknown uuu op => [sub --unknown uuu op], []
+   */
+  parseOptions(argv: string[]): ParseOptionsResult;
+  /**
+   * Return an object containing local option values as key-value pairs
+   */
+  opts<T extends OptionValues>(): T;
+  /**
+   * Return an object containing merged local and global option values as key-value pairs.
+   */
+  optsWithGlobals<T extends OptionValues>(): T;
+  /**
+   * Set the description.
+   *
+   * @returns `this` command for chaining
+   */
+  description(str: string): this;
+  /** @deprecated since v8, instead use .argument to add command argument with description */
+  description(str: string, argsDescription: Record<string, string>): this;
+  /**
+   * Get the description.
+   */
+  description(): string;
+  /**
+   * Set the summary. Used when listed as subcommand of parent.
+   *
+   * @returns `this` command for chaining
+   */
+  summary(str: string): this;
+  /**
+   * Get the summary.
+   */
+  summary(): string;
+  /**
+   * Set an alias for the command.
+   *
+   * You may call more than once to add multiple aliases. Only the first alias is shown in the auto-generated help.
+   *
+   * @returns `this` command for chaining
+   */
+  alias(alias: string): this;
+  /**
+   * Get alias for the command.
+   */
+  alias(): string;
+  /**
+   * Set aliases for the command.
+   *
+   * Only the first alias is shown in the auto-generated help.
+   *
+   * @returns `this` command for chaining
+   */
+  aliases(aliases: readonly string[]): this;
+  /**
+   * Get aliases for the command.
+   */
+  aliases(): string[];
+  /**
+   * Set the command usage.
+   *
+   * @returns `this` command for chaining
+   */
+  usage(str: string): this;
+  /**
+   * Get the command usage.
+   */
+  usage(): string;
+  /**
+   * Set the name of the command.
+   *
+   * @returns `this` command for chaining
+   */
+  name(str: string): this;
+  /**
+   * Get the name of the command.
+   */
+  name(): string;
+  /**
+   * Set the name of the command from script filename, such as process.argv[1],
+   * or import.meta.filename.
+   *
+   * (Used internally and public although not documented in README.)
+   *
+   * @example
+   * ```ts
+   * program.nameFromFilename(import.meta.filename);
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  nameFromFilename(filename: string): this;
+  /**
+   * Set the directory for searching for executable subcommands of this command.
+   *
+   * @example
+   * ```ts
+   * program.executableDir(import.meta.dirname);
+   * // or
+   * program.executableDir('subcommands');
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  executableDir(path: string): this;
+  /**
+   * Get the executable search directory.
+   */
+  executableDir(): string | null;
+  /**
+   * Set the help group heading for this subcommand in parent command's help.
+   *
+   * @returns `this` command for chaining
+   */
+  helpGroup(heading: string): this;
+  /**
+   * Get the help group heading for this subcommand in parent command's help.
+   */
+  helpGroup(): string;
+  /**
+   * Set the default help group heading for subcommands added to this command.
+   * (This does not override a group set directly on the subcommand using .helpGroup().)
+   *
+   * @example
+   * program.commandsGroup('Development Commands:);
+   * program.command('watch')...
+   * program.command('lint')...
+   * ...
+   *
+   * @returns `this` command for chaining
+   */
+  commandsGroup(heading: string): this;
+  /**
+   * Get the default help group heading for subcommands added to this command.
+   */
+  commandsGroup(): string;
+  /**
+   * Set the default help group heading for options added to this command.
+   * (This does not override a group set directly on the option using .helpGroup().)
+   *
+   * @example
+   * program
+   *   .optionsGroup('Development Options:')
+   *   .option('-d, --debug', 'output extra debugging')
+   *   .option('-p, --profile', 'output profiling information')
+   *
+   * @returns `this` command for chaining
+   */
+  optionsGroup(heading: string): this;
+  /**
+   * Get the default help group heading for options added to this command.
+   */
+  optionsGroup(): string;
+  /**
+   * Output help information for this command.
+   *
+   * Outputs built-in help, and custom text added using `.addHelpText()`.
+   *
+   */
+  outputHelp(context?: HelpContext): void;
+  /** @deprecated since v7 */
+  outputHelp(cb: (str: string) => string): void;
+  /**
+   * Return command help documentation.
+   */
+  helpInformation(context?: HelpContext): string;
+  /**
+   * You can pass in flags and a description to override the help
+   * flags and help description for your command. Pass in false
+   * to disable the built-in help option.
+   */
+  helpOption(flags?: string | boolean, description?: string): this;
+  /**
+   * Supply your own option to use for the built-in help option.
+   * This is an alternative to using helpOption() to customise the flags and description etc.
+   */
+  addHelpOption(option: Option): this;
+  /**
+   * Output help information and exit.
+   *
+   * Outputs built-in help, and custom text added using `.addHelpText()`.
+   */
+  help(context?: HelpContext): never;
+  /** @deprecated since v7 */
+  help(cb: (str: string) => string): never;
+  /**
+   * Add additional text to be displayed with the built-in help.
+   *
+   * Position is 'before' or 'after' to affect just this command,
+   * and 'beforeAll' or 'afterAll' to affect this command and all its subcommands.
+   */
+  addHelpText(position: AddHelpTextPosition, text: string): this;
+  addHelpText(position: AddHelpTextPosition, text: (context: AddHelpTextContext) => string): this;
+  /**
+   * Add a listener (callback) for when events occur. (Implemented using EventEmitter.)
+   */
+  on(event: string | symbol, listener: (...args: any[]) => void): this;
+}
+interface CommandOptions {
+  hidden?: boolean;
+  isDefault?: boolean;
+  /** @deprecated since v7, replaced by hidden */
+  noHelp?: boolean;
+}
+interface ExecutableCommandOptions extends CommandOptions {
+  executableFile?: string;
+}
+interface ParseOptionsResult {
+  operands: string[];
+  unknown: string[];
+}
+//#endregion
+//#region src/cli/program.d.ts
+declare function createProgram(options?: {
+  json?: boolean;
+}): Command;
+//#endregion
+//#region src/core/agent/context.d.ts
+interface AgentApiClient extends Pick<OpenTagApi, "createAgent" | "listAgents" | "getAgent" | "getAgentConfig" | "updateAgent" | "suspendAgent" | "reactivateAgent" | "rebindAgentComputer" | "deleteAgent" | "listAccountComputers" | "me" | "getAgentImBinding" | "getAgentImBindingConfig" | "createFeishuSetupAttempt" | "getFeishuSetupAttempt" | "cancelFeishuSetupAttempt" | "getImBindingDiagnostics" | "disableImBinding"> {}
+interface AgentCommandDependencies {
+  accessToken?: string;
+  api?: AgentApiClient;
+  home?: string;
+}
+//#endregion
+//#region src/core/agent/mutations.d.ts
+interface AgentCreateOptions extends AgentCommandDependencies {
+  computerId?: string;
+  displayName: string;
+  instructions?: string;
+  instructionsFile?: string;
+  maxDurationMs?: number | string;
+  model?: string;
+  name: string;
+  reasoningEffort?: string;
+  runtimeProvider: string;
+}
+interface AgentCreateResult {
+  agent: AgentAdminConfig;
+  warning?: string;
+}
+interface AgentBindOptions extends AgentCommandDependencies {
+  computerId?: string;
+}
+interface AgentBindResult {
+  agent: AgentAdminConfig;
+  warning?: string;
+}
+interface AgentUpdateOptions extends AgentCommandDependencies {
+  clearMaxDuration?: boolean;
+  clearModel?: boolean;
+  clearReasoningEffort?: boolean;
+  displayName?: string;
+  instructions?: string;
+  instructionsFile?: string;
+  maxDurationMs?: number | string;
+  model?: string;
+  reasoningEffort?: string;
+}
+/**
+ * Resolves the Computer an Agent runs on. Having none to select is no longer a failure: an Agent can
+ * exist before a Computer does and be bound afterwards. An ambiguous choice still is, because
+ * guessing which machine the Account meant would silently place the Agent on the wrong one.
+ */
+declare function selectComputer(response: ListAccountComputersResponse, requestedComputerId?: string): AccountComputerSummary | undefined;
+declare function runAgentCreate(options: AgentCreateOptions): Promise<AgentCreateResult>;
+declare function runAgentBind(agentId: string, options: AgentBindOptions): Promise<AgentBindResult>;
+declare function runAgentUpdate(agentId: string, options: AgentUpdateOptions): Promise<AgentAdminConfig>;
+declare function runAgentDelete(agentId: string, options?: AgentCommandDependencies): Promise<string>;
+//#endregion
+//#region src/core/agent/formatting.d.ts
+declare function formatAgentCreated(result: AgentCreateResult): string;
+declare function formatAgentBound(result: AgentBindResult): string;
+declare function formatAgentList(response: ListAgentsResponse): string;
+declare function formatAgent(agent: AgentAdminConfig): string;
+//#endregion
+//#region src/core/agent/queries.d.ts
+type AgentListOptions = AgentCommandDependencies;
+declare function runAgentList(options?: AgentListOptions): Promise<ListAgentsResponse>;
+declare function runAgentShow(agentId: string, options?: AgentCommandDependencies): Promise<AgentAdminConfig>;
+//#endregion
+//#region src/core/auth/login.d.ts
+interface LoginOptions {
+  api?: Pick<OpenTagApi, "exchangeConnectCode">;
+  code: string;
+  home?: string;
+  now?: () => Date;
+  serverUrl: string;
+}
+interface LoginResult {
+  credentialsPath: string;
+  message: string;
+}
+declare function runLogin(options: LoginOptions): Promise<LoginResult>;
+//#endregion
+//#region src/core/channel/config.d.ts
+declare const channelConfig: ChannelConfig;
+//#endregion
+//#region src/core/command/context.d.ts
+type CommandContextAuthOptions = {
+  accessToken?: string;
+  api?: OpenTagApi;
+  requireAuth?: boolean;
+};
+type CommandContextLocationOptions = {
+  environment?: NodeJS.ProcessEnv;
+  home?: string;
+  serverUrl?: string;
+};
+type CommandContextOptions = CommandContextAuthOptions & CommandContextLocationOptions;
+type CommandContextIdentityAccess = {
+  readonly accessToken?: string;
+  readonly api?: OpenTagApi;
+};
+type CommandContextIdentity = CommandContextIdentityAccess & {
+  readonly credentials?: StoredCredentials;
+};
+type CommandContextLocation = {
+  readonly environment: NodeJS.ProcessEnv;
+  readonly home: string;
+};
+type CommandContext = CommandContextIdentity & CommandContextLocation;
+/** Resolve home, credentials, token, and API from one detached command context. */
+declare function resolveCommandContext(options?: CommandContextOptions): Promise<CommandContext>;
+//#endregion
+//#region src/core/command/environment.d.ts
+/** Build a detached child-process environment without changing the parent process. */
+declare function buildChildEnvironment(baseEnvironment: NodeJS.ProcessEnv, options?: {
+  keys?: readonly string[];
+  overrides?: NodeJS.ProcessEnv;
+}): NodeJS.ProcessEnv;
+//#endregion
+//#region src/core/computer/formatting.d.ts
+declare function formatComputerList(response: ListAccountComputersResponse): string;
+//#endregion
+//#region src/core/computer/queries.d.ts
+declare function listComputers(home?: string): Promise<ListAccountComputersResponse>;
+//#endregion
+//#region src/core/context-tree/state.d.ts
+interface ContextTreeState {
+  configPath: string;
+  target?: string;
+  /** `not-cloned` is a GitHub target the first Agent Session has yet to clone. */
+  tree: "unknown" | "valid" | "invalid" | "not-cloned";
+  detail?: string;
+}
+//#endregion
+//#region src/core/daemon/service/types.d.ts
+type DaemonServiceState = "active" | "inactive" | "not-installed" | "unknown";
+type DaemonServicePlatform = "launchd" | "systemd" | "unsupported";
+interface RuntimeOwnerInfo {
+  consistency: "consistent" | "malformed" | "missing" | "stale" | "unmanaged" | "unverified";
+  pid?: number;
+}
+interface DaemonServiceInfo {
+  configuredHome?: string;
+  currentHome: string;
+  definitionPath: string;
+  detail?: string;
+  drifted?: boolean;
+  logHint: string;
+  pid?: number;
+  platform: DaemonServicePlatform;
+  runtimeOwner?: RuntimeOwnerInfo;
+  serviceId: string;
+  state: DaemonServiceState;
+}
+//#endregion
+//#region src/core/diagnostics/doctor.d.ts
+type DoctorCheckStatus = "pass" | "fail" | "unknown" | "info" | "skipped";
+type DoctorCheckScope = "target" | "local-configuration" | "daemon-service" | "server" | "agent-runtime" | "provider-cli" | "context-tree";
+interface DoctorCheck {
+  code: string;
+  scope: DoctorCheckScope;
+  status: DoctorCheckStatus;
+  blocking: boolean;
+  label: string;
+  detail: string;
+  observedFrom?: string;
+  path?: string;
+  remediation?: string;
+  command?: string;
+}
+interface DoctorNextAction {
+  checkCode: string;
+  command: string;
+  reason: string;
+}
+interface DoctorTarget {
+  home: string;
+  homeSource: "environment" | "channel-default";
+  cliVersion: string;
+  channel: string;
+  platform: NodeJS.Platform;
+  arch: string;
+  nodeVersion: string;
+}
+interface DoctorReport {
+  target: DoctorTarget;
+  checks: DoctorCheck[];
+  nextActions: DoctorNextAction[];
+  providerCliSetup: "ready" | "needs_attention" | "unknown";
+  notEvaluated: readonly string[];
+  exitCode: 0 | 1;
+}
+interface DoctorResult extends DoctorReport {
+  message: string;
+}
+type HealthChecker = (serverUrl: string) => Promise<ServerHealth>;
+type LocalConfigurationInspector = (home: string) => Promise<LocalComputerConfigurationInspection>;
+type DaemonServiceInspector = (home: string) => Promise<DaemonServiceInfo>;
+type RuntimeDetector = (options: {
+  environment: NodeJS.ProcessEnv;
+  platform: NodeJS.Platform;
+}) => Promise<AgentRuntimeCliInstallation[]>;
+type IntegrationCliDetector = (options: {
+  environment: NodeJS.ProcessEnv;
+  platform: NodeJS.Platform;
+}) => Promise<IntegrationCliInstallation[]>;
+type ContextTreeInspector = (home: string) => Promise<ContextTreeState>;
+interface DoctorOptions {
+  env?: NodeJS.ProcessEnv;
+  platform?: NodeJS.Platform;
+  arch?: string;
+  nodeVersion?: string;
+  cliVersion?: string;
+  channel?: string;
+  healthChecker?: HealthChecker;
+  inspectLocalConfiguration?: LocalConfigurationInspector;
+  inspectDaemonService?: DaemonServiceInspector;
+  runtimeDetector?: RuntimeDetector;
+  integrationCliDetector?: IntegrationCliDetector;
+  inspectContextTreeState?: ContextTreeInspector;
+}
+declare function runDoctor(options?: DoctorOptions): Promise<DoctorResult>;
+//#endregion
+//#region src/core/provider-cli/shared.d.ts
+interface ProviderCliNextAction {
+  readonly provider: ProviderCliProvider | "all";
+  readonly command: string;
+  readonly reason: string;
+}
+interface ProviderCliCommandDeps {
+  /** OS account home override; tests inject an isolated account root. */
+  readonly accountHome?: string;
+  /** Invoking-process environment override (PATH authority for detection). */
+  readonly env?: NodeJS.ProcessEnv;
+  readonly platform?: NodeJS.Platform;
+  readonly arch?: string;
+  readonly catalog?: readonly ProviderCliCatalogEntry[];
+  readonly fetcher?: ProviderCliFetcher;
+  readonly execFile?: ProviderCliExecFile;
+  /** Test-only hook: runs inside the provider lock before the winner is persisted. */
+  readonly beforeWinnerReverify?: (winner: ProviderCliCandidate) => Promise<void>;
+  /** Test-only hook: replaces the cross-process lock retry wait. */
+  readonly sleep?: (ms: number) => Promise<void>;
+  readonly stdout?: (chunk: string) => void;
+  readonly stderr?: (chunk: string) => void;
+}
+//#endregion
+//#region src/core/provider-cli/ensure.d.ts
+/**
+ * Reusable orchestration for `opentag provider-cli ensure`.
+ *
+ * Human mode prints bounded single-line phase updates and never prompts, with or
+ * without a TTY. `--json` mode writes one common command envelope and suppresses phase lines.
+ */
+interface ProviderCliEnsureCommandOptions extends ProviderCliCommandDeps {
+  readonly provider: string;
+  /** Observe real foreground phases when a parent command owns final presentation. */
+  readonly onPhase?: (event: ProviderCliPhaseEvent) => void;
+  readonly managedOnly?: boolean;
+  /** `--no-path-update` passes false. */
+  readonly pathUpdate?: boolean;
+  readonly dryRun?: boolean;
+  readonly json?: boolean;
+}
+interface ProviderCliEnsureCommandResult {
+  readonly exitCode: CommandExitCode;
+  readonly results: readonly ProviderCliEnsureResult[];
+  readonly nextActions: readonly ProviderCliNextAction[];
+}
+declare function runProviderCliEnsure(options: ProviderCliEnsureCommandOptions): Promise<ProviderCliEnsureCommandResult>;
+//#endregion
+//#region src/core/provider-cli/inspect.d.ts
+/**
+ * Reusable orchestration for `opentag provider-cli inspect`: read-only diagnostics for
+ * the selected Provider CLI. `--json` emits one common command envelope.
+ */
+interface ProviderCliInspectCommandOptions extends ProviderCliCommandDeps {
+  readonly provider: string;
+  readonly json?: boolean;
+}
+interface ProviderCliInspectCommandResult {
+  readonly exitCode: CommandExitCode;
+  readonly results: readonly ProviderCliInspection[];
+  readonly nextActions: readonly ProviderCliNextAction[];
+}
+declare function runProviderCliInspect(options: ProviderCliInspectCommandOptions): Promise<ProviderCliInspectCommandResult>;
+//#endregion
+//#region src/core/session/index.d.ts
+interface SessionMessageOptions {
+  message?: string;
+  messageFile?: string;
+  messageId?: string;
+}
+declare function runSessionCreate(options: SessionMessageOptions & {
+  model?: string;
+  reasoningEffort?: string;
+  maxDurationMs?: number;
+}): Promise<SessionCliCommandResponse>;
+declare function runSessionSend(targetSessionId: string, options: SessionMessageOptions): Promise<SessionCliCommandResponse>;
+declare function runSessionList(options: {
+  recursive?: boolean;
+  limit?: number;
+  cursor?: string;
+  since?: string;
+}): Promise<SessionCliListResponse>;
+declare function formatSessionCommandResult(result: SessionCliCommandResponse): string;
+declare function formatSessionList(result: SessionCliListResponse): string;
+//#endregion
+//#region src/index.d.ts
+declare const CommandError: typeof CommandError$1;
+declare const commandExitCode: typeof commandExitCode$1;
+declare const EXIT_CODES: {
+  readonly success: 0;
+  readonly failure: 1;
+  readonly usage: 2;
+  readonly serviceUnavailable: 3;
+  readonly interrupted: 130;
+};
+declare const executeCommand: typeof executeCommand$1;
+declare const presentCommand: typeof presentCommand$1;
+declare const toCommandError: typeof toCommandError$1;
+//#endregion
+export { CHANNEL, CLI_PACKAGE_NAME, CLI_VERSION, CommandError, type CommandResult, type DoctorNextAction, type DoctorOptions, type DoctorResult, EXIT_CODES, type LoginOptions, type LoginResult, type ProviderCliEnsureCommandOptions, type ProviderCliEnsureCommandResult, type ProviderCliInspectCommandOptions, type ProviderCliInspectCommandResult, type ProviderCliNextAction, buildChildEnvironment, channelConfig, commandExitCode, createProgram, executeCommand, formatAgent, formatAgentBound, formatAgentCreated, formatAgentList, formatComputerList, formatSessionCommandResult, formatSessionList, listComputers, presentCommand, resolveCommandContext, runAgentBind, runAgentCreate, runAgentDelete, runAgentList, runAgentShow, runAgentUpdate, runDoctor, runLogin, runProviderCliEnsure, runProviderCliInspect, runSessionCreate, runSessionList, runSessionSend, selectComputer, toCommandError };
+//# sourceMappingURL=index.d.mts.map