@mastra/slack 1.5.1 → 1.6.0

package/dist/index.d.ts

@@ -1,192 +1,2229 @@
-import { Mastra } from '@mastra/core/mastra';
-import { ChannelAdapterConfig, StreamingConfig, ToolDisplay, StaticToolDisplay, ChannelHandlers, ChannelConfig, WaitUntilFn, WaitUntilResolver, ChannelProvider, ChannelConnectResult, ChannelInstallationInfo, ChannelPlatformInfo } from '@mastra/core/channels';
-import { ApiRoute } from '@mastra/core/server';
-import { SlackAdapterConfig, SlackAdapter } from '@chat-adapter/slack';
-export { SlackAdapter, createSlackAdapter } from '@chat-adapter/slack';
-import { z } from 'zod';
-import { ChannelsStorage } from '@mastra/core/storage';
-
+import { ChannelAdapterConfig, ChannelConfig, ChannelConnectResult, ChannelHandlers, ChannelInstallationInfo, ChannelPlatformInfo, ChannelProvider, StaticToolDisplay, StreamingConfig, ToolDisplay, WaitUntilFn, WaitUntilResolver } from "@mastra/core/channels";
+import { ChannelsStorage } from "@mastra/core/storage";
+import { SlackAdapter, SlackAdapter as SlackAdapter$1, SlackAdapterConfig, createSlackAdapter } from "@chat-adapter/slack";
+import { Mastra } from "@mastra/core/mastra";
+import { ApiRoute } from "@mastra/core/server";
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/zod/4.4.3/09b4e1f4024540142723f154808f0d43eb14b44b685c1085d435a20f90e89165/node_modules/zod/v4/core/json-schema.d.cts
+type _JSONSchema = boolean | JSONSchema;
+type JSONSchema = {
+  [k: string]: unknown;
+  $schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#" | "http://json-schema.org/draft-04/schema#";
+  $id?: string;
+  $anchor?: string;
+  $ref?: string;
+  $dynamicRef?: string;
+  $dynamicAnchor?: string;
+  $vocabulary?: Record<string, boolean>;
+  $comment?: string;
+  $defs?: Record<string, JSONSchema>;
+  type?: "object" | "array" | "string" | "number" | "boolean" | "null" | "integer";
+  additionalItems?: _JSONSchema;
+  unevaluatedItems?: _JSONSchema;
+  prefixItems?: _JSONSchema[];
+  items?: _JSONSchema | _JSONSchema[];
+  contains?: _JSONSchema;
+  additionalProperties?: _JSONSchema;
+  unevaluatedProperties?: _JSONSchema;
+  properties?: Record<string, _JSONSchema>;
+  patternProperties?: Record<string, _JSONSchema>;
+  dependentSchemas?: Record<string, _JSONSchema>;
+  propertyNames?: _JSONSchema;
+  if?: _JSONSchema;
+  then?: _JSONSchema;
+  else?: _JSONSchema;
+  allOf?: JSONSchema[];
+  anyOf?: JSONSchema[];
+  oneOf?: JSONSchema[];
+  not?: _JSONSchema;
+  multipleOf?: number;
+  maximum?: number;
+  exclusiveMaximum?: number | boolean;
+  minimum?: number;
+  exclusiveMinimum?: number | boolean;
+  maxLength?: number;
+  minLength?: number;
+  pattern?: string;
+  maxItems?: number;
+  minItems?: number;
+  uniqueItems?: boolean;
+  maxContains?: number;
+  minContains?: number;
+  maxProperties?: number;
+  minProperties?: number;
+  required?: string[];
+  dependentRequired?: Record<string, string[]>;
+  enum?: Array<string | number | boolean | null>;
+  const?: string | number | boolean | null;
+  id?: string;
+  title?: string;
+  description?: string;
+  default?: unknown;
+  deprecated?: boolean;
+  readOnly?: boolean;
+  writeOnly?: boolean;
+  nullable?: boolean;
+  examples?: unknown[];
+  format?: string;
+  contentMediaType?: string;
+  contentEncoding?: string;
+  contentSchema?: JSONSchema;
+  _prefault?: unknown;
+};
+type BaseSchema = JSONSchema;
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/zod/4.4.3/09b4e1f4024540142723f154808f0d43eb14b44b685c1085d435a20f90e89165/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 ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/zod/4.4.3/09b4e1f4024540142723f154808f0d43eb14b44b685c1085d435a20f90e89165/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 ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/zod/4.4.3/09b4e1f4024540142723f154808f0d43eb14b44b685c1085d435a20f90e89165/node_modules/zod/v4/core/to-json-schema.d.cts
+type Processor<T extends $ZodType = $ZodType> = (schema: T, ctx: ToJSONSchemaContext, json: BaseSchema, params: ProcessParams) => void;
+interface JSONSchemaGeneratorParams {
+  processors: Record<string, Processor>;
+  /** A registry used to look up metadata for each schema. Any schema with an `id` property will be extracted as a $def.
+   *  @default globalRegistry */
+  metadata?: $ZodRegistry<Record<string, any>>;
+  /** The JSON Schema version to target.
+   * - `"draft-2020-12"` — Default. JSON Schema Draft 2020-12
+   * - `"draft-07"` — JSON Schema Draft 7
+   * - `"draft-04"` — JSON Schema Draft 4
+   * - `"openapi-3.0"` — OpenAPI 3.0 Schema Object */
+  target?: "draft-04" | "draft-07" | "draft-2020-12" | "openapi-3.0" | ({} & string) | undefined;
+  /** How to handle unrepresentable types.
+   * - `"throw"` — Default. Unrepresentable types throw an error
+   * - `"any"` — Unrepresentable types become `{}` */
+  unrepresentable?: "throw" | "any";
+  /** Arbitrary custom logic that can be used to modify the generated JSON Schema. */
+  override?: (ctx: {
+    zodSchema: $ZodTypes;
+    jsonSchema: BaseSchema;
+    path: (string | number)[];
+  }) => void;
+  /** Whether to extract the `"input"` or `"output"` type. Relevant to transforms, defaults, coerced primitives, etc.
+   * - `"output"` — Default. Convert the output schema.
+   * - `"input"` — Convert the input schema. */
+  io?: "input" | "output";
+  cycles?: "ref" | "throw";
+  reused?: "ref" | "inline";
+  external?: {
+    registry: $ZodRegistry<{
+      id?: string | undefined;
+    }>;
+    uri?: ((id: string) => string) | undefined;
+    defs: Record<string, BaseSchema>;
+  } | undefined;
+}
+/**
+ * Parameters for the toJSONSchema function.
+ */
+type ToJSONSchemaParams = Omit<JSONSchemaGeneratorParams, "processors" | "external">;
+interface ProcessParams {
+  schemaPath: $ZodType[];
+  path: (string | number)[];
+}
+interface Seen {
+  /** JSON Schema result for this Zod schema */
+  schema: BaseSchema;
+  /** A cached version of the schema that doesn't get overwritten during ref resolution */
+  def?: BaseSchema;
+  defId?: string | undefined;
+  /** Number of times this schema was encountered during traversal */
+  count: number;
+  /** Cycle path */
+  cycle?: (string | number)[] | undefined;
+  isParent?: boolean | undefined;
+  /** Schema to inherit JSON Schema properties from (set by processor for wrappers) */
+  ref?: $ZodType | null;
+  /** JSON Schema property path for this schema */
+  path?: (string | number)[] | undefined;
+}
+interface ToJSONSchemaContext {
+  processors: Record<string, Processor>;
+  metadataRegistry: $ZodRegistry<Record<string, any>>;
+  target: "draft-04" | "draft-07" | "draft-2020-12" | "openapi-3.0" | ({} & string);
+  unrepresentable: "throw" | "any";
+  override: (ctx: {
+    zodSchema: $ZodType;
+    jsonSchema: BaseSchema;
+    path: (string | number)[];
+  }) => void;
+  io: "input" | "output";
+  counter: number;
+  seen: Map<$ZodType, Seen>;
+  cycles: "ref" | "throw";
+  reused: "ref" | "inline";
+  external?: {
+    registry: $ZodRegistry<{
+      id?: string | undefined;
+    }>;
+    uri?: ((id: string) => string) | undefined;
+    defs: Record<string, BaseSchema>;
+  } | undefined;
+}
+type ZodStandardSchemaWithJSON$1<T> = StandardSchemaWithJSONProps<input<T>, output<T>>;
+interface ZodStandardJSONSchemaPayload<T> extends BaseSchema {
+  "~standard": ZodStandardSchemaWithJSON$1<T>;
+}
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/zod/4.4.3/09b4e1f4024540142723f154808f0d43eb14b44b685c1085d435a20f90e89165/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 PropValues = Record<string, Set<Primitive>>;
+type PrimitiveSet = Set<Primitive>;
+type EmptyToNever<T> = keyof T extends never ? never : T;
+declare abstract class Class {
+  constructor(..._args: any[]);
+}
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/zod/4.4.3/09b4e1f4024540142723f154808f0d43eb14b44b685c1085d435a20f90e89165/node_modules/zod/v4/core/versions.d.cts
+declare const version: {
+  readonly major: 4;
+  readonly minor: 4;
+  readonly patch: number;
+};
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/zod/4.4.3/09b4e1f4024540142723f154808f0d43eb14b44b685c1085d435a20f90e89165/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 Marks a value as a fallback that an outer wrapper (e.g.
+   * $ZodOptional) may override with its own interpretation when input was
+   * undefined. Set by $ZodCatch when catchValue substitutes and by every
+   * $ZodTransform invocation. */
+  fallback?: 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 */
+  optin?: "optional" | undefined;
+  /** @internal */
+  optout?: "optional" | undefined;
+  /** @internal The set of literal values that will pass validation. Must be an exhaustive set. Used to determine optionality in z.record().
+   *
+   * Defined on: enum, const, literal, null, undefined
+   * Passthrough: optional, nullable, branded, default, catch, pipe
+   * Todo: unions?
+   */
+  values?: PrimitiveSet | undefined;
+  /** Default value bubbled up from  */
+  /** @internal A set of literal discriminators used for the fast path in discriminated unions. */
+  propValues?: PropValues | undefined;
+  /** @internal This flag indicates that a schema validation can be represented with a regular expression. Used to determine allowable schemas in z.templateLiteral(). */
+  pattern: RegExp | undefined;
+  /** @internal The constructor function of this schema. */
+  constr: new (def: any) => $ZodType;
+  /** @internal A catchall object for bag metadata related to this schema. Commonly modified by checks using `onattach`. */
+  bag: Record<string, unknown>;
+  /** @internal The set of issues this schema might throw during type checking. */
+  isst: $ZodIssueBase;
+  /** @internal Subject to change, not a public API. */
+  processJSONSchema?: ((ctx: ToJSONSchemaContext, json: BaseSchema, params: ProcessParams) => void) | undefined;
+  /** An optional method used to override `toJSONSchema` logic. */
+  toJSONSchema?: () => unknown;
+  /** @internal The parent of this schema. Only set during certain clone operations. */
+  parent?: $ZodType | undefined;
+}
+/** @internal */
+interface $ZodTypeInternals<out O = unknown, out I = unknown> extends _$ZodTypeInternals {
+  /** @internal The inferred output type */
+  output: O;
+  /** @internal The inferred input type */
+  input: I;
+}
+type $ZodStandardSchema<T> = StandardSchemaV1.Props<input<T>, output<T>>;
+type SomeType = {
+  _zod: _$ZodTypeInternals;
+};
+interface $ZodType<O = unknown, I = unknown, Internals extends $ZodTypeInternals<O, I> = $ZodTypeInternals<O, I>> {
+  _zod: Internals;
+  "~standard": $ZodStandardSchema<this>;
+}
+interface _$ZodType<T extends $ZodTypeInternals = $ZodTypeInternals> extends $ZodType<T["output"], T["input"], T> {}
+declare const $ZodType: $constructor<$ZodType>;
+interface $ZodStringDef extends $ZodTypeDef {
+  type: "string";
+  coerce?: boolean;
+  checks?: $ZodCheck<string>[];
+}
+interface $ZodStringInternals<Input> extends $ZodTypeInternals<string, Input> {
+  def: $ZodStringDef;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  pattern: RegExp;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  isst: $ZodIssueInvalidType;
+  bag: LoosePartial<{
+    minimum: number;
+    maximum: number;
+    patterns: Set<RegExp>;
+    format: string;
+    contentEncoding: string;
+  }>;
+}
+interface $ZodString<Input = unknown> extends _$ZodType<$ZodStringInternals<Input>> {}
+declare const $ZodString: $constructor<$ZodString>;
+interface $ZodStringFormatDef<Format extends string = string> extends $ZodStringDef, $ZodCheckStringFormatDef<Format> {}
+interface $ZodStringFormatInternals<Format extends string = string> extends $ZodStringInternals<string>, $ZodCheckStringFormatInternals {
+  def: $ZodStringFormatDef<Format>;
+}
+interface $ZodStringFormat<Format extends string = string> extends $ZodType {
+  _zod: $ZodStringFormatInternals<Format>;
+}
+declare const $ZodStringFormat: $constructor<$ZodStringFormat>;
+interface $ZodGUIDInternals extends $ZodStringFormatInternals<"guid"> {}
+interface $ZodGUID extends $ZodType {
+  _zod: $ZodGUIDInternals;
+}
+declare const $ZodGUID: $constructor<$ZodGUID>;
+interface $ZodUUIDDef extends $ZodStringFormatDef<"uuid"> {
+  version?: "v1" | "v2" | "v3" | "v4" | "v5" | "v6" | "v7" | "v8";
+}
+interface $ZodUUIDInternals extends $ZodStringFormatInternals<"uuid"> {
+  def: $ZodUUIDDef;
+}
+interface $ZodUUID extends $ZodType {
+  _zod: $ZodUUIDInternals;
+}
+declare const $ZodUUID: $constructor<$ZodUUID>;
+interface $ZodEmailInternals extends $ZodStringFormatInternals<"email"> {}
+interface $ZodEmail extends $ZodType {
+  _zod: $ZodEmailInternals;
+}
+declare const $ZodEmail: $constructor<$ZodEmail>;
+interface $ZodURLDef extends $ZodStringFormatDef<"url"> {
+  hostname?: RegExp | undefined;
+  protocol?: RegExp | undefined;
+  normalize?: boolean | undefined;
+}
+interface $ZodURLInternals extends $ZodStringFormatInternals<"url"> {
+  def: $ZodURLDef;
+}
+interface $ZodURL extends $ZodType {
+  _zod: $ZodURLInternals;
+}
+declare const $ZodURL: $constructor<$ZodURL>;
+interface $ZodEmojiInternals extends $ZodStringFormatInternals<"emoji"> {}
+interface $ZodEmoji extends $ZodType {
+  _zod: $ZodEmojiInternals;
+}
+declare const $ZodEmoji: $constructor<$ZodEmoji>;
+interface $ZodNanoIDInternals extends $ZodStringFormatInternals<"nanoid"> {}
+interface $ZodNanoID extends $ZodType {
+  _zod: $ZodNanoIDInternals;
+}
+declare const $ZodNanoID: $constructor<$ZodNanoID>;
+/**
+ * @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";
+  };
+};
+type $InferObjectOutput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? IsAny<T[keyof T]> extends true ? Record<string, unknown> : Record<string, output<T[keyof T]>> : keyof (T & Extra) extends never ? Record<string, never> : Prettify<{ -readonly [k in keyof T as T[k] extends OptionalOutSchema ? never : k]: T[k]["_zod"]["output"]; } & { -readonly [k in keyof T as T[k] extends OptionalOutSchema ? k : never]?: T[k]["_zod"]["output"]; } & Extra>;
+type $InferObjectInput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? IsAny<T[keyof T]> extends true ? Record<string, unknown> : Record<string, input<T[keyof T]>> : keyof (T & Extra) extends never ? Record<string, never> : Prettify<{ -readonly [k in keyof T as T[k] extends OptionalInSchema ? never : k]: T[k]["_zod"]["input"]; } & { -readonly [k in keyof T as T[k] extends OptionalInSchema ? k : never]?: T[k]["_zod"]["input"]; } & Extra>;
+type $ZodObjectConfig = {
+  out: Record<string, unknown>;
+  in: Record<string, unknown>;
+};
+type $loose = {
+  out: Record<string, unknown>;
+  in: Record<string, unknown>;
+};
+type $strict = {
+  out: {};
+  in: {};
+};
+type $strip = {
+  out: {};
+  in: {};
+};
+type $catchall<T extends SomeType> = {
+  out: {
+    [k: string]: output<T>;
+  };
+  in: {
+    [k: string]: input<T>;
+  };
+};
+type $ZodShape = Readonly<{
+  [k: string]: $ZodType;
+}>;
+interface $ZodObjectDef<Shape extends $ZodShape = $ZodShape> extends $ZodTypeDef {
+  type: "object";
+  shape: Shape;
+  catchall?: $ZodType | undefined;
+}
+interface $ZodObjectInternals<
+/** @ts-ignore Cast variance */
+out Shape extends $ZodShape = $ZodShape, out Config extends $ZodObjectConfig = $ZodObjectConfig> extends _$ZodTypeInternals {
+  def: $ZodObjectDef<Shape>;
+  config: Config;
+  isst: $ZodIssueInvalidType | $ZodIssueUnrecognizedKeys;
+  propValues: PropValues;
+  output: $InferObjectOutput<Shape, Config["out"]>;
+  input: $InferObjectInput<Shape, Config["in"]>;
+  optin?: "optional" | undefined;
+  optout?: "optional" | undefined;
+}
+type $ZodLooseShape = Record<string, any>;
+interface $ZodObject<
+/** @ts-ignore Cast variance */
+out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Params extends $ZodObjectConfig = $ZodObjectConfig> extends $ZodType<any, any, $ZodObjectInternals<Shape, Params>> {}
+declare const $ZodObject: $constructor<$ZodObject>;
+type $InferUnionOutput<T extends SomeType> = T extends any ? output<T> : never;
+type $InferUnionInput<T extends SomeType> = T extends any ? input<T> : never;
+interface $ZodUnionDef<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodTypeDef {
+  type: "union";
+  options: Options;
+  inclusive?: boolean;
+}
+type IsOptionalIn<T extends SomeType> = T extends OptionalInSchema ? true : false;
+type IsOptionalOut<T extends SomeType> = T extends OptionalOutSchema ? true : false;
+interface $ZodUnionInternals<T extends readonly SomeType[] = readonly $ZodType[]> extends _$ZodTypeInternals {
+  def: $ZodUnionDef<T>;
+  isst: $ZodIssueInvalidUnion;
+  pattern: T[number]["_zod"]["pattern"];
+  values: T[number]["_zod"]["values"];
+  output: $InferUnionOutput<T[number]>;
+  input: $InferUnionInput<T[number]>;
+  optin: IsOptionalIn<T[number]> extends false ? "optional" | undefined : "optional";
+  optout: IsOptionalOut<T[number]> extends false ? "optional" | undefined : "optional";
+}
+interface $ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType<any, any, $ZodUnionInternals<T>> {
+  _zod: $ZodUnionInternals<T>;
+}
+declare const $ZodUnion: $constructor<$ZodUnion>;
+interface $ZodIntersectionDef<Left extends SomeType = $ZodType, Right extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "intersection";
+  left: Left;
+  right: Right;
+}
+interface $ZodIntersectionInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _$ZodTypeInternals {
+  def: $ZodIntersectionDef<A, B>;
+  isst: never;
+  optin: A["_zod"]["optin"] | B["_zod"]["optin"];
+  optout: A["_zod"]["optout"] | B["_zod"]["optout"];
+  output: output<A> & output<B>;
+  input: input<A> & input<B>;
+}
+interface $ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodIntersectionInternals<A, B>;
+}
+declare const $ZodIntersection: $constructor<$ZodIntersection>;
+interface $ZodTupleDef<T extends TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends $ZodTypeDef {
+  type: "tuple";
+  items: T;
+  rest: Rest;
+}
+type $InferTupleInputType<T extends TupleItems, Rest extends SomeType | null> = [...TupleInputTypeWithOptionals<T>, ...(Rest extends SomeType ? input<Rest>[] : [])];
+type TupleInputTypeNoOptionals<T extends TupleItems> = { [k in keyof T]: input<T[k]>; };
+type TupleInputTypeWithOptionals<T extends TupleItems> = T extends readonly [...infer Prefix extends SomeType[], infer Tail extends SomeType] ? Tail["_zod"]["optin"] extends "optional" ? [...TupleInputTypeWithOptionals<Prefix>, input<Tail>?] : TupleInputTypeNoOptionals<T> : [];
+type $InferTupleOutputType<T extends TupleItems, Rest extends SomeType | null> = [...TupleOutputTypeWithOptionals<T>, ...(Rest extends SomeType ? output<Rest>[] : [])];
+type TupleOutputTypeNoOptionals<T extends TupleItems> = { [k in keyof T]: output<T[k]>; };
+type TupleOutputTypeWithOptionals<T extends TupleItems> = T extends readonly [...infer Prefix extends SomeType[], infer Tail extends SomeType] ? Tail["_zod"]["optout"] extends "optional" ? [...TupleOutputTypeWithOptionals<Prefix>, output<Tail>?] : TupleOutputTypeNoOptionals<T> : [];
+interface $ZodTupleInternals<T extends TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends _$ZodTypeInternals {
+  def: $ZodTupleDef<T, Rest>;
+  isst: $ZodIssueInvalidType | $ZodIssueTooBig<unknown[]> | $ZodIssueTooSmall<unknown[]>;
+  output: $InferTupleOutputType<T, Rest>;
+  input: $InferTupleInputType<T, Rest>;
+}
+interface $ZodTuple<T extends TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends $ZodType {
+  _zod: $ZodTupleInternals<T, Rest>;
+}
+declare const $ZodTuple: $constructor<$ZodTuple>;
+type $ZodRecordKey = $ZodType<string | number | symbol, unknown>;
+interface $ZodRecordDef<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "record";
+  keyType: Key;
+  valueType: Value;
+  /** @default "strict" - errors on keys not matching keyType. "loose" passes through non-matching keys unchanged. */
+  mode?: "strict" | "loose";
+}
+type $InferZodRecordOutput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<output<Key>, output<Value>>> : Record<output<Key>, output<Value>>;
+type $InferZodRecordInput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<input<Key> & PropertyKey, input<Value>>> : Record<input<Key> & PropertyKey, input<Value>>;
+interface $ZodRecordInternals<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeInternals<$InferZodRecordOutput<Key, Value>, $InferZodRecordInput<Key, Value>> {
+  def: $ZodRecordDef<Key, Value>;
+  isst: $ZodIssueInvalidType | $ZodIssueInvalidKey<Record<PropertyKey, unknown>>;
+  optin?: "optional" | undefined;
+  optout?: "optional" | undefined;
+}
+type $partial = {
+  "~~partial": true;
+};
+interface $ZodRecord<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodRecordInternals<Key, Value>;
+}
+declare const $ZodRecord: $constructor<$ZodRecord>;
+interface $ZodMapDef<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "map";
+  keyType: Key;
+  valueType: Value;
+}
+interface $ZodMapInternals<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodTypeInternals<Map<output<Key>, output<Value>>, Map<input<Key>, input<Value>>> {
+  def: $ZodMapDef<Key, Value>;
+  isst: $ZodIssueInvalidType | $ZodIssueInvalidKey | $ZodIssueInvalidElement<unknown>;
+  optin?: "optional" | undefined;
+  optout?: "optional" | undefined;
+}
+interface $ZodMap<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodMapInternals<Key, Value>;
+}
+declare const $ZodMap: $constructor<$ZodMap>;
+interface $ZodSetDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "set";
+  valueType: T;
+}
+interface $ZodSetInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<Set<output<T>>, Set<input<T>>> {
+  def: $ZodSetDef<T>;
+  isst: $ZodIssueInvalidType;
+  optin?: "optional" | undefined;
+  optout?: "optional" | undefined;
+}
+interface $ZodSet<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodSetInternals<T>;
+}
+declare const $ZodSet: $constructor<$ZodSet>;
+type $InferEnumOutput<T extends EnumLike> = T[keyof T] & {};
+type $InferEnumInput<T extends EnumLike> = T[keyof T] & {};
+interface $ZodEnumDef<T extends EnumLike = EnumLike> extends $ZodTypeDef {
+  type: "enum";
+  entries: T;
+}
+interface $ZodEnumInternals<
+/** @ts-ignore Cast variance */
+out T extends EnumLike = EnumLike> extends $ZodTypeInternals<$InferEnumOutput<T>, $InferEnumInput<T>> {
+  def: $ZodEnumDef<T>;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  values: PrimitiveSet;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  pattern: RegExp;
+  isst: $ZodIssueInvalidValue;
+}
+interface $ZodEnum<T extends EnumLike = EnumLike> extends $ZodType {
+  _zod: $ZodEnumInternals<T>;
+}
+declare const $ZodEnum: $constructor<$ZodEnum>;
+interface $ZodLiteralDef<T extends Literal> extends $ZodTypeDef {
+  type: "literal";
+  values: T[];
+}
+interface $ZodLiteralInternals<T extends Literal = Literal> extends $ZodTypeInternals<T, T> {
+  def: $ZodLiteralDef<T>;
+  values: Set<T>;
+  pattern: RegExp;
+  isst: $ZodIssueInvalidValue;
+}
+interface $ZodLiteral<T extends Literal = Literal> extends $ZodType {
+  _zod: $ZodLiteralInternals<T>;
+}
+declare const $ZodLiteral: $constructor<$ZodLiteral>;
+/** Do not reference this directly. */
+interface File extends _File {
+  readonly type: string;
+  readonly size: number;
+}
+interface $ZodFileDef extends $ZodTypeDef {
+  type: "file";
+}
+interface $ZodFileInternals extends $ZodTypeInternals<File, File> {
+  def: $ZodFileDef;
+  isst: $ZodIssueInvalidType;
+  bag: LoosePartial<{
+    minimum: number;
+    maximum: number;
+    mime: MimeTypes[];
+  }>;
+}
+interface $ZodFile extends $ZodType {
+  _zod: $ZodFileInternals;
+}
+declare const $ZodFile: $constructor<$ZodFile>;
+interface $ZodTransformDef extends $ZodTypeDef {
+  type: "transform";
+  transform: (input: unknown, payload: ParsePayload<unknown>) => MaybeAsync<unknown>;
+}
+interface $ZodTransformInternals<O = unknown, I = unknown> extends $ZodTypeInternals<O, I> {
+  def: $ZodTransformDef;
+  isst: never;
+}
+interface $ZodTransform<O = unknown, I = unknown> extends $ZodType {
+  _zod: $ZodTransformInternals<O, I>;
+}
+declare const $ZodTransform: $constructor<$ZodTransform>;
+interface $ZodOptionalDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "optional";
+  innerType: T;
+}
+interface $ZodOptionalInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T> | undefined, input<T> | undefined> {
+  def: $ZodOptionalDef<T>;
+  optin: "optional";
+  optout: "optional";
+  isst: never;
+  values: T["_zod"]["values"];
+  pattern: T["_zod"]["pattern"];
+}
+interface $ZodOptional<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodOptionalInternals<T>;
+}
+declare const $ZodOptional: $constructor<$ZodOptional>;
+interface $ZodExactOptionalDef<T extends SomeType = $ZodType> extends $ZodOptionalDef<T> {}
+interface $ZodExactOptionalInternals<T extends SomeType = $ZodType> extends $ZodOptionalInternals<T> {
+  def: $ZodExactOptionalDef<T>;
+  output: output<T>;
+  input: input<T>;
+}
+interface $ZodExactOptional<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodExactOptionalInternals<T>;
+}
+declare const $ZodExactOptional: $constructor<$ZodExactOptional>;
+interface $ZodNullableDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "nullable";
+  innerType: T;
+}
+interface $ZodNullableInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T> | null, input<T> | null> {
+  def: $ZodNullableDef<T>;
+  optin: T["_zod"]["optin"];
+  optout: T["_zod"]["optout"];
+  isst: never;
+  values: T["_zod"]["values"];
+  pattern: T["_zod"]["pattern"];
+}
+interface $ZodNullable<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodNullableInternals<T>;
+}
+declare const $ZodNullable: $constructor<$ZodNullable>;
+interface $ZodDefaultDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "default";
+  innerType: T;
+  /** The default value. May be a getter. */
+  defaultValue: NoUndefined<output<T>>;
+}
+interface $ZodDefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T>>, input<T> | undefined> {
+  def: $ZodDefaultDef<T>;
+  optin: "optional";
+  optout?: "optional" | undefined;
+  isst: never;
+  values: T["_zod"]["values"];
+}
+interface $ZodDefault<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodDefaultInternals<T>;
+}
+declare const $ZodDefault: $constructor<$ZodDefault>;
+interface $ZodPrefaultDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "prefault";
+  innerType: T;
+  /** The default value. May be a getter. */
+  defaultValue: input<T>;
+}
+interface $ZodPrefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T>>, input<T> | undefined> {
+  def: $ZodPrefaultDef<T>;
+  optin: "optional";
+  optout?: "optional" | undefined;
+  isst: never;
+  values: T["_zod"]["values"];
+}
+interface $ZodPrefault<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodPrefaultInternals<T>;
+}
+declare const $ZodPrefault: $constructor<$ZodPrefault>;
+interface $ZodNonOptionalDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "nonoptional";
+  innerType: T;
+}
+interface $ZodNonOptionalInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T>>, NoUndefined<input<T>>> {
+  def: $ZodNonOptionalDef<T>;
+  isst: $ZodIssueInvalidType;
+  values: T["_zod"]["values"];
+  optin: "optional" | undefined;
+  optout: "optional" | undefined;
+}
+interface $ZodNonOptional<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodNonOptionalInternals<T>;
+}
+declare const $ZodNonOptional: $constructor<$ZodNonOptional>;
+interface $ZodSuccessDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "success";
+  innerType: T;
+}
+interface $ZodSuccessInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<boolean, input<T>> {
+  def: $ZodSuccessDef<T>;
+  isst: never;
+  optin: T["_zod"]["optin"];
+  optout: "optional" | undefined;
+}
+interface $ZodSuccess<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodSuccessInternals<T>;
+}
+declare const $ZodSuccess: $constructor<$ZodSuccess>;
+interface $ZodCatchCtx extends ParsePayload {
+  /** @deprecated Use `ctx.issues` */
+  error: {
+    issues: $ZodIssue[];
+  };
+  /** @deprecated Use `ctx.value` */
+  input: unknown;
+}
+interface $ZodCatchDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "catch";
+  innerType: T;
+  catchValue: (ctx: $ZodCatchCtx) => unknown;
+}
+interface $ZodCatchInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T>, input<T>> {
+  def: $ZodCatchDef<T>;
+  optin: T["_zod"]["optin"];
+  optout: T["_zod"]["optout"];
+  isst: never;
+  values: T["_zod"]["values"];
+}
+interface $ZodCatch<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodCatchInternals<T>;
+}
+declare const $ZodCatch: $constructor<$ZodCatch>;
+interface $ZodNaNDef extends $ZodTypeDef {
+  type: "nan";
+}
+interface $ZodNaNInternals extends $ZodTypeInternals<number, number> {
+  def: $ZodNaNDef;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodNaN extends $ZodType {
+  _zod: $ZodNaNInternals;
+}
+declare const $ZodNaN: $constructor<$ZodNaN>;
+interface $ZodPipeDef<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "pipe";
+  in: A;
+  out: B;
+  /** Only defined inside $ZodCodec instances. */
+  transform?: (value: output<A>, payload: ParsePayload<output<A>>) => MaybeAsync<input<B>>;
+  /** Only defined inside $ZodCodec instances. */
+  reverseTransform?: (value: input<B>, payload: ParsePayload<input<B>>) => MaybeAsync<output<A>>;
+}
+interface $ZodPipeInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<output<B>, input<A>> {
+  def: $ZodPipeDef<A, B>;
+  isst: never;
+  values: A["_zod"]["values"];
+  optin: A["_zod"]["optin"];
+  optout: B["_zod"]["optout"];
+  propValues: A["_zod"]["propValues"];
+}
+interface $ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodPipeInternals<A, B>;
+}
+declare const $ZodPipe: $constructor<$ZodPipe>;
+interface $ZodReadonlyDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "readonly";
+  innerType: T;
+}
+interface $ZodReadonlyInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<MakeReadonly<output<T>>, MakeReadonly<input<T>>> {
+  def: $ZodReadonlyDef<T>;
+  optin: T["_zod"]["optin"];
+  optout: T["_zod"]["optout"];
+  isst: never;
+  propValues: T["_zod"]["propValues"];
+  values: T["_zod"]["values"];
+}
+interface $ZodReadonly<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodReadonlyInternals<T>;
+}
+declare const $ZodReadonly: $constructor<$ZodReadonly>;
+interface $ZodTemplateLiteralDef extends $ZodTypeDef {
+  type: "template_literal";
+  parts: $ZodTemplateLiteralPart[];
+  format?: string | undefined;
+}
+interface $ZodTemplateLiteralInternals<Template extends string = string> extends $ZodTypeInternals<Template, Template> {
+  pattern: RegExp;
+  def: $ZodTemplateLiteralDef;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodTemplateLiteral<Template extends string = string> extends $ZodType {
+  _zod: $ZodTemplateLiteralInternals<Template>;
+}
+type LiteralPart = Exclude<Literal, symbol>;
+interface SchemaPartInternals extends $ZodTypeInternals<LiteralPart, LiteralPart> {
+  pattern: RegExp;
+}
+interface SchemaPart extends $ZodType {
+  _zod: SchemaPartInternals;
+}
+type $ZodTemplateLiteralPart = LiteralPart | SchemaPart;
+declare const $ZodTemplateLiteral: $constructor<$ZodTemplateLiteral>;
+type $ZodFunctionArgs = $ZodType<unknown[], unknown[]>;
+type $ZodFunctionIn = $ZodFunctionArgs;
+type $ZodFunctionOut = $ZodType;
+type $InferInnerFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : output<Args>) => input<Returns>;
+type $InferInnerFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : output<Args>) => MaybeAsync<input<Returns>>;
+type $InferOuterFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : input<Args>) => output<Returns>;
+type $InferOuterFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : input<Args>) => Promise<output<Returns>>;
+interface $ZodFunctionDef<In extends $ZodFunctionIn = $ZodFunctionIn, Out extends $ZodFunctionOut = $ZodFunctionOut> extends $ZodTypeDef {
+  type: "function";
+  input: In;
+  output: Out;
+}
+interface $ZodFunctionInternals<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> extends $ZodTypeInternals<$InferOuterFunctionType<Args, Returns>, $InferInnerFunctionType<Args, Returns>> {
+  def: $ZodFunctionDef<Args, Returns>;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodFunction<Args extends $ZodFunctionIn = $ZodFunctionIn, Returns extends $ZodFunctionOut = $ZodFunctionOut> extends $ZodType<any, any, $ZodFunctionInternals<Args, Returns>> {
+  /** @deprecated */
+  _def: $ZodFunctionDef<Args, Returns>;
+  _input: $InferInnerFunctionType<Args, Returns>;
+  _output: $InferOuterFunctionType<Args, Returns>;
+  implement<F extends $InferInnerFunctionType<Args, Returns>>(func: F): (...args: Parameters<this["_output"]>) => ReturnType<F> extends ReturnType<this["_output"]> ? ReturnType<F> : ReturnType<this["_output"]>;
+  implementAsync<F extends $InferInnerFunctionTypeAsync<Args, Returns>>(func: F): F extends $InferOuterFunctionTypeAsync<Args, Returns> ? F : $InferOuterFunctionTypeAsync<Args, Returns>;
+  input<const Items extends TupleItems, const Rest extends $ZodFunctionOut = $ZodFunctionOut>(args: Items, rest?: Rest): $ZodFunction<$ZodTuple<Items, Rest>, Returns>;
+  input<NewArgs extends $ZodFunctionIn>(args: NewArgs): $ZodFunction<NewArgs, Returns>;
+  input(...args: any[]): $ZodFunction<any, Returns>;
+  output<NewReturns extends $ZodType>(output: NewReturns): $ZodFunction<Args, NewReturns>;
+}
+declare const $ZodFunction: $constructor<$ZodFunction>;
+interface $ZodPromiseDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "promise";
+  innerType: T;
+}
+interface $ZodPromiseInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<Promise<output<T>>, MaybeAsync<input<T>>> {
+  def: $ZodPromiseDef<T>;
+  isst: never;
+}
+interface $ZodPromise<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodPromiseInternals<T>;
+}
+declare const $ZodPromise: $constructor<$ZodPromise>;
+interface $ZodLazyDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "lazy";
+  getter: () => T;
+}
+interface $ZodLazyInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T>, input<T>> {
+  def: $ZodLazyDef<T>;
+  isst: never;
+  /** Auto-cached way to retrieve the inner schema */
+  innerType: T;
+  pattern: T["_zod"]["pattern"];
+  propValues: T["_zod"]["propValues"];
+  optin: T["_zod"]["optin"];
+  optout: T["_zod"]["optout"];
+}
+interface $ZodLazy<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodLazyInternals<T>;
+}
+declare const $ZodLazy: $constructor<$ZodLazy>;
+interface $ZodCustomDef<O = unknown> extends $ZodTypeDef, $ZodCheckDef {
+  type: "custom";
+  check: "custom";
+  path?: PropertyKey[] | undefined;
+  error?: $ZodErrorMap | undefined;
+  params?: Record<string, any> | undefined;
+  fn: (arg: O) => unknown;
+}
+interface $ZodCustomInternals<O = unknown, I = unknown> extends $ZodTypeInternals<O, I>, $ZodCheckInternals<O> {
+  def: $ZodCustomDef;
+  issc: $ZodIssue;
+  isst: never;
+  bag: LoosePartial<{
+    Class: typeof Class;
+  }>;
+}
+interface $ZodCustom<O = unknown, I = unknown> extends $ZodType {
+  _zod: $ZodCustomInternals<O, I>;
+}
+declare const $ZodCustom: $constructor<$ZodCustom>;
+type $ZodTypes = $ZodString | $ZodNumber | $ZodBigInt | $ZodBoolean | $ZodDate | $ZodSymbol | $ZodUndefined | $ZodNullable | $ZodNull | $ZodAny | $ZodUnknown | $ZodNever | $ZodVoid | $ZodArray | $ZodObject | $ZodUnion | $ZodIntersection | $ZodTuple | $ZodRecord | $ZodMap | $ZodSet | $ZodLiteral | $ZodEnum | $ZodFunction | $ZodPromise | $ZodLazy | $ZodOptional | $ZodDefault | $ZodPrefault | $ZodTemplateLiteral | $ZodCustom | $ZodTransform | $ZodNonOptional | $ZodReadonly | $ZodNaN | $ZodPipe | $ZodSuccess | $ZodCatch | $ZodFile;
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/zod/4.4.3/09b4e1f4024540142723f154808f0d43eb14b44b685c1085d435a20f90e89165/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 $ZodCheckMaxLengthDef extends $ZodCheckDef {
+  check: "max_length";
+  maximum: number;
+}
+interface $ZodCheckMaxLengthInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+  def: $ZodCheckMaxLengthDef;
+  issc: $ZodIssueTooBig<T>;
+}
+interface $ZodCheckMaxLength<T extends HasLength = HasLength> extends $ZodCheck<T> {
+  _zod: $ZodCheckMaxLengthInternals<T>;
+}
+declare const $ZodCheckMaxLength: $constructor<$ZodCheckMaxLength>;
+interface $ZodCheckMinLengthDef extends $ZodCheckDef {
+  check: "min_length";
+  minimum: number;
+}
+interface $ZodCheckMinLengthInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+  def: $ZodCheckMinLengthDef;
+  issc: $ZodIssueTooSmall<T>;
+}
+interface $ZodCheckMinLength<T extends HasLength = HasLength> extends $ZodCheck<T> {
+  _zod: $ZodCheckMinLengthInternals<T>;
+}
+declare const $ZodCheckMinLength: $constructor<$ZodCheckMinLength>;
+interface $ZodCheckLengthEqualsDef extends $ZodCheckDef {
+  check: "length_equals";
+  length: number;
+}
+interface $ZodCheckLengthEqualsInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+  def: $ZodCheckLengthEqualsDef;
+  issc: $ZodIssueTooBig<T> | $ZodIssueTooSmall<T>;
+}
+interface $ZodCheckLengthEquals<T extends HasLength = HasLength> extends $ZodCheck<T> {
+  _zod: $ZodCheckLengthEqualsInternals<T>;
+}
+declare const $ZodCheckLengthEquals: $constructor<$ZodCheckLengthEquals>;
+type $ZodStringFormats = "email" | "url" | "emoji" | "uuid" | "guid" | "nanoid" | "cuid" | "cuid2" | "ulid" | "xid" | "ksuid" | "datetime" | "date" | "time" | "duration" | "ipv4" | "ipv6" | "cidrv4" | "cidrv6" | "base64" | "base64url" | "json_string" | "e164" | "lowercase" | "uppercase" | "regex" | "jwt" | "starts_with" | "ends_with" | "includes";
+interface $ZodCheckStringFormatDef<Format extends string = string> extends $ZodCheckDef {
+  check: "string_format";
+  format: Format;
+  pattern?: RegExp | undefined;
+}
+interface $ZodCheckStringFormatInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckStringFormatDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckRegexDef extends $ZodCheckStringFormatDef {
+  format: "regex";
+  pattern: RegExp;
+}
+interface $ZodCheckRegexInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckRegexDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckRegex extends $ZodCheck<string> {
+  _zod: $ZodCheckRegexInternals;
+}
+declare const $ZodCheckRegex: $constructor<$ZodCheckRegex>;
+interface $ZodCheckLowerCaseDef extends $ZodCheckStringFormatDef<"lowercase"> {}
+interface $ZodCheckLowerCaseInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckLowerCaseDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckLowerCase extends $ZodCheck<string> {
+  _zod: $ZodCheckLowerCaseInternals;
+}
+declare const $ZodCheckLowerCase: $constructor<$ZodCheckLowerCase>;
+interface $ZodCheckUpperCaseDef extends $ZodCheckStringFormatDef<"uppercase"> {}
+interface $ZodCheckUpperCaseInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckUpperCaseDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckUpperCase extends $ZodCheck<string> {
+  _zod: $ZodCheckUpperCaseInternals;
+}
+declare const $ZodCheckUpperCase: $constructor<$ZodCheckUpperCase>;
+interface $ZodCheckIncludesDef extends $ZodCheckStringFormatDef<"includes"> {
+  includes: string;
+  position?: number | undefined;
+}
+interface $ZodCheckIncludesInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckIncludesDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckIncludes extends $ZodCheck<string> {
+  _zod: $ZodCheckIncludesInternals;
+}
+declare const $ZodCheckIncludes: $constructor<$ZodCheckIncludes>;
+interface $ZodCheckStartsWithDef extends $ZodCheckStringFormatDef<"starts_with"> {
+  prefix: string;
+}
+interface $ZodCheckStartsWithInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckStartsWithDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckStartsWith extends $ZodCheck<string> {
+  _zod: $ZodCheckStartsWithInternals;
+}
+declare const $ZodCheckStartsWith: $constructor<$ZodCheckStartsWith>;
+interface $ZodCheckEndsWithDef extends $ZodCheckStringFormatDef<"ends_with"> {
+  suffix: string;
+}
+interface $ZodCheckEndsWithInternals extends $ZodCheckInternals<string> {
+  def: $ZodCheckEndsWithDef;
+  issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckEndsWith extends $ZodCheckInternals<string> {
+  _zod: $ZodCheckEndsWithInternals;
+}
+declare const $ZodCheckEndsWith: $constructor<$ZodCheckEndsWith>;
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/zod/4.4.3/09b4e1f4024540142723f154808f0d43eb14b44b685c1085d435a20f90e89165/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;
+}
+type $ZodIssueInvalidUnion = $ZodIssueInvalidUnionNoMatch | $ZodIssueInvalidUnionMultipleMatch;
+interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
+  readonly code: "invalid_key";
+  readonly origin: "map" | "record";
+  readonly issues: $ZodIssue[];
+  readonly input?: Input;
+}
+interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase {
+  readonly code: "invalid_element";
+  readonly origin: "map" | "set";
+  readonly key: unknown;
+  readonly issues: $ZodIssue[];
+  readonly input?: Input;
+}
+interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {
+  readonly code: "invalid_value";
+  readonly values: Primitive[];
+  readonly input?: Input;
+}
+interface $ZodIssueCustom extends $ZodIssueBase {
+  readonly code: "custom";
+  readonly params?: Record<string, any> | undefined;
+  readonly input?: unknown;
+}
+type $ZodIssue = $ZodIssueInvalidType | $ZodIssueTooBig | $ZodIssueTooSmall | $ZodIssueInvalidStringFormat | $ZodIssueNotMultipleOf | $ZodIssueUnrecognizedKeys | $ZodIssueInvalidUnion | $ZodIssueInvalidKey | $ZodIssueInvalidElement | $ZodIssueInvalidValue | $ZodIssueCustom;
+type $ZodInternalIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue$1<T> : never;
+type RawIssue$1<T extends $ZodIssueBase> = T extends any ? Flatten<MakePartial<T, "message" | "path"> & {
+  /** The input data */
+  readonly input: unknown;
+  /** The schema or check that originated this issue. */
+  readonly inst?: $ZodType | $ZodCheck;
+  /** If `true`, Zod will continue executing checks/refinements after this issue. */
+  readonly continue?: boolean | undefined;
+} & Record<string, unknown>> : never;
+type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = $ZodInternalIssue<T>;
+interface $ZodErrorMap<T extends $ZodIssueBase = $ZodIssue> {
+  (issue: $ZodRawIssue<T>): {
+    message: string;
+  } | string | undefined | null;
+}
+interface $ZodError<T = unknown> extends Error {
+  type: T;
+  issues: $ZodIssue[];
+  _zod: {
+    output: T;
+    def: $ZodIssue[];
+  };
+  stack?: string;
+  name: string;
+}
+declare const $ZodError: $constructor<$ZodError>;
+type $ZodFlattenedError<T, U = string> = _FlattenedError<T, U>;
+type _FlattenedError<T, U = string> = {
+  formErrors: U[];
+  fieldErrors: { [P in keyof T]?: U[]; };
+};
+type _ZodFormattedError<T, U = string> = T extends [any, ...any[]] ? { [K in keyof T]?: $ZodFormattedError<T[K], U>; } : T extends any[] ? {
+  [k: number]: $ZodFormattedError<T[number], U>;
+} : T extends object ? Flatten<{ [K in keyof T]?: $ZodFormattedError<T[K], U>; }> : any;
+type $ZodFormattedError<T, U = string> = {
+  _errors: U[];
+} & Flatten<_ZodFormattedError<T, U>>;
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/zod/4.4.3/09b4e1f4024540142723f154808f0d43eb14b44b685c1085d435a20f90e89165/node_modules/zod/v4/core/core.d.cts
+type ZodTrait = {
+  _zod: {
+    def: any;
+    [k: string]: any;
+  };
+};
+interface $constructor<T extends ZodTrait, D = T["_zod"]["def"]> {
+  new (def: D): T;
+  init(inst: T, def: D): asserts inst is T;
+}
+declare function $constructor<T extends ZodTrait, D = T["_zod"]["def"]>(name: string, initializer: (inst: T, def: D) => void, params?: {
+  Parent?: typeof Class;
+}): $constructor<T, D>;
+declare const $brand: unique symbol;
+type $brand<T extends string | number | symbol = string | number | symbol> = {
+  [$brand]: { [k in T]: true; };
+};
+type $ZodBranded<T extends SomeType, Brand extends string | number | symbol, Dir extends "in" | "out" | "inout" = "out"> = T & (Dir extends "inout" ? {
+  _zod: {
+    input: input<T> & $brand<Brand>;
+    output: output<T> & $brand<Brand>;
+  };
+} : Dir extends "in" ? {
+  _zod: {
+    input: input<T> & $brand<Brand>;
+  };
+} : {
+  _zod: {
+    output: output<T> & $brand<Brand>;
+  };
+});
+type input<T> = T extends {
+  _zod: {
+    input: any;
+  };
+} ? T["_zod"]["input"] : unknown;
+type output<T> = T extends {
+  _zod: {
+    output: any;
+  };
+} ? T["_zod"]["output"] : unknown;
+//#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/zod/4.4.3/09b4e1f4024540142723f154808f0d43eb14b44b685c1085d435a20f90e89165/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">;
+/**
+ * @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 $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 ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/zod/4.4.3/09b4e1f4024540142723f154808f0d43eb14b44b685c1085d435a20f90e89165/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 ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/zod/4.4.3/09b4e1f4024540142723f154808f0d43eb14b44b685c1085d435a20f90e89165/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 ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/zod/4.4.3/09b4e1f4024540142723f154808f0d43eb14b44b685c1085d435a20f90e89165/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>(fn: (schema: this) => T): T;
+}
+interface _ZodType<out Internals extends $ZodTypeInternals = $ZodTypeInternals> extends ZodType<any, any, Internals> {}
+declare const ZodType: $constructor<ZodType>;
+interface _ZodString<T extends $ZodStringInternals<unknown> = $ZodStringInternals<unknown>> extends _ZodType<T> {
+  format: string | null;
+  minLength: number | null;
+  maxLength: number | null;
+  regex(regex: RegExp, params?: string | $ZodCheckRegexParams): this;
+  includes(value: string, params?: string | $ZodCheckIncludesParams): this;
+  startsWith(value: string, params?: string | $ZodCheckStartsWithParams): this;
+  endsWith(value: string, params?: string | $ZodCheckEndsWithParams): this;
+  min(minLength: number, params?: string | $ZodCheckMinLengthParams): this;
+  max(maxLength: number, params?: string | $ZodCheckMaxLengthParams): this;
+  length(len: number, params?: string | $ZodCheckLengthEqualsParams): this;
+  nonempty(params?: string | $ZodCheckMinLengthParams): this;
+  lowercase(params?: string | $ZodCheckLowerCaseParams): this;
+  uppercase(params?: string | $ZodCheckUpperCaseParams): this;
+  trim(): this;
+  normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): this;
+  toLowerCase(): this;
+  toUpperCase(): this;
+  slugify(): this;
+}
+/** @internal */
+declare const _ZodString: $constructor<_ZodString>;
+interface ZodString extends _ZodString<$ZodStringInternals<string>> {
+  /** @deprecated Use `z.email()` instead. */
+  email(params?: string | $ZodCheckEmailParams): this;
+  /** @deprecated Use `z.url()` instead. */
+  url(params?: string | $ZodCheckURLParams): this;
+  /** @deprecated Use `z.jwt()` instead. */
+  jwt(params?: string | $ZodCheckJWTParams): this;
+  /** @deprecated Use `z.emoji()` instead. */
+  emoji(params?: string | $ZodCheckEmojiParams): this;
+  /** @deprecated Use `z.guid()` instead. */
+  guid(params?: string | $ZodCheckGUIDParams): this;
+  /** @deprecated Use `z.uuid()` instead. */
+  uuid(params?: string | $ZodCheckUUIDParams): this;
+  /** @deprecated Use `z.uuid()` instead. */
+  uuidv4(params?: string | $ZodCheckUUIDParams): this;
+  /** @deprecated Use `z.uuid()` instead. */
+  uuidv6(params?: string | $ZodCheckUUIDParams): this;
+  /** @deprecated Use `z.uuid()` instead. */
+  uuidv7(params?: string | $ZodCheckUUIDParams): this;
+  /** @deprecated Use `z.nanoid()` instead. */
+  nanoid(params?: string | $ZodCheckNanoIDParams): this;
+  /** @deprecated Use `z.guid()` instead. */
+  guid(params?: string | $ZodCheckGUIDParams): this;
+  /**
+   * @deprecated 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 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>;
+  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 ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodIntersectionInternals<A, B>>, $ZodIntersection<A, B> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
+declare const ZodIntersection: $constructor<ZodIntersection>;
+interface ZodEnum<
+/** @ts-ignore Cast variance */
+out T extends EnumLike = EnumLike> extends _ZodType<$ZodEnumInternals<T>>, $ZodEnum<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  enum: T;
+  options: Array<T[keyof T]>;
+  extract<const U extends readonly (keyof T)[]>(values: U, params?: string | $ZodEnumParams): ZodEnum<Flatten<Pick<T, U[number]>>>;
+  exclude<const U extends readonly (keyof T)[]>(values: U, params?: string | $ZodEnumParams): ZodEnum<Flatten<Omit<T, U[number]>>>;
+}
+declare const ZodEnum: $constructor<ZodEnum>;
+interface ZodTransform<O = unknown, I = unknown> extends _ZodType<$ZodTransformInternals<O, I>>, $ZodTransform<O, I> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
+declare const ZodTransform: $constructor<ZodTransform>;
+interface ZodOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodOptionalInternals<T>>, $ZodOptional<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodOptional: $constructor<ZodOptional>;
+interface ZodExactOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodExactOptionalInternals<T>>, $ZodExactOptional<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodExactOptional: $constructor<ZodExactOptional>;
+interface ZodNullable<T extends SomeType = $ZodType> extends _ZodType<$ZodNullableInternals<T>>, $ZodNullable<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodNullable: $constructor<ZodNullable>;
+interface ZodDefault<T extends SomeType = $ZodType> extends _ZodType<$ZodDefaultInternals<T>>, $ZodDefault<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+  /** @deprecated Use `.unwrap()` instead. */
+  removeDefault(): T;
+}
+declare const ZodDefault: $constructor<ZodDefault>;
+interface ZodPrefault<T extends SomeType = $ZodType> extends _ZodType<$ZodPrefaultInternals<T>>, $ZodPrefault<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodPrefault: $constructor<ZodPrefault>;
+interface ZodNonOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodNonOptionalInternals<T>>, $ZodNonOptional<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodNonOptional: $constructor<ZodNonOptional>;
+interface ZodCatch<T extends SomeType = $ZodType> extends _ZodType<$ZodCatchInternals<T>>, $ZodCatch<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+  /** @deprecated Use `.unwrap()` instead. */
+  removeCatch(): T;
+}
+declare const ZodCatch: $constructor<ZodCatch>;
+interface ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodPipeInternals<A, B>>, $ZodPipe<A, B> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  in: A;
+  out: B;
+}
+declare const ZodPipe: $constructor<ZodPipe>;
+interface ZodReadonly<T extends SomeType = $ZodType> extends _ZodType<$ZodReadonlyInternals<T>>, $ZodReadonly<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodReadonly: $constructor<ZodReadonly>;
+//#endregion
+//#region src/schemas.d.ts
 /**
  * Zod schemas for Slack channel data stored in ChannelsStorage.
  * These define the shape of the `data` JSON blob in ChannelInstallation records.
  */
-declare const SlashCommandSchema: z.ZodObject<{
-    command: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    usageHint: z.ZodOptional<z.ZodString>;
-    prompt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-declare const SlackInstallationDataSchema: z.ZodObject<{
-    appId: z.ZodString;
-    clientId: z.ZodString;
-    clientSecret: z.ZodString;
-    signingSecret: z.ZodString;
-    teamId: z.ZodString;
-    teamName: z.ZodOptional<z.ZodString>;
-    botToken: z.ZodString;
-    botUserId: z.ZodString;
-    name: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    slashCommands: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        command: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        usageHint: z.ZodOptional<z.ZodString>;
-        prompt: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-type SlackInstallationData = z.infer<typeof SlackInstallationDataSchema>;
-declare const SlackPendingDataSchema: z.ZodObject<{
-    appId: z.ZodString;
-    clientId: z.ZodString;
-    clientSecret: z.ZodString;
-    signingSecret: z.ZodString;
-    authorizationUrl: z.ZodString;
-    name: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    slashCommands: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        command: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        usageHint: z.ZodOptional<z.ZodString>;
-        prompt: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    redirectUrl: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-type SlackPendingData = z.infer<typeof SlackPendingDataSchema>;
-declare const SlackConfigDataSchema: z.ZodObject<{
-    token: z.ZodOptional<z.ZodString>;
-    refreshToken: z.ZodString;
-}, z.core.$strip>;
-type SlackConfigData = z.infer<typeof SlackConfigDataSchema>;
+declare const SlashCommandSchema: ZodObject<{
+  command: ZodString;
+  description: ZodOptional<ZodString>;
+  usageHint: ZodOptional<ZodString>;
+  prompt: ZodOptional<ZodString>;
+}, $strip>;
+/** Who owns an installation: a registered Agent (default) or an AgentController. */
+declare const OwnerTypeSchema: ZodEnum<{
+  agent: "agent";
+  agentController: "agentController";
+}>;
+type SlackOwnerType = output<typeof OwnerTypeSchema>;
+declare const SlackInstallationDataSchema: ZodObject<{
+  ownerType: ZodOptional<ZodEnum<{
+    agent: "agent";
+    agentController: "agentController";
+  }>>;
+  appId: ZodString;
+  clientId: ZodString;
+  clientSecret: ZodString;
+  signingSecret: ZodString;
+  teamId: ZodString;
+  teamName: ZodOptional<ZodString>;
+  botToken: ZodString;
+  botUserId: ZodString;
+  name: ZodOptional<ZodString>;
+  description: ZodOptional<ZodString>;
+  slashCommands: ZodOptional<ZodArray<ZodObject<{
+    command: ZodString;
+    description: ZodOptional<ZodString>;
+    usageHint: ZodOptional<ZodString>;
+    prompt: ZodOptional<ZodString>;
+  }, $strip>>>;
+}, $strip>;
+type SlackInstallationData = output<typeof SlackInstallationDataSchema>;
+declare const SlackPendingDataSchema: ZodObject<{
+  ownerType: ZodOptional<ZodEnum<{
+    agent: "agent";
+    agentController: "agentController";
+  }>>;
+  appId: ZodString;
+  clientId: ZodString;
+  clientSecret: ZodString;
+  signingSecret: ZodString;
+  authorizationUrl: ZodString;
+  name: ZodOptional<ZodString>;
+  description: ZodOptional<ZodString>;
+  slashCommands: ZodOptional<ZodArray<ZodObject<{
+    command: ZodString;
+    description: ZodOptional<ZodString>;
+    usageHint: ZodOptional<ZodString>;
+    prompt: ZodOptional<ZodString>;
+  }, $strip>>>;
+  redirectUrl: ZodOptional<ZodString>;
+}, $strip>;
+type SlackPendingData = output<typeof SlackPendingDataSchema>;
+declare const SlackConfigDataSchema: ZodObject<{
+  token: ZodOptional<ZodString>;
+  refreshToken: ZodString;
+}, $strip>;
+type SlackConfigData = output<typeof SlackConfigDataSchema>;
 /** Normalized slash command config as stored in installation data. */
-type StoredSlashCommand = z.infer<typeof SlashCommandSchema>;
+type StoredSlashCommand = output<typeof SlashCommandSchema>;
 interface SlackInstallation {
-    id: string;
-    agentId: string;
-    webhookId: string;
-    configHash: string;
-    installedAt: Date;
-    appId: string;
-    clientId: string;
-    clientSecret: string;
-    signingSecret: string;
-    teamId: string;
-    teamName?: string;
-    botToken: string;
-    botUserId: string;
-    /** Explicit name passed to connect(), takes priority over agent.name */
-    name?: string;
-    /** Explicit description passed to connect(), takes priority over agent.getDescription() */
-    description?: string;
-    slashCommands?: StoredSlashCommand[];
+  id: string;
+  /** Owner key: an agent id when ownerType is 'agent' (default), or an AgentController id. */
+  agentId: string;
+  /** Defaults to 'agent' when absent (pre-existing installations). */
+  ownerType?: SlackOwnerType;
+  webhookId: string;
+  configHash: string;
+  installedAt: Date;
+  appId: string;
+  clientId: string;
+  clientSecret: string;
+  signingSecret: string;
+  teamId: string;
+  teamName?: string;
+  botToken: string;
+  botUserId: string;
+  /** Explicit name passed to connect(), takes priority over agent.name */
+  name?: string;
+  /** Explicit description passed to connect(), takes priority over agent.getDescription() */
+  description?: string;
+  slashCommands?: StoredSlashCommand[];
 }
 interface SlackPendingInstallation {
-    id: string;
-    agentId: string;
-    webhookId: string;
-    configHash: string;
-    createdAt: Date;
-    appId: string;
-    clientId: string;
-    clientSecret: string;
-    signingSecret: string;
-    authorizationUrl: string;
-    /** Explicit name passed to connect(), takes priority over agent.name */
-    name?: string;
-    /** Explicit description passed to connect(), takes priority over agent.getDescription() */
-    description?: string;
-    slashCommands?: StoredSlashCommand[];
-    redirectUrl?: string;
+  id: string;
+  /** Owner key: an agent id when ownerType is 'agent' (default), or an AgentController id. */
+  agentId: string;
+  /** Defaults to 'agent' when absent (pre-existing installations). */
+  ownerType?: SlackOwnerType;
+  webhookId: string;
+  configHash: string;
+  createdAt: Date;
+  appId: string;
+  clientId: string;
+  clientSecret: string;
+  signingSecret: string;
+  authorizationUrl: string;
+  /** Explicit name passed to connect(), takes priority over agent.name */
+  name?: string;
+  /** Explicit description passed to connect(), takes priority over agent.getDescription() */
+  description?: string;
+  slashCommands?: StoredSlashCommand[];
+  redirectUrl?: string;
 }
 interface SlackConfigTokens {
-    token?: string;
-    refreshToken: string;
-    updatedAt: Date;
+  token?: string;
+  refreshToken: string;
+  updatedAt: Date;
 }
-
+//#endregion
+//#region src/types.d.ts
 /**
  * Per-adapter overrides shared across both streaming and static branches
  * of {@link SlackAdapterChannelConfig}.
  */
 interface SlackAdapterChannelConfigBase {
-    /** CORS configuration for the Slack webhook route. */
-    cors?: ChannelAdapterConfig['cors'];
-    /** Slack gateway listener toggle. Currently a no-op for Slack (HTTP-only). */
-    gateway?: ChannelAdapterConfig['gateway'];
-    /** Override how errors are rendered in Slack messages. */
-    formatError?: ChannelAdapterConfig['formatError'];
-    /**
-     * Control Slack typing indicators and Assistant-mode status text.
-     *
-     * - `true` — use built-in defaults: `"is typing…"` while generating text,
-     *   `"is calling {toolName}…"` while a tool runs, `"is waiting for
-     *   approval…"` while a tool is suspended. Slack auto-prepends the app
-     *   name so the user sees `"<App Name> is typing…"`.
-     * - `false` — never call `startTyping`. Useful when a live streaming
-     *   widget (e.g. `toolDisplay: 'grouped'`) already conveys progress.
-     * - `(chunk, ctx) => string | false | null | undefined | void` — set
-     *   custom copy per chunk. Return a string to override the status,
-     *   or `false`/`null`/`undefined` to leave it unchanged. Compose with
-     *   `defaultTypingStatus` (exported from `@mastra/core/channels`) to
-     *   fall back to defaults for chunks you don't handle.
-     *
-     * @default true
-     */
-    typingStatus?: ChannelAdapterConfig['typingStatus'];
+  /** CORS configuration for the Slack webhook route. */
+  cors?: ChannelAdapterConfig['cors'];
+  /** Slack gateway listener toggle. Currently a no-op for Slack (HTTP-only). */
+  gateway?: ChannelAdapterConfig['gateway'];
+  /** Override how errors are rendered in Slack messages. */
+  formatError?: ChannelAdapterConfig['formatError'];
+  /**
+   * Control Slack typing indicators and Assistant-mode status text.
+   *
+   * - `true` — use built-in defaults: `"is typing…"` while generating text,
+   *   `"is calling {toolName}…"` while a tool runs, `"is waiting for
+   *   approval…"` while a tool is suspended. Slack auto-prepends the app
+   *   name so the user sees `"<App Name> is typing…"`.
+   * - `false` — never call `startTyping`. Useful when a live streaming
+   *   widget (e.g. `toolDisplay: 'grouped'`) already conveys progress.
+   * - `(chunk, ctx) => string | false | null | undefined | void` — set
+   *   custom copy per chunk. Return a string to override the status,
+   *   or `false`/`null`/`undefined` to leave it unchanged. Compose with
+   *   `defaultTypingStatus` (exported from `@mastra/core/channels`) to
+   *   fall back to defaults for chunks you don't handle.
+   *
+   * @default true
+   */
+  typingStatus?: ChannelAdapterConfig['typingStatus'];
 }
 /**
  * Slack adapter overrides with `streaming` enabled (the default). Allows any
  * `toolDisplay` mode, including the streaming-only `'timeline'` / `'grouped'`.
  */
 interface SlackAdapterStreamingConfig extends SlackAdapterChannelConfigBase {
-    /**
-     * Stream agent text deltas to Slack as the agent generates them.
-     *
-     * - `true` (default) — stream with default options.
-     * - `{ updateIntervalMs }` — stream with a custom post-and-edit interval.
-     *
-     * @default true
-     */
-    streaming?: Exclude<StreamingConfig, false>;
-    /**
-     * How tool calls are rendered in Slack.
-     *
-     * - `'cards'` — per-tool "Running…" → "Result" Block Kit cards (the streaming
-     *   session is closed/posted/reopened around each card).
-     * - `'text'` — per-tool plain-text messages (no Block Kit).
-     * - `'timeline'` — render tools as inline task entries beside the streaming text.
-     * - `'grouped'` (default in Slack) — collapse all tools into a single
-     *   "Thinking Steps" plan widget. Renders well in Slack's AI Assistant UI.
-     * - `'hidden'` — execute tools silently; only the typing status indicates work.
-     * - Function form ({@link ToolDisplay}): a `ToolDisplayFn` for full control.
-     *
-     * Approve/deny prompts (`requireApproval`) always render as a separate card.
-     *
-     * @default 'grouped'
-     */
-    toolDisplay?: ToolDisplay;
+  /**
+   * Stream agent text deltas to Slack as the agent generates them.
+   *
+   * - `true` (default) — stream with default options.
+   * - `{ updateIntervalMs }` — stream with a custom post-and-edit interval.
+   *
+   * @default true
+   */
+  streaming?: Exclude<StreamingConfig, false>;
+  /**
+   * How tool calls are rendered in Slack.
+   *
+   * - `'cards'` — per-tool "Running…" → "Result" Block Kit cards (the streaming
+   *   session is closed/posted/reopened around each card).
+   * - `'text'` — per-tool plain-text messages (no Block Kit).
+   * - `'timeline'` — render tools as inline task entries beside the streaming text.
+   * - `'grouped'` (default in Slack) — collapse all tools into a single
+   *   "Thinking Steps" plan widget. Renders well in Slack's AI Assistant UI.
+   * - `'hidden'` — execute tools silently; only the typing status indicates work.
+   * - Function form ({@link ToolDisplay}): a `ToolDisplayFn` for full control.
+   *
+   * Approve/deny prompts (`requireApproval`) always render as a separate card.
+   *
+   * @default 'grouped'
+   */
+  toolDisplay?: ToolDisplay;
 }
 /**
  * Slack adapter overrides with `streaming: false`. Restricts `toolDisplay`
  * to modes that post discrete messages (no `StreamingPlan` available).
  */
 interface SlackAdapterStaticConfig extends SlackAdapterChannelConfigBase {
-    /**
-     * Disable Slack's native message streaming and buffer text until `step-finish`.
-     * `'timeline'` and `'grouped'` modes require streaming, so they're not
-     * available on this branch.
-     */
-    streaming: false;
-    /**
-     * How tool calls are rendered in Slack (static modes only).
-     *
-     * - `'cards'` (default) — per-tool "Running…" → "Result" Block Kit cards.
-     * - `'text'` — per-tool plain-text messages (no Block Kit).
-     * - `'hidden'` — execute tools silently; only the typing status indicates work.
-     * - Function form ({@link ToolDisplay}): a `ToolDisplayFn` for full control.
-     *
-     * @default 'cards'
-     */
-    toolDisplay?: StaticToolDisplay;
+  /**
+   * Disable Slack's native message streaming and buffer text until `step-finish`.
+   * `'timeline'` and `'grouped'` modes require streaming, so they're not
+   * available on this branch.
+   */
+  streaming: false;
+  /**
+   * How tool calls are rendered in Slack (static modes only).
+   *
+   * - `'cards'` (default) — per-tool "Running…" → "Result" Block Kit cards.
+   * - `'text'` — per-tool plain-text messages (no Block Kit).
+   * - `'hidden'` — execute tools silently; only the typing status indicates work.
+   * - Function form ({@link ToolDisplay}): a `ToolDisplayFn` for full control.
+   *
+   * @default 'cards'
+   */
+  toolDisplay?: StaticToolDisplay;
 }
 /**
  * Per-adapter overrides applied to the Slack entry inside
@@ -200,170 +2237,170 @@ type SlackAdapterChannelConfig = SlackAdapterStreamingConfig | SlackAdapterStati
  * {@link SlackProviderConfig}.
  */
 interface SlackProviderConfigBase extends SlackAdapterChannelConfigBase {
-    /**
-     * Override built-in event handlers (e.g. `onDirectMessage`, `onMention`).
-     * Forwarded to `AgentChannels` for every agent connected via this provider.
-     *
-     * @example
-     * ```ts
-     * handlers: {
-     *   onDirectMessage: async (thread, message, defaultHandler) => {
-     *     console.log('DM:', message.text);
-     *     await defaultHandler(thread, message);
-     *   },
-     * }
-     * ```
-     */
-    handlers?: ChannelHandlers;
-    /** Which media types to send inline to the model. See `ChannelConfig.inlineMedia`. */
-    inlineMedia?: ChannelConfig['inlineMedia'];
-    /** Promote URLs in message text to file parts. See `ChannelConfig.inlineLinks`. */
-    inlineLinks?: ChannelConfig['inlineLinks'];
-    /** State adapter for deduplication, locking, and subscriptions. */
-    state?: ChannelConfig['state'];
-    /** Fetch recent thread messages from Slack when the agent joins mid-conversation. */
-    threadContext?: ChannelConfig['threadContext'];
-    /** Whether to include channel tools (add_reaction, remove_reaction). */
-    tools?: ChannelConfig['tools'];
-    /** Additional options passed directly to the Chat SDK. */
-    chatOptions?: ChannelConfig['chatOptions'];
-    /**
-     * Logger forwarded to the underlying `SlackAdapter` for internal error
-     * reporting. Defaults to the adapter's `ConsoleLogger`.
-     */
-    logger?: SlackAdapterConfig['logger'];
-    /**
-     * Slack App Configuration access token for programmatic app creation.
-     * Generate at: https://api.slack.com/apps > "Your App Configuration Tokens"
-     *
-     * Optional — will rotate to get a fresh token on startup using `refreshToken`.
-     */
-    token?: string;
-    /**
-     * Slack App Configuration refresh token.
-     * Used for automatic token rotation. Single-use; each rotation returns a new pair.
-     *
-     * Can be provided here or later via `configure({ refreshToken })`.
-     * If omitted, the provider starts unconfigured and cannot create apps until
-     * `configure()` is called or tokens are loaded from storage.
-     */
-    refreshToken?: string;
-    /**
-     * Base URL for webhook callbacks.
-     * Required when calling connect() to create apps.
-     * Can also be set later via setBaseUrl() or auto-detected from server config.
-     *
-     * For local development, use a tunnel like cloudflared:
-     * ```
-     * baseUrl: 'https://abc123.trycloudflare.com'
-     * ```
-     */
-    baseUrl?: string;
-    /**
-     * Custom storage for installations.
-     * Defaults to using Mastra's ChannelsStorage from the global storage.
-     * Throws if no persistent storage is available.
-     */
-    storage?: ChannelsStorage;
-    /**
-     * Path to redirect to after OAuth completion.
-     * Defaults to "/" (homepage)
-     */
-    redirectPath?: string;
-    /**
-     * Called when a workspace successfully installs the app.
-     */
-    onInstall?: (installation: SlackInstallation) => Promise<void>;
-    /**
-     * Encryption key for sensitive data (clientSecret, signingSecret, botToken).
-     * If not provided, secrets are stored in plaintext (not recommended for production).
-     *
-     * Use a 32+ character random string. Can be set via MASTRA_ENCRYPTION_KEY env var.
-     */
-    encryptionKey?: string;
-    /**
-     * Resolver that returns a `waitUntil` for the current Slack webhook request.
-     *
-     * Required on serverless runtimes where Hono can't bridge the platform's
-     * `ExecutionContext` automatically (Vercel, AWS Lambda). Without `waitUntil`, the
-     * runtime freezes the invocation as soon as the 200 ack returns, killing the
-     * agent run mid-flight and leaving the user with no Slack reply.
-     *
-     * Pass the bare `waitUntil(promise)` function from your platform's SDK. If your
-     * runtime requires the Hono `Context` to derive `waitUntil`, use
-     * {@link resolveWaitUntil} instead.
-     *
-     * Cloudflare Workers and Netlify users typically don't need this — Mastra's
-     * default helper already reads `c.executionCtx.waitUntil` and
-     * `c.env.context.waitUntil`.
-     *
-     * @example
-     * ```ts
-     * import { waitUntil } from '@vercel/functions';
-     * new SlackProvider({ waitUntil });
-     * ```
-     */
-    waitUntil?: WaitUntilFn;
-    /**
-     * Resolve `waitUntil` from the request's Hono `Context`. Use this when the runtime
-     * exposes `waitUntil` through the request and core's default doesn't cover it.
-     *
-     * For platforms whose `waitUntil` is a bare import (e.g. `@vercel/functions`),
-     * pass it via {@link waitUntil} instead.
-     *
-     * Resolution order: {@link waitUntil} → {@link resolveWaitUntil} → core default.
-     */
-    resolveWaitUntil?: WaitUntilResolver;
-    /**
-     * Per-adapter overrides applied to the Slack adapter entry inside
-     * `AgentChannels.adapters` — for example `toolDisplay`, `streaming`,
-     * `formatError`.
-     *
-     * @deprecated Pass these fields at the top level of `SlackProviderConfig`
-     * instead. Top-level fields win; values from `adapterConfig` are merged in
-     * as a fallback for backwards compatibility.
-     */
-    adapterConfig?: SlackAdapterChannelConfig;
+  /**
+   * Override built-in event handlers (e.g. `onDirectMessage`, `onMention`).
+   * Forwarded to `AgentChannels` for every agent connected via this provider.
+   *
+   * @example
+   * ```ts
+   * handlers: {
+   *   onDirectMessage: async (thread, message, defaultHandler) => {
+   *     console.log('DM:', message.text);
+   *     await defaultHandler(thread, message);
+   *   },
+   * }
+   * ```
+   */
+  handlers?: ChannelHandlers;
+  /** Which media types to send inline to the model. See `ChannelConfig.inlineMedia`. */
+  inlineMedia?: ChannelConfig['inlineMedia'];
+  /** Promote URLs in message text to file parts. See `ChannelConfig.inlineLinks`. */
+  inlineLinks?: ChannelConfig['inlineLinks'];
+  /** State adapter for deduplication, locking, and subscriptions. */
+  state?: ChannelConfig['state'];
+  /** Fetch recent thread messages from Slack when the agent joins mid-conversation. */
+  threadContext?: ChannelConfig['threadContext'];
+  /** Whether to include channel tools (add_reaction, remove_reaction). */
+  tools?: ChannelConfig['tools'];
+  /** Additional options passed directly to the Chat SDK. */
+  chatOptions?: ChannelConfig['chatOptions'];
+  /**
+   * Logger forwarded to the underlying `SlackAdapter` for internal error
+   * reporting. Defaults to the adapter's `ConsoleLogger`.
+   */
+  logger?: SlackAdapterConfig['logger'];
+  /**
+   * Slack App Configuration access token for programmatic app creation.
+   * Generate at: https://api.slack.com/apps > "Your App Configuration Tokens"
+   *
+   * Optional — will rotate to get a fresh token on startup using `refreshToken`.
+   */
+  token?: string;
+  /**
+   * Slack App Configuration refresh token.
+   * Used for automatic token rotation. Single-use; each rotation returns a new pair.
+   *
+   * Can be provided here or later via `configure({ refreshToken })`.
+   * If omitted, the provider starts unconfigured and cannot create apps until
+   * `configure()` is called or tokens are loaded from storage.
+   */
+  refreshToken?: string;
+  /**
+   * Base URL for webhook callbacks.
+   * Required when calling connect() to create apps.
+   * Can also be set later via setBaseUrl() or auto-detected from server config.
+   *
+   * For local development, use a tunnel like cloudflared:
+   * ```
+   * baseUrl: 'https://abc123.trycloudflare.com'
+   * ```
+   */
+  baseUrl?: string;
+  /**
+   * Custom storage for installations.
+   * Defaults to using Mastra's ChannelsStorage from the global storage.
+   * Throws if no persistent storage is available.
+   */
+  storage?: ChannelsStorage;
+  /**
+   * Path to redirect to after OAuth completion.
+   * Defaults to "/" (homepage)
+   */
+  redirectPath?: string;
+  /**
+   * Called when a workspace successfully installs the app.
+   */
+  onInstall?: (installation: SlackInstallation) => Promise<void>;
+  /**
+   * Encryption key for sensitive data (clientSecret, signingSecret, botToken).
+   * If not provided, secrets are stored in plaintext (not recommended for production).
+   *
+   * Use a 32+ character random string. Can be set via MASTRA_ENCRYPTION_KEY env var.
+   */
+  encryptionKey?: string;
+  /**
+   * Resolver that returns a `waitUntil` for the current Slack webhook request.
+   *
+   * Required on serverless runtimes where Hono can't bridge the platform's
+   * `ExecutionContext` automatically (Vercel, AWS Lambda). Without `waitUntil`, the
+   * runtime freezes the invocation as soon as the 200 ack returns, killing the
+   * agent run mid-flight and leaving the user with no Slack reply.
+   *
+   * Pass the bare `waitUntil(promise)` function from your platform's SDK. If your
+   * runtime requires the Hono `Context` to derive `waitUntil`, use
+   * {@link resolveWaitUntil} instead.
+   *
+   * Cloudflare Workers and Netlify users typically don't need this — Mastra's
+   * default helper already reads `c.executionCtx.waitUntil` and
+   * `c.env.context.waitUntil`.
+   *
+   * @example
+   * ```ts
+   * import { waitUntil } from '@vercel/functions';
+   * new SlackProvider({ waitUntil });
+   * ```
+   */
+  waitUntil?: WaitUntilFn;
+  /**
+   * Resolve `waitUntil` from the request's Hono `Context`. Use this when the runtime
+   * exposes `waitUntil` through the request and core's default doesn't cover it.
+   *
+   * For platforms whose `waitUntil` is a bare import (e.g. `@vercel/functions`),
+   * pass it via {@link waitUntil} instead.
+   *
+   * Resolution order: {@link waitUntil} → {@link resolveWaitUntil} → core default.
+   */
+  resolveWaitUntil?: WaitUntilResolver;
+  /**
+   * Per-adapter overrides applied to the Slack adapter entry inside
+   * `AgentChannels.adapters` — for example `toolDisplay`, `streaming`,
+   * `formatError`.
+   *
+   * @deprecated Pass these fields at the top level of `SlackProviderConfig`
+   * instead. Top-level fields win; values from `adapterConfig` are merged in
+   * as a fallback for backwards compatibility.
+   */
+  adapterConfig?: SlackAdapterChannelConfig;
 }
 /**
  * Slack provider configuration with `streaming` enabled (the default).
  * Allows any `toolDisplay` mode.
  */
 interface SlackProviderStreamingConfig extends SlackProviderConfigBase {
-    /**
-     * Stream agent text deltas to Slack as the agent generates them.
-     *
-     * - `true` (default) — stream with default options.
-     * - `{ updateIntervalMs }` — stream with a custom post-and-edit interval.
-     *
-     * @default true
-     */
-    streaming?: Exclude<StreamingConfig, false>;
-    /**
-     * How tool calls are rendered in Slack. See {@link SlackAdapterStreamingConfig#toolDisplay}.
-     *
-     * @default 'grouped'
-     */
-    toolDisplay?: ToolDisplay;
+  /**
+   * Stream agent text deltas to Slack as the agent generates them.
+   *
+   * - `true` (default) — stream with default options.
+   * - `{ updateIntervalMs }` — stream with a custom post-and-edit interval.
+   *
+   * @default true
+   */
+  streaming?: Exclude<StreamingConfig, false>;
+  /**
+   * How tool calls are rendered in Slack. See {@link SlackAdapterStreamingConfig#toolDisplay}.
+   *
+   * @default 'grouped'
+   */
+  toolDisplay?: ToolDisplay;
 }
 /**
  * Slack provider configuration with `streaming: false`. Restricts
  * `toolDisplay` to modes that post discrete messages.
  */
 interface SlackProviderStaticConfig extends SlackProviderConfigBase {
-    /**
-     * Disable Slack's native message streaming and buffer text until `step-finish`.
-     * `'timeline'` and `'grouped'` modes require streaming, so they're not
-     * available on this branch.
-     */
-    streaming: false;
-    /**
-     * How tool calls are rendered in Slack (static modes only). See
-     * {@link SlackAdapterStaticConfig#toolDisplay}.
-     *
-     * @default 'cards'
-     */
-    toolDisplay?: StaticToolDisplay;
+  /**
+   * Disable Slack's native message streaming and buffer text until `step-finish`.
+   * `'timeline'` and `'grouped'` modes require streaming, so they're not
+   * available on this branch.
+   */
+  streaming: false;
+  /**
+   * How tool calls are rendered in Slack (static modes only). See
+   * {@link SlackAdapterStaticConfig#toolDisplay}.
+   *
+   * @default 'cards'
+   */
+  toolDisplay?: StaticToolDisplay;
 }
 /**
  * Configuration for SlackProvider at the Mastra level.
@@ -382,86 +2419,86 @@ type SlackProviderConfig = SlackProviderStreamingConfig | SlackProviderStaticCon
  * This is serializable and can be stored in the database for stored agents.
  */
 interface SlackConnectOptions {
-    /**
-     * Display name for the Slack bot.
-     * Defaults to agent name, then agent ID.
-     */
-    name?: string;
-    /**
-     * Bot description shown in Slack.
-     * Defaults to "{name} - Powered by Mastra".
-     */
-    description?: string;
-    /**
-     * URL to an image for the app icon.
-     * Should be a square PNG/JPG, minimum 512x512px.
-     * The image will be automatically downloaded and uploaded to Slack.
-     *
-     * @example
-     * iconUrl: 'https://example.com/my-bot-avatar.png'
-     */
-    iconUrl?: string;
-    /**
-     * Slash commands this agent supports.
-     *
-     * Simple form - command triggers agent.generate() with the input text:
-     * ```ts
-     * slashCommands: ['/ask']
-     * ```
-     *
-     * With custom prompt template:
-     * ```ts
-     * slashCommands: [
-     *   {
-     *     command: '/summarize',
-     *     description: 'Summarize a URL',
-     *     prompt: 'Fetch and summarize: {{text}}'
-     *   }
-     * ]
-     * ```
-     *
-     * Use {{text}} as placeholder for user input.
-     */
-    slashCommands?: (string | SlashCommandConfig)[];
-    /**
-     * Customize the Slack app manifest before it's sent to the Manifest API.
-     *
-     * Receives the default manifest (built from name, description, slashCommands,
-     * and internal URLs) and returns the final manifest to use.
-     *
-     * Use this for any advanced Slack configuration: custom scopes, events,
-     * interactivity settings, etc.
-     *
-     * @example
-     * // Add extra scopes
-     * manifest: (m) => ({
-     *   ...m,
-     *   oauth_config: {
-     *     ...m.oauth_config,
-     *     scopes: { bot: [...(m.oauth_config?.scopes?.bot ?? []), 'files:write'] }
-     *   }
-     * })
-     *
-     * @example
-     * // Subscribe to additional events
-     * manifest: (m) => ({
-     *   ...m,
-     *   settings: {
-     *     ...m.settings,
-     *     event_subscriptions: {
-     *       ...m.settings?.event_subscriptions,
-     *       bot_events: [...(m.settings?.event_subscriptions?.bot_events ?? []), 'reaction_added']
-     *     }
-     *   }
-     * })
-     */
-    manifest?: (defaults: SlackAppManifest) => SlackAppManifest;
-    /**
-     * URL to redirect to after successful OAuth completion.
-     * Typically set by the Studio UI to return to the agent page.
-     * Defaults to `SlackProviderConfig.redirectPath` or `/`.
-     */
-    redirectUrl?: string;
+  /**
+   * Display name for the Slack bot.
+   * Defaults to agent name, then agent ID.
+   */
+  name?: string;
+  /**
+   * Bot description shown in Slack.
+   * Defaults to "{name} - Powered by Mastra".
+   */
+  description?: string;
+  /**
+   * URL to an image for the app icon.
+   * Should be a square PNG/JPG, minimum 512x512px.
+   * The image will be automatically downloaded and uploaded to Slack.
+   *
+   * @example
+   * iconUrl: 'https://example.com/my-bot-avatar.png'
+   */
+  iconUrl?: string;
+  /**
+   * Slash commands this agent supports.
+   *
+   * Simple form - command triggers agent.generate() with the input text:
+   * ```ts
+   * slashCommands: ['/ask']
+   * ```
+   *
+   * With custom prompt template:
+   * ```ts
+   * slashCommands: [
+   *   {
+   *     command: '/summarize',
+   *     description: 'Summarize a URL',
+   *     prompt: 'Fetch and summarize: {{text}}'
+   *   }
+   * ]
+   * ```
+   *
+   * Use {{text}} as placeholder for user input.
+   */
+  slashCommands?: (string | SlashCommandConfig)[];
+  /**
+   * Customize the Slack app manifest before it's sent to the Manifest API.
+   *
+   * Receives the default manifest (built from name, description, slashCommands,
+   * and internal URLs) and returns the final manifest to use.
+   *
+   * Use this for any advanced Slack configuration: custom scopes, events,
+   * interactivity settings, etc.
+   *
+   * @example
+   * // Add extra scopes
+   * manifest: (m) => ({
+   *   ...m,
+   *   oauth_config: {
+   *     ...m.oauth_config,
+   *     scopes: { bot: [...(m.oauth_config?.scopes?.bot ?? []), 'files:write'] }
+   *   }
+   * })
+   *
+   * @example
+   * // Subscribe to additional events
+   * manifest: (m) => ({
+   *   ...m,
+   *   settings: {
+   *     ...m.settings,
+   *     event_subscriptions: {
+   *       ...m.settings?.event_subscriptions,
+   *       bot_events: [...(m.settings?.event_subscriptions?.bot_events ?? []), 'reaction_added']
+   *     }
+   *   }
+   * })
+   */
+  manifest?: (defaults: SlackAppManifest) => SlackAppManifest;
+  /**
+   * URL to redirect to after successful OAuth completion.
+   * Typically set by the Studio UI to return to the agent page.
+   * Defaults to `SlackProviderConfig.redirectPath` or `/`.
+   */
+  redirectUrl?: string;
 }
 /**
  * Slash command configuration (fully serializable).
@@ -470,104 +2507,105 @@ interface SlackConnectOptions {
  * and sent to the agent. Like Claude Code's slash commands.
  */
 interface SlashCommandConfig {
-    /** Command name including slash (e.g., "/ask") */
-    command: string;
-    /** Short description shown in Slack's command picker */
-    description?: string;
-    /** Usage hint shown in Slack (e.g., "[question]") */
-    usageHint?: string;
-    /**
-     * Prompt template sent to the agent.
-     * Use {{text}} as placeholder for user input.
-     *
-     * Defaults to "{{text}}" (just passes input directly).
-     *
-     * @example
-     * prompt: 'Summarize the following URL: {{text}}'
-     * prompt: 'Write {{text}} in TypeScript'
-     */
-    prompt?: string;
+  /** Command name including slash (e.g., "/ask") */
+  command: string;
+  /** Short description shown in Slack's command picker */
+  description?: string;
+  /** Usage hint shown in Slack (e.g., "[question]") */
+  usageHint?: string;
+  /**
+   * Prompt template sent to the agent.
+   * Use {{text}} as placeholder for user input.
+   *
+   * Defaults to "{{text}}" (just passes input directly).
+   *
+   * @example
+   * prompt: 'Summarize the following URL: {{text}}'
+   * prompt: 'Write {{text}} in TypeScript'
+   */
+  prompt?: string;
 }
 interface SlackMessage {
-    text?: string;
-    blocks?: SlackBlock[];
-    response_type?: 'in_channel' | 'ephemeral';
-    replace_original?: boolean;
-    delete_original?: boolean;
+  text?: string;
+  blocks?: SlackBlock[];
+  response_type?: 'in_channel' | 'ephemeral';
+  replace_original?: boolean;
+  delete_original?: boolean;
 }
 interface SlackBlock {
-    type: string;
-    [key: string]: unknown;
+  type: string;
+  [key: string]: unknown;
 }
 /**
  * Slack App Manifest for programmatic app creation.
  * @see https://api.slack.com/reference/manifests
  */
 interface SlackAppManifest {
-    display_information: {
-        name: string;
-        description?: string;
-        background_color?: string;
-        long_description?: string;
+  display_information: {
+    name: string;
+    description?: string;
+    background_color?: string;
+    long_description?: string;
+  };
+  features?: {
+    app_home?: {
+      home_tab_enabled?: boolean;
+      messages_tab_enabled?: boolean;
+      messages_tab_read_only_enabled?: boolean;
+    };
+    bot_user?: {
+      display_name: string;
+      always_online?: boolean;
     };
-    features?: {
-        app_home?: {
-            home_tab_enabled?: boolean;
-            messages_tab_enabled?: boolean;
-            messages_tab_read_only_enabled?: boolean;
-        };
-        bot_user?: {
-            display_name: string;
-            always_online?: boolean;
-        };
-        slash_commands?: Array<{
-            command: string;
-            description: string;
-            url: string;
-            usage_hint?: string;
-        }>;
-        assistant_view?: {
-            assistant_description: string;
-            suggested_prompts?: Array<{
-                title: string;
-                message: string;
-            }>;
-        };
+    slash_commands?: Array<{
+      command: string;
+      description: string;
+      url: string;
+      usage_hint?: string;
+    }>;
+    assistant_view?: {
+      assistant_description: string;
+      suggested_prompts?: Array<{
+        title: string;
+        message: string;
+      }>;
     };
-    oauth_config?: {
-        redirect_urls?: string[];
-        scopes?: {
-            bot?: string[];
-            user?: string[];
-        };
+  };
+  oauth_config?: {
+    redirect_urls?: string[];
+    scopes?: {
+      bot?: string[];
+      user?: string[];
     };
-    settings?: {
-        event_subscriptions?: {
-            request_url?: string;
-            bot_events?: string[];
-            user_events?: string[];
-        };
-        interactivity?: {
-            is_enabled?: boolean;
-            request_url?: string;
-            message_menu_options_url?: string;
-        };
-        org_deploy_enabled?: boolean;
-        socket_mode_enabled?: boolean;
-        token_rotation_enabled?: boolean;
+  };
+  settings?: {
+    event_subscriptions?: {
+      request_url?: string;
+      bot_events?: string[];
+      user_events?: string[];
     };
+    interactivity?: {
+      is_enabled?: boolean;
+      request_url?: string;
+      message_menu_options_url?: string;
+    };
+    org_deploy_enabled?: boolean;
+    socket_mode_enabled?: boolean;
+    token_rotation_enabled?: boolean;
+  };
 }
 /**
  * Credentials returned when creating a Slack app via manifest API.
  */
 interface SlackAppCredentials {
-    appId: string;
-    clientId: string;
-    clientSecret: string;
-    signingSecret: string;
-    oauthAuthorizeUrl?: string;
+  appId: string;
+  clientId: string;
+  clientSecret: string;
+  signingSecret: string;
+  oauthAuthorizeUrl?: string;
 }
-
+//#endregion
+//#region src/provider.d.ts
 /**
  * Slack channel integration for Mastra.
  *
@@ -606,174 +2644,198 @@ interface SlackAppCredentials {
  * ```
  */
 declare class SlackProvider implements ChannelProvider {
-    #private;
-    readonly id = "slack";
-    constructor(config?: SlackProviderConfig);
-    /**
-     * Provide or clear Slack App Configuration credentials at runtime.
-     *
-     * Use this when credentials aren't available at construction time — for example,
-     * when they're entered through the Editor UI or loaded from a vault.
-     *
-     * Pass `null` to clear credentials and delete stored tokens.
-     *
-     * @example
-     * ```ts
-     * const slack = new SlackProvider();
-     * // Provide credentials (persists to storage immediately):
-     * await slack.configure({ refreshToken: 'xoxe-1-...' });
-     * // Clear credentials and stored tokens:
-     * await slack.configure(null);
-     * ```
-     */
-    configure(credentials: {
-        refreshToken: string;
-        token?: string;
-    } | null): Promise<void>;
-    /**
-     * Called by Mastra when this channel is registered.
-     * @internal
-     */
-    __attach(mastra: Mastra): void;
-    /**
-     * Set the base URL for webhook callbacks.
-     * Only needed if not using Mastra server config.
-     */
-    setBaseUrl(baseUrl: string): void;
-    /**
-     * Restore active Slack installations from storage.
-     *
-     * For each active installation in the database, this creates a SlackAdapter
-     * and injects AgentChannels into the corresponding Agent so it can receive
-     * Slack events immediately on startup.
-     *
-     * Does NOT auto-provision new apps. Use `connect(agentId, options)` to
-     * create a new Slack app for an agent.
-     */
-    initialize(): Promise<void>;
-    /**
-     * Get API routes for the Mastra server.
-     * Add these to your Mastra config via `server.apiRoutes`.
-     *
-     * The mastra instance is automatically injected via createHandler.
-     * On first request, auto-initializes any agents with slack configs.
-     */
-    getRoutes(): ApiRoute[];
-    /**
-     * Connect an agent to Slack by creating a new Slack app.
-     *
-     * @returns OAuth connect result with authorization URL for user redirect
-     */
-    connect(agentId: string, options?: SlackConnectOptions): Promise<ChannelConnectResult>;
-    /**
-     * Disconnect an agent from Slack by deleting its app.
-     */
-    disconnect(agentId: string): Promise<void>;
-    /**
-     * Get the Slack installation for an agent.
-     */
-    getInstallation(agentId: string): Promise<SlackInstallation | null>;
-    /**
-     * List all Slack installations (public info only).
-     * Includes both active and pending installations.
-     */
-    listInstallations(): Promise<ChannelInstallationInfo[]>;
-    /**
-     * Discovery metadata for the editor UI.
-     */
-    getInfo(): ChannelPlatformInfo;
-    /**
-     * Check if the provider has credentials and can create/manage Slack apps.
-     * Returns false if no refresh token has been provided via constructor, `configure()`, or storage.
-     */
-    isConfigured(): boolean;
-    /**
-     * Get the SlackAdapter for an installation.
-     * Used internally for message formatting and posting.
-     */
-    getAdapter(installationId: string): SlackAdapter | undefined;
-}
-
+  #private;
+  readonly id = "slack";
+  constructor(config?: SlackProviderConfig);
+  /**
+   * Provide or clear Slack App Configuration credentials at runtime.
+   *
+   * Use this when credentials aren't available at construction time — for example,
+   * when they're entered through the Editor UI or loaded from a vault.
+   *
+   * Pass `null` to clear credentials and delete stored tokens.
+   *
+   * @example
+   * ```ts
+   * const slack = new SlackProvider();
+   * // Provide credentials (persists to storage immediately):
+   * await slack.configure({ refreshToken: 'xoxe-1-...' });
+   * // Clear credentials and stored tokens:
+   * await slack.configure(null);
+   * ```
+   */
+  configure(credentials: {
+    refreshToken: string;
+    token?: string;
+  } | null): Promise<void>;
+  /**
+   * Called by Mastra when this channel is registered.
+   * @internal
+   */
+  __attach(mastra: Mastra): void;
+  /**
+   * Set the base URL for webhook callbacks.
+   * Only needed if not using Mastra server config.
+   */
+  setBaseUrl(baseUrl: string): void;
+  /**
+   * Restore active Slack installations from storage.
+   *
+   * For each active installation in the database, this creates a SlackAdapter
+   * and injects AgentChannels into the corresponding Agent so it can receive
+   * Slack events immediately on startup.
+   *
+   * Does NOT auto-provision new apps. Use `connect(agentId, options)` to
+   * create a new Slack app for an agent.
+   */
+  initialize(): Promise<void>;
+  /**
+   * Get API routes for the Mastra server.
+   * Add these to your Mastra config via `server.apiRoutes`.
+   *
+   * The mastra instance is automatically injected via createHandler.
+   * On first request, auto-initializes any agents with slack configs.
+   */
+  getRoutes(): ApiRoute[];
+  /**
+   * Connect an agent to Slack by creating a new Slack app.
+   *
+   * @returns OAuth connect result with authorization URL for user redirect
+   */
+  connect(agentId: string, options?: SlackConnectOptions): Promise<ChannelConnectResult>;
+  /**
+   * Connect to Slack by creating a new Slack app for an arbitrary connection id
+   * (no registered agent required — e.g. an AgentController or custom owner).
+   * Since there is no agent to derive a display name from, `name` is required.
+   *
+   * @returns OAuth connect result with authorization URL for user redirect
+   */
+  connect(options: SlackConnectOptions & {
+    id: string;
+    name: string;
+  }): Promise<ChannelConnectResult>;
+  /**
+   * Disconnect an agent from Slack by deleting its app.
+   */
+  disconnect(agentId: string): Promise<void>;
+  /**
+   * Get the Slack installation for an agent.
+   */
+  getInstallation(agentId: string): Promise<SlackInstallation | null>;
+  /**
+   * List all Slack installations (public info only).
+   * Includes both active and pending installations.
+   */
+  listInstallations(): Promise<ChannelInstallationInfo[]>;
+  /**
+   * Discovery metadata for the editor UI.
+   */
+  getInfo(): ChannelPlatformInfo;
+  /**
+   * Check if the provider has credentials and can create/manage Slack apps.
+   * Returns false if no refresh token has been provided via constructor, `configure()`, or storage.
+   */
+  isConfigured(): boolean;
+  /**
+   * Get the SlackAdapter for an installation.
+   * Used internally for message formatting and posting.
+   */
+  getAdapter(installationId: string): SlackAdapter$1 | undefined;
+}
+//#endregion
+//#region src/client.d.ts
 interface SlackManifestClientConfig {
+  token: string;
+  refreshToken: string;
+  onTokenRotation?: (tokens: {
     token: string;
     refreshToken: string;
-    onTokenRotation?: (tokens: {
-        token: string;
-        refreshToken: string;
-    }) => Promise<void>;
+  }) => Promise<void>;
 }
 /**
  * Client for Slack's App Manifest API.
  * Handles programmatic app creation, deletion, and token rotation.
  */
 declare class SlackManifestClient {
-    #private;
-    constructor(config: SlackManifestClientConfig);
-    /**
-     * Get current tokens (after potential rotation).
-     */
-    getTokens(): {
-        token: string;
-        refreshToken: string;
-    };
-    /**
-     * Update tokens (e.g., from storage on startup).
-     */
-    setTokens(tokens: {
-        token: string;
-        refreshToken: string;
-    }): void;
-    /**
-     * Rotate the configuration tokens.
-     * Slack config access tokens expire after 12 hours; the refresh token is single-use
-     * and each rotation returns a new access token + refresh token pair.
-     *
-     * Concurrent callers share the same in-flight rotation to avoid burning
-     * single-use refresh tokens.
-     */
-    rotateToken(): Promise<void>;
-    /**
-     * Create a new Slack app from a manifest.
-     */
-    createApp(manifest: SlackAppManifest): Promise<SlackAppCredentials>;
-    /**
-     * Delete a Slack app.
-     */
-    deleteApp(appId: string): Promise<void>;
-    /**
-     * Update an existing Slack app's manifest.
-     */
-    updateApp(appId: string, manifest: SlackAppManifest): Promise<void>;
-    /**
-     * Set the app icon via undocumented apps.icon.set API.
-     */
-    setAppIcon(appId: string, imageData: ArrayBuffer): Promise<void>;
-}
-
+  #private;
+  constructor(config: SlackManifestClientConfig);
+  /**
+   * Get current tokens (after potential rotation).
+   */
+  getTokens(): {
+    token: string;
+    refreshToken: string;
+  };
+  /**
+   * Update tokens (e.g., from storage on startup).
+   */
+  setTokens(tokens: {
+    token: string;
+    refreshToken: string;
+  }): void;
+  /**
+   * Rotate the configuration tokens.
+   * Slack config access tokens expire after 12 hours; the refresh token is single-use
+   * and each rotation returns a new access token + refresh token pair.
+   *
+   * Concurrent callers share the same in-flight rotation to avoid burning
+   * single-use refresh tokens.
+   */
+  rotateToken(): Promise<void>;
+  /**
+   * Create a new Slack app from a manifest.
+   */
+  createApp(manifest: SlackAppManifest): Promise<SlackAppCredentials>;
+  /**
+   * Delete a Slack app.
+   */
+  deleteApp(appId: string): Promise<void>;
+  /**
+   * Check whether a Slack app still exists.
+   *
+   * Uses the read-only `apps.manifest.export` endpoint as an existence probe.
+   * Returns `false` when Slack reports the app is missing/inaccessible
+   * (e.g. it was deleted from the Slack admin UI), `true` when it exports
+   * successfully. Network/transport errors are re-thrown so callers can
+   * distinguish "app is gone" from "couldn't reach Slack".
+   */
+  appExists(appId: string): Promise<boolean>;
+  /**
+   * Update an existing Slack app's manifest.
+   */
+  updateApp(appId: string, manifest: SlackAppManifest): Promise<void>;
+  /**
+   * Set the app icon via undocumented apps.icon.set API.
+   */
+  setAppIcon(appId: string, imageData: ArrayBuffer): Promise<void>;
+}
+//#endregion
+//#region src/crypto.d.ts
 /**
  * Verify a Slack request signature.
  * @see https://api.slack.com/authentication/verifying-requests-from-slack
  */
 declare function verifySlackRequest(params: {
-    signingSecret: string;
-    timestamp: string;
-    body: string;
-    signature: string;
+  signingSecret: string;
+  timestamp: string;
+  body: string;
+  signature: string;
 }): boolean;
 /**
  * Parse URL-encoded form body from Slack slash commands.
  * Uses URLSearchParams which correctly handles `+` as space.
  */
 declare function parseSlackFormBody(body: string): Record<string, string>;
-
+//#endregion
+//#region src/manifest.d.ts
 /**
  * Slash command for manifest building.
  * Simplified version of SlashCommandConfig for manifest generation.
  */
 interface SlashCommand {
-    command: string;
-    description?: string;
-    usageHint?: string;
+  command: string;
+  description?: string;
+  usageHint?: string;
 }
 /**
  * Default bot scopes required for agent functionality.
@@ -784,22 +2846,23 @@ declare const DEFAULT_BOT_SCOPES: readonly ["chat:write", "chat:write.public", "
  */
 declare const DEFAULT_BOT_EVENTS: readonly ["app_mention", "message.channels", "message.groups", "message.im", "message.mpim"];
 interface BuildManifestOptions {
-    /** Display name for the Slack app */
-    name: string;
-    /** Description shown in Slack */
-    description?: string;
-    /** URL for event webhooks */
-    webhookUrl: string;
-    /** URL for OAuth redirect */
-    oauthRedirectUrl: string;
-    /** URL for slash command webhooks (defaults to webhookUrl) */
-    commandsUrl?: string;
-    /** Slash commands to register */
-    slashCommands?: SlashCommand[];
+  /** Display name for the Slack app */
+  name: string;
+  /** Description shown in Slack */
+  description?: string;
+  /** URL for event webhooks */
+  webhookUrl: string;
+  /** URL for OAuth redirect */
+  oauthRedirectUrl: string;
+  /** URL for slash command webhooks (defaults to webhookUrl) */
+  commandsUrl?: string;
+  /** Slash commands to register */
+  slashCommands?: SlashCommand[];
 }
 /**
  * Build a Slack app manifest for an agent.
  */
 declare function buildManifest(options: BuildManifestOptions): SlackAppManifest;
-
-export { DEFAULT_BOT_EVENTS, DEFAULT_BOT_SCOPES, type SlackAdapterChannelConfig, type SlackAppManifest, type SlackBlock, type SlackConfigData, SlackConfigDataSchema, type SlackConfigTokens, type SlackConnectOptions, type SlackInstallation, type SlackInstallationData, SlackInstallationDataSchema, SlackManifestClient, type SlackMessage, type SlackPendingData, SlackPendingDataSchema, type SlackPendingInstallation, SlackProvider, type SlackProviderConfig, type SlashCommandConfig, buildManifest, parseSlackFormBody, verifySlackRequest };
+//#endregion
+export { DEFAULT_BOT_EVENTS, DEFAULT_BOT_SCOPES, type SlackAdapter, type SlackAdapterChannelConfig, type SlackAppManifest, type SlackBlock, type SlackConfigData, SlackConfigDataSchema, type SlackConfigTokens, type SlackConnectOptions, type SlackInstallation, type SlackInstallationData, SlackInstallationDataSchema, SlackManifestClient, type SlackMessage, type SlackPendingData, SlackPendingDataSchema, type SlackPendingInstallation, SlackProvider, type SlackProviderConfig, type SlashCommandConfig, buildManifest, createSlackAdapter, parseSlackFormBody, verifySlackRequest };
+//# sourceMappingURL=index.d.ts.map