@heybox/hb-sdk 0.9.1-alpha.0 → 0.9.1-alpha.10

package/types/card-controller.d.ts

@@ -0,0 +1,3682 @@
+import { WorkspaceCardJson, WorkspaceCardInputSchema, WorkspaceCardControllerContext, WorkspaceCardControllerResult, WorkspaceCardSize, WorkspaceCardDocuments, WorkspaceCardController } from '@heybox/hb-sdk-protocol';
+export { WorkspaceCardController, WorkspaceCardControllerContext, WorkspaceCardControllerResult, WorkspaceCardDefinition, WorkspaceCardDocuments, WorkspaceCardJson, WorkspaceCardRefreshContext, WorkspaceCardSize, WorkspaceCardState } from '@heybox/hb-sdk-protocol';
+
+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;
+
+/** 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> {
+}
+
+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 {
+}
+
+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>;
+}
+
+type JSONType = string | number | boolean | null | JSONType[] | {
+    [key: string]: JSONType;
+};
+type JWTAlgorithm = "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "EdDSA" | (string & {});
+type MimeTypes = "application/json" | "application/xml" | "application/x-www-form-urlencoded" | "application/javascript" | "application/pdf" | "application/zip" | "application/vnd.ms-excel" | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "application/msword" | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/vnd.ms-powerpoint" | "application/vnd.openxmlformats-officedocument.presentationml.presentation" | "application/octet-stream" | "application/graphql" | "text/html" | "text/plain" | "text/css" | "text/javascript" | "text/csv" | "image/png" | "image/jpeg" | "image/gif" | "image/svg+xml" | "image/webp" | "audio/mpeg" | "audio/ogg" | "audio/wav" | "audio/webm" | "video/mp4" | "video/webm" | "video/ogg" | "font/woff" | "font/woff2" | "font/ttf" | "font/otf" | "multipart/form-data" | (string & {});
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type Omit$1<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+type MakePartial<T, K extends keyof T> = Omit$1<T, K> & InexactPartial<Pick<T, K>>;
+type NoUndefined<T> = T extends undefined ? never : T;
+type LoosePartial<T extends object> = InexactPartial<T> & {
+    [k: string]: unknown;
+};
+type Mask<Keys extends PropertyKey> = {
+    [K in Keys]?: true;
+};
+type Writeable<T> = {
+    -readonly [P in keyof T]: T[P];
+} & {};
+type InexactPartial<T> = {
+    [P in keyof T]?: T[P] | undefined;
+};
+type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
+    readonly [Symbol.toStringTag]: string;
+} | Date | Error | Generator | Promise<unknown> | RegExp;
+type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;
+type SomeObject = Record<PropertyKey, any>;
+type Identity<T> = T;
+type Flatten<T> = Identity<{
+    [k in keyof T]: T[k];
+}>;
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type Extend<A extends SomeObject, B extends SomeObject> = Flatten<keyof A & keyof B extends never ? A & B : {
+    [K in keyof A as K extends keyof B ? never : K]: A[K];
+} & {
+    [K in keyof B]: B[K];
+}>;
+type TupleItems = ReadonlyArray<SomeType>;
+type AnyFunc = (...args: any[]) => any;
+type MaybeAsync<T> = T | Promise<T>;
+type EnumValue = string | number;
+type EnumLike = Readonly<Record<string, EnumValue>>;
+type ToEnum<T extends EnumValue> = Flatten<{
+    [k in T]: k;
+}>;
+type Literal = string | number | bigint | boolean | null | undefined;
+type Primitive = string | number | symbol | bigint | boolean | null | undefined;
+type HasLength = {
+    length: number;
+};
+type Numeric = number | bigint | Date;
+type PropValues = Record<string, Set<Primitive>>;
+type PrimitiveSet = Set<Primitive>;
+type EmptyToNever<T> = keyof T extends never ? never : T;
+declare abstract class Class {
+    constructor(..._args: any[]);
+}
+
+declare const version: {
+    readonly major: 4;
+    readonly minor: 4;
+    readonly patch: number;
+};
+
+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<T extends $ZodTypeInternals = $ZodTypeInternals> extends $ZodType<T["output"], T["input"], T> {
+}
+interface $ZodType<O = unknown, I = unknown, Internals extends $ZodTypeInternals<O, I> = $ZodTypeInternals<O, I>> {
+    _zod: Internals;
+    "~standard": $ZodStandardSchema<this>;
+}
+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>;
+type _File = typeof globalThis extends {
+    File: infer F extends new (...args: any[]) => any;
+} ? InstanceType<F> : {};
+/** Do not reference this directly. */
+interface File extends _File {
+    readonly type: string;
+    readonly size: number;
+}
+interface $ZodFileDef extends $ZodTypeDef {
+    type: "file";
+}
+interface $ZodFileInternals extends $ZodTypeInternals<File, File> {
+    def: $ZodFileDef;
+    isst: $ZodIssueInvalidType;
+    bag: LoosePartial<{
+        minimum: number;
+        maximum: number;
+        mime: MimeTypes[];
+    }>;
+}
+interface $ZodFile extends $ZodType {
+    _zod: $ZodFileInternals;
+}
+declare const $ZodFile: $constructor<$ZodFile>;
+interface $ZodTransformDef extends $ZodTypeDef {
+    type: "transform";
+    transform: (input: unknown, payload: ParsePayload<unknown>) => MaybeAsync<unknown>;
+}
+interface $ZodTransformInternals<O = unknown, I = unknown> extends $ZodTypeInternals<O, I> {
+    def: $ZodTransformDef;
+    isst: never;
+}
+interface $ZodTransform<O = unknown, I = unknown> extends $ZodType {
+    _zod: $ZodTransformInternals<O, I>;
+}
+declare const $ZodTransform: $constructor<$ZodTransform>;
+interface $ZodOptionalDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+    type: "optional";
+    innerType: T;
+}
+interface $ZodOptionalInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T> | undefined, input<T> | undefined> {
+    def: $ZodOptionalDef<T>;
+    optin: "optional";
+    optout: "optional";
+    isst: never;
+    values: T["_zod"]["values"];
+    pattern: T["_zod"]["pattern"];
+}
+interface $ZodOptional<T extends SomeType = $ZodType> extends $ZodType {
+    _zod: $ZodOptionalInternals<T>;
+}
+declare const $ZodOptional: $constructor<$ZodOptional>;
+interface $ZodExactOptionalDef<T extends SomeType = $ZodType> extends $ZodOptionalDef<T> {
+}
+interface $ZodExactOptionalInternals<T extends SomeType = $ZodType> extends $ZodOptionalInternals<T> {
+    def: $ZodExactOptionalDef<T>;
+    output: output<T>;
+    input: input<T>;
+}
+interface $ZodExactOptional<T extends SomeType = $ZodType> extends $ZodType {
+    _zod: $ZodExactOptionalInternals<T>;
+}
+declare const $ZodExactOptional: $constructor<$ZodExactOptional>;
+interface $ZodNullableDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+    type: "nullable";
+    innerType: T;
+}
+interface $ZodNullableInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T> | null, input<T> | null> {
+    def: $ZodNullableDef<T>;
+    optin: T["_zod"]["optin"];
+    optout: T["_zod"]["optout"];
+    isst: never;
+    values: T["_zod"]["values"];
+    pattern: T["_zod"]["pattern"];
+}
+interface $ZodNullable<T extends SomeType = $ZodType> extends $ZodType {
+    _zod: $ZodNullableInternals<T>;
+}
+declare const $ZodNullable: $constructor<$ZodNullable>;
+interface $ZodDefaultDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+    type: "default";
+    innerType: T;
+    /** The default value. May be a getter. */
+    defaultValue: NoUndefined<output<T>>;
+}
+interface $ZodDefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T>>, input<T> | undefined> {
+    def: $ZodDefaultDef<T>;
+    optin: "optional";
+    optout?: "optional" | undefined;
+    isst: never;
+    values: T["_zod"]["values"];
+}
+interface $ZodDefault<T extends SomeType = $ZodType> extends $ZodType {
+    _zod: $ZodDefaultInternals<T>;
+}
+declare const $ZodDefault: $constructor<$ZodDefault>;
+interface $ZodPrefaultDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+    type: "prefault";
+    innerType: T;
+    /** The default value. May be a getter. */
+    defaultValue: input<T>;
+}
+interface $ZodPrefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T>>, input<T> | undefined> {
+    def: $ZodPrefaultDef<T>;
+    optin: "optional";
+    optout?: "optional" | undefined;
+    isst: never;
+    values: T["_zod"]["values"];
+}
+interface $ZodPrefault<T extends SomeType = $ZodType> extends $ZodType {
+    _zod: $ZodPrefaultInternals<T>;
+}
+declare const $ZodPrefault: $constructor<$ZodPrefault>;
+interface $ZodNonOptionalDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+    type: "nonoptional";
+    innerType: T;
+}
+interface $ZodNonOptionalInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T>>, NoUndefined<input<T>>> {
+    def: $ZodNonOptionalDef<T>;
+    isst: $ZodIssueInvalidType;
+    values: T["_zod"]["values"];
+    optin: "optional" | undefined;
+    optout: "optional" | undefined;
+}
+interface $ZodNonOptional<T extends SomeType = $ZodType> extends $ZodType {
+    _zod: $ZodNonOptionalInternals<T>;
+}
+declare const $ZodNonOptional: $constructor<$ZodNonOptional>;
+interface $ZodSuccessDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+    type: "success";
+    innerType: T;
+}
+interface $ZodSuccessInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<boolean, input<T>> {
+    def: $ZodSuccessDef<T>;
+    isst: never;
+    optin: T["_zod"]["optin"];
+    optout: "optional" | undefined;
+}
+interface $ZodSuccess<T extends SomeType = $ZodType> extends $ZodType {
+    _zod: $ZodSuccessInternals<T>;
+}
+declare const $ZodSuccess: $constructor<$ZodSuccess>;
+interface $ZodCatchCtx extends ParsePayload {
+    /** @deprecated Use `ctx.issues` */
+    error: {
+        issues: $ZodIssue[];
+    };
+    /** @deprecated Use `ctx.value` */
+    input: unknown;
+}
+interface $ZodCatchDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+    type: "catch";
+    innerType: T;
+    catchValue: (ctx: $ZodCatchCtx) => unknown;
+}
+interface $ZodCatchInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T>, input<T>> {
+    def: $ZodCatchDef<T>;
+    optin: T["_zod"]["optin"];
+    optout: T["_zod"]["optout"];
+    isst: never;
+    values: T["_zod"]["values"];
+}
+interface $ZodCatch<T extends SomeType = $ZodType> extends $ZodType {
+    _zod: $ZodCatchInternals<T>;
+}
+declare const $ZodCatch: $constructor<$ZodCatch>;
+interface $ZodNaNDef extends $ZodTypeDef {
+    type: "nan";
+}
+interface $ZodNaNInternals extends $ZodTypeInternals<number, number> {
+    def: $ZodNaNDef;
+    isst: $ZodIssueInvalidType;
+}
+interface $ZodNaN extends $ZodType {
+    _zod: $ZodNaNInternals;
+}
+declare const $ZodNaN: $constructor<$ZodNaN>;
+interface $ZodPipeDef<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeDef {
+    type: "pipe";
+    in: A;
+    out: B;
+    /** Only defined inside $ZodCodec instances. */
+    transform?: (value: output<A>, payload: ParsePayload<output<A>>) => MaybeAsync<input<B>>;
+    /** Only defined inside $ZodCodec instances. */
+    reverseTransform?: (value: input<B>, payload: ParsePayload<input<B>>) => MaybeAsync<output<A>>;
+}
+interface $ZodPipeInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<output<B>, input<A>> {
+    def: $ZodPipeDef<A, B>;
+    isst: never;
+    values: A["_zod"]["values"];
+    optin: A["_zod"]["optin"];
+    optout: B["_zod"]["optout"];
+    propValues: A["_zod"]["propValues"];
+}
+interface $ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
+    _zod: $ZodPipeInternals<A, B>;
+}
+declare const $ZodPipe: $constructor<$ZodPipe>;
+interface $ZodReadonlyDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+    type: "readonly";
+    innerType: T;
+}
+interface $ZodReadonlyInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<MakeReadonly<output<T>>, MakeReadonly<input<T>>> {
+    def: $ZodReadonlyDef<T>;
+    optin: T["_zod"]["optin"];
+    optout: T["_zod"]["optout"];
+    isst: never;
+    propValues: T["_zod"]["propValues"];
+    values: T["_zod"]["values"];
+}
+interface $ZodReadonly<T extends SomeType = $ZodType> extends $ZodType {
+    _zod: $ZodReadonlyInternals<T>;
+}
+declare const $ZodReadonly: $constructor<$ZodReadonly>;
+interface $ZodTemplateLiteralDef extends $ZodTypeDef {
+    type: "template_literal";
+    parts: $ZodTemplateLiteralPart[];
+    format?: string | undefined;
+}
+interface $ZodTemplateLiteralInternals<Template extends string = string> extends $ZodTypeInternals<Template, Template> {
+    pattern: RegExp;
+    def: $ZodTemplateLiteralDef;
+    isst: $ZodIssueInvalidType;
+}
+type LiteralPart = Exclude<Literal, symbol>;
+interface SchemaPartInternals extends $ZodTypeInternals<LiteralPart, LiteralPart> {
+    pattern: RegExp;
+}
+interface SchemaPart extends $ZodType {
+    _zod: SchemaPartInternals;
+}
+type $ZodTemplateLiteralPart = LiteralPart | SchemaPart;
+interface $ZodTemplateLiteral<Template extends string = string> extends $ZodType {
+    _zod: $ZodTemplateLiteralInternals<Template>;
+}
+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;
+
+interface $ZodCheckDef {
+    check: string;
+    error?: $ZodErrorMap<never> | undefined;
+    /** If true, no later checks will be executed if this check fails. Default `false`. */
+    abort?: boolean | undefined;
+    /** If provided, the check runs only when this returns `true`. By default, it is skipped if prior parsing produced aborting issues. */
+    when?: ((payload: ParsePayload) => boolean) | undefined;
+}
+interface $ZodCheckInternals<T> {
+    def: $ZodCheckDef;
+    /** The set of issues this check might throw. */
+    issc?: $ZodIssueBase;
+    check(payload: ParsePayload<T>): MaybeAsync<void>;
+    onattach: ((schema: $ZodType) => void)[];
+}
+interface $ZodCheck<in T = never> {
+    _zod: $ZodCheckInternals<T>;
+}
+declare const $ZodCheck: $constructor<$ZodCheck<any>>;
+interface $ZodCheckLessThanDef extends $ZodCheckDef {
+    check: "less_than";
+    value: Numeric;
+    inclusive: boolean;
+}
+interface $ZodCheckLessThanInternals<T extends Numeric = Numeric> extends $ZodCheckInternals<T> {
+    def: $ZodCheckLessThanDef;
+    issc: $ZodIssueTooBig<T>;
+}
+interface $ZodCheckLessThan<T extends Numeric = Numeric> extends $ZodCheck<T> {
+    _zod: $ZodCheckLessThanInternals<T>;
+}
+declare const $ZodCheckLessThan: $constructor<$ZodCheckLessThan>;
+interface $ZodCheckGreaterThanDef extends $ZodCheckDef {
+    check: "greater_than";
+    value: Numeric;
+    inclusive: boolean;
+}
+interface $ZodCheckGreaterThanInternals<T extends Numeric = Numeric> extends $ZodCheckInternals<T> {
+    def: $ZodCheckGreaterThanDef;
+    issc: $ZodIssueTooSmall<T>;
+}
+interface $ZodCheckGreaterThan<T extends Numeric = Numeric> extends $ZodCheck<T> {
+    _zod: $ZodCheckGreaterThanInternals<T>;
+}
+declare const $ZodCheckGreaterThan: $constructor<$ZodCheckGreaterThan>;
+interface $ZodCheckMultipleOfDef<T extends number | bigint = number | bigint> extends $ZodCheckDef {
+    check: "multiple_of";
+    value: T;
+}
+interface $ZodCheckMultipleOfInternals<T extends number | bigint = number | bigint> extends $ZodCheckInternals<T> {
+    def: $ZodCheckMultipleOfDef<T>;
+    issc: $ZodIssueNotMultipleOf;
+}
+interface $ZodCheckMultipleOf<T extends number | bigint = number | bigint> extends $ZodCheck<T> {
+    _zod: $ZodCheckMultipleOfInternals<T>;
+}
+declare const $ZodCheckMultipleOf: $constructor<$ZodCheckMultipleOf<number | bigint>>;
+type $ZodNumberFormats = "int32" | "uint32" | "float32" | "float64" | "safeint";
+interface $ZodCheckNumberFormatDef extends $ZodCheckDef {
+    check: "number_format";
+    format: $ZodNumberFormats;
+}
+interface $ZodCheckNumberFormatInternals extends $ZodCheckInternals<number> {
+    def: $ZodCheckNumberFormatDef;
+    issc: $ZodIssueInvalidType | $ZodIssueTooBig<"number"> | $ZodIssueTooSmall<"number">;
+}
+interface $ZodCheckNumberFormat extends $ZodCheck<number> {
+    _zod: $ZodCheckNumberFormatInternals;
+}
+declare const $ZodCheckNumberFormat: $constructor<$ZodCheckNumberFormat>;
+interface $ZodCheckMaxLengthDef extends $ZodCheckDef {
+    check: "max_length";
+    maximum: number;
+}
+interface $ZodCheckMaxLengthInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+    def: $ZodCheckMaxLengthDef;
+    issc: $ZodIssueTooBig<T>;
+}
+interface $ZodCheckMaxLength<T extends HasLength = HasLength> extends $ZodCheck<T> {
+    _zod: $ZodCheckMaxLengthInternals<T>;
+}
+declare const $ZodCheckMaxLength: $constructor<$ZodCheckMaxLength>;
+interface $ZodCheckMinLengthDef extends $ZodCheckDef {
+    check: "min_length";
+    minimum: number;
+}
+interface $ZodCheckMinLengthInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+    def: $ZodCheckMinLengthDef;
+    issc: $ZodIssueTooSmall<T>;
+}
+interface $ZodCheckMinLength<T extends HasLength = HasLength> extends $ZodCheck<T> {
+    _zod: $ZodCheckMinLengthInternals<T>;
+}
+declare const $ZodCheckMinLength: $constructor<$ZodCheckMinLength>;
+interface $ZodCheckLengthEqualsDef extends $ZodCheckDef {
+    check: "length_equals";
+    length: number;
+}
+interface $ZodCheckLengthEqualsInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+    def: $ZodCheckLengthEqualsDef;
+    issc: $ZodIssueTooBig<T> | $ZodIssueTooSmall<T>;
+}
+interface $ZodCheckLengthEquals<T extends HasLength = HasLength> extends $ZodCheck<T> {
+    _zod: $ZodCheckLengthEqualsInternals<T>;
+}
+declare const $ZodCheckLengthEquals: $constructor<$ZodCheckLengthEquals>;
+type $ZodStringFormats = "email" | "url" | "emoji" | "uuid" | "guid" | "nanoid" | "cuid" | "cuid2" | "ulid" | "xid" | "ksuid" | "datetime" | "date" | "time" | "duration" | "ipv4" | "ipv6" | "cidrv4" | "cidrv6" | "base64" | "base64url" | "json_string" | "e164" | "lowercase" | "uppercase" | "regex" | "jwt" | "starts_with" | "ends_with" | "includes";
+interface $ZodCheckStringFormatDef<Format extends string = string> extends $ZodCheckDef {
+    check: "string_format";
+    format: Format;
+    pattern?: RegExp | undefined;
+}
+interface $ZodCheckStringFormatInternals extends $ZodCheckInternals<string> {
+    def: $ZodCheckStringFormatDef;
+    issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckRegexDef extends $ZodCheckStringFormatDef {
+    format: "regex";
+    pattern: RegExp;
+}
+interface $ZodCheckRegexInternals extends $ZodCheckInternals<string> {
+    def: $ZodCheckRegexDef;
+    issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckRegex extends $ZodCheck<string> {
+    _zod: $ZodCheckRegexInternals;
+}
+declare const $ZodCheckRegex: $constructor<$ZodCheckRegex>;
+interface $ZodCheckLowerCaseDef extends $ZodCheckStringFormatDef<"lowercase"> {
+}
+interface $ZodCheckLowerCaseInternals extends $ZodCheckInternals<string> {
+    def: $ZodCheckLowerCaseDef;
+    issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckLowerCase extends $ZodCheck<string> {
+    _zod: $ZodCheckLowerCaseInternals;
+}
+declare const $ZodCheckLowerCase: $constructor<$ZodCheckLowerCase>;
+interface $ZodCheckUpperCaseDef extends $ZodCheckStringFormatDef<"uppercase"> {
+}
+interface $ZodCheckUpperCaseInternals extends $ZodCheckInternals<string> {
+    def: $ZodCheckUpperCaseDef;
+    issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckUpperCase extends $ZodCheck<string> {
+    _zod: $ZodCheckUpperCaseInternals;
+}
+declare const $ZodCheckUpperCase: $constructor<$ZodCheckUpperCase>;
+interface $ZodCheckIncludesDef extends $ZodCheckStringFormatDef<"includes"> {
+    includes: string;
+    position?: number | undefined;
+}
+interface $ZodCheckIncludesInternals extends $ZodCheckInternals<string> {
+    def: $ZodCheckIncludesDef;
+    issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckIncludes extends $ZodCheck<string> {
+    _zod: $ZodCheckIncludesInternals;
+}
+declare const $ZodCheckIncludes: $constructor<$ZodCheckIncludes>;
+interface $ZodCheckStartsWithDef extends $ZodCheckStringFormatDef<"starts_with"> {
+    prefix: string;
+}
+interface $ZodCheckStartsWithInternals extends $ZodCheckInternals<string> {
+    def: $ZodCheckStartsWithDef;
+    issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckStartsWith extends $ZodCheck<string> {
+    _zod: $ZodCheckStartsWithInternals;
+}
+declare const $ZodCheckStartsWith: $constructor<$ZodCheckStartsWith>;
+interface $ZodCheckEndsWithDef extends $ZodCheckStringFormatDef<"ends_with"> {
+    suffix: string;
+}
+interface $ZodCheckEndsWithInternals extends $ZodCheckInternals<string> {
+    def: $ZodCheckEndsWithDef;
+    issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckEndsWith extends $ZodCheckInternals<string> {
+    _zod: $ZodCheckEndsWithInternals;
+}
+declare const $ZodCheckEndsWith: $constructor<$ZodCheckEndsWith>;
+
+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>>;
+
+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;
+
+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 $ZodCheckNumberFormatParams = CheckParams<$ZodCheckNumberFormat, "format" | "when">;
+type $ZodCheckLessThanParams = CheckParams<$ZodCheckLessThan, "inclusive" | "value" | "when">;
+type $ZodCheckGreaterThanParams = CheckParams<$ZodCheckGreaterThan, "inclusive" | "value" | "when">;
+type $ZodCheckMultipleOfParams = CheckParams<$ZodCheckMultipleOf, "value" | "when">;
+type $ZodCheckMaxLengthParams = CheckParams<$ZodCheckMaxLength, "maximum" | "when">;
+type $ZodCheckMinLengthParams = CheckParams<$ZodCheckMinLength, "minimum" | "when">;
+type $ZodCheckLengthEqualsParams = CheckParams<$ZodCheckLengthEquals, "length" | "when">;
+type $ZodCheckRegexParams = CheckParams<$ZodCheckRegex, "format" | "pattern" | "when">;
+type $ZodCheckLowerCaseParams = CheckParams<$ZodCheckLowerCase, "format" | "when">;
+type $ZodCheckUpperCaseParams = CheckParams<$ZodCheckUpperCase, "format" | "when">;
+type $ZodCheckIncludesParams = CheckParams<$ZodCheckIncludes, "includes" | "format" | "when" | "pattern">;
+type $ZodCheckStartsWithParams = CheckParams<$ZodCheckStartsWith, "prefix" | "format" | "when" | "pattern">;
+type $ZodCheckEndsWithParams = CheckParams<$ZodCheckEndsWith, "suffix" | "format" | "pattern" | "when">;
+type $ZodEnumParams = TypeParams<$ZodEnum, "entries">;
+type $ZodNonOptionalParams = TypeParams<$ZodNonOptional, "innerType">;
+type $ZodCustomParams = CheckTypeParams<$ZodCustom, "fn">;
+type $ZodSuperRefineIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
+type RawIssue<T extends $ZodIssueBase> = T extends any ? Flatten<MakePartial<T, "message" | "path"> & {
+    /** The schema or check that originated this issue. */
+    readonly inst?: $ZodType | $ZodCheck;
+    /** If `true`, Zod will execute subsequent checks/refinements instead of immediately aborting */
+    readonly continue?: boolean | undefined;
+} & Record<string, unknown>> : never;
+interface $RefinementCtx<T = unknown> extends ParsePayload<T> {
+    addIssue(arg: string | $ZodSuperRefineIssue): void;
+}
+interface $ZodSuperRefineParams {
+    /** If provided, the refinement runs only when this returns `true`. By default, it is skipped if prior parsing produced aborting issues. */
+    when?: ((payload: ParsePayload) => boolean) | undefined;
+}
+
+/** 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>;
+
+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>;
+};
+
+type ZodStandardSchemaWithJSON<T> = StandardSchemaWithJSONProps<input<T>, output<T>>;
+interface _ZodType<out Internals extends $ZodTypeInternals = $ZodTypeInternals> extends ZodType<any, any, Internals> {
+}
+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;
+}
+declare const ZodType: $constructor<ZodType>;
+interface _ZodString<T extends $ZodStringInternals<unknown> = $ZodStringInternals<unknown>> extends _ZodType<T> {
+    format: string | null;
+    minLength: number | null;
+    maxLength: number | null;
+    regex(regex: RegExp, params?: string | $ZodCheckRegexParams): this;
+    includes(value: string, params?: string | $ZodCheckIncludesParams): this;
+    startsWith(value: string, params?: string | $ZodCheckStartsWithParams): this;
+    endsWith(value: string, params?: string | $ZodCheckEndsWithParams): this;
+    min(minLength: number, params?: string | $ZodCheckMinLengthParams): this;
+    max(maxLength: number, params?: string | $ZodCheckMaxLengthParams): this;
+    length(len: number, params?: string | $ZodCheckLengthEqualsParams): this;
+    nonempty(params?: string | $ZodCheckMinLengthParams): this;
+    lowercase(params?: string | $ZodCheckLowerCaseParams): this;
+    uppercase(params?: string | $ZodCheckUpperCaseParams): this;
+    trim(): this;
+    normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): this;
+    toLowerCase(): this;
+    toUpperCase(): this;
+    slugify(): this;
+}
+/** @internal */
+declare const _ZodString: $constructor<_ZodString>;
+interface ZodString extends _ZodString<$ZodStringInternals<string>> {
+    /** @deprecated Use `z.email()` instead. */
+    email(params?: string | $ZodCheckEmailParams): this;
+    /** @deprecated Use `z.url()` instead. */
+    url(params?: string | $ZodCheckURLParams): this;
+    /** @deprecated Use `z.jwt()` instead. */
+    jwt(params?: string | $ZodCheckJWTParams): this;
+    /** @deprecated Use `z.emoji()` instead. */
+    emoji(params?: string | $ZodCheckEmojiParams): this;
+    /** @deprecated Use `z.guid()` instead. */
+    guid(params?: string | $ZodCheckGUIDParams): this;
+    /** @deprecated Use `z.uuid()` instead. */
+    uuid(params?: string | $ZodCheckUUIDParams): this;
+    /** @deprecated Use `z.uuid()` instead. */
+    uuidv4(params?: string | $ZodCheckUUIDParams): this;
+    /** @deprecated Use `z.uuid()` instead. */
+    uuidv6(params?: string | $ZodCheckUUIDParams): this;
+    /** @deprecated Use `z.uuid()` instead. */
+    uuidv7(params?: string | $ZodCheckUUIDParams): this;
+    /** @deprecated Use `z.nanoid()` instead. */
+    nanoid(params?: string | $ZodCheckNanoIDParams): this;
+    /** @deprecated Use `z.guid()` instead. */
+    guid(params?: string | $ZodCheckGUIDParams): this;
+    /**
+     * @deprecated CUID v1 is deprecated by its authors due to information leakage
+     * (timestamps embedded in the id). Use `z.cuid2()` instead.
+     * See https://github.com/paralleldrive/cuid.
+     */
+    cuid(params?: string | $ZodCheckCUIDParams): this;
+    /** @deprecated Use `z.cuid2()` instead. */
+    cuid2(params?: string | $ZodCheckCUID2Params): this;
+    /** @deprecated Use `z.ulid()` instead. */
+    ulid(params?: string | $ZodCheckULIDParams): this;
+    /** @deprecated Use `z.base64()` instead. */
+    base64(params?: string | $ZodCheckBase64Params): this;
+    /** @deprecated Use `z.base64url()` instead. */
+    base64url(params?: string | $ZodCheckBase64URLParams): this;
+    /** @deprecated Use `z.xid()` instead. */
+    xid(params?: string | $ZodCheckXIDParams): this;
+    /** @deprecated Use `z.ksuid()` instead. */
+    ksuid(params?: string | $ZodCheckKSUIDParams): this;
+    /** @deprecated Use `z.ipv4()` instead. */
+    ipv4(params?: string | $ZodCheckIPv4Params): this;
+    /** @deprecated Use `z.ipv6()` instead. */
+    ipv6(params?: string | $ZodCheckIPv6Params): this;
+    /** @deprecated Use `z.cidrv4()` instead. */
+    cidrv4(params?: string | $ZodCheckCIDRv4Params): this;
+    /** @deprecated Use `z.cidrv6()` instead. */
+    cidrv6(params?: string | $ZodCheckCIDRv6Params): this;
+    /** @deprecated Use `z.e164()` instead. */
+    e164(params?: string | $ZodCheckE164Params): this;
+    /** @deprecated Use `z.iso.datetime()` instead. */
+    datetime(params?: string | $ZodCheckISODateTimeParams): this;
+    /** @deprecated Use `z.iso.date()` instead. */
+    date(params?: string | $ZodCheckISODateParams): this;
+    /** @deprecated Use `z.iso.time()` instead. */
+    time(params?: string | $ZodCheckISOTimeParams): this;
+    /** @deprecated Use `z.iso.duration()` instead. */
+    duration(params?: string | $ZodCheckISODurationParams): this;
+}
+declare const ZodString: $constructor<ZodString>;
+interface _ZodNumber<Internals extends $ZodNumberInternals = $ZodNumberInternals> extends _ZodType<Internals> {
+    gt(value: number, params?: string | $ZodCheckGreaterThanParams): this;
+    /** Identical to .min() */
+    gte(value: number, params?: string | $ZodCheckGreaterThanParams): this;
+    min(value: number, params?: string | $ZodCheckGreaterThanParams): this;
+    lt(value: number, params?: string | $ZodCheckLessThanParams): this;
+    /** Identical to .max() */
+    lte(value: number, params?: string | $ZodCheckLessThanParams): this;
+    max(value: number, params?: string | $ZodCheckLessThanParams): this;
+    /** Consider `z.int()` instead. This API is considered *legacy*; it will never be removed but a better alternative exists. */
+    int(params?: string | $ZodCheckNumberFormatParams): this;
+    /** @deprecated This is now identical to `.int()`. Only numbers in the safe integer range are accepted. */
+    safe(params?: string | $ZodCheckNumberFormatParams): this;
+    positive(params?: string | $ZodCheckGreaterThanParams): this;
+    nonnegative(params?: string | $ZodCheckGreaterThanParams): this;
+    negative(params?: string | $ZodCheckLessThanParams): this;
+    nonpositive(params?: string | $ZodCheckLessThanParams): this;
+    multipleOf(value: number, params?: string | $ZodCheckMultipleOfParams): this;
+    /** @deprecated Use `.multipleOf()` instead. */
+    step(value: number, params?: string | $ZodCheckMultipleOfParams): this;
+    /** @deprecated In v4 and later, z.number() does not allow infinite values by default. This is a no-op. */
+    finite(params?: unknown): this;
+    minValue: number | null;
+    maxValue: number | null;
+    /** @deprecated Check the `format` property instead.  */
+    isInt: boolean;
+    /** @deprecated Number schemas no longer accept infinite values, so this always returns `true`. */
+    isFinite: boolean;
+    format: string | null;
+}
+interface ZodNumber extends _ZodNumber<$ZodNumberInternals<number>> {
+}
+declare const ZodNumber: $constructor<ZodNumber>;
+interface _ZodBoolean<T extends $ZodBooleanInternals = $ZodBooleanInternals> extends _ZodType<T> {
+}
+interface ZodBoolean extends _ZodBoolean<$ZodBooleanInternals<boolean>> {
+}
+declare const ZodBoolean: $constructor<ZodBoolean>;
+interface ZodNull extends _ZodType<$ZodNullInternals> {
+}
+declare const ZodNull: $constructor<ZodNull>;
+interface 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 ZodRecord<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends _ZodType<$ZodRecordInternals<Key, Value>>, $ZodRecord<Key, Value> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
+    keyType: Key;
+    valueType: Value;
+}
+declare const ZodRecord: $constructor<ZodRecord>;
+interface ZodEnum<
+/** @ts-ignore Cast variance */
+out T extends EnumLike = EnumLike> extends _ZodType<$ZodEnumInternals<T>>, $ZodEnum<T> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
+    enum: T;
+    options: Array<T[keyof T]>;
+    extract<const U extends readonly (keyof T)[]>(values: U, params?: string | $ZodEnumParams): ZodEnum<Flatten<Pick<T, U[number]>>>;
+    exclude<const U extends readonly (keyof T)[]>(values: U, params?: string | $ZodEnumParams): ZodEnum<Flatten<Omit<T, U[number]>>>;
+}
+declare const ZodEnum: $constructor<ZodEnum>;
+interface ZodLiteral<T extends Literal = Literal> extends _ZodType<$ZodLiteralInternals<T>>, $ZodLiteral<T> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
+    values: Set<T>;
+    /** @legacy Use `.values` instead. Accessing this property will throw an error if the literal accepts multiple values. */
+    value: T;
+}
+declare const ZodLiteral: $constructor<ZodLiteral>;
+interface ZodTransform<O = unknown, I = unknown> extends _ZodType<$ZodTransformInternals<O, I>>, $ZodTransform<O, I> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
+}
+declare const ZodTransform: $constructor<ZodTransform>;
+interface ZodOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodOptionalInternals<T>>, $ZodOptional<T> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
+    unwrap(): T;
+}
+declare const ZodOptional: $constructor<ZodOptional>;
+interface ZodExactOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodExactOptionalInternals<T>>, $ZodExactOptional<T> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
+    unwrap(): T;
+}
+declare const ZodExactOptional: $constructor<ZodExactOptional>;
+interface ZodNullable<T extends SomeType = $ZodType> extends _ZodType<$ZodNullableInternals<T>>, $ZodNullable<T> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
+    unwrap(): T;
+}
+declare const ZodNullable: $constructor<ZodNullable>;
+interface ZodDefault<T extends SomeType = $ZodType> extends _ZodType<$ZodDefaultInternals<T>>, $ZodDefault<T> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
+    unwrap(): T;
+    /** @deprecated Use `.unwrap()` instead. */
+    removeDefault(): T;
+}
+declare const ZodDefault: $constructor<ZodDefault>;
+interface ZodPrefault<T extends SomeType = $ZodType> extends _ZodType<$ZodPrefaultInternals<T>>, $ZodPrefault<T> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
+    unwrap(): T;
+}
+declare const ZodPrefault: $constructor<ZodPrefault>;
+interface ZodNonOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodNonOptionalInternals<T>>, $ZodNonOptional<T> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
+    unwrap(): T;
+}
+declare const ZodNonOptional: $constructor<ZodNonOptional>;
+interface ZodCatch<T extends SomeType = $ZodType> extends _ZodType<$ZodCatchInternals<T>>, $ZodCatch<T> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
+    unwrap(): T;
+    /** @deprecated Use `.unwrap()` instead. */
+    removeCatch(): T;
+}
+declare const ZodCatch: $constructor<ZodCatch>;
+interface ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodPipeInternals<A, B>>, $ZodPipe<A, B> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
+    in: A;
+    out: B;
+}
+declare const ZodPipe: $constructor<ZodPipe>;
+interface ZodReadonly<T extends SomeType = $ZodType> extends _ZodType<$ZodReadonlyInternals<T>>, $ZodReadonly<T> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
+    unwrap(): T;
+}
+declare const ZodReadonly: $constructor<ZodReadonly>;
+type _ZodJSONSchema = ZodUnion<[
+    ZodString,
+    ZodNumber,
+    ZodBoolean,
+    ZodNull,
+    ZodArray<ZodJSONSchema>,
+    ZodRecord<ZodString, ZodJSONSchema>
+]>;
+type _ZodJSONSchemaInternals = _ZodJSONSchema["_zod"];
+interface ZodJSONSchemaInternals extends _ZodJSONSchemaInternals {
+    output: JSONType;
+    input: JSONType;
+}
+interface ZodJSONSchema extends _ZodJSONSchema {
+    _zod: ZodJSONSchemaInternals;
+}
+
+/**
+ * 间距档位；DSL 不提供自由数值，间距只能取自 design token 档位。
+ *
+ * 同一档位在纵向与横向映射到不同 token 家族（`space-stack-*` 与 `space-inline-*`），
+ * 因此插件声明的是节奏而不是像素。
+ */
+declare const viewGapSchema: ZodEnum<{
+    none: "none";
+    micro: "micro";
+    xs: "xs";
+    compact: "compact";
+    sm: "sm";
+    related: "related";
+    md: "md";
+    emphasis: "emphasis";
+    section: "section";
+    lg: "lg";
+}>;
+/** 容器内边距档位；`block-xs` / `block-sm` 仅上下留白 4px / 8px，不改变文案左右对齐，其余映射到 inset token，`card` 为 20px 安全区。 */
+declare const viewPaddingSchema: ZodEnum<{
+    none: "none";
+    sm: "sm";
+    md: "md";
+    lg: "lg";
+    "block-xs": "block-xs";
+    "block-sm": "block-sm";
+    balanced: "balanced";
+    card: "card";
+}>;
+/** 交叉轴对齐方式。 */
+declare const viewAlignSchema: ZodEnum<{
+    start: "start";
+    center: "center";
+    end: "end";
+    stretch: "stretch";
+}>;
+/** 主轴分布方式。 */
+declare const viewDistributeSchema: ZodEnum<{
+    start: "start";
+    center: "center";
+    end: "end";
+    between: "between";
+}>;
+/**
+ * 容器表面配方。
+ *
+ * 插件只声明「这是一块什么」，具体底色、描边与圆角由宿主决定，宿主因此可以整体改版而不需要插件跟进。
+ */
+declare const viewSurfaceSchema: ZodEnum<{
+    none: "none";
+    card: "card";
+    panel: "panel";
+    inset: "inset";
+    outline: "outline";
+    tint: "tint";
+}>;
+/**
+ * 容器出血档位。
+ *
+ * `card-top` 只把容器表面延伸到标准 Card 的顶部与左右内边界；容器内容仍由宿主按 Card
+ * 安全区内收。旧宿主忽略该新增属性后仍渲染同一内容，只是退回普通内嵌表面。
+ */
+declare const viewBleedSchema: ZodEnum<{
+    "card-top": "card-top";
+}>;
+/** 圆角档位；映射到 `radius-surface-*`、`radius-dialog` 与圆形控件使用的 `full`。 */
+declare const viewRadiusSchema: ZodEnum<{
+    none: "none";
+    sm: "sm";
+    md: "md";
+    lg: "lg";
+    full: "full";
+}>;
+/** 层次档位；`raised` 同时切换局部 color context。 */
+declare const viewElevationSchema: ZodEnum<{
+    flat: "flat";
+    raised: "raised";
+}>;
+/** 容器横向尺寸档位；`auto` 使用内容固有宽度，`fill` 贯通父容器，DSL 不提供自由宽度。 */
+declare const viewWidthSchema: ZodEnum<{
+    auto: "auto";
+    fill: "fill";
+}>;
+/** 容器固定正方形尺寸；`md` 为 48×48 媒体槽，`hero` 为与头部主图一致的 60×60 占位槽。 */
+declare const viewBoxSizeSchema: ZodEnum<{
+    md: "md";
+    hero: "hero";
+}>;
+/** 容器纵向固定尺寸档位；只开放已有固定卡板合同需要的结构高度。 */
+declare const viewHeightSchema: ZodEnum<{
+    "data-tile": "data-tile";
+}>;
+/** 网格列数；固定档位而不是自由数值，避免出现宿主无法保证可读性的窄列。 */
+declare const viewGridColumnsSchema: ZodUnion<readonly [ZodLiteral<2>, ZodLiteral<3>, ZodLiteral<4>]>;
+/** 文本语义层级。 */
+declare const viewTextVariantSchema: ZodEnum<{
+    display: "display";
+    title: "title";
+    "title-large": "title-large";
+    subtitle: "subtitle";
+    body: "body";
+    "body-large": "body-large";
+    caption: "caption";
+    label: "label";
+    status: "status";
+    "status-large": "status-large";
+    meta: "meta";
+    "meta-large": "meta-large";
+    "meta-compact": "meta-compact";
+    "data-label": "data-label";
+}>;
+/** 文本字重覆写；缺省时使用语义层级自带的字重。 */
+declare const viewTextWeightSchema: ZodEnum<{
+    regular: "regular";
+    medium: "medium";
+    semibold: "semibold";
+}>;
+/**
+ * 宿主批准的文本完整 Paint；只表达完整视觉配方，不接受插件传入自由颜色或渐变字面量。
+ *
+ * 不认识该字段的旧宿主会忽略它，因此调用方仍应同时声明可读的 `tone` 作为降级语义色。
+ */
+declare const viewTextPaintSchema: ZodEnum<{
+    "achievement-completion": "achievement-completion";
+}>;
+/** 内容语气；映射到 semantic token 或宿主提供的上下文强调色，不接受任意颜色。 */
+declare const viewToneSchema: ZodEnum<{
+    success: "success";
+    default: "default";
+    accent: "accent";
+    muted: "muted";
+    warning: "warning";
+    danger: "danger";
+}>;
+/** 文本专用语气；额外开放 `Text/Strong` 和 `Text/Tertiary`。 */
+declare const viewTextToneSchema: ZodEnum<{
+    success: "success";
+    default: "default";
+    strong: "strong";
+    accent: "accent";
+    muted: "muted";
+    warning: "warning";
+    danger: "danger";
+    tertiary: "tertiary";
+}>;
+/** 比例条厚度档位；`sm` 保持既有细条，`md`/`lg` 服务高信息密度图表。 */
+declare const viewMeterSizeSchema: ZodEnum<{
+    sm: "sm";
+    md: "md";
+    lg: "lg";
+}>;
+/** 环形进度尺寸档位；`hero` 对应卡片头部稳定使用的 60px 视觉锚点。 */
+declare const viewRadialProgressSizeSchema: ZodEnum<{
+    sm: "sm";
+    md: "md";
+    hero: "hero";
+}>;
+/** 环形进度中心的宿主批准图形；不接受 Runtime 自由图片地址。 */
+declare const viewRadialProgressCenterGraphicSchema: ZodEnum<{
+    "achievement-completion-medal": "achievement-completion-medal";
+}>;
+/** 分类柱图柱宽档位；`md` 对应 PC 1×1 卡片的 22px 主柱。 */
+declare const viewBarChartSizeSchema: ZodEnum<{
+    sm: "sm";
+    md: "md";
+}>;
+/** 按钮视觉层级。 */
+declare const viewButtonVariantSchema: ZodEnum<{
+    primary: "primary";
+    secondary: "secondary";
+    ghost: "ghost";
+}>;
+/** 图片填充方式。 */
+declare const viewImageFitSchema: ZodEnum<{
+    cover: "cover";
+    contain: "contain";
+}>;
+/**
+ * 图片呈现强度。
+ *
+ * `deemphasized` 只表达内容尚不可用或需要弱化，宿主统一映射为灰阶与受控透明度；它不携带
+ * disabled、锁定或业务分类语义，调用方仍需用可读文本、图标或整体可访问名称表达真实状态。
+ */
+declare const viewImageAppearanceSchema: ZodEnum<{
+    default: "default";
+    deemphasized: "deemphasized";
+}>;
+/** 图片色彩语义；semantic 表示颜色承载业务含义，两类图片均保留原色，不随卡片主次添加滤镜。 */
+declare const viewImageColorRoleSchema: ZodEnum<{
+    content: "content";
+    semantic: "semantic";
+}>;
+/**
+ * 图片尺寸档位。
+ *
+ * 只用于必须固定边长的图：缺省时图片由容器与自身固有像素决定宽度，在宽卡的网格里会被
+ * 撑到整格宽，那是媒体图的行为而不是图标或列表缩略图的行为。档位而非自由数值，保证同一份
+ * 文档在不同卡片尺寸下呈现一致。`thumb` 对应列表行 40px 方图；`hero` 对应 60px 头部视觉锚点；
+ * `xl` 对应 80px 独立装饰层；`content` 对应 128px 内容列表图；`feature` 是宽卡主图固定边长；
+ * `landscape-compact` 与 `landscape-content` 分别提供 82×48px、128×74px 的整数横图槽。
+ */
+declare const viewImageSizeSchema: ZodEnum<{
+    sm: "sm";
+    md: "md";
+    lg: "lg";
+    hero: "hero";
+    content: "content";
+    thumb: "thumb";
+    xl: "xl";
+    feature: "feature";
+    "landscape-compact": "landscape-compact";
+    "landscape-content": "landscape-content";
+}>;
+/** 图标边长档位；只开放宿主批准的 16px、20px 与 24px，不接受自由尺寸。 */
+declare const viewIconSizeSchema: ZodUnion<readonly [ZodLiteral<16>, ZodLiteral<20>, ZodLiteral<24>]>;
+/** 图标颜色语义；disabled 对应 Text/Disabled 弱色，仅改变颜色，不禁用交互。实际色值由宿主主题映射。 */
+declare const viewIconColorSchema: ZodEnum<{
+    default: "default";
+    accent: "accent";
+    tertiary: "tertiary";
+    secondary: "secondary";
+    disabled: "disabled";
+}>;
+/** 图片遮罩；`fadeBottom` 在中段渐隐，`fadeBottomContent` 为底部短摘要保留更大画面，`fadeBottomEdge` 在底边收口。 */
+declare const viewImageOverlaySchema: ZodEnum<{
+    none: "none";
+    scrim: "scrim";
+    gradientBottom: "gradientBottom";
+    gradientTopBottom: "gradientTopBottom";
+    fadeBottom: "fadeBottom";
+    fadeBottomContent: "fadeBottomContent";
+    fadeBottomEdge: "fadeBottomEdge";
+}>;
+/** 列表条目排版。 */
+declare const viewListVariantSchema: ZodEnum<{
+    compact: "compact";
+    media: "media";
+    plain: "plain";
+}>;
+/** 轮播页指示器形态；具体视觉由宿主统一提供。 */
+declare const viewCarouselPaginationSchema: ZodEnum<{
+    none: "none";
+    bullets: "bullets";
+    fraction: "fraction";
+}>;
+/** 轮播页指示器相对内容的放置方式。 */
+declare const viewCarouselPaginationPlacementSchema: ZodEnum<{
+    inside: "inside";
+    outside: "outside";
+}>;
+/** 单个视口同时展示的轮播页数档位。 */
+declare const viewCarouselSlidesPerViewSchema: ZodUnion<readonly [ZodLiteral<1>, ZodLiteral<2>, ZodLiteral<3>]>;
+/**
+ * 新文档到达时使用的过渡配置。
+ *
+ * 配置只选择宿主受控的语义效果，不开放时长、缓动、位移或任意 CSS；旧宿主会剥离这个
+ * 可选根属性并直接显示新文档，因此它属于向前兼容的渐进增强。
+ */
+declare const viewTransitionSchema: ZodObject<{
+    effect: ZodEnum<{
+        crossfade: "crossfade";
+        morph: "morph";
+    }>;
+}, $strip>;
+/**
+ * 节点动作。
+ *
+ * `input` 是 Runtime 在构建文档时就已确定的静态 JSON；`inputFrom` 把「宿主此刻持有的用户输入」
+ * 并进同一份 input，取值按「input 键 → `textField` 节点 id」映射。做成显式映射而不是隐式约定，
+ * 是因为一个提交按钮可能收集多个字段，而字段与按钮在文档里往往不相邻。
+ *
+ * 不认识 `inputFrom` 的旧宿主会忽略它并只发送静态 `input`，因此声明该绑定的 Command 必须把对应
+ * 键声明为必填，让缺失在 Runtime 侧稳定失败，而不是拿着空值执行。
+ */
+declare const viewActionSchema: ZodObject<{
+    commandId: ZodString;
+    input: ZodOptional<ZodJSONSchema>;
+    inputFrom: ZodOptional<ZodRecord<ZodString, ZodString>>;
+}, $strip>;
+/** 比例条中的一个语义数据段；颜色只能来自宿主语气映射。 */
+declare const viewMeterSegmentSchema: ZodObject<{
+    value: ZodNumber;
+    label: ZodString;
+    tone: ZodOptional<ZodEnum<{
+        success: "success";
+        default: "default";
+        accent: "accent";
+        muted: "muted";
+        warning: "warning";
+        danger: "danger";
+    }>>;
+}, $strip>;
+/** 分类柱图中的一个数据项；标签和数值由 Runtime 提供，视觉归一化由宿主持有。 */
+declare const viewBarChartItemSchema: ZodObject<{
+    label: ZodString;
+    value: ZodNumber;
+    valueLabel: ZodOptional<ZodString>;
+}, $strip>;
+/**
+ * 文本节点的行内富文本片段。
+ *
+ * `spans` 是 `value` 的并行表达而不是替代品：不认识它的宿主把它当未知属性剥离后仍渲染 `value`，
+ * 富文本因此走「未知属性静默忽略」这条向前兼容路径，不需要递增文档 schema major。
+ * 代价是两处文本必须始终一致，该不变量由 `parseViewDocument` 结算。
+ */
+declare const viewTextSpanSchema: ZodObject<{
+    text: ZodString;
+    marks: ZodOptional<ZodArray<ZodEnum<{
+        strong: "strong";
+        em: "em";
+    }>>>;
+}, $strip>;
+/** 图片缺失或加载失败时的回退表达。 */
+declare const viewImageFallbackSchema: ZodObject<{
+    source: ZodOptional<ZodLiteral<"app-ambient">>;
+    icon: ZodOptional<ZodString>;
+    text: ZodOptional<ZodString>;
+}, $strip>;
+/** 字段组条目；`value` 缺省时渲染 `placeholder`，不虚构字段。 */
+declare const viewFieldItemSchema: ZodObject<{
+    label: ZodString;
+    value: ZodOptional<ZodString>;
+    placeholder: ZodOptional<ZodString>;
+}, $strip>;
+/**
+ * 列表条目；`action` 缺省即为不可点击条目，不显示点击暗示。
+ *
+ * `disabled` 表达「这条现在点不了」，与「不给 action」不同：后者是静态信息行，前者必须同时给出
+ * 可读原因，否则用户只会看到一行点不动的东西。
+ */
+declare const viewListItemSchema: ZodObject<{
+    id: ZodString;
+    title: ZodString;
+    subtitle: ZodOptional<ZodString>;
+    meta: ZodOptional<ZodString>;
+    image: ZodOptional<ZodString>;
+    imageFallback: ZodOptional<ZodObject<{
+        source: ZodOptional<ZodLiteral<"app-ambient">>;
+        icon: ZodOptional<ZodString>;
+        text: ZodOptional<ZodString>;
+    }, $strip>>;
+    imageShape: ZodOptional<ZodEnum<{
+        landscape: "landscape";
+        square: "square";
+        circle: "circle";
+    }>>;
+    imageFit: ZodOptional<ZodEnum<{
+        cover: "cover";
+        contain: "contain";
+    }>>;
+    imageAppearance: ZodOptional<ZodEnum<{
+        default: "default";
+        deemphasized: "deemphasized";
+    }>>;
+    imageColorRole: ZodOptional<ZodEnum<{
+        content: "content";
+        semantic: "semantic";
+    }>>;
+    icon: ZodOptional<ZodString>;
+    tone: ZodOptional<ZodEnum<{
+        success: "success";
+        default: "default";
+        accent: "accent";
+        muted: "muted";
+        warning: "warning";
+        danger: "danger";
+    }>>;
+    badge: ZodOptional<ZodObject<{
+        text: ZodString;
+        tone: ZodOptional<ZodEnum<{
+            success: "success";
+            default: "default";
+            accent: "accent";
+            muted: "muted";
+            warning: "warning";
+            danger: "danger";
+        }>>;
+    }, $strip>>;
+    current: ZodOptional<ZodBoolean>;
+    disabled: ZodOptional<ZodBoolean>;
+    disabledReason: ZodOptional<ZodString>;
+    action: ZodOptional<ZodObject<{
+        commandId: ZodString;
+        input: ZodOptional<ZodJSONSchema>;
+        inputFrom: ZodOptional<ZodRecord<ZodString, ZodString>>;
+    }, $strip>>;
+    secondaryAction: ZodOptional<ZodObject<{
+        text: ZodString;
+        variant: ZodOptional<ZodEnum<{
+            primary: "primary";
+            secondary: "secondary";
+            ghost: "ghost";
+        }>>;
+        tone: ZodOptional<ZodEnum<{
+            success: "success";
+            default: "default";
+            accent: "accent";
+            muted: "muted";
+            warning: "warning";
+            danger: "danger";
+        }>>;
+        disabled: ZodOptional<ZodBoolean>;
+        disabledReason: ZodOptional<ZodString>;
+        action: ZodOptional<ZodObject<{
+            commandId: ZodString;
+            input: ZodOptional<ZodJSONSchema>;
+            inputFrom: ZodOptional<ZodRecord<ZodString, ZodString>>;
+        }, $strip>>;
+    }, $strip>>;
+}, $strip>;
+/**
+ * Region 顶部的瞬时说明。
+ *
+ * 做成 Region 字段而不是节点：提示属于领域状态，出现与消失不应该让内容重排；宿主把它渲染在
+ * 固定槽位并置 `role="status"`。Runtime 通过移除该字段来收回提示，宿主不自动过期。
+ */
+declare const viewRegionNoticeSchema: ZodObject<{
+    id: ZodString;
+    text: ZodString;
+    tone: ZodOptional<ZodEnum<{
+        success: "success";
+        default: "default";
+        accent: "accent";
+        muted: "muted";
+        warning: "warning";
+        danger: "danger";
+    }>>;
+    dismissible: ZodOptional<ZodBoolean>;
+}, $strip>;
+/**
+ * 容器节点共享的修饰。
+ *
+ * 做成属性而不是包装节点：包装会让每一层留白或表面都额外吃掉一层树深度，很快顶爆 `maxDepth`；
+ * 平铺成可选属性则深度不变，并且天然走「未知属性静默忽略」这条向前兼容路径。
+ */
+interface ViewBoxModifiers {
+    /** 宿主自持呈现状态时使用的稳定键。 */
+    readonly id?: string;
+    /** 子节点间距档位。 */
+    readonly gap?: ViewGap;
+    /** 容器内边距档位；声明了表面时缺省为 `md`。 */
+    readonly padding?: ViewPadding;
+    /** 交叉轴对齐。 */
+    readonly align?: ViewAlign;
+    /** 主轴分布。 */
+    readonly distribute?: ViewDistribute;
+    /** 表面配方。 */
+    readonly surface?: ViewSurface;
+    /** 让表面延伸到宿主持有的受控边界，内容仍保留安全区。 */
+    readonly bleed?: ViewBleed;
+    /** 圆角档位；声明了表面时缺省为 `md`。 */
+    readonly radius?: ViewRadius;
+    /** 层次档位。 */
+    readonly elevation?: ViewElevation;
+    /** 横向尺寸档位；`auto` 使用内容固有宽度，`fill` 贯通父容器。 */
+    readonly width?: ViewWidth;
+    /** 固定正方形尺寸；用于标准媒体／图标槽，不接受自由宽高。 */
+    readonly size?: ViewBoxSize;
+    /** 纵向固定尺寸档位。 */
+    readonly height?: ViewHeight;
+    /** 是否吃掉父容器主轴的剩余空间。 */
+    readonly grow?: boolean;
+    /** 整个容器可点击时回送的 Command。 */
+    readonly action?: ViewAction;
+    /** 图标等无可见文字的点击容器使用的可访问名称。 */
+    readonly accessibilityLabel?: string;
+    /** 可选交互外观；soft 用带留白的淡底，media 仅增强图片和标题，text 仅改变文字反馈，content 仅增强内部强调文案和缩略图，默认不改变布局。 */
+    readonly interaction?: 'soft' | 'media' | 'text' | 'content';
+}
+/**
+ * 宿主无法识别的节点；只要求 `type`，并允许携带降级子树。
+ *
+ * 额外属性在运行时始终是 JSON（schema 只接受 JSON 输入），但静态类型保持 `unknown`：渲染层不应
+ * 依赖任何未知属性的形状。跨进程边界的 JSON 断言集中在 Host 快照一处，不散落到词表定义。
+ */
+type ViewUnknownNode = {
+    /** 宿主未知的节点类型。 */
+    type: string;
+    /** 供旧宿主渲染的降级子树。 */
+    fallback?: ViewNode;
+    /** 其余未知属性一律忽略。 */
+    [key: string]: unknown;
+};
+/** 分段容器的一段。 */
+interface ViewTabItem {
+    /** 稳定键；宿主用它记住当前分段并生成可访问控件 id。 */
+    readonly id: string;
+    /** 分段标签。 */
+    readonly label: string;
+    /** 标签上的计数或状态标记。 */
+    readonly badge?: string;
+    /** 该段内容；只在被选中时渲染。 */
+    readonly children: ViewNode[];
+}
+/** `frame` 节点 `params` 的 JSON 值；必须能原样跨进程复制。 */
+type ViewFrameParams = null | boolean | number | string | readonly ViewFrameParams[] | {
+    readonly [key: string]: ViewFrameParams;
+};
+/** `renderer` 节点引用的当前 Extension 实例运行期资源。 */
+interface ViewRendererContent {
+    /** 实例资源空间中的逻辑 key；Host 结合当前 Extension 身份构造最终地址。 */
+    readonly resourceKey: string;
+    /** 读取当前实例私有空间或同 Package 共享空间；缺省为 `instance`。 */
+    readonly space?: 'instance' | 'shared';
+}
+/**
+ * 宿主已知词表内的节点。
+ *
+ * 与 `ViewUnknownNode` 分开声明：未知节点带索引签名，若并入同一 union 会让 TypeScript 无法按
+ * `type` 收窄，渲染层也就失去类型安全。
+ */
+type ViewKnownNode = (ViewBoxModifiers & {
+    type: 'vstack';
+    children: ViewNode[];
+}) | (ViewBoxModifiers & {
+    type: 'hstack';
+    wrap?: boolean;
+    children: ViewNode[];
+}) | (ViewBoxModifiers & {
+    type: 'zstack';
+    children: ViewNode[];
+}) | (ViewBoxModifiers & {
+    type: 'grid';
+    columns: ViewGridColumns;
+    children: ViewNode[];
+}) | {
+    readonly type: 'carousel';
+    /** 宿主保存当前页与生成可访问控件 id 使用的稳定键。 */
+    readonly id: string;
+    /** 轮播区域的可访问名称。 */
+    readonly label: string;
+    /** 每个直接子节点是一页。 */
+    readonly children: ViewNode[];
+    /** 旧宿主不认识 `carousel` 时渲染的降级内容。 */
+    readonly fallback?: ViewNode;
+    /** 单个视口同时展示的页数，缺省为 1。 */
+    readonly slidesPerView?: ViewCarouselSlidesPerView;
+    /** 页间距档位，缺省为 `sm`。 */
+    readonly gap?: ViewGap;
+    /** 是否首尾循环；页数不足时宿主自动退回非循环。 */
+    readonly loop?: boolean;
+    /** 是否让当前页居中。 */
+    readonly centered?: boolean;
+    /** 是否显示上一页/下一页按钮，缺省显示。 */
+    readonly navigation?: boolean;
+    /** 页指示器形态，缺省为 `bullets`。 */
+    readonly pagination?: ViewCarouselPagination;
+    /** 页指示器位于内容内部或外部，缺省为 `outside`。 */
+    readonly paginationPlacement?: ViewCarouselPaginationPlacement;
+    /** 自动播放间隔（毫秒）；缺省不自动播放，系统要求减少动态效果时宿主忽略此值。 */
+    readonly autoplayDelay?: number;
+} | (Omit<ViewBoxModifiers, 'action'> & {
+    type: 'group';
+    title?: string;
+    /** 标题可作为折叠开关；声明后必须提供 `id`。 */
+    collapsible?: boolean;
+    /** 折叠开关的初始状态，缺省展开。 */
+    defaultExpanded?: boolean;
+    /** 标题在可滚动容器内保持吸顶。 */
+    stickyTitle?: boolean;
+    children: ViewNode[];
+}) | {
+    type: 'spacer';
+    id?: string;
+} | {
+    type: 'text';
+    id?: string;
+    value: string;
+    /** 行内富文本片段；缺省时按 `value` 渲染纯文本。 */
+    spans?: ViewTextSpan[];
+    variant?: ViewTextVariant;
+    weight?: ViewTextWeight;
+    tone?: ViewTextTone;
+    /** 宿主批准的完整文本 Paint；旧宿主忽略时由 `tone` 保证可读降级。 */
+    paint?: ViewTextPaint;
+    maxLines?: number;
+    /** 按 maxLines 预留完整行高，短文案也保持同一布局高度。 */
+    reserveLines?: boolean;
+} | {
+    type: 'image';
+    id?: string;
+    src: string;
+    aspectRatio?: string;
+    /** 固定尺寸档位；缺省时宽度由容器与图片固有像素决定。除两个 landscape 档位外均只固定宽度并由宽高比结算高度。 */
+    size?: ViewImageSize;
+    fit?: ViewImageFit;
+    /** 呈现强度；缺省完整显示。 */
+    appearance?: ViewImageAppearance;
+    /** semantic 用于颜色承担信息的图片；两类图片在标准态与强调态均保留原色。 */
+    colorRole?: output<typeof viewImageColorRoleSchema>;
+    radius?: ViewRadius;
+    overlay?: ViewImageOverlay;
+    fallback?: ViewImageFallback;
+} | {
+    readonly type: 'icon';
+    readonly id?: string;
+    readonly name: string;
+    /** 图标边长档位；缺省跟随宿主正文尺寸。 */
+    readonly size?: ViewIconSize;
+    /** 图标颜色语义；优先于旧文档的 `tone`。 */
+    readonly color?: ViewIconColor;
+    readonly tone?: ViewTone;
+} | {
+    readonly type: 'fields';
+    readonly id?: string;
+    items: ViewFieldItem[];
+} | {
+    readonly type: 'list';
+    readonly id?: string;
+    readonly variant?: ViewListVariant;
+    /** 初始展示条数；其余条目由宿主用「显示全部」就地展开，声明后必须提供 `id`。 */
+    readonly initialCount?: number;
+    items: ViewListItem[];
+} | {
+    type: 'badge';
+    id?: string;
+    text: string;
+    /** `primary` 跟随明暗模式；`primary-media` 固定使用媒体上的深色模式主色配对，均不读取游戏强调色。 */
+    tone?: ViewTone | 'primary' | 'primary-media';
+} | {
+    readonly type: 'divider';
+    readonly id?: string;
+} | {
+    type: 'button';
+    id?: string;
+    text: string;
+    variant?: ViewButtonVariant;
+    /** 意图语气；映射规则见 schema 内 `tone` 字段说明。 */
+    tone?: ViewTone;
+    disabled?: boolean;
+    disabledReason?: string;
+    busy?: boolean;
+    action?: ViewAction;
+} | {
+    readonly type: 'switch';
+    /** 稳定键；用于关联可见标签与不可用原因。 */
+    readonly id: string;
+    /** 用户可见且可访问的开关名称。 */
+    readonly label: string;
+    /** Runtime 已确认的当前状态。 */
+    readonly checked: boolean;
+    /** 当前不可切换。 */
+    readonly disabled?: boolean;
+    /** 不可切换的可见原因。 */
+    readonly disabledReason?: string;
+    /** 切换请求正在由 Runtime 结算。 */
+    readonly busy?: boolean;
+    /** 用户请求切换时回送的 Command。 */
+    readonly action?: ViewAction;
+    /** 旧宿主不认识 `switch` 时渲染的降级内容。 */
+    readonly fallback?: ViewNode;
+} | {
+    type: 'expandable';
+    id: string;
+    collapsedLines: number;
+    expandText: string;
+    collapseText: string;
+    children: ViewNode[];
+} | {
+    type: 'renderer';
+    id: string;
+    /** Manifest 顶层 Renderer View 目录中的稳定 id。 */
+    rendererViewId: string;
+    /** 可选运行期内容；只允许 HTML adapter 使用。 */
+    content?: ViewRendererContent;
+    aspectRatio?: string;
+    height?: number;
+} | {
+    type: 'frame';
+    id: string;
+    /** Manifest `frames` 目录中的稳定 id；引擎由 Runtime 侧工厂创建并拥有 iframe。 */
+    frameId: string;
+    /** 引擎身份键：同 `(frameId, key)` 命中同一个引擎与同一个 iframe；缺省为共享引擎。 */
+    key?: string;
+    /** 本次引用的用法参数；变化只通知引擎，从不销毁或重建它。 */
+    params?: ViewFrameParams;
+    aspectRatio?: string;
+    height?: number;
+} | {
+    type: 'meter';
+    id?: string;
+    /** 比例值，值域 [0,1]。 */
+    value: number;
+    /** 可访问名称；缺省时宿主以百分比文本兜底。 */
+    label?: string;
+    tone?: ViewTone;
+    /** 可选分段；各段之和必须等于 `value`，使旧宿主仍可用单段比例降级。 */
+    segments?: ViewMeterSegment[];
+    /** 厚度档位；缺省 `sm` 保持旧视觉。 */
+    size?: ViewMeterSize;
+    /** 是否显示由宿主按实际宽度均匀计算的容量刻度。 */
+    ticks?: boolean;
+} | {
+    readonly type: 'radialProgress';
+    readonly id?: string;
+    /** 完成比例，值域 [0,1]。 */
+    readonly value: number;
+    /** 环形进度的可访问名称。 */
+    readonly label: string;
+    /** 环内显示文本；缺省时由宿主显示四舍五入后的百分比。 */
+    readonly valueLabel?: string;
+    /** 宿主批准的环内图形；新宿主以它替换可见环内文本，旧宿主仍显示 `valueLabel`。 */
+    readonly centerGraphic?: ViewRadialProgressCenterGraphic;
+    /** 环形进度尺寸档位；缺省为 `sm`。 */
+    readonly size?: ViewRadialProgressSize;
+    /** 进度语气；缺省使用当前应用 accent。 */
+    readonly tone?: ViewTone;
+    /** 旧宿主不认识 `radialProgress` 时渲染的降级内容。 */
+    readonly fallback?: ViewNode;
+} | {
+    type: 'sparkline';
+    id?: string;
+    /** 原始数值序列，宿主归一化绘制。 */
+    values: number[];
+    /** 可访问名称；缺省时宿主以末值文本兜底。 */
+    label?: string;
+    tone?: ViewTone;
+} | {
+    readonly type: 'barChart';
+    readonly id?: string;
+    /** 有限分类数据项；宿主按同组最大值归一化柱高。 */
+    readonly items: ViewBarChartItem[];
+    /** 整张图的可访问名称，应包含数据口径。 */
+    readonly label: string;
+    /** 柱宽档位；缺省为 `sm`。 */
+    readonly size?: ViewBarChartSize;
+    /** 柱体语气；缺省使用当前应用 accent。 */
+    readonly tone?: ViewTone;
+    /** 旧宿主不认识 `barChart` 时渲染的降级内容。 */
+    readonly fallback?: ViewNode;
+} | {
+    readonly type: 'tabs';
+    /** 宿主保存当前分段使用的稳定键。 */
+    readonly id: string;
+    /** 分段列表；每段的 `children` 只在该段被选中时渲染。 */
+    readonly items: ViewTabItem[];
+    /** 旧宿主不认识 `tabs` 时渲染的降级内容。 */
+    readonly fallback?: ViewNode;
+} | {
+    readonly type: 'textField';
+    /** 稳定键；动作用 `inputFrom` 按该键取值。 */
+    readonly id: string;
+    /** 用户可见且可访问的字段名。 */
+    readonly label: string;
+    /** 输入提示。 */
+    readonly placeholder?: string;
+    /** Runtime 提供的初始值；用户开始编辑后宿主持有草稿，不再被同一份值覆盖。 */
+    readonly value?: string;
+    /** 最大字符数；宿主同时用于截断提交值。 */
+    readonly maxLength?: number;
+    /** 当前不可编辑。 */
+    readonly disabled?: boolean;
+    /** 是否提供清空按钮。 */
+    readonly clearable?: boolean;
+    /** 变化时丢弃宿主草稿并重新取用 `value`；Runtime 用它在提交成功后清空输入。 */
+    readonly resetToken?: string;
+    /** 在字段内按下回车时回送的 Command；取值仍由 `inputFrom` 显式声明。 */
+    readonly submitAction?: ViewAction;
+    /** 旧宿主不认识 `textField` 时渲染的降级内容。 */
+    readonly fallback?: ViewNode;
+};
+/** 视图文档中的一个内容节点。 */
+type ViewNode = ViewKnownNode | ViewUnknownNode;
+/** Region 重试动作的宿主呈现方式。 */
+declare const viewRetryPresentationSchema: ZodEnum<{
+    button: "button";
+    inline: "inline";
+}>;
+/**
+ * 视图文档中的一个内容区域。
+ *
+ * `loading`、`empty`、`error` 的状态文案与交互统一由宿主提供；`loading` 携带布局蓝图节点，
+ * 宿主保留布局 footprint 并占位渲染叶子内容。`empty` 与 `error` 可选携带不改变状态语义的业务视觉锚点，
+ * 未提供节点时仍使用纯宿主状态。`refreshing` 仅与 `ready` 同时出现，表示保留当前内容的局部刷新。
+ * 一个 Region 失败不得遮挡或替换同卡其他已成功 Region。
+ */
+declare const viewRegionSchema: ZodObject<{
+    id: ZodString;
+    title: ZodOptional<ZodString>;
+    status: ZodEnum<{
+        error: "error";
+        ready: "ready";
+        loading: "loading";
+        empty: "empty";
+    }>;
+    refreshing: ZodOptional<ZodBoolean>;
+    retry: ZodOptional<ZodObject<{
+        commandId: ZodString;
+        input: ZodOptional<ZodJSONSchema>;
+        inputFrom: ZodOptional<ZodRecord<ZodString, ZodString>>;
+    }, $strip>>;
+    errorText: ZodOptional<ZodString>;
+    retryPresentation: ZodOptional<ZodEnum<{
+        button: "button";
+        inline: "inline";
+    }>>;
+    emptyText: ZodOptional<ZodString>;
+    notice: ZodOptional<ZodObject<{
+        id: ZodString;
+        text: ZodString;
+        tone: ZodOptional<ZodEnum<{
+            success: "success";
+            default: "default";
+            accent: "accent";
+            muted: "muted";
+            warning: "warning";
+            danger: "danger";
+        }>>;
+        dismissible: ZodOptional<ZodBoolean>;
+    }, $strip>>;
+    nodes: ZodDefault<ZodArray<ZodType<ViewNode, unknown, $ZodTypeInternals<ViewNode, unknown>>>>;
+}, $strip>;
+/** Runtime 产出的视图文档根。 */
+declare const viewDocumentSchema: ZodObject<{
+    schema: ZodNumber;
+    transition: ZodOptional<ZodObject<{
+        effect: ZodEnum<{
+            crossfade: "crossfade";
+            morph: "morph";
+        }>;
+    }, $strip>>;
+    regions: ZodArray<ZodObject<{
+        id: ZodString;
+        title: ZodOptional<ZodString>;
+        status: ZodEnum<{
+            error: "error";
+            ready: "ready";
+            loading: "loading";
+            empty: "empty";
+        }>;
+        refreshing: ZodOptional<ZodBoolean>;
+        retry: ZodOptional<ZodObject<{
+            commandId: ZodString;
+            input: ZodOptional<ZodJSONSchema>;
+            inputFrom: ZodOptional<ZodRecord<ZodString, ZodString>>;
+        }, $strip>>;
+        errorText: ZodOptional<ZodString>;
+        retryPresentation: ZodOptional<ZodEnum<{
+            button: "button";
+            inline: "inline";
+        }>>;
+        emptyText: ZodOptional<ZodString>;
+        notice: ZodOptional<ZodObject<{
+            id: ZodString;
+            text: ZodString;
+            tone: ZodOptional<ZodEnum<{
+                success: "success";
+                default: "default";
+                accent: "accent";
+                muted: "muted";
+                warning: "warning";
+                danger: "danger";
+            }>>;
+            dismissible: ZodOptional<ZodBoolean>;
+        }, $strip>>;
+        nodes: ZodDefault<ZodArray<ZodType<ViewNode, unknown, $ZodTypeInternals<ViewNode, unknown>>>>;
+    }, $strip>>;
+}, $strip>;
+/** 间距档位；`micro` 是高密度文字栈使用的 2px 光学间距，其余档位映射语义空间 token。 */
+type ViewGap = output<typeof viewGapSchema>;
+/** 内边距档位。 */
+type ViewPadding = output<typeof viewPaddingSchema>;
+/** 交叉轴对齐方式。 */
+type ViewAlign = output<typeof viewAlignSchema>;
+/** 主轴分布方式。 */
+type ViewDistribute = output<typeof viewDistributeSchema>;
+/** 表面配方。 */
+type ViewSurface = output<typeof viewSurfaceSchema>;
+/** 容器出血档位。 */
+type ViewBleed = output<typeof viewBleedSchema>;
+/** 圆角档位。 */
+type ViewRadius = output<typeof viewRadiusSchema>;
+/** 层次档位。 */
+type ViewElevation = output<typeof viewElevationSchema>;
+/** 横向尺寸档位。 */
+type ViewWidth = output<typeof viewWidthSchema>;
+/** 容器固定正方形尺寸档位。 */
+type ViewBoxSize = output<typeof viewBoxSizeSchema>;
+/** 容器纵向固定尺寸档位。 */
+type ViewHeight = output<typeof viewHeightSchema>;
+/** 网格列数。 */
+type ViewGridColumns = output<typeof viewGridColumnsSchema>;
+/** 文本语义层级。 */
+type ViewTextVariant = output<typeof viewTextVariantSchema>;
+/** 文本字重。 */
+type ViewTextWeight = output<typeof viewTextWeightSchema>;
+/** 宿主批准的文本完整 Paint。 */
+type ViewTextPaint = output<typeof viewTextPaintSchema>;
+/** 文本专用语气。 */
+type ViewTextTone = output<typeof viewTextToneSchema>;
+/** 行内富文本片段。 */
+type ViewTextSpan = output<typeof viewTextSpanSchema>;
+/** 内容语气。 */
+type ViewTone = output<typeof viewToneSchema>;
+/** 比例条厚度档位。 */
+type ViewMeterSize = output<typeof viewMeterSizeSchema>;
+/** 比例条语义数据段。 */
+type ViewMeterSegment = output<typeof viewMeterSegmentSchema>;
+/** 环形进度尺寸档位。 */
+type ViewRadialProgressSize = output<typeof viewRadialProgressSizeSchema>;
+/** 环形进度中心的宿主批准图形。 */
+type ViewRadialProgressCenterGraphic = output<typeof viewRadialProgressCenterGraphicSchema>;
+/** 分类柱图柱宽档位。 */
+type ViewBarChartSize = output<typeof viewBarChartSizeSchema>;
+/** 分类柱图中的一个数据项。 */
+type ViewBarChartItem = output<typeof viewBarChartItemSchema>;
+/** 按钮视觉层级。 */
+type ViewButtonVariant = output<typeof viewButtonVariantSchema>;
+/** 图片填充方式。 */
+type ViewImageFit = output<typeof viewImageFitSchema>;
+/** 图片呈现强度。 */
+type ViewImageAppearance = output<typeof viewImageAppearanceSchema>;
+/** 图片尺寸档位。 */
+type ViewImageSize = output<typeof viewImageSizeSchema>;
+/** 图标边长档位。 */
+type ViewIconSize = output<typeof viewIconSizeSchema>;
+/** 图标颜色语义。 */
+type ViewIconColor = output<typeof viewIconColorSchema>;
+/** 图片遮罩。 */
+type ViewImageOverlay = output<typeof viewImageOverlaySchema>;
+/** 列表条目排版。 */
+type ViewListVariant = output<typeof viewListVariantSchema>;
+/** 轮播页指示器形态。 */
+type ViewCarouselPagination = output<typeof viewCarouselPaginationSchema>;
+/** 轮播页指示器相对内容的放置方式。 */
+type ViewCarouselPaginationPlacement = output<typeof viewCarouselPaginationPlacementSchema>;
+/** 单个视口同时展示的轮播页数档位。 */
+type ViewCarouselSlidesPerView = output<typeof viewCarouselSlidesPerViewSchema>;
+/** 文档更新的过渡配置。 */
+type ViewTransition = output<typeof viewTransitionSchema>;
+/** 节点动作。 */
+type ViewAction = output<typeof viewActionSchema>;
+/** 图片回退表达。 */
+type ViewImageFallback = output<typeof viewImageFallbackSchema>;
+/** 字段组条目。 */
+type ViewFieldItem = output<typeof viewFieldItemSchema>;
+/** 列表条目。 */
+type ViewListItem = output<typeof viewListItemSchema>;
+/** Region 顶部瞬时说明。 */
+type ViewRegionNotice = output<typeof viewRegionNoticeSchema>;
+/** Region 重试动作的宿主呈现方式。 */
+type ViewRetryPresentation = output<typeof viewRetryPresentationSchema>;
+/** 视图内容区域。 */
+type ViewRegion = output<typeof viewRegionSchema>;
+/** 视图文档根。 */
+type ViewDocument = output<typeof viewDocumentSchema>;
+
+/**
+ * @file 为 Extension Runtime 提供构造视图文档的类型安全 builder。
+ *
+ * builder 只是编写期语法糖，产出的始终是可序列化 JSON；跨进程边界传输的是文档本身，不是函数。
+ */
+/** 容器节点的可选项；与 `ViewBoxModifiers` 同形。 */
+type BoxOptions = ViewBoxModifiers;
+/** `hstack` 节点的可选项。 */
+interface HStackOptions extends BoxOptions {
+    /** 是否允许换行。 */
+    readonly wrap?: boolean;
+}
+/** `group` 节点的可选项。 */
+interface GroupOptions extends BoxOptions {
+    /** 分组小标题。 */
+    readonly title?: string;
+    /** 标题兼作折叠开关；声明后必须提供 `id`。 */
+    readonly collapsible?: boolean;
+    /** 折叠开关初始状态，缺省展开。 */
+    readonly defaultExpanded?: boolean;
+    /** 标题在可滚动容器内吸顶。 */
+    readonly stickyTitle?: boolean;
+}
+/** `carousel` 节点的可选项。 */
+interface CarouselOptions {
+    /** 单个视口同时展示的页数，缺省为 1。 */
+    readonly slidesPerView?: ViewCarouselSlidesPerView;
+    /** 页间距档位，缺省为 `sm`。 */
+    readonly gap?: ViewGap;
+    /** 是否首尾循环。 */
+    readonly loop?: boolean;
+    /** 是否让当前页居中。 */
+    readonly centered?: boolean;
+    /** 是否显示上一页/下一页按钮，缺省显示。 */
+    readonly navigation?: boolean;
+    /** 页指示器形态，缺省为 `bullets`。 */
+    readonly pagination?: ViewCarouselPagination;
+    /** 页指示器位于内容内部或外部，缺省为 `outside`。 */
+    readonly paginationPlacement?: ViewCarouselPaginationPlacement;
+    /** 自动播放间隔（毫秒）；缺省不自动播放。 */
+    readonly autoplayDelay?: number;
+    /** 旧宿主不认识 `carousel` 时渲染的降级内容。 */
+    readonly fallback?: ViewNode;
+}
+/** `text` 节点的可选项。 */
+interface TextOptions {
+    /** 稳定键。 */
+    readonly id?: string;
+    /**
+     * 行内富文本片段。
+     *
+     * 调用方仍必须给出与片段拼接一致的 `value`：它是不认识 `spans` 的宿主的降级渲染源。
+     */
+    readonly spans?: readonly ViewTextSpan[];
+    /** 语义层级。 */
+    readonly variant?: ViewTextVariant;
+    /** 字重覆写。 */
+    readonly weight?: ViewTextWeight;
+    /** 语气。 */
+    readonly tone?: ViewTextTone;
+    /** 宿主批准的完整文本 Paint；应同时声明 `tone` 供旧宿主降级。 */
+    readonly paint?: ViewTextPaint;
+    /** 截断行数。 */
+    readonly maxLines?: number;
+    /** 按 maxLines 预留完整行高，使短标题与多行标题对齐。 */
+    readonly reserveLines?: boolean;
+}
+/** `image` 节点的可选项。 */
+interface ImageOptions {
+    /** 稳定键。 */
+    readonly id?: string;
+    /** 宽高比，例如 `16/9`。 */
+    readonly aspectRatio?: string;
+    /** 固定尺寸档位；入口图标与列表缩略图这类不该被容器撑开的图必须声明，整数横图槽使用 landscape 档位。 */
+    readonly size?: ViewImageSize;
+    /** 填充方式。 */
+    readonly fit?: ViewImageFit;
+    /** 呈现强度；`deemphasized` 由宿主统一弱化，不改变图片本身。 */
+    readonly appearance?: ViewImageAppearance;
+    /** 圆角档位。 */
+    readonly radius?: ViewRadius;
+    /** 遮罩；在图片之上叠加文字时保证对比度。 */
+    readonly overlay?: ViewImageOverlay;
+    /** 缺失或加载失败时的回退表达。 */
+    readonly fallback?: ViewImageFallback;
+}
+/** `button` 节点的可选项。 */
+interface ButtonOptions {
+    /** 稳定键。 */
+    readonly id?: string;
+    /** 视觉层级。 */
+    readonly variant?: ViewButtonVariant;
+    /** 意图语气；`primary` 映射为对应 intent 实底，`secondary`/`ghost` 只着色文字。 */
+    readonly tone?: ViewTone;
+    /** 当前不可用。 */
+    readonly disabled?: boolean;
+    /** 不可用的可见原因；`disabled` 为真时应当提供。 */
+    readonly disabledReason?: string;
+    /** 已接受且处理中；与 `disabled` 语义不同，不可互相替代。 */
+    readonly busy?: boolean;
+    /** 点击后回送的 Command。 */
+    readonly action?: ViewAction;
+}
+/** `switch` 节点的可选项。 */
+interface ToggleOptions {
+    /** 当前不可切换。 */
+    readonly disabled?: boolean;
+    /** 不可切换的可见原因；`disabled` 为真时应当提供。 */
+    readonly disabledReason?: string;
+    /** 切换请求正在由 Runtime 结算。 */
+    readonly busy?: boolean;
+    /** 用户请求切换时回送的 Command；input 应携带目标状态以便 Runtime 幂等结算。 */
+    readonly action?: ViewAction;
+    /** 旧宿主不认识 `switch` 时渲染的降级内容。 */
+    readonly fallback?: ViewNode;
+}
+/** `list` 节点的可选项。 */
+interface ListOptions {
+    /** 稳定键。 */
+    readonly id?: string;
+    /** 条目排版。 */
+    readonly variant?: ViewListVariant;
+    /** 初始展示条数；其余条目由宿主就地展开，声明后必须提供 `id`。 */
+    readonly initialCount?: number;
+}
+/** `tabs` 节点的可选项。 */
+interface TabsOptions {
+    /** 旧宿主不认识 `tabs` 时渲染的降级内容。 */
+    readonly fallback?: ViewNode;
+}
+/** `textField` 节点的可选项。 */
+interface TextFieldOptions {
+    /** 输入提示。 */
+    readonly placeholder?: string;
+    /** Runtime 提供的初始值。 */
+    readonly value?: string;
+    /** 最大字符数。 */
+    readonly maxLength?: number;
+    /** 当前不可编辑。 */
+    readonly disabled?: boolean;
+    /** 是否提供清空按钮。 */
+    readonly clearable?: boolean;
+    /** 变化时丢弃宿主草稿并重新取用 `value`。 */
+    readonly resetToken?: string;
+    /** 在字段内按下回车时回送的 Command。 */
+    readonly submitAction?: ViewAction;
+    /** 旧宿主不认识 `textField` 时渲染的降级内容。 */
+    readonly fallback?: ViewNode;
+}
+/** `meter` 节点的可选项。 */
+interface MeterOptions {
+    /** 稳定键。 */
+    readonly id?: string;
+    /** 可访问名称；缺省时宿主使用百分比文本。 */
+    readonly label?: string;
+    /** 单段比例条语气；分段存在时由各段自己的语气覆盖。 */
+    readonly tone?: ViewTone;
+    /** 可选数据段；总和必须等于 `value`，以保持旧宿主降级语义。 */
+    readonly segments?: readonly ViewMeterSegment[];
+    /** 厚度档位；缺省 `sm` 保持既有细条。 */
+    readonly size?: ViewMeterSize;
+    /** 是否按实际宽度显示约 24px 一档、首尾均匀分布的刻度。 */
+    readonly ticks?: boolean;
+}
+/** `radialProgress` 节点的可选项。 */
+interface RadialProgressOptions {
+    /** 稳定键。 */
+    readonly id?: string;
+    /** 环内显示文本；缺省时由宿主显示四舍五入后的百分比。 */
+    readonly valueLabel?: string;
+    /** 宿主批准的环内图形；旧宿主仍显示 `valueLabel`。 */
+    readonly centerGraphic?: ViewRadialProgressCenterGraphic;
+    /** 环形进度尺寸档位；缺省使用宿主紧凑档。 */
+    readonly size?: ViewRadialProgressSize;
+    /** 进度语气；缺省使用当前应用 accent。 */
+    readonly tone?: ViewTone;
+    /** 旧宿主不认识 `radialProgress` 时渲染的降级内容。 */
+    readonly fallback?: ViewNode;
+}
+/** `barChart` 节点的可选项。 */
+interface BarChartOptions {
+    /** 稳定键。 */
+    readonly id?: string;
+    /** 柱宽档位；缺省使用宿主紧凑档。 */
+    readonly size?: ViewBarChartSize;
+    /** 柱体语气；缺省使用当前应用 accent。 */
+    readonly tone?: ViewTone;
+    /** 旧宿主不认识 `barChart` 时渲染的降级内容。 */
+    readonly fallback?: ViewNode;
+}
+/** `frame` 节点的可选项。 */
+interface FrameOptions {
+    /** 引擎身份键；同 `(frameId, key)` 命中同一个引擎与同一个 iframe，缺省为共享引擎。 */
+    readonly key?: string;
+    /** 本次引用的用法参数；变化只通知引擎，从不销毁或重建它。 */
+    readonly params?: ViewFrameParams;
+    /** 宽高比，例如 `16/9`。 */
+    readonly aspectRatio?: string;
+    /** 固定高度，单位为 CSS 像素。 */
+    readonly height?: number;
+}
+/** `renderer` 节点的可选项。 */
+interface RendererOptions {
+    /** 由 Host 按当前 Extension 身份解析的运行期内容引用。 */
+    readonly content?: ViewRendererContent;
+    /** 宽高比，例如 `16/9`。 */
+    readonly aspectRatio?: string;
+    /** 固定高度，单位为 CSS 像素。 */
+    readonly height?: number;
+}
+/** Region 的可选项。 */
+interface RegionOptions {
+    /** 区域标题。 */
+    readonly title?: string;
+    /** 已有内容正在原位刷新；仅用于 `ready` Region。 */
+    readonly refreshing?: boolean;
+    /** 失败时的重试动作。 */
+    readonly retry?: ViewAction;
+    /** 覆盖宿主默认错误文案；仅用于 `error` Region。 */
+    readonly errorText?: string;
+    /** 重试动作的宿主呈现方式；`inline` 使用 Accent 文字动作。 */
+    readonly retryPresentation?: ViewRetryPresentation;
+    /** 覆盖宿主默认空态文案。 */
+    readonly emptyText?: string;
+    /** 顶部瞬时说明；不参与节点预算，也不引起内容重排。 */
+    readonly notice?: ViewRegionNotice;
+}
+/** ViewDocument 根的可选配置。 */
+interface ViewDocumentOptions {
+    /** 新文档替换旧文档时由包内 renderer 执行的受控过渡。 */
+    readonly transition?: ViewTransition;
+}
+/**
+ * 纵向排列子节点。
+ *
+ * @param children - 子节点。
+ * @param options - 间距、留白、对齐与表面配方。
+ */
+declare function vstack(children: readonly ViewNode[], options?: BoxOptions): ViewNode;
+/**
+ * 横向排列子节点。
+ *
+ * @param children - 子节点。
+ * @param options - 间距、留白、对齐、分布、换行与表面配方。
+ */
+declare function hstack(children: readonly ViewNode[], options?: HStackOptions): ViewNode;
+/**
+ * 层叠排列子节点；首个子节点决定尺寸，其余子节点铺满其上。
+ *
+ * `padding` 只作用于覆盖层，底层子节点保持出血，因此封面加标题不需要额外的负边距技巧。
+ *
+ * @param children - 子节点，第一个为底层。
+ * @param options - 覆盖层对齐、留白与表面配方。
+ */
+declare function zstack(children: readonly ViewNode[], options?: BoxOptions): ViewNode;
+/**
+ * 等宽多列网格。
+ *
+ * @param columns - 列数档位。
+ * @param children - 子节点。
+ * @param options - 间距、留白与表面配方。
+ */
+declare function grid(columns: ViewGridColumns, children: readonly ViewNode[], options?: BoxOptions): ViewNode;
+/**
+ * 可触摸、鼠标拖拽及键盘翻页的轮播容器；每个直接子节点是一页。
+ *
+ * @param id - 宿主保存当前页与生成可访问控件 id 使用的稳定键。
+ * @param label - 轮播区域的可访问名称。
+ * @param children - 轮播页。
+ * @param options - 页数、间距、循环、导航、指示器与自动播放参数。
+ */
+declare function carousel(id: string, label: string, children: readonly ViewNode[], options?: CarouselOptions): ViewNode;
+/**
+ * 带可选小标题的语义分组；渲染为带标题的 section，纵向排列。
+ *
+ * @param children - 子节点。
+ * @param options - 标题与容器修饰。
+ */
+declare function group(children: readonly ViewNode[], options?: GroupOptions): ViewNode;
+/**
+ * 吃掉父容器主轴剩余空间的弹性空隙；用于把同一行的内容推向两端。
+ *
+ * @param options - 稳定键。
+ */
+declare function spacer(options?: {
+    readonly id?: string;
+}): ViewNode;
+/**
+ * 文本节点。
+ *
+ * @param value - 文本内容；给出 `spans` 时它同时是不认识富文本的宿主的降级渲染源，两者必须一致。
+ * @param options - 层级、字重、语气、截断与行内富文本片段。
+ */
+declare function text(value: string, options?: TextOptions): ViewNode;
+/**
+ * 图片节点。
+ *
+ * @param src - 图片地址。
+ * @param options - 宽高比、尺寸档位、填充方式、呈现强度、圆角、遮罩与回退。
+ */
+declare function image(src: string, options?: ImageOptions): ViewNode;
+/**
+ * 图标节点。
+ *
+ * @param name - 图标名。
+ * @param options - 语气与稳定键。
+ */
+declare function icon(name: string, options?: {
+    readonly id?: string;
+    readonly size?: ViewIconSize;
+    readonly color?: ViewIconColor;
+    readonly tone?: ViewTone;
+}): ViewNode;
+/**
+ * 标签值字段组；`value` 缺省时渲染 `placeholder`，不虚构字段。
+ *
+ * @param items - 字段条目。
+ * @param options - 稳定键。
+ */
+declare function fields(items: readonly ViewFieldItem[], options?: {
+    readonly id?: string;
+}): ViewNode;
+/**
+ * 列表节点；条目 `action` 缺省即不可点击。
+ *
+ * 列表是同构条目的紧凑表达：一个节点承载全部条目，因此长列表不会吃掉节点预算。需要逐条自定义排版时
+ * 改用容器手写，代价是节点数按条目线性增长。
+ *
+ * @param items - 列表条目。
+ * @param options - 排版与稳定键。
+ */
+declare function list(items: readonly ViewListItem[], options?: ListOptions): ViewNode;
+/**
+ * 状态标记。
+ *
+ * @param value - 标记文本。
+ * @param options - 语气与稳定键。
+ */
+declare function badge(value: string, options?: {
+    readonly id?: string;
+    /** `primary` 使用主色标签；`primary-media` 固定白底黑字，均不随游戏强调色变化。 */
+    readonly tone?: ViewTone | 'primary' | 'primary-media';
+}): ViewNode;
+/**
+ * 分隔线。
+ *
+ * @param options - 稳定键。
+ */
+declare function divider(options?: {
+    readonly id?: string;
+}): ViewNode;
+/**
+ * 按钮节点。
+ *
+ * @param value - 按钮文案。
+ * @param options - 视觉层级、可用性与动作。
+ */
+declare function button(value: string, options?: ButtonOptions): ViewNode;
+/**
+ * 分段容器；当前分段由宿主自持，不产生 Command 往返。
+ *
+ * @param id - 宿主保存当前分段使用的稳定键。
+ * @param items - 分段列表。
+ * @param options - 降级内容。
+ */
+declare function tabs(id: string, items: readonly ViewTabItem[], options?: TabsOptions): ViewNode;
+/**
+ * 文本输入字段；草稿由宿主持有，只有动作按 `inputFrom` 提交时才回送 Runtime。
+ *
+ * @param id - 稳定键；动作用 `inputFrom` 按该键取值。
+ * @param label - 用户可见且可访问的字段名。
+ * @param options - 初始值、上限与提交动作。
+ */
+declare function textField(id: string, label: string, options?: TextFieldOptions): ViewNode;
+/**
+ * 胶囊开关；状态由 Runtime 持有，宿主只回送切换请求并等待新文档确认。
+ *
+ * @param id - 关联标签、原因与更新时身份使用的稳定键。
+ * @param label - 用户可见且可访问的开关名称。
+ * @param checked - Runtime 已确认的当前状态。
+ * @param options - 可用性、结算状态、动作与旧宿主降级内容。
+ */
+declare function toggle(id: string, label: string, checked: boolean, options?: ToggleOptions): ViewNode;
+/**
+ * 长文本展开控件；展开状态由宿主自持，不产生 Command 往返。
+ *
+ * @param id - 宿主记忆展开状态使用的稳定键。
+ * @param children - 被截断的子节点。
+ * @param options - 折叠行数与展开/收起文案。
+ */
+declare function expandable(id: string, children: readonly ViewNode[], options: {
+    readonly collapsedLines: number;
+    readonly expandText: string;
+    readonly collapseText: string;
+}): ViewNode;
+/**
+ * Renderer Module 逃生舱节点；尺寸静态声明，宿主渲染前即可预留空间。
+ *
+ * @param id - 稳定键。
+ * @param rendererViewId - Manifest 顶层 Renderer View 目录中的稳定 id。
+ * @param options - 运行期内容引用、宽高比或固定高度。
+ */
+declare function renderer(id: string, rendererViewId: string, options?: RendererOptions): ViewNode;
+/**
+ * Frame 引用节点：文档只声明"在这里显示哪个引擎"，iframe 与视图端口归 Runtime 侧的 frame 引擎。
+ *
+ * 引用它的节点或实例销毁不会销毁引擎；引擎按 Manifest `frames[].ttlMs` 存活，窗口内再次引用
+ * 同一 `(frameId, key)` 会命中同一个 iframe。尺寸静态声明，宿主渲染前即可预留空间。
+ *
+ * @param id - 稳定键。
+ * @param frameId - Manifest `frames` 目录中的稳定 id。
+ * @param options - 引擎身份键、用法参数、宽高比或固定高度。
+ */
+declare function frame(id: string, frameId: string, options?: FrameOptions): ViewNode;
+/**
+ * 横向比例条；可渐进增强为受控厚度、均匀刻度和多数据段。
+ *
+ * @param value - 已用比例，也是旧宿主剥离新增属性后的单段降级值。
+ * @param options - 可访问名称、语气、分段、厚度与刻度。
+ */
+declare function meter(value: number, options?: MeterOptions): ViewNode;
+/**
+ * 环形进度；同时保留可访问名称与环内文本，不能只靠圆弧传达结果。
+ *
+ * @param value - 完成比例，值域 [0,1]。
+ * @param label - 包含完整数值口径的可访问名称。
+ * @param options - 环内文本、尺寸、语气与旧宿主降级内容。
+ */
+declare function radialProgress(value: number, label: string, options?: RadialProgressOptions): ViewNode;
+/**
+ * 有限分类柱图；Runtime 提交原始非负值，宿主负责归一化和视觉配方。
+ *
+ * @param label - 整张图的可访问名称。
+ * @param items - 分类标签与原始值。
+ * @param options - 柱宽、语气与旧宿主降级内容。
+ */
+declare function barChart(label: string, items: readonly ViewBarChartItem[], options?: BarChartOptions): ViewNode;
+/**
+ * 构造一个内容区域。
+ *
+ * @param id - 区域稳定键。
+ * @param status - 区域状态。
+ * @param nodes - `ready` 时的内容、`loading` 时的布局蓝图，或 `empty/error` 的可选视觉锚点。
+ * @param options - 标题、刷新、错误/空态文案与重试呈现。
+ */
+declare function region(id: string, status: ViewRegion['status'], nodes?: readonly ViewNode[], options?: RegionOptions): ViewRegion;
+/**
+ * 构造一个携带当前 schema 版本的视图文档。
+ *
+ * @param regions - 文档区域。
+ * @param options - 文档级过渡等渐进增强配置。
+ */
+declare function viewDocument(regions: readonly ViewRegion[], options?: ViewDocumentOptions): ViewDocument;
+
+/** 直接复用 PC DSL 的受限 Controller 作者入口。 */
+
+interface WorkspaceCardAuthorDefinition {
+    title: string;
+    sizes: readonly WorkspaceCardSize[];
+    defaultSize: WorkspaceCardSize;
+    documents?: WorkspaceCardDocuments;
+    loadingDocuments?: WorkspaceCardDocuments;
+    errorDocuments?: WorkspaceCardDocuments;
+}
+type WorkspaceCardActionInputSchema = WorkspaceCardInputSchema;
+interface WorkspaceCardActionHandle<Input extends WorkspaceCardJson = WorkspaceCardJson> {
+    (input: Input): ViewAction;
+    kind: 'invoke' | 'openMiniProgram';
+    input?: WorkspaceCardActionInputSchema;
+    run?: (ctx: WorkspaceCardControllerContext, input: Input) => WorkspaceCardControllerResult | Promise<WorkspaceCardControllerResult>;
+}
+interface WorkspaceCardsControllerAuthoring {
+    networkOrigins?: readonly string[];
+    cards: Readonly<Record<string, WorkspaceCardAuthorDefinition>>;
+    actions?: Readonly<Record<string, WorkspaceCardActionHandle>>;
+    refresh?: WorkspaceCardController['refresh'];
+}
+declare function defineCard<T extends WorkspaceCardAuthorDefinition>(definition: T): T;
+declare const actionInput: {
+    readonly string: (options?: {
+        maxLength?: number;
+    }) => WorkspaceCardActionInputSchema;
+    readonly number: () => WorkspaceCardActionInputSchema;
+    readonly boolean: () => WorkspaceCardActionInputSchema;
+    readonly array: (items: WorkspaceCardActionInputSchema, options?: {
+        maxItems?: number;
+    }) => WorkspaceCardActionInputSchema;
+    readonly object: (properties: Readonly<Record<string, WorkspaceCardActionInputSchema>>) => WorkspaceCardActionInputSchema;
+};
+declare function defineAction<Input extends WorkspaceCardJson>(definition: {
+    input?: WorkspaceCardActionInputSchema;
+    run(ctx: WorkspaceCardControllerContext, input: Input): WorkspaceCardControllerResult | Promise<WorkspaceCardControllerResult>;
+}): WorkspaceCardActionHandle<Input>;
+declare function defineOpenMiniProgramAction<Input extends WorkspaceCardJson = WorkspaceCardJson>(options?: {
+    input?: WorkspaceCardActionInputSchema;
+}): WorkspaceCardActionHandle<Input>;
+declare function defineWorkspaceCardsController<T extends WorkspaceCardsControllerAuthoring>(controller: T): T;
+/** 定义控制器；构建器和 Host 分别验证静态 action 表。 */
+declare function defineWorkspaceCardController<T extends WorkspaceCardController>(controller: T): T;
+/** 生成固定受管 invoke 入口；身份由 Host 根据真实卡片绑定。 */
+declare function invoke(actionId: string, params?: WorkspaceCardJson): ViewAction;
+/** 只允许打开当前小程序。 */
+declare function openMiniProgram(actionId: string, params?: WorkspaceCardJson): ViewAction;
+
+export { actionInput, badge, barChart, button, carousel, defineAction, defineCard, defineOpenMiniProgramAction, defineWorkspaceCardController, defineWorkspaceCardsController, divider, expandable, fields, frame, grid, group, hstack, icon, image, invoke, list, meter, openMiniProgram, radialProgress, region, renderer, spacer, tabs, text, textField, toggle, viewDocument, vstack, zstack };
+export type { BarChartOptions, BoxOptions, ButtonOptions, CarouselOptions, FrameOptions, GroupOptions, HStackOptions, ImageOptions, ListOptions, MeterOptions, RadialProgressOptions, RegionOptions, RendererOptions, TabsOptions, TextFieldOptions, TextOptions, ToggleOptions, ViewAction, ViewDocument, ViewDocumentOptions, ViewNode, WorkspaceCardActionHandle, WorkspaceCardActionInputSchema, WorkspaceCardAuthorDefinition, WorkspaceCardsControllerAuthoring };