svelte-docinfo 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,3381 @@
+/**
+ * Metadata types for library source code analysis.
+ *
+ * These types represent the structure of `src/lib/` exports,
+ * extracted at build time via TypeScript compiler analysis.
+ * Used for generating API documentation and enabling code search.
+ *
+ * Hierarchy: `ModuleJson` → `DeclarationJson` (discriminated union on `kind`) → `MemberJson` (discriminated union on `kind`)
+ *
+ * ## Zod input/output split
+ *
+ * Array fields use `.default([])` so they're optional in serialized JSON (compact)
+ * but guaranteed `[]` at runtime after `.parse()`. Input types (`ModuleJsonInput`,
+ * `DeclarationJsonInput`, `ComponentPropJsonInput`) accept optional arrays;
+ * output types (`ModuleJson`, `DeclarationJson`, `ComponentPropJson`) guarantee arrays.
+ * Use `compactReplacer` (in `declaration-helpers.ts`) with `JSON.stringify` for compact output.
+ *
+ * ## Discriminated union
+ *
+ * `DeclarationJson` is a `z.discriminatedUnion` on `kind` with 9 variants:
+ * `FunctionDeclarationJson`, `ClassDeclarationJson`, `InterfaceDeclarationJson`,
+ * `TypeDeclarationJson`, `VariableDeclarationJson`, `EnumDeclarationJson`,
+ * `ComponentDeclarationJson`, `SnippetDeclarationJson`, `NamespaceDeclarationJson`.
+ * Each variant has only the fields relevant to that kind, enforced by
+ * `z.strictObject`. Use `isKind` (in `declaration-helpers.ts`) to narrow.
+ *
+ * `MemberJson` is similarly a `z.discriminatedUnion` on `kind` with 3 variants:
+ * `FunctionMemberJson`, `VariableMemberJson`, `ConstructorMemberJson`.
+ * Each variant has only the fields relevant to that member kind.
+ *
+ * Internal analysis code that constructs declarations incrementally uses
+ * `DeclarationJsonBuild` — a permissive interface with all fields optional.
+ * Zod validation at the `ModuleJson.parse()` boundary enforces variant correctness.
+ *
+ * @see `declaration-helpers.ts` for display formatting and type narrowing utilities
+ * @see `analyze.ts` for the main analysis entry points
+ * @see `tsdoc.ts` for JSDoc/TSDoc extraction into these types
+ * @see `postprocess.ts` for post-processing (`mergeReExports`, `findDuplicates`)
+ *
+ * @module
+ */
+import { z } from 'zod';
+/**
+ * The kind of top-level exported declaration.
+ *
+ * Does not include `'constructor'` — constructors only appear as `MemberKind`
+ * (nested in classes, interfaces, or types with construct signatures), never as
+ * top-level module exports.
+ */
+export declare const DeclarationKind: z.ZodEnum<{
+    function: "function";
+    type: "type";
+    variable: "variable";
+    class: "class";
+    interface: "interface";
+    enum: "enum";
+    component: "component";
+    snippet: "snippet";
+    namespace: "namespace";
+}>;
+export type DeclarationKind = z.infer<typeof DeclarationKind>;
+/**
+ * TypeScript modifier keywords extracted from declarations.
+ *
+ * Only modifiers that appear on public API members are included.
+ * Private members (including `#field` syntax) are filtered out during analysis.
+ * Protected members are included as part of the extension API.
+ */
+export declare const DeclarationModifier: z.ZodEnum<{
+    public: "public";
+    protected: "protected";
+    readonly: "readonly";
+    static: "static";
+    abstract: "abstract";
+    getter: "getter";
+    setter: "setter";
+}>;
+export type DeclarationModifier = z.infer<typeof DeclarationModifier>;
+/**
+ * Reactivity flavor for a variable declaration or class field, captured from
+ * the rune call at the initializer (e.g., `let count = $state(0)`).
+ *
+ * Only the value-producing reactivity runes are represented here — `$props`
+ * and `$bindable` are modeled separately as `ComponentPropJson.bindable`
+ * (and prop-presence on the `props` array). A renderer wanting "all rune
+ * annotations across declarations and props" needs to read both this field
+ * and `ComponentPropJson.bindable`.
+ *
+ * - `$state` — deeply reactive proxy
+ * - `$state.raw` — reference-only reactive (no proxy)
+ * - `$derived` — recomputed from dependencies (re-assignable)
+ * - `$derived.by` — same as `$derived`, with a function argument
+ *
+ * Detection is syntactic (AST-based) and runs on every analyzed file
+ * regardless of extension. Most reactive declarations live in `.svelte`,
+ * `.svelte.ts`, or `.svelte.js`, but the field will also surface on any
+ * `.ts`/`.js` file that uses the same rune call patterns — by design, so
+ * documentation pipelines can capture any rune-shaped declaration their
+ * conventions choose to expose.
+ */
+export declare const Reactivity: z.ZodEnum<{
+    $state: "$state";
+    "$state.raw": "$state.raw";
+    $derived: "$derived";
+    "$derived.by": "$derived.by";
+}>;
+export type Reactivity = z.infer<typeof Reactivity>;
+/**
+ * Generic type parameter metadata extracted from declarations like `<T extends string = unknown>`.
+ *
+ * Present on functions, classes, interfaces, type aliases, and Svelte components
+ * that declare generic type parameters.
+ */
+export declare const GenericParamJson: z.ZodObject<{
+    /** Parameter name like `T`. */
+    name: z.ZodString;
+    /** Constraint like `string` from `T extends string`. */
+    constraint: z.ZodOptional<z.ZodString>;
+    /** Default type like `unknown` from `T = unknown`. */
+    defaultType: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type GenericParamJson = z.infer<typeof GenericParamJson>;
+/**
+ * Parameter information for functions and methods.
+ *
+ * Kept distinct from `ComponentPropJson` despite structural similarity.
+ * Function parameters form a tuple with positional semantics:
+ * calling order matters (`fn(a, b)` vs `fn(b, a)`),
+ * may include rest parameters and destructuring patterns.
+ */
+export declare const ParameterJson: z.ZodObject<{
+    /** Parameter name (e.g., `options`, `...args`). */
+    name: z.ZodString;
+    /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+    type: z.ZodString;
+    /** Whether the parameter has a `?` token. */
+    optional: z.ZodDefault<z.ZodBoolean>;
+    /** Whether the parameter uses rest syntax (`...args`). */
+    rest: z.ZodDefault<z.ZodBoolean>;
+    /** Description from `@param` tag. */
+    description: z.ZodOptional<z.ZodString>;
+    /** Default value expression from the source (e.g., `'hello'`, `42`). */
+    defaultValue: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ParameterJson = z.infer<typeof ParameterJson>;
+export type ParameterJsonInput = z.input<typeof ParameterJson>;
+/**
+ * Component prop information for Svelte components.
+ *
+ * Standalone schema (not extending `ParameterJson`) because component props
+ * have different semantics: named attributes with no positional order
+ * (`<Foo {a} {b} />` = `<Foo {b} {a} />`), no rest parameters,
+ * and support for two-way binding via `$bindable` rune.
+ */
+export declare const ComponentPropJson: z.ZodObject<{
+    examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    deprecatedMessage: z.ZodOptional<z.ZodString>;
+    seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    since: z.ZodOptional<z.ZodString>;
+    /** Prop name as declared in the component's `$props()` type. */
+    name: z.ZodString;
+    /** Resolved TypeScript type string. */
+    type: z.ZodString;
+    /** Whether the prop is optional in the component's props type. */
+    optional: z.ZodDefault<z.ZodBoolean>;
+    /** Description from JSDoc on the prop's type declaration. */
+    description: z.ZodOptional<z.ZodString>;
+    /** Default value expression from destructuring or `@default` tag. */
+    defaultValue: z.ZodOptional<z.ZodString>;
+    /** Whether the prop uses the `$bindable()` rune, enabling two-way binding. */
+    bindable: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Structured parameters for callable props (e.g., `Snippet<[text: string]>`).
+     *
+     * Present when the prop has extractable parameters, absent otherwise.
+     * Only populated when there are actual parameters — bare `Snippet` / `Snippet<[]>`
+     * does not set this field. Intentionally `.optional()` rather than
+     * `.default([])` (see the array-field policy note above): absence is a
+     * meaningful signal, not an empty list.
+     */
+    parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /** Parameter name (e.g., `options`, `...args`). */
+        name: z.ZodString;
+        /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+        type: z.ZodString;
+        /** Whether the parameter has a `?` token. */
+        optional: z.ZodDefault<z.ZodBoolean>;
+        /** Whether the parameter uses rest syntax (`...args`). */
+        rest: z.ZodDefault<z.ZodBoolean>;
+        /** Description from `@param` tag. */
+        description: z.ZodOptional<z.ZodString>;
+        /** Default value expression from the source (e.g., `'hello'`, `42`). */
+        defaultValue: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type ComponentPropJson = z.infer<typeof ComponentPropJson>;
+export type ComponentPropJsonInput = z.input<typeof ComponentPropJson>;
+/**
+ * A single function overload signature.
+ *
+ * When a function has multiple overload signatures, each public overload
+ * is captured here. The implementation signature is excluded.
+ */
+export declare const OverloadJson: z.ZodObject<{
+    /** Full TypeScript type signature for this overload. */
+    typeSignature: z.ZodString;
+    /** Parameters for this overload. */
+    parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Parameter name (e.g., `options`, `...args`). */
+        name: z.ZodString;
+        /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+        type: z.ZodString;
+        /** Whether the parameter has a `?` token. */
+        optional: z.ZodDefault<z.ZodBoolean>;
+        /** Whether the parameter uses rest syntax (`...args`). */
+        rest: z.ZodDefault<z.ZodBoolean>;
+        /** Description from `@param` tag. */
+        description: z.ZodOptional<z.ZodString>;
+        /** Default value expression from the source (e.g., `'hello'`, `42`). */
+        defaultValue: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    /** Return type for this overload. */
+    returnType: z.ZodOptional<z.ZodString>;
+    /** Generic type parameters for this overload. */
+    genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Parameter name like `T`. */
+        name: z.ZodString;
+        /** Constraint like `string` from `T extends string`. */
+        constraint: z.ZodOptional<z.ZodString>;
+        /** Default type like `unknown` from `T = unknown`. */
+        defaultType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    /** JSDoc/TSDoc comment specific to this overload. */
+    docComment: z.ZodOptional<z.ZodString>;
+    /** Return value description from `@returns` tag on this overload. */
+    returnDescription: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type OverloadJson = z.infer<typeof OverloadJson>;
+export type OverloadJsonInput = z.input<typeof OverloadJson>;
+/**
+ * The subset of declaration kinds that appear as nested members in classes, interfaces, and types.
+ *
+ * Class members include constructors (`'constructor'`), methods (`'function'`),
+ * and properties/accessors (`'variable'`). Interface/type properties use the same kinds
+ * for property signatures, method signatures, index signatures, and call/construct signatures.
+ *
+ * Top-level-only kinds (`'class'`, `'interface'`, `'type'`, `'enum'`, `'component'`) never
+ * appear as members — nesting is exactly one level deep.
+ */
+export declare const MemberKind: z.ZodEnum<{
+    function: "function";
+    variable: "variable";
+    constructor: "constructor";
+}>;
+export type MemberKind = z.infer<typeof MemberKind>;
+/**
+ * A function member (method, call signature, method signature).
+ * Has `parameters`, `returnType`, `returnDescription`, `overloads`.
+ *
+ * `optional` reflects a `?` token on the declaration (e.g., `foo?(): void`
+ * on an interface or type literal). Always `false` for index/call/construct
+ * signatures and for class methods (TypeScript disallows optional methods on
+ * classes).
+ *
+ * `name` is the user-chosen method/property identifier, except for call
+ * signatures on interfaces and type aliases where it is the literal sentinel
+ * `'(call)'`.
+ */
+export declare const FunctionMemberJson: z.ZodObject<{
+    kind: z.ZodLiteral<"function">;
+    /**
+     * User-chosen identifier, or the literal `'(call)'` sentinel for
+     * unnamed call signatures.
+     */
+    name: z.ZodString;
+    /** Whether the member has a `?` token in its declaration. */
+    optional: z.ZodDefault<z.ZodBoolean>;
+    returnType: z.ZodOptional<z.ZodString>;
+    returnDescription: z.ZodOptional<z.ZodString>;
+    parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Parameter name (e.g., `options`, `...args`). */
+        name: z.ZodString;
+        /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+        type: z.ZodString;
+        /** Whether the parameter has a `?` token. */
+        optional: z.ZodDefault<z.ZodBoolean>;
+        /** Whether the parameter uses rest syntax (`...args`). */
+        rest: z.ZodDefault<z.ZodBoolean>;
+        /** Description from `@param` tag. */
+        description: z.ZodOptional<z.ZodString>;
+        /** Default value expression from the source (e.g., `'hello'`, `42`). */
+        defaultValue: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    overloads: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Full TypeScript type signature for this overload. */
+        typeSignature: z.ZodString;
+        /** Parameters for this overload. */
+        parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name (e.g., `options`, `...args`). */
+            name: z.ZodString;
+            /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+            type: z.ZodString;
+            /** Whether the parameter has a `?` token. */
+            optional: z.ZodDefault<z.ZodBoolean>;
+            /** Whether the parameter uses rest syntax (`...args`). */
+            rest: z.ZodDefault<z.ZodBoolean>;
+            /** Description from `@param` tag. */
+            description: z.ZodOptional<z.ZodString>;
+            /** Default value expression from the source (e.g., `'hello'`, `42`). */
+            defaultValue: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        /** Return type for this overload. */
+        returnType: z.ZodOptional<z.ZodString>;
+        /** Generic type parameters for this overload. */
+        genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name like `T`. */
+            name: z.ZodString;
+            /** Constraint like `string` from `T extends string`. */
+            constraint: z.ZodOptional<z.ZodString>;
+            /** Default type like `unknown` from `T = unknown`. */
+            defaultType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        /** JSDoc/TSDoc comment specific to this overload. */
+        docComment: z.ZodOptional<z.ZodString>;
+        /** Return value description from `@returns` tag on this overload. */
+        returnDescription: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    partial: z.ZodDefault<z.ZodBoolean>;
+    examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    deprecatedMessage: z.ZodOptional<z.ZodString>;
+    seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    since: z.ZodOptional<z.ZodString>;
+    docComment: z.ZodOptional<z.ZodString>;
+    typeSignature: z.ZodOptional<z.ZodString>;
+    modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        public: "public";
+        protected: "protected";
+        readonly: "readonly";
+        static: "static";
+        abstract: "abstract";
+        getter: "getter";
+        setter: "setter";
+    }>>>;
+    sourceLine: z.ZodOptional<z.ZodNumber>;
+    genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Parameter name like `T`. */
+        name: z.ZodString;
+        /** Constraint like `string` from `T extends string`. */
+        constraint: z.ZodOptional<z.ZodString>;
+        /** Default type like `unknown` from `T = unknown`. */
+        defaultType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type FunctionMemberJson = z.infer<typeof FunctionMemberJson>;
+/**
+ * A variable member (property, accessor, index signature, enum value).
+ * Shared fields plus optional `reactivity` for class fields initialized with
+ * a Svelte rune (`$state`, `$state.raw`, `$derived`, `$derived.by`).
+ *
+ * `optional` reflects a `?` token on the declaration (e.g., `x?: string`).
+ * Always `false` for index signatures and enum values.
+ */
+export declare const VariableMemberJson: z.ZodObject<{
+    kind: z.ZodLiteral<"variable">;
+    /** Whether the member has a `?` token in its declaration. */
+    optional: z.ZodDefault<z.ZodBoolean>;
+    /** Rune flavor when this field is initialized with a value-producing reactivity rune. */
+    reactivity: z.ZodOptional<z.ZodEnum<{
+        $state: "$state";
+        "$state.raw": "$state.raw";
+        $derived: "$derived";
+        "$derived.by": "$derived.by";
+    }>>;
+    /** Default value documented via `@default`. Authoritative initializer (when human-readable) is in `typeSignature`. */
+    defaultValue: z.ZodOptional<z.ZodString>;
+    mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    partial: z.ZodDefault<z.ZodBoolean>;
+    examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    deprecatedMessage: z.ZodOptional<z.ZodString>;
+    seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    since: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    docComment: z.ZodOptional<z.ZodString>;
+    typeSignature: z.ZodOptional<z.ZodString>;
+    modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        public: "public";
+        protected: "protected";
+        readonly: "readonly";
+        static: "static";
+        abstract: "abstract";
+        getter: "getter";
+        setter: "setter";
+    }>>>;
+    sourceLine: z.ZodOptional<z.ZodNumber>;
+    genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Parameter name like `T`. */
+        name: z.ZodString;
+        /** Constraint like `string` from `T extends string`. */
+        constraint: z.ZodOptional<z.ZodString>;
+        /** Default type like `unknown` from `T = unknown`. */
+        defaultType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type VariableMemberJson = z.infer<typeof VariableMemberJson>;
+/**
+ * A constructor member (class constructor, construct signature).
+ * Has `parameters`, `overloads` — but not `returnType`/`returnDescription`
+ * (constructors always return their class).
+ *
+ * `name` is narrowed to two literal sentinels: `'constructor'` for class
+ * constructors and `'(construct)'` for interface/type-alias construct
+ * signatures (which share `kind: 'constructor'` but originate from
+ * `getConstructSignatures()` on a non-class type — no user-chosen identifier
+ * exists). The literal is preserved (rather than omitted) so `getDisplayName`
+ * and consumer renderers reading `member.name` keep working without a
+ * constructor-specific branch.
+ */
+export declare const ConstructorMemberJson: z.ZodObject<{
+    kind: z.ZodLiteral<"constructor">;
+    name: z.ZodUnion<readonly [z.ZodLiteral<"constructor">, z.ZodLiteral<"(construct)">]>;
+    parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Parameter name (e.g., `options`, `...args`). */
+        name: z.ZodString;
+        /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+        type: z.ZodString;
+        /** Whether the parameter has a `?` token. */
+        optional: z.ZodDefault<z.ZodBoolean>;
+        /** Whether the parameter uses rest syntax (`...args`). */
+        rest: z.ZodDefault<z.ZodBoolean>;
+        /** Description from `@param` tag. */
+        description: z.ZodOptional<z.ZodString>;
+        /** Default value expression from the source (e.g., `'hello'`, `42`). */
+        defaultValue: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    overloads: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Full TypeScript type signature for this overload. */
+        typeSignature: z.ZodString;
+        /** Parameters for this overload. */
+        parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name (e.g., `options`, `...args`). */
+            name: z.ZodString;
+            /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+            type: z.ZodString;
+            /** Whether the parameter has a `?` token. */
+            optional: z.ZodDefault<z.ZodBoolean>;
+            /** Whether the parameter uses rest syntax (`...args`). */
+            rest: z.ZodDefault<z.ZodBoolean>;
+            /** Description from `@param` tag. */
+            description: z.ZodOptional<z.ZodString>;
+            /** Default value expression from the source (e.g., `'hello'`, `42`). */
+            defaultValue: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        /** Return type for this overload. */
+        returnType: z.ZodOptional<z.ZodString>;
+        /** Generic type parameters for this overload. */
+        genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name like `T`. */
+            name: z.ZodString;
+            /** Constraint like `string` from `T extends string`. */
+            constraint: z.ZodOptional<z.ZodString>;
+            /** Default type like `unknown` from `T = unknown`. */
+            defaultType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        /** JSDoc/TSDoc comment specific to this overload. */
+        docComment: z.ZodOptional<z.ZodString>;
+        /** Return value description from `@returns` tag on this overload. */
+        returnDescription: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    partial: z.ZodDefault<z.ZodBoolean>;
+    examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    deprecatedMessage: z.ZodOptional<z.ZodString>;
+    seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    since: z.ZodOptional<z.ZodString>;
+    docComment: z.ZodOptional<z.ZodString>;
+    typeSignature: z.ZodOptional<z.ZodString>;
+    modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        public: "public";
+        protected: "protected";
+        readonly: "readonly";
+        static: "static";
+        abstract: "abstract";
+        getter: "getter";
+        setter: "setter";
+    }>>>;
+    sourceLine: z.ZodOptional<z.ZodNumber>;
+    genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Parameter name like `T`. */
+        name: z.ZodString;
+        /** Constraint like `string` from `T extends string`. */
+        constraint: z.ZodOptional<z.ZodString>;
+        /** Default type like `unknown` from `T = unknown`. */
+        defaultType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type ConstructorMemberJson = z.infer<typeof ConstructorMemberJson>;
+/**
+ * Metadata for a nested declaration within a class, interface, type, or enum.
+ *
+ * Discriminated union on `kind` with 3 variants: `FunctionMemberJson`,
+ * `VariableMemberJson`, `ConstructorMemberJson`. Use `isKind` (in
+ * `declaration-helpers.ts`) to narrow, or check `member.kind` directly.
+ *
+ * Does not include fields that exist on declarations but not on members
+ * (`extends`, `intersects`, `implements`, `props`, `alsoExportedFrom`, `aliasOf`).
+ *
+ * Nesting is exactly one level deep — members never contain their own members.
+ */
+export declare const MemberJson: z.ZodDiscriminatedUnion<[
+    typeof FunctionMemberJson,
+    typeof VariableMemberJson,
+    typeof ConstructorMemberJson
+], 'kind'>;
+export type MemberJson = z.infer<typeof MemberJson>;
+export type MemberJsonInput = z.input<typeof MemberJson>;
+/** A function declaration. Has `parameters`, `returnType`, `returnDescription`, `overloads`. */
+export declare const FunctionDeclarationJson: z.ZodObject<{
+    kind: z.ZodLiteral<"function">;
+    returnType: z.ZodOptional<z.ZodString>;
+    returnDescription: z.ZodOptional<z.ZodString>;
+    parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Parameter name (e.g., `options`, `...args`). */
+        name: z.ZodString;
+        /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+        type: z.ZodString;
+        /** Whether the parameter has a `?` token. */
+        optional: z.ZodDefault<z.ZodBoolean>;
+        /** Whether the parameter uses rest syntax (`...args`). */
+        rest: z.ZodDefault<z.ZodBoolean>;
+        /** Description from `@param` tag. */
+        description: z.ZodOptional<z.ZodString>;
+        /** Default value expression from the source (e.g., `'hello'`, `42`). */
+        defaultValue: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    overloads: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Full TypeScript type signature for this overload. */
+        typeSignature: z.ZodString;
+        /** Parameters for this overload. */
+        parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name (e.g., `options`, `...args`). */
+            name: z.ZodString;
+            /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+            type: z.ZodString;
+            /** Whether the parameter has a `?` token. */
+            optional: z.ZodDefault<z.ZodBoolean>;
+            /** Whether the parameter uses rest syntax (`...args`). */
+            rest: z.ZodDefault<z.ZodBoolean>;
+            /** Description from `@param` tag. */
+            description: z.ZodOptional<z.ZodString>;
+            /** Default value expression from the source (e.g., `'hello'`, `42`). */
+            defaultValue: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        /** Return type for this overload. */
+        returnType: z.ZodOptional<z.ZodString>;
+        /** Generic type parameters for this overload. */
+        genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name like `T`. */
+            name: z.ZodString;
+            /** Constraint like `string` from `T extends string`. */
+            constraint: z.ZodOptional<z.ZodString>;
+            /** Default type like `unknown` from `T = unknown`. */
+            defaultType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        /** JSDoc/TSDoc comment specific to this overload. */
+        docComment: z.ZodOptional<z.ZodString>;
+        /** Return value description from `@returns` tag on this overload. */
+        returnDescription: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    alsoExportedFrom: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    aliasOf: z.ZodOptional<z.ZodObject<{
+        module: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    partial: z.ZodDefault<z.ZodBoolean>;
+    examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    deprecatedMessage: z.ZodOptional<z.ZodString>;
+    seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    since: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    docComment: z.ZodOptional<z.ZodString>;
+    typeSignature: z.ZodOptional<z.ZodString>;
+    modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        public: "public";
+        protected: "protected";
+        readonly: "readonly";
+        static: "static";
+        abstract: "abstract";
+        getter: "getter";
+        setter: "setter";
+    }>>>;
+    sourceLine: z.ZodOptional<z.ZodNumber>;
+    genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Parameter name like `T`. */
+        name: z.ZodString;
+        /** Constraint like `string` from `T extends string`. */
+        constraint: z.ZodOptional<z.ZodString>;
+        /** Default type like `unknown` from `T = unknown`. */
+        defaultType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type FunctionDeclarationJson = z.infer<typeof FunctionDeclarationJson>;
+/** A class declaration. Has `members`, `extends`, `implements`. */
+export declare const ClassDeclarationJson: z.ZodObject<{
+    kind: z.ZodLiteral<"class">;
+    /**
+     * Extended base class (single; TypeScript allows only one).
+     *
+     * @see `implements` (this variant), `InterfaceDeclarationJson.extends`,
+     *   `TypeDeclarationJson.intersects`, `ComponentDeclarationJson.intersects`
+     *   for sibling "related type identifiers" fields. Field shapes mirror TS syntax.
+     */
+    extends: z.ZodOptional<z.ZodString>;
+    /** Implemented interfaces. */
+    implements: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    /**
+     * Class members: methods, properties, constructors, getters/setters.
+     */
+    members: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"function">;
+        /**
+         * User-chosen identifier, or the literal `'(call)'` sentinel for
+         * unnamed call signatures.
+         */
+        name: z.ZodString;
+        /** Whether the member has a `?` token in its declaration. */
+        optional: z.ZodDefault<z.ZodBoolean>;
+        returnType: z.ZodOptional<z.ZodString>;
+        returnDescription: z.ZodOptional<z.ZodString>;
+        parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name (e.g., `options`, `...args`). */
+            name: z.ZodString;
+            /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+            type: z.ZodString;
+            /** Whether the parameter has a `?` token. */
+            optional: z.ZodDefault<z.ZodBoolean>;
+            /** Whether the parameter uses rest syntax (`...args`). */
+            rest: z.ZodDefault<z.ZodBoolean>;
+            /** Description from `@param` tag. */
+            description: z.ZodOptional<z.ZodString>;
+            /** Default value expression from the source (e.g., `'hello'`, `42`). */
+            defaultValue: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        overloads: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Full TypeScript type signature for this overload. */
+            typeSignature: z.ZodString;
+            /** Parameters for this overload. */
+            parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name (e.g., `options`, `...args`). */
+                name: z.ZodString;
+                /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+                type: z.ZodString;
+                /** Whether the parameter has a `?` token. */
+                optional: z.ZodDefault<z.ZodBoolean>;
+                /** Whether the parameter uses rest syntax (`...args`). */
+                rest: z.ZodDefault<z.ZodBoolean>;
+                /** Description from `@param` tag. */
+                description: z.ZodOptional<z.ZodString>;
+                /** Default value expression from the source (e.g., `'hello'`, `42`). */
+                defaultValue: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            /** Return type for this overload. */
+            returnType: z.ZodOptional<z.ZodString>;
+            /** Generic type parameters for this overload. */
+            genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name like `T`. */
+                name: z.ZodString;
+                /** Constraint like `string` from `T extends string`. */
+                constraint: z.ZodOptional<z.ZodString>;
+                /** Default type like `unknown` from `T = unknown`. */
+                defaultType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            /** JSDoc/TSDoc comment specific to this overload. */
+            docComment: z.ZodOptional<z.ZodString>;
+            /** Return value description from `@returns` tag on this overload. */
+            returnDescription: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        partial: z.ZodDefault<z.ZodBoolean>;
+        examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        deprecatedMessage: z.ZodOptional<z.ZodString>;
+        seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, z.core.$strict>>>;
+        since: z.ZodOptional<z.ZodString>;
+        docComment: z.ZodOptional<z.ZodString>;
+        typeSignature: z.ZodOptional<z.ZodString>;
+        modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            public: "public";
+            protected: "protected";
+            readonly: "readonly";
+            static: "static";
+            abstract: "abstract";
+            getter: "getter";
+            setter: "setter";
+        }>>>;
+        sourceLine: z.ZodOptional<z.ZodNumber>;
+        genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name like `T`. */
+            name: z.ZodString;
+            /** Constraint like `string` from `T extends string`. */
+            constraint: z.ZodOptional<z.ZodString>;
+            /** Default type like `unknown` from `T = unknown`. */
+            defaultType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"variable">;
+        /** Whether the member has a `?` token in its declaration. */
+        optional: z.ZodDefault<z.ZodBoolean>;
+        /** Rune flavor when this field is initialized with a value-producing reactivity rune. */
+        reactivity: z.ZodOptional<z.ZodEnum<{
+            $state: "$state";
+            "$state.raw": "$state.raw";
+            $derived: "$derived";
+            "$derived.by": "$derived.by";
+        }>>;
+        /** Default value documented via `@default`. Authoritative initializer (when human-readable) is in `typeSignature`. */
+        defaultValue: z.ZodOptional<z.ZodString>;
+        mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        partial: z.ZodDefault<z.ZodBoolean>;
+        examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        deprecatedMessage: z.ZodOptional<z.ZodString>;
+        seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, z.core.$strict>>>;
+        since: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        docComment: z.ZodOptional<z.ZodString>;
+        typeSignature: z.ZodOptional<z.ZodString>;
+        modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            public: "public";
+            protected: "protected";
+            readonly: "readonly";
+            static: "static";
+            abstract: "abstract";
+            getter: "getter";
+            setter: "setter";
+        }>>>;
+        sourceLine: z.ZodOptional<z.ZodNumber>;
+        genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name like `T`. */
+            name: z.ZodString;
+            /** Constraint like `string` from `T extends string`. */
+            constraint: z.ZodOptional<z.ZodString>;
+            /** Default type like `unknown` from `T = unknown`. */
+            defaultType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"constructor">;
+        name: z.ZodUnion<readonly [z.ZodLiteral<"constructor">, z.ZodLiteral<"(construct)">]>;
+        parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name (e.g., `options`, `...args`). */
+            name: z.ZodString;
+            /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+            type: z.ZodString;
+            /** Whether the parameter has a `?` token. */
+            optional: z.ZodDefault<z.ZodBoolean>;
+            /** Whether the parameter uses rest syntax (`...args`). */
+            rest: z.ZodDefault<z.ZodBoolean>;
+            /** Description from `@param` tag. */
+            description: z.ZodOptional<z.ZodString>;
+            /** Default value expression from the source (e.g., `'hello'`, `42`). */
+            defaultValue: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        overloads: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Full TypeScript type signature for this overload. */
+            typeSignature: z.ZodString;
+            /** Parameters for this overload. */
+            parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name (e.g., `options`, `...args`). */
+                name: z.ZodString;
+                /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+                type: z.ZodString;
+                /** Whether the parameter has a `?` token. */
+                optional: z.ZodDefault<z.ZodBoolean>;
+                /** Whether the parameter uses rest syntax (`...args`). */
+                rest: z.ZodDefault<z.ZodBoolean>;
+                /** Description from `@param` tag. */
+                description: z.ZodOptional<z.ZodString>;
+                /** Default value expression from the source (e.g., `'hello'`, `42`). */
+                defaultValue: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            /** Return type for this overload. */
+            returnType: z.ZodOptional<z.ZodString>;
+            /** Generic type parameters for this overload. */
+            genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name like `T`. */
+                name: z.ZodString;
+                /** Constraint like `string` from `T extends string`. */
+                constraint: z.ZodOptional<z.ZodString>;
+                /** Default type like `unknown` from `T = unknown`. */
+                defaultType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            /** JSDoc/TSDoc comment specific to this overload. */
+            docComment: z.ZodOptional<z.ZodString>;
+            /** Return value description from `@returns` tag on this overload. */
+            returnDescription: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        partial: z.ZodDefault<z.ZodBoolean>;
+        examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        deprecatedMessage: z.ZodOptional<z.ZodString>;
+        seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, z.core.$strict>>>;
+        since: z.ZodOptional<z.ZodString>;
+        docComment: z.ZodOptional<z.ZodString>;
+        typeSignature: z.ZodOptional<z.ZodString>;
+        modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            public: "public";
+            protected: "protected";
+            readonly: "readonly";
+            static: "static";
+            abstract: "abstract";
+            getter: "getter";
+            setter: "setter";
+        }>>>;
+        sourceLine: z.ZodOptional<z.ZodNumber>;
+        genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name like `T`. */
+            name: z.ZodString;
+            /** Constraint like `string` from `T extends string`. */
+            constraint: z.ZodOptional<z.ZodString>;
+            /** Default type like `unknown` from `T = unknown`. */
+            defaultType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>], "kind">>>;
+    alsoExportedFrom: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    aliasOf: z.ZodOptional<z.ZodObject<{
+        module: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    partial: z.ZodDefault<z.ZodBoolean>;
+    examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    deprecatedMessage: z.ZodOptional<z.ZodString>;
+    seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    since: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    docComment: z.ZodOptional<z.ZodString>;
+    typeSignature: z.ZodOptional<z.ZodString>;
+    modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        public: "public";
+        protected: "protected";
+        readonly: "readonly";
+        static: "static";
+        abstract: "abstract";
+        getter: "getter";
+        setter: "setter";
+    }>>>;
+    sourceLine: z.ZodOptional<z.ZodNumber>;
+    genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Parameter name like `T`. */
+        name: z.ZodString;
+        /** Constraint like `string` from `T extends string`. */
+        constraint: z.ZodOptional<z.ZodString>;
+        /** Default type like `unknown` from `T = unknown`. */
+        defaultType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type ClassDeclarationJson = z.infer<typeof ClassDeclarationJson>;
+/** An interface declaration. Has `members`, `extends`. */
+export declare const InterfaceDeclarationJson: z.ZodObject<{
+    kind: z.ZodLiteral<"interface">;
+    /**
+     * Extended interfaces.
+     *
+     * @see `ClassDeclarationJson.extends`, `ClassDeclarationJson.implements`,
+     *   `TypeDeclarationJson.intersects`, `ComponentDeclarationJson.intersects`
+     *   for sibling "related type identifiers" fields. Field shapes mirror TS syntax.
+     */
+    extends: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    /**
+     * Interface members: property signatures, method signatures, index signatures,
+     * call/construct signatures.
+     */
+    members: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"function">;
+        /**
+         * User-chosen identifier, or the literal `'(call)'` sentinel for
+         * unnamed call signatures.
+         */
+        name: z.ZodString;
+        /** Whether the member has a `?` token in its declaration. */
+        optional: z.ZodDefault<z.ZodBoolean>;
+        returnType: z.ZodOptional<z.ZodString>;
+        returnDescription: z.ZodOptional<z.ZodString>;
+        parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name (e.g., `options`, `...args`). */
+            name: z.ZodString;
+            /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+            type: z.ZodString;
+            /** Whether the parameter has a `?` token. */
+            optional: z.ZodDefault<z.ZodBoolean>;
+            /** Whether the parameter uses rest syntax (`...args`). */
+            rest: z.ZodDefault<z.ZodBoolean>;
+            /** Description from `@param` tag. */
+            description: z.ZodOptional<z.ZodString>;
+            /** Default value expression from the source (e.g., `'hello'`, `42`). */
+            defaultValue: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        overloads: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Full TypeScript type signature for this overload. */
+            typeSignature: z.ZodString;
+            /** Parameters for this overload. */
+            parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name (e.g., `options`, `...args`). */
+                name: z.ZodString;
+                /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+                type: z.ZodString;
+                /** Whether the parameter has a `?` token. */
+                optional: z.ZodDefault<z.ZodBoolean>;
+                /** Whether the parameter uses rest syntax (`...args`). */
+                rest: z.ZodDefault<z.ZodBoolean>;
+                /** Description from `@param` tag. */
+                description: z.ZodOptional<z.ZodString>;
+                /** Default value expression from the source (e.g., `'hello'`, `42`). */
+                defaultValue: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            /** Return type for this overload. */
+            returnType: z.ZodOptional<z.ZodString>;
+            /** Generic type parameters for this overload. */
+            genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name like `T`. */
+                name: z.ZodString;
+                /** Constraint like `string` from `T extends string`. */
+                constraint: z.ZodOptional<z.ZodString>;
+                /** Default type like `unknown` from `T = unknown`. */
+                defaultType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            /** JSDoc/TSDoc comment specific to this overload. */
+            docComment: z.ZodOptional<z.ZodString>;
+            /** Return value description from `@returns` tag on this overload. */
+            returnDescription: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        partial: z.ZodDefault<z.ZodBoolean>;
+        examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        deprecatedMessage: z.ZodOptional<z.ZodString>;
+        seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, z.core.$strict>>>;
+        since: z.ZodOptional<z.ZodString>;
+        docComment: z.ZodOptional<z.ZodString>;
+        typeSignature: z.ZodOptional<z.ZodString>;
+        modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            public: "public";
+            protected: "protected";
+            readonly: "readonly";
+            static: "static";
+            abstract: "abstract";
+            getter: "getter";
+            setter: "setter";
+        }>>>;
+        sourceLine: z.ZodOptional<z.ZodNumber>;
+        genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name like `T`. */
+            name: z.ZodString;
+            /** Constraint like `string` from `T extends string`. */
+            constraint: z.ZodOptional<z.ZodString>;
+            /** Default type like `unknown` from `T = unknown`. */
+            defaultType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"variable">;
+        /** Whether the member has a `?` token in its declaration. */
+        optional: z.ZodDefault<z.ZodBoolean>;
+        /** Rune flavor when this field is initialized with a value-producing reactivity rune. */
+        reactivity: z.ZodOptional<z.ZodEnum<{
+            $state: "$state";
+            "$state.raw": "$state.raw";
+            $derived: "$derived";
+            "$derived.by": "$derived.by";
+        }>>;
+        /** Default value documented via `@default`. Authoritative initializer (when human-readable) is in `typeSignature`. */
+        defaultValue: z.ZodOptional<z.ZodString>;
+        mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        partial: z.ZodDefault<z.ZodBoolean>;
+        examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        deprecatedMessage: z.ZodOptional<z.ZodString>;
+        seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, z.core.$strict>>>;
+        since: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        docComment: z.ZodOptional<z.ZodString>;
+        typeSignature: z.ZodOptional<z.ZodString>;
+        modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            public: "public";
+            protected: "protected";
+            readonly: "readonly";
+            static: "static";
+            abstract: "abstract";
+            getter: "getter";
+            setter: "setter";
+        }>>>;
+        sourceLine: z.ZodOptional<z.ZodNumber>;
+        genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name like `T`. */
+            name: z.ZodString;
+            /** Constraint like `string` from `T extends string`. */
+            constraint: z.ZodOptional<z.ZodString>;
+            /** Default type like `unknown` from `T = unknown`. */
+            defaultType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"constructor">;
+        name: z.ZodUnion<readonly [z.ZodLiteral<"constructor">, z.ZodLiteral<"(construct)">]>;
+        parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name (e.g., `options`, `...args`). */
+            name: z.ZodString;
+            /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+            type: z.ZodString;
+            /** Whether the parameter has a `?` token. */
+            optional: z.ZodDefault<z.ZodBoolean>;
+            /** Whether the parameter uses rest syntax (`...args`). */
+            rest: z.ZodDefault<z.ZodBoolean>;
+            /** Description from `@param` tag. */
+            description: z.ZodOptional<z.ZodString>;
+            /** Default value expression from the source (e.g., `'hello'`, `42`). */
+            defaultValue: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        overloads: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Full TypeScript type signature for this overload. */
+            typeSignature: z.ZodString;
+            /** Parameters for this overload. */
+            parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name (e.g., `options`, `...args`). */
+                name: z.ZodString;
+                /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+                type: z.ZodString;
+                /** Whether the parameter has a `?` token. */
+                optional: z.ZodDefault<z.ZodBoolean>;
+                /** Whether the parameter uses rest syntax (`...args`). */
+                rest: z.ZodDefault<z.ZodBoolean>;
+                /** Description from `@param` tag. */
+                description: z.ZodOptional<z.ZodString>;
+                /** Default value expression from the source (e.g., `'hello'`, `42`). */
+                defaultValue: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            /** Return type for this overload. */
+            returnType: z.ZodOptional<z.ZodString>;
+            /** Generic type parameters for this overload. */
+            genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name like `T`. */
+                name: z.ZodString;
+                /** Constraint like `string` from `T extends string`. */
+                constraint: z.ZodOptional<z.ZodString>;
+                /** Default type like `unknown` from `T = unknown`. */
+                defaultType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            /** JSDoc/TSDoc comment specific to this overload. */
+            docComment: z.ZodOptional<z.ZodString>;
+            /** Return value description from `@returns` tag on this overload. */
+            returnDescription: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        partial: z.ZodDefault<z.ZodBoolean>;
+        examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        deprecatedMessage: z.ZodOptional<z.ZodString>;
+        seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, z.core.$strict>>>;
+        since: z.ZodOptional<z.ZodString>;
+        docComment: z.ZodOptional<z.ZodString>;
+        typeSignature: z.ZodOptional<z.ZodString>;
+        modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            public: "public";
+            protected: "protected";
+            readonly: "readonly";
+            static: "static";
+            abstract: "abstract";
+            getter: "getter";
+            setter: "setter";
+        }>>>;
+        sourceLine: z.ZodOptional<z.ZodNumber>;
+        genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name like `T`. */
+            name: z.ZodString;
+            /** Constraint like `string` from `T extends string`. */
+            constraint: z.ZodOptional<z.ZodString>;
+            /** Default type like `unknown` from `T = unknown`. */
+            defaultType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>], "kind">>>;
+    alsoExportedFrom: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    aliasOf: z.ZodOptional<z.ZodObject<{
+        module: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    partial: z.ZodDefault<z.ZodBoolean>;
+    examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    deprecatedMessage: z.ZodOptional<z.ZodString>;
+    seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    since: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    docComment: z.ZodOptional<z.ZodString>;
+    typeSignature: z.ZodOptional<z.ZodString>;
+    modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        public: "public";
+        protected: "protected";
+        readonly: "readonly";
+        static: "static";
+        abstract: "abstract";
+        getter: "getter";
+        setter: "setter";
+    }>>>;
+    sourceLine: z.ZodOptional<z.ZodNumber>;
+    genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Parameter name like `T`. */
+        name: z.ZodString;
+        /** Constraint like `string` from `T extends string`. */
+        constraint: z.ZodOptional<z.ZodString>;
+        /** Default type like `unknown` from `T = unknown`. */
+        defaultType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type InterfaceDeclarationJson = z.infer<typeof InterfaceDeclarationJson>;
+/** A type alias declaration. Has `members`, `intersects`. */
+export declare const TypeDeclarationJson: z.ZodObject<{
+    kind: z.ZodLiteral<"type">;
+    /**
+     * Types from intersection branches whose properties are all external (filtered out of `members`).
+     *
+     * @see `ComponentDeclarationJson.intersects`, `ClassDeclarationJson.extends`,
+     *   `ClassDeclarationJson.implements`, `InterfaceDeclarationJson.extends`
+     *   for sibling "related type identifiers" fields. Field shapes mirror TS syntax.
+     */
+    intersects: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    /**
+     * Type members: property signatures, method signatures, index signatures,
+     * call/construct signatures.
+     */
+    members: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"function">;
+        /**
+         * User-chosen identifier, or the literal `'(call)'` sentinel for
+         * unnamed call signatures.
+         */
+        name: z.ZodString;
+        /** Whether the member has a `?` token in its declaration. */
+        optional: z.ZodDefault<z.ZodBoolean>;
+        returnType: z.ZodOptional<z.ZodString>;
+        returnDescription: z.ZodOptional<z.ZodString>;
+        parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name (e.g., `options`, `...args`). */
+            name: z.ZodString;
+            /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+            type: z.ZodString;
+            /** Whether the parameter has a `?` token. */
+            optional: z.ZodDefault<z.ZodBoolean>;
+            /** Whether the parameter uses rest syntax (`...args`). */
+            rest: z.ZodDefault<z.ZodBoolean>;
+            /** Description from `@param` tag. */
+            description: z.ZodOptional<z.ZodString>;
+            /** Default value expression from the source (e.g., `'hello'`, `42`). */
+            defaultValue: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        overloads: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Full TypeScript type signature for this overload. */
+            typeSignature: z.ZodString;
+            /** Parameters for this overload. */
+            parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name (e.g., `options`, `...args`). */
+                name: z.ZodString;
+                /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+                type: z.ZodString;
+                /** Whether the parameter has a `?` token. */
+                optional: z.ZodDefault<z.ZodBoolean>;
+                /** Whether the parameter uses rest syntax (`...args`). */
+                rest: z.ZodDefault<z.ZodBoolean>;
+                /** Description from `@param` tag. */
+                description: z.ZodOptional<z.ZodString>;
+                /** Default value expression from the source (e.g., `'hello'`, `42`). */
+                defaultValue: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            /** Return type for this overload. */
+            returnType: z.ZodOptional<z.ZodString>;
+            /** Generic type parameters for this overload. */
+            genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name like `T`. */
+                name: z.ZodString;
+                /** Constraint like `string` from `T extends string`. */
+                constraint: z.ZodOptional<z.ZodString>;
+                /** Default type like `unknown` from `T = unknown`. */
+                defaultType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            /** JSDoc/TSDoc comment specific to this overload. */
+            docComment: z.ZodOptional<z.ZodString>;
+            /** Return value description from `@returns` tag on this overload. */
+            returnDescription: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        partial: z.ZodDefault<z.ZodBoolean>;
+        examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        deprecatedMessage: z.ZodOptional<z.ZodString>;
+        seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, z.core.$strict>>>;
+        since: z.ZodOptional<z.ZodString>;
+        docComment: z.ZodOptional<z.ZodString>;
+        typeSignature: z.ZodOptional<z.ZodString>;
+        modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            public: "public";
+            protected: "protected";
+            readonly: "readonly";
+            static: "static";
+            abstract: "abstract";
+            getter: "getter";
+            setter: "setter";
+        }>>>;
+        sourceLine: z.ZodOptional<z.ZodNumber>;
+        genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name like `T`. */
+            name: z.ZodString;
+            /** Constraint like `string` from `T extends string`. */
+            constraint: z.ZodOptional<z.ZodString>;
+            /** Default type like `unknown` from `T = unknown`. */
+            defaultType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"variable">;
+        /** Whether the member has a `?` token in its declaration. */
+        optional: z.ZodDefault<z.ZodBoolean>;
+        /** Rune flavor when this field is initialized with a value-producing reactivity rune. */
+        reactivity: z.ZodOptional<z.ZodEnum<{
+            $state: "$state";
+            "$state.raw": "$state.raw";
+            $derived: "$derived";
+            "$derived.by": "$derived.by";
+        }>>;
+        /** Default value documented via `@default`. Authoritative initializer (when human-readable) is in `typeSignature`. */
+        defaultValue: z.ZodOptional<z.ZodString>;
+        mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        partial: z.ZodDefault<z.ZodBoolean>;
+        examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        deprecatedMessage: z.ZodOptional<z.ZodString>;
+        seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, z.core.$strict>>>;
+        since: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        docComment: z.ZodOptional<z.ZodString>;
+        typeSignature: z.ZodOptional<z.ZodString>;
+        modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            public: "public";
+            protected: "protected";
+            readonly: "readonly";
+            static: "static";
+            abstract: "abstract";
+            getter: "getter";
+            setter: "setter";
+        }>>>;
+        sourceLine: z.ZodOptional<z.ZodNumber>;
+        genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name like `T`. */
+            name: z.ZodString;
+            /** Constraint like `string` from `T extends string`. */
+            constraint: z.ZodOptional<z.ZodString>;
+            /** Default type like `unknown` from `T = unknown`. */
+            defaultType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"constructor">;
+        name: z.ZodUnion<readonly [z.ZodLiteral<"constructor">, z.ZodLiteral<"(construct)">]>;
+        parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name (e.g., `options`, `...args`). */
+            name: z.ZodString;
+            /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+            type: z.ZodString;
+            /** Whether the parameter has a `?` token. */
+            optional: z.ZodDefault<z.ZodBoolean>;
+            /** Whether the parameter uses rest syntax (`...args`). */
+            rest: z.ZodDefault<z.ZodBoolean>;
+            /** Description from `@param` tag. */
+            description: z.ZodOptional<z.ZodString>;
+            /** Default value expression from the source (e.g., `'hello'`, `42`). */
+            defaultValue: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        overloads: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Full TypeScript type signature for this overload. */
+            typeSignature: z.ZodString;
+            /** Parameters for this overload. */
+            parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name (e.g., `options`, `...args`). */
+                name: z.ZodString;
+                /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+                type: z.ZodString;
+                /** Whether the parameter has a `?` token. */
+                optional: z.ZodDefault<z.ZodBoolean>;
+                /** Whether the parameter uses rest syntax (`...args`). */
+                rest: z.ZodDefault<z.ZodBoolean>;
+                /** Description from `@param` tag. */
+                description: z.ZodOptional<z.ZodString>;
+                /** Default value expression from the source (e.g., `'hello'`, `42`). */
+                defaultValue: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            /** Return type for this overload. */
+            returnType: z.ZodOptional<z.ZodString>;
+            /** Generic type parameters for this overload. */
+            genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name like `T`. */
+                name: z.ZodString;
+                /** Constraint like `string` from `T extends string`. */
+                constraint: z.ZodOptional<z.ZodString>;
+                /** Default type like `unknown` from `T = unknown`. */
+                defaultType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            /** JSDoc/TSDoc comment specific to this overload. */
+            docComment: z.ZodOptional<z.ZodString>;
+            /** Return value description from `@returns` tag on this overload. */
+            returnDescription: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        partial: z.ZodDefault<z.ZodBoolean>;
+        examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        deprecatedMessage: z.ZodOptional<z.ZodString>;
+        seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, z.core.$strict>>>;
+        since: z.ZodOptional<z.ZodString>;
+        docComment: z.ZodOptional<z.ZodString>;
+        typeSignature: z.ZodOptional<z.ZodString>;
+        modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            public: "public";
+            protected: "protected";
+            readonly: "readonly";
+            static: "static";
+            abstract: "abstract";
+            getter: "getter";
+            setter: "setter";
+        }>>>;
+        sourceLine: z.ZodOptional<z.ZodNumber>;
+        genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name like `T`. */
+            name: z.ZodString;
+            /** Constraint like `string` from `T extends string`. */
+            constraint: z.ZodOptional<z.ZodString>;
+            /** Default type like `unknown` from `T = unknown`. */
+            defaultType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>], "kind">>>;
+    alsoExportedFrom: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    aliasOf: z.ZodOptional<z.ZodObject<{
+        module: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    partial: z.ZodDefault<z.ZodBoolean>;
+    examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    deprecatedMessage: z.ZodOptional<z.ZodString>;
+    seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    since: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    docComment: z.ZodOptional<z.ZodString>;
+    typeSignature: z.ZodOptional<z.ZodString>;
+    modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        public: "public";
+        protected: "protected";
+        readonly: "readonly";
+        static: "static";
+        abstract: "abstract";
+        getter: "getter";
+        setter: "setter";
+    }>>>;
+    sourceLine: z.ZodOptional<z.ZodNumber>;
+    genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Parameter name like `T`. */
+        name: z.ZodString;
+        /** Constraint like `string` from `T extends string`. */
+        constraint: z.ZodOptional<z.ZodString>;
+        /** Default type like `unknown` from `T = unknown`. */
+        defaultType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type TypeDeclarationJson = z.infer<typeof TypeDeclarationJson>;
+/**
+ * A variable declaration. Has optional `reactivity` for top-level rune-module
+ * exports (e.g., `export let count = $state(0)` in `.svelte.ts` or `<script module>`).
+ */
+export declare const VariableDeclarationJson: z.ZodObject<{
+    kind: z.ZodLiteral<"variable">;
+    /** Rune flavor when this variable is initialized with a value-producing reactivity rune. */
+    reactivity: z.ZodOptional<z.ZodEnum<{
+        $state: "$state";
+        "$state.raw": "$state.raw";
+        $derived: "$derived";
+        "$derived.by": "$derived.by";
+    }>>;
+    /** Default value documented via `@default`. Useful when the AST initializer is opaque (a call expression, computed value) and the author wants to document the conceptual default. */
+    defaultValue: z.ZodOptional<z.ZodString>;
+    alsoExportedFrom: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    aliasOf: z.ZodOptional<z.ZodObject<{
+        module: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    partial: z.ZodDefault<z.ZodBoolean>;
+    examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    deprecatedMessage: z.ZodOptional<z.ZodString>;
+    seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    since: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    docComment: z.ZodOptional<z.ZodString>;
+    typeSignature: z.ZodOptional<z.ZodString>;
+    modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        public: "public";
+        protected: "protected";
+        readonly: "readonly";
+        static: "static";
+        abstract: "abstract";
+        getter: "getter";
+        setter: "setter";
+    }>>>;
+    sourceLine: z.ZodOptional<z.ZodNumber>;
+    genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Parameter name like `T`. */
+        name: z.ZodString;
+        /** Constraint like `string` from `T extends string`. */
+        constraint: z.ZodOptional<z.ZodString>;
+        /** Default type like `unknown` from `T = unknown`. */
+        defaultType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type VariableDeclarationJson = z.infer<typeof VariableDeclarationJson>;
+/** An enum declaration. Has `members` for enum values. */
+export declare const EnumDeclarationJson: z.ZodObject<{
+    kind: z.ZodLiteral<"enum">;
+    /** Enum members: name/value pairs with optional JSDoc. */
+    members: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"function">;
+        /**
+         * User-chosen identifier, or the literal `'(call)'` sentinel for
+         * unnamed call signatures.
+         */
+        name: z.ZodString;
+        /** Whether the member has a `?` token in its declaration. */
+        optional: z.ZodDefault<z.ZodBoolean>;
+        returnType: z.ZodOptional<z.ZodString>;
+        returnDescription: z.ZodOptional<z.ZodString>;
+        parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name (e.g., `options`, `...args`). */
+            name: z.ZodString;
+            /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+            type: z.ZodString;
+            /** Whether the parameter has a `?` token. */
+            optional: z.ZodDefault<z.ZodBoolean>;
+            /** Whether the parameter uses rest syntax (`...args`). */
+            rest: z.ZodDefault<z.ZodBoolean>;
+            /** Description from `@param` tag. */
+            description: z.ZodOptional<z.ZodString>;
+            /** Default value expression from the source (e.g., `'hello'`, `42`). */
+            defaultValue: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        overloads: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Full TypeScript type signature for this overload. */
+            typeSignature: z.ZodString;
+            /** Parameters for this overload. */
+            parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name (e.g., `options`, `...args`). */
+                name: z.ZodString;
+                /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+                type: z.ZodString;
+                /** Whether the parameter has a `?` token. */
+                optional: z.ZodDefault<z.ZodBoolean>;
+                /** Whether the parameter uses rest syntax (`...args`). */
+                rest: z.ZodDefault<z.ZodBoolean>;
+                /** Description from `@param` tag. */
+                description: z.ZodOptional<z.ZodString>;
+                /** Default value expression from the source (e.g., `'hello'`, `42`). */
+                defaultValue: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            /** Return type for this overload. */
+            returnType: z.ZodOptional<z.ZodString>;
+            /** Generic type parameters for this overload. */
+            genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name like `T`. */
+                name: z.ZodString;
+                /** Constraint like `string` from `T extends string`. */
+                constraint: z.ZodOptional<z.ZodString>;
+                /** Default type like `unknown` from `T = unknown`. */
+                defaultType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            /** JSDoc/TSDoc comment specific to this overload. */
+            docComment: z.ZodOptional<z.ZodString>;
+            /** Return value description from `@returns` tag on this overload. */
+            returnDescription: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        partial: z.ZodDefault<z.ZodBoolean>;
+        examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        deprecatedMessage: z.ZodOptional<z.ZodString>;
+        seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, z.core.$strict>>>;
+        since: z.ZodOptional<z.ZodString>;
+        docComment: z.ZodOptional<z.ZodString>;
+        typeSignature: z.ZodOptional<z.ZodString>;
+        modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            public: "public";
+            protected: "protected";
+            readonly: "readonly";
+            static: "static";
+            abstract: "abstract";
+            getter: "getter";
+            setter: "setter";
+        }>>>;
+        sourceLine: z.ZodOptional<z.ZodNumber>;
+        genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name like `T`. */
+            name: z.ZodString;
+            /** Constraint like `string` from `T extends string`. */
+            constraint: z.ZodOptional<z.ZodString>;
+            /** Default type like `unknown` from `T = unknown`. */
+            defaultType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"variable">;
+        /** Whether the member has a `?` token in its declaration. */
+        optional: z.ZodDefault<z.ZodBoolean>;
+        /** Rune flavor when this field is initialized with a value-producing reactivity rune. */
+        reactivity: z.ZodOptional<z.ZodEnum<{
+            $state: "$state";
+            "$state.raw": "$state.raw";
+            $derived: "$derived";
+            "$derived.by": "$derived.by";
+        }>>;
+        /** Default value documented via `@default`. Authoritative initializer (when human-readable) is in `typeSignature`. */
+        defaultValue: z.ZodOptional<z.ZodString>;
+        mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        partial: z.ZodDefault<z.ZodBoolean>;
+        examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        deprecatedMessage: z.ZodOptional<z.ZodString>;
+        seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, z.core.$strict>>>;
+        since: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        docComment: z.ZodOptional<z.ZodString>;
+        typeSignature: z.ZodOptional<z.ZodString>;
+        modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            public: "public";
+            protected: "protected";
+            readonly: "readonly";
+            static: "static";
+            abstract: "abstract";
+            getter: "getter";
+            setter: "setter";
+        }>>>;
+        sourceLine: z.ZodOptional<z.ZodNumber>;
+        genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name like `T`. */
+            name: z.ZodString;
+            /** Constraint like `string` from `T extends string`. */
+            constraint: z.ZodOptional<z.ZodString>;
+            /** Default type like `unknown` from `T = unknown`. */
+            defaultType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"constructor">;
+        name: z.ZodUnion<readonly [z.ZodLiteral<"constructor">, z.ZodLiteral<"(construct)">]>;
+        parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name (e.g., `options`, `...args`). */
+            name: z.ZodString;
+            /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+            type: z.ZodString;
+            /** Whether the parameter has a `?` token. */
+            optional: z.ZodDefault<z.ZodBoolean>;
+            /** Whether the parameter uses rest syntax (`...args`). */
+            rest: z.ZodDefault<z.ZodBoolean>;
+            /** Description from `@param` tag. */
+            description: z.ZodOptional<z.ZodString>;
+            /** Default value expression from the source (e.g., `'hello'`, `42`). */
+            defaultValue: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        overloads: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Full TypeScript type signature for this overload. */
+            typeSignature: z.ZodString;
+            /** Parameters for this overload. */
+            parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name (e.g., `options`, `...args`). */
+                name: z.ZodString;
+                /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+                type: z.ZodString;
+                /** Whether the parameter has a `?` token. */
+                optional: z.ZodDefault<z.ZodBoolean>;
+                /** Whether the parameter uses rest syntax (`...args`). */
+                rest: z.ZodDefault<z.ZodBoolean>;
+                /** Description from `@param` tag. */
+                description: z.ZodOptional<z.ZodString>;
+                /** Default value expression from the source (e.g., `'hello'`, `42`). */
+                defaultValue: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            /** Return type for this overload. */
+            returnType: z.ZodOptional<z.ZodString>;
+            /** Generic type parameters for this overload. */
+            genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name like `T`. */
+                name: z.ZodString;
+                /** Constraint like `string` from `T extends string`. */
+                constraint: z.ZodOptional<z.ZodString>;
+                /** Default type like `unknown` from `T = unknown`. */
+                defaultType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            /** JSDoc/TSDoc comment specific to this overload. */
+            docComment: z.ZodOptional<z.ZodString>;
+            /** Return value description from `@returns` tag on this overload. */
+            returnDescription: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        partial: z.ZodDefault<z.ZodBoolean>;
+        examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        deprecatedMessage: z.ZodOptional<z.ZodString>;
+        seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, z.core.$strict>>>;
+        since: z.ZodOptional<z.ZodString>;
+        docComment: z.ZodOptional<z.ZodString>;
+        typeSignature: z.ZodOptional<z.ZodString>;
+        modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            public: "public";
+            protected: "protected";
+            readonly: "readonly";
+            static: "static";
+            abstract: "abstract";
+            getter: "getter";
+            setter: "setter";
+        }>>>;
+        sourceLine: z.ZodOptional<z.ZodNumber>;
+        genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name like `T`. */
+            name: z.ZodString;
+            /** Constraint like `string` from `T extends string`. */
+            constraint: z.ZodOptional<z.ZodString>;
+            /** Default type like `unknown` from `T = unknown`. */
+            defaultType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>], "kind">>>;
+    alsoExportedFrom: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    aliasOf: z.ZodOptional<z.ZodObject<{
+        module: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    partial: z.ZodDefault<z.ZodBoolean>;
+    examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    deprecatedMessage: z.ZodOptional<z.ZodString>;
+    seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    since: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    docComment: z.ZodOptional<z.ZodString>;
+    typeSignature: z.ZodOptional<z.ZodString>;
+    modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        public: "public";
+        protected: "protected";
+        readonly: "readonly";
+        static: "static";
+        abstract: "abstract";
+        getter: "getter";
+        setter: "setter";
+    }>>>;
+    sourceLine: z.ZodOptional<z.ZodNumber>;
+    genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Parameter name like `T`. */
+        name: z.ZodString;
+        /** Constraint like `string` from `T extends string`. */
+        constraint: z.ZodOptional<z.ZodString>;
+        /** Default type like `unknown` from `T = unknown`. */
+        defaultType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type EnumDeclarationJson = z.infer<typeof EnumDeclarationJson>;
+/** A Svelte component declaration. Has `props`, `intersects`, `acceptsChildren`. */
+export declare const ComponentDeclarationJson: z.ZodObject<{
+    kind: z.ZodLiteral<"component">;
+    /**
+     * Types from intersection branches whose properties are all external (filtered out of `props`).
+     *
+     * @see `TypeDeclarationJson.intersects`, `ClassDeclarationJson.extends`,
+     *   `ClassDeclarationJson.implements`, `InterfaceDeclarationJson.extends`
+     *   for sibling "related type identifiers" fields. Field shapes mirror TS syntax.
+     */
+    intersects: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    /** Svelte component props. */
+    props: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        deprecatedMessage: z.ZodOptional<z.ZodString>;
+        seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, z.core.$strict>>>;
+        since: z.ZodOptional<z.ZodString>;
+        /** Prop name as declared in the component's `$props()` type. */
+        name: z.ZodString;
+        /** Resolved TypeScript type string. */
+        type: z.ZodString;
+        /** Whether the prop is optional in the component's props type. */
+        optional: z.ZodDefault<z.ZodBoolean>;
+        /** Description from JSDoc on the prop's type declaration. */
+        description: z.ZodOptional<z.ZodString>;
+        /** Default value expression from destructuring or `@default` tag. */
+        defaultValue: z.ZodOptional<z.ZodString>;
+        /** Whether the prop uses the `$bindable()` rune, enabling two-way binding. */
+        bindable: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Structured parameters for callable props (e.g., `Snippet<[text: string]>`).
+         *
+         * Present when the prop has extractable parameters, absent otherwise.
+         * Only populated when there are actual parameters — bare `Snippet` / `Snippet<[]>`
+         * does not set this field. Intentionally `.optional()` rather than
+         * `.default([])` (see the array-field policy note above): absence is a
+         * meaningful signal, not an empty list.
+         */
+        parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            /** Parameter name (e.g., `options`, `...args`). */
+            name: z.ZodString;
+            /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+            type: z.ZodString;
+            /** Whether the parameter has a `?` token. */
+            optional: z.ZodDefault<z.ZodBoolean>;
+            /** Whether the parameter uses rest syntax (`...args`). */
+            rest: z.ZodDefault<z.ZodBoolean>;
+            /** Description from `@param` tag. */
+            description: z.ZodOptional<z.ZodString>;
+            /** Default value expression from the source (e.g., `'hello'`, `42`). */
+            defaultValue: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>;
+    /** Whether the component accepts children (explicit `children` prop, inherited, or implicit template usage). */
+    acceptsChildren: z.ZodDefault<z.ZodBoolean>;
+    /** Script language. `undefined` means TypeScript (default), `'js'` for JavaScript-only components. */
+    lang: z.ZodOptional<z.ZodEnum<{
+        js: "js";
+    }>>;
+    alsoExportedFrom: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    aliasOf: z.ZodOptional<z.ZodObject<{
+        module: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    partial: z.ZodDefault<z.ZodBoolean>;
+    examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    deprecatedMessage: z.ZodOptional<z.ZodString>;
+    seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    since: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    docComment: z.ZodOptional<z.ZodString>;
+    typeSignature: z.ZodOptional<z.ZodString>;
+    modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        public: "public";
+        protected: "protected";
+        readonly: "readonly";
+        static: "static";
+        abstract: "abstract";
+        getter: "getter";
+        setter: "setter";
+    }>>>;
+    sourceLine: z.ZodOptional<z.ZodNumber>;
+    genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Parameter name like `T`. */
+        name: z.ZodString;
+        /** Constraint like `string` from `T extends string`. */
+        constraint: z.ZodOptional<z.ZodString>;
+        /** Default type like `unknown` from `T = unknown`. */
+        defaultType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type ComponentDeclarationJson = z.infer<typeof ComponentDeclarationJson>;
+/** A Svelte snippet declaration exported from `<script module>`. Has `parameters`. */
+export declare const SnippetDeclarationJson: z.ZodObject<{
+    kind: z.ZodLiteral<"snippet">;
+    /** Snippet parameters. */
+    parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Parameter name (e.g., `options`, `...args`). */
+        name: z.ZodString;
+        /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+        type: z.ZodString;
+        /** Whether the parameter has a `?` token. */
+        optional: z.ZodDefault<z.ZodBoolean>;
+        /** Whether the parameter uses rest syntax (`...args`). */
+        rest: z.ZodDefault<z.ZodBoolean>;
+        /** Description from `@param` tag. */
+        description: z.ZodOptional<z.ZodString>;
+        /** Default value expression from the source (e.g., `'hello'`, `42`). */
+        defaultValue: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    alsoExportedFrom: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    aliasOf: z.ZodOptional<z.ZodObject<{
+        module: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    partial: z.ZodDefault<z.ZodBoolean>;
+    examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    deprecatedMessage: z.ZodOptional<z.ZodString>;
+    seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    since: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    docComment: z.ZodOptional<z.ZodString>;
+    typeSignature: z.ZodOptional<z.ZodString>;
+    modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        public: "public";
+        protected: "protected";
+        readonly: "readonly";
+        static: "static";
+        abstract: "abstract";
+        getter: "getter";
+        setter: "setter";
+    }>>>;
+    sourceLine: z.ZodOptional<z.ZodNumber>;
+    genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Parameter name like `T`. */
+        name: z.ZodString;
+        /** Constraint like `string` from `T extends string`. */
+        constraint: z.ZodOptional<z.ZodString>;
+        /** Default type like `unknown` from `T = unknown`. */
+        defaultType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type SnippetDeclarationJson = z.infer<typeof SnippetDeclarationJson>;
+/**
+ * A namespace re-export binding: `export * as ns from './x'`.
+ *
+ * Carries no inline members — `module` points to the source module whose
+ * declarations are projected under this name. Consumers that want to render
+ * `ns.a` can deref by reading the source module's `declarations` array.
+ */
+export declare const NamespaceDeclarationJson: z.ZodObject<{
+    kind: z.ZodLiteral<"namespace">;
+    /** Source module path (relative to `sourceRoot`) projected under this binding. */
+    module: z.ZodString;
+    alsoExportedFrom: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    aliasOf: z.ZodOptional<z.ZodObject<{
+        module: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    partial: z.ZodDefault<z.ZodBoolean>;
+    examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    deprecatedMessage: z.ZodOptional<z.ZodString>;
+    seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    since: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    docComment: z.ZodOptional<z.ZodString>;
+    typeSignature: z.ZodOptional<z.ZodString>;
+    modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        public: "public";
+        protected: "protected";
+        readonly: "readonly";
+        static: "static";
+        abstract: "abstract";
+        getter: "getter";
+        setter: "setter";
+    }>>>;
+    sourceLine: z.ZodOptional<z.ZodNumber>;
+    genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Parameter name like `T`. */
+        name: z.ZodString;
+        /** Constraint like `string` from `T extends string`. */
+        constraint: z.ZodOptional<z.ZodString>;
+        /** Default type like `unknown` from `T = unknown`. */
+        defaultType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type NamespaceDeclarationJson = z.infer<typeof NamespaceDeclarationJson>;
+/**
+ * Metadata for an exported declaration (function, type, class, component, etc.).
+ *
+ * Discriminated union on `kind` — each variant has only the fields relevant to that kind.
+ * Use `isKind` (in `declaration-helpers.ts`) to narrow, or check `declaration.kind` directly.
+ */
+export declare const DeclarationJson: z.ZodDiscriminatedUnion<[
+    typeof FunctionDeclarationJson,
+    typeof ClassDeclarationJson,
+    typeof InterfaceDeclarationJson,
+    typeof TypeDeclarationJson,
+    typeof VariableDeclarationJson,
+    typeof EnumDeclarationJson,
+    typeof ComponentDeclarationJson,
+    typeof SnippetDeclarationJson,
+    typeof NamespaceDeclarationJson
+], 'kind'>;
+export type DeclarationJson = z.infer<typeof DeclarationJson>;
+export type DeclarationJsonInput = z.input<typeof DeclarationJson>;
+/**
+ * Metadata for a source module — the top-level container in the data model.
+ *
+ * `analyze` and `analyzeFromFiles` return `Array<ModuleJson>` sorted alphabetically by `path`.
+ * Each module contains its exported `declarations`, dependency graph, and optional `moduleComment`.
+ */
+export declare const ModuleJson: z.ZodObject<{
+    /**
+     * Path relative to `sourceRoot` (e.g., `helpers.ts` for the default
+     * SvelteKit `src/lib` layout). `sourceRoot` is configurable via
+     * `createSourceOptions` / the CLI `--source-root` flag — consumers with a
+     * custom layout (e.g., `sourcePaths: ['src/lib', 'src/routes']`,
+     * `sourceRoot: 'src'`) see prefixes like `lib/foo.ts` here.
+     */
+    path: z.ZodString;
+    /** Exported declarations from this module. */
+    declarations: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"function">;
+        returnType: z.ZodOptional<z.ZodString>;
+        returnDescription: z.ZodOptional<z.ZodString>;
+        parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name (e.g., `options`, `...args`). */
+            name: z.ZodString;
+            /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+            type: z.ZodString;
+            /** Whether the parameter has a `?` token. */
+            optional: z.ZodDefault<z.ZodBoolean>;
+            /** Whether the parameter uses rest syntax (`...args`). */
+            rest: z.ZodDefault<z.ZodBoolean>;
+            /** Description from `@param` tag. */
+            description: z.ZodOptional<z.ZodString>;
+            /** Default value expression from the source (e.g., `'hello'`, `42`). */
+            defaultValue: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        overloads: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Full TypeScript type signature for this overload. */
+            typeSignature: z.ZodString;
+            /** Parameters for this overload. */
+            parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name (e.g., `options`, `...args`). */
+                name: z.ZodString;
+                /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+                type: z.ZodString;
+                /** Whether the parameter has a `?` token. */
+                optional: z.ZodDefault<z.ZodBoolean>;
+                /** Whether the parameter uses rest syntax (`...args`). */
+                rest: z.ZodDefault<z.ZodBoolean>;
+                /** Description from `@param` tag. */
+                description: z.ZodOptional<z.ZodString>;
+                /** Default value expression from the source (e.g., `'hello'`, `42`). */
+                defaultValue: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            /** Return type for this overload. */
+            returnType: z.ZodOptional<z.ZodString>;
+            /** Generic type parameters for this overload. */
+            genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name like `T`. */
+                name: z.ZodString;
+                /** Constraint like `string` from `T extends string`. */
+                constraint: z.ZodOptional<z.ZodString>;
+                /** Default type like `unknown` from `T = unknown`. */
+                defaultType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            /** JSDoc/TSDoc comment specific to this overload. */
+            docComment: z.ZodOptional<z.ZodString>;
+            /** Return value description from `@returns` tag on this overload. */
+            returnDescription: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        alsoExportedFrom: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        aliasOf: z.ZodOptional<z.ZodObject<{
+            module: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>>;
+        mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        partial: z.ZodDefault<z.ZodBoolean>;
+        examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        deprecatedMessage: z.ZodOptional<z.ZodString>;
+        seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, z.core.$strict>>>;
+        since: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        docComment: z.ZodOptional<z.ZodString>;
+        typeSignature: z.ZodOptional<z.ZodString>;
+        modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            public: "public";
+            protected: "protected";
+            readonly: "readonly";
+            static: "static";
+            abstract: "abstract";
+            getter: "getter";
+            setter: "setter";
+        }>>>;
+        sourceLine: z.ZodOptional<z.ZodNumber>;
+        genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name like `T`. */
+            name: z.ZodString;
+            /** Constraint like `string` from `T extends string`. */
+            constraint: z.ZodOptional<z.ZodString>;
+            /** Default type like `unknown` from `T = unknown`. */
+            defaultType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"class">;
+        /**
+         * Extended base class (single; TypeScript allows only one).
+         *
+         * @see `implements` (this variant), `InterfaceDeclarationJson.extends`,
+         *   `TypeDeclarationJson.intersects`, `ComponentDeclarationJson.intersects`
+         *   for sibling "related type identifiers" fields. Field shapes mirror TS syntax.
+         */
+        extends: z.ZodOptional<z.ZodString>;
+        /** Implemented interfaces. */
+        implements: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        /**
+         * Class members: methods, properties, constructors, getters/setters.
+         */
+        members: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"function">;
+            /**
+             * User-chosen identifier, or the literal `'(call)'` sentinel for
+             * unnamed call signatures.
+             */
+            name: z.ZodString;
+            /** Whether the member has a `?` token in its declaration. */
+            optional: z.ZodDefault<z.ZodBoolean>;
+            returnType: z.ZodOptional<z.ZodString>;
+            returnDescription: z.ZodOptional<z.ZodString>;
+            parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name (e.g., `options`, `...args`). */
+                name: z.ZodString;
+                /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+                type: z.ZodString;
+                /** Whether the parameter has a `?` token. */
+                optional: z.ZodDefault<z.ZodBoolean>;
+                /** Whether the parameter uses rest syntax (`...args`). */
+                rest: z.ZodDefault<z.ZodBoolean>;
+                /** Description from `@param` tag. */
+                description: z.ZodOptional<z.ZodString>;
+                /** Default value expression from the source (e.g., `'hello'`, `42`). */
+                defaultValue: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            overloads: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Full TypeScript type signature for this overload. */
+                typeSignature: z.ZodString;
+                /** Parameters for this overload. */
+                parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    /** Parameter name (e.g., `options`, `...args`). */
+                    name: z.ZodString;
+                    /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+                    type: z.ZodString;
+                    /** Whether the parameter has a `?` token. */
+                    optional: z.ZodDefault<z.ZodBoolean>;
+                    /** Whether the parameter uses rest syntax (`...args`). */
+                    rest: z.ZodDefault<z.ZodBoolean>;
+                    /** Description from `@param` tag. */
+                    description: z.ZodOptional<z.ZodString>;
+                    /** Default value expression from the source (e.g., `'hello'`, `42`). */
+                    defaultValue: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                /** Return type for this overload. */
+                returnType: z.ZodOptional<z.ZodString>;
+                /** Generic type parameters for this overload. */
+                genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    /** Parameter name like `T`. */
+                    name: z.ZodString;
+                    /** Constraint like `string` from `T extends string`. */
+                    constraint: z.ZodOptional<z.ZodString>;
+                    /** Default type like `unknown` from `T = unknown`. */
+                    defaultType: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                /** JSDoc/TSDoc comment specific to this overload. */
+                docComment: z.ZodOptional<z.ZodString>;
+                /** Return value description from `@returns` tag on this overload. */
+                returnDescription: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            partial: z.ZodDefault<z.ZodBoolean>;
+            examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            deprecatedMessage: z.ZodOptional<z.ZodString>;
+            seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                type: z.ZodOptional<z.ZodString>;
+                description: z.ZodString;
+            }, z.core.$strict>>>;
+            since: z.ZodOptional<z.ZodString>;
+            docComment: z.ZodOptional<z.ZodString>;
+            typeSignature: z.ZodOptional<z.ZodString>;
+            modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                public: "public";
+                protected: "protected";
+                readonly: "readonly";
+                static: "static";
+                abstract: "abstract";
+                getter: "getter";
+                setter: "setter";
+            }>>>;
+            sourceLine: z.ZodOptional<z.ZodNumber>;
+            genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name like `T`. */
+                name: z.ZodString;
+                /** Constraint like `string` from `T extends string`. */
+                constraint: z.ZodOptional<z.ZodString>;
+                /** Default type like `unknown` from `T = unknown`. */
+                defaultType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"variable">;
+            /** Whether the member has a `?` token in its declaration. */
+            optional: z.ZodDefault<z.ZodBoolean>;
+            /** Rune flavor when this field is initialized with a value-producing reactivity rune. */
+            reactivity: z.ZodOptional<z.ZodEnum<{
+                $state: "$state";
+                "$state.raw": "$state.raw";
+                $derived: "$derived";
+                "$derived.by": "$derived.by";
+            }>>;
+            /** Default value documented via `@default`. Authoritative initializer (when human-readable) is in `typeSignature`. */
+            defaultValue: z.ZodOptional<z.ZodString>;
+            mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            partial: z.ZodDefault<z.ZodBoolean>;
+            examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            deprecatedMessage: z.ZodOptional<z.ZodString>;
+            seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                type: z.ZodOptional<z.ZodString>;
+                description: z.ZodString;
+            }, z.core.$strict>>>;
+            since: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            docComment: z.ZodOptional<z.ZodString>;
+            typeSignature: z.ZodOptional<z.ZodString>;
+            modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                public: "public";
+                protected: "protected";
+                readonly: "readonly";
+                static: "static";
+                abstract: "abstract";
+                getter: "getter";
+                setter: "setter";
+            }>>>;
+            sourceLine: z.ZodOptional<z.ZodNumber>;
+            genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name like `T`. */
+                name: z.ZodString;
+                /** Constraint like `string` from `T extends string`. */
+                constraint: z.ZodOptional<z.ZodString>;
+                /** Default type like `unknown` from `T = unknown`. */
+                defaultType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"constructor">;
+            name: z.ZodUnion<readonly [z.ZodLiteral<"constructor">, z.ZodLiteral<"(construct)">]>;
+            parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name (e.g., `options`, `...args`). */
+                name: z.ZodString;
+                /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+                type: z.ZodString;
+                /** Whether the parameter has a `?` token. */
+                optional: z.ZodDefault<z.ZodBoolean>;
+                /** Whether the parameter uses rest syntax (`...args`). */
+                rest: z.ZodDefault<z.ZodBoolean>;
+                /** Description from `@param` tag. */
+                description: z.ZodOptional<z.ZodString>;
+                /** Default value expression from the source (e.g., `'hello'`, `42`). */
+                defaultValue: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            overloads: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Full TypeScript type signature for this overload. */
+                typeSignature: z.ZodString;
+                /** Parameters for this overload. */
+                parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    /** Parameter name (e.g., `options`, `...args`). */
+                    name: z.ZodString;
+                    /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+                    type: z.ZodString;
+                    /** Whether the parameter has a `?` token. */
+                    optional: z.ZodDefault<z.ZodBoolean>;
+                    /** Whether the parameter uses rest syntax (`...args`). */
+                    rest: z.ZodDefault<z.ZodBoolean>;
+                    /** Description from `@param` tag. */
+                    description: z.ZodOptional<z.ZodString>;
+                    /** Default value expression from the source (e.g., `'hello'`, `42`). */
+                    defaultValue: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                /** Return type for this overload. */
+                returnType: z.ZodOptional<z.ZodString>;
+                /** Generic type parameters for this overload. */
+                genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    /** Parameter name like `T`. */
+                    name: z.ZodString;
+                    /** Constraint like `string` from `T extends string`. */
+                    constraint: z.ZodOptional<z.ZodString>;
+                    /** Default type like `unknown` from `T = unknown`. */
+                    defaultType: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                /** JSDoc/TSDoc comment specific to this overload. */
+                docComment: z.ZodOptional<z.ZodString>;
+                /** Return value description from `@returns` tag on this overload. */
+                returnDescription: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            partial: z.ZodDefault<z.ZodBoolean>;
+            examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            deprecatedMessage: z.ZodOptional<z.ZodString>;
+            seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                type: z.ZodOptional<z.ZodString>;
+                description: z.ZodString;
+            }, z.core.$strict>>>;
+            since: z.ZodOptional<z.ZodString>;
+            docComment: z.ZodOptional<z.ZodString>;
+            typeSignature: z.ZodOptional<z.ZodString>;
+            modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                public: "public";
+                protected: "protected";
+                readonly: "readonly";
+                static: "static";
+                abstract: "abstract";
+                getter: "getter";
+                setter: "setter";
+            }>>>;
+            sourceLine: z.ZodOptional<z.ZodNumber>;
+            genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name like `T`. */
+                name: z.ZodString;
+                /** Constraint like `string` from `T extends string`. */
+                constraint: z.ZodOptional<z.ZodString>;
+                /** Default type like `unknown` from `T = unknown`. */
+                defaultType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>], "kind">>>;
+        alsoExportedFrom: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        aliasOf: z.ZodOptional<z.ZodObject<{
+            module: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>>;
+        mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        partial: z.ZodDefault<z.ZodBoolean>;
+        examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        deprecatedMessage: z.ZodOptional<z.ZodString>;
+        seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, z.core.$strict>>>;
+        since: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        docComment: z.ZodOptional<z.ZodString>;
+        typeSignature: z.ZodOptional<z.ZodString>;
+        modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            public: "public";
+            protected: "protected";
+            readonly: "readonly";
+            static: "static";
+            abstract: "abstract";
+            getter: "getter";
+            setter: "setter";
+        }>>>;
+        sourceLine: z.ZodOptional<z.ZodNumber>;
+        genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name like `T`. */
+            name: z.ZodString;
+            /** Constraint like `string` from `T extends string`. */
+            constraint: z.ZodOptional<z.ZodString>;
+            /** Default type like `unknown` from `T = unknown`. */
+            defaultType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"interface">;
+        /**
+         * Extended interfaces.
+         *
+         * @see `ClassDeclarationJson.extends`, `ClassDeclarationJson.implements`,
+         *   `TypeDeclarationJson.intersects`, `ComponentDeclarationJson.intersects`
+         *   for sibling "related type identifiers" fields. Field shapes mirror TS syntax.
+         */
+        extends: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        /**
+         * Interface members: property signatures, method signatures, index signatures,
+         * call/construct signatures.
+         */
+        members: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"function">;
+            /**
+             * User-chosen identifier, or the literal `'(call)'` sentinel for
+             * unnamed call signatures.
+             */
+            name: z.ZodString;
+            /** Whether the member has a `?` token in its declaration. */
+            optional: z.ZodDefault<z.ZodBoolean>;
+            returnType: z.ZodOptional<z.ZodString>;
+            returnDescription: z.ZodOptional<z.ZodString>;
+            parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name (e.g., `options`, `...args`). */
+                name: z.ZodString;
+                /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+                type: z.ZodString;
+                /** Whether the parameter has a `?` token. */
+                optional: z.ZodDefault<z.ZodBoolean>;
+                /** Whether the parameter uses rest syntax (`...args`). */
+                rest: z.ZodDefault<z.ZodBoolean>;
+                /** Description from `@param` tag. */
+                description: z.ZodOptional<z.ZodString>;
+                /** Default value expression from the source (e.g., `'hello'`, `42`). */
+                defaultValue: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            overloads: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Full TypeScript type signature for this overload. */
+                typeSignature: z.ZodString;
+                /** Parameters for this overload. */
+                parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    /** Parameter name (e.g., `options`, `...args`). */
+                    name: z.ZodString;
+                    /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+                    type: z.ZodString;
+                    /** Whether the parameter has a `?` token. */
+                    optional: z.ZodDefault<z.ZodBoolean>;
+                    /** Whether the parameter uses rest syntax (`...args`). */
+                    rest: z.ZodDefault<z.ZodBoolean>;
+                    /** Description from `@param` tag. */
+                    description: z.ZodOptional<z.ZodString>;
+                    /** Default value expression from the source (e.g., `'hello'`, `42`). */
+                    defaultValue: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                /** Return type for this overload. */
+                returnType: z.ZodOptional<z.ZodString>;
+                /** Generic type parameters for this overload. */
+                genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    /** Parameter name like `T`. */
+                    name: z.ZodString;
+                    /** Constraint like `string` from `T extends string`. */
+                    constraint: z.ZodOptional<z.ZodString>;
+                    /** Default type like `unknown` from `T = unknown`. */
+                    defaultType: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                /** JSDoc/TSDoc comment specific to this overload. */
+                docComment: z.ZodOptional<z.ZodString>;
+                /** Return value description from `@returns` tag on this overload. */
+                returnDescription: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            partial: z.ZodDefault<z.ZodBoolean>;
+            examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            deprecatedMessage: z.ZodOptional<z.ZodString>;
+            seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                type: z.ZodOptional<z.ZodString>;
+                description: z.ZodString;
+            }, z.core.$strict>>>;
+            since: z.ZodOptional<z.ZodString>;
+            docComment: z.ZodOptional<z.ZodString>;
+            typeSignature: z.ZodOptional<z.ZodString>;
+            modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                public: "public";
+                protected: "protected";
+                readonly: "readonly";
+                static: "static";
+                abstract: "abstract";
+                getter: "getter";
+                setter: "setter";
+            }>>>;
+            sourceLine: z.ZodOptional<z.ZodNumber>;
+            genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name like `T`. */
+                name: z.ZodString;
+                /** Constraint like `string` from `T extends string`. */
+                constraint: z.ZodOptional<z.ZodString>;
+                /** Default type like `unknown` from `T = unknown`. */
+                defaultType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"variable">;
+            /** Whether the member has a `?` token in its declaration. */
+            optional: z.ZodDefault<z.ZodBoolean>;
+            /** Rune flavor when this field is initialized with a value-producing reactivity rune. */
+            reactivity: z.ZodOptional<z.ZodEnum<{
+                $state: "$state";
+                "$state.raw": "$state.raw";
+                $derived: "$derived";
+                "$derived.by": "$derived.by";
+            }>>;
+            /** Default value documented via `@default`. Authoritative initializer (when human-readable) is in `typeSignature`. */
+            defaultValue: z.ZodOptional<z.ZodString>;
+            mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            partial: z.ZodDefault<z.ZodBoolean>;
+            examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            deprecatedMessage: z.ZodOptional<z.ZodString>;
+            seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                type: z.ZodOptional<z.ZodString>;
+                description: z.ZodString;
+            }, z.core.$strict>>>;
+            since: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            docComment: z.ZodOptional<z.ZodString>;
+            typeSignature: z.ZodOptional<z.ZodString>;
+            modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                public: "public";
+                protected: "protected";
+                readonly: "readonly";
+                static: "static";
+                abstract: "abstract";
+                getter: "getter";
+                setter: "setter";
+            }>>>;
+            sourceLine: z.ZodOptional<z.ZodNumber>;
+            genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name like `T`. */
+                name: z.ZodString;
+                /** Constraint like `string` from `T extends string`. */
+                constraint: z.ZodOptional<z.ZodString>;
+                /** Default type like `unknown` from `T = unknown`. */
+                defaultType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"constructor">;
+            name: z.ZodUnion<readonly [z.ZodLiteral<"constructor">, z.ZodLiteral<"(construct)">]>;
+            parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name (e.g., `options`, `...args`). */
+                name: z.ZodString;
+                /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+                type: z.ZodString;
+                /** Whether the parameter has a `?` token. */
+                optional: z.ZodDefault<z.ZodBoolean>;
+                /** Whether the parameter uses rest syntax (`...args`). */
+                rest: z.ZodDefault<z.ZodBoolean>;
+                /** Description from `@param` tag. */
+                description: z.ZodOptional<z.ZodString>;
+                /** Default value expression from the source (e.g., `'hello'`, `42`). */
+                defaultValue: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            overloads: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Full TypeScript type signature for this overload. */
+                typeSignature: z.ZodString;
+                /** Parameters for this overload. */
+                parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    /** Parameter name (e.g., `options`, `...args`). */
+                    name: z.ZodString;
+                    /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+                    type: z.ZodString;
+                    /** Whether the parameter has a `?` token. */
+                    optional: z.ZodDefault<z.ZodBoolean>;
+                    /** Whether the parameter uses rest syntax (`...args`). */
+                    rest: z.ZodDefault<z.ZodBoolean>;
+                    /** Description from `@param` tag. */
+                    description: z.ZodOptional<z.ZodString>;
+                    /** Default value expression from the source (e.g., `'hello'`, `42`). */
+                    defaultValue: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                /** Return type for this overload. */
+                returnType: z.ZodOptional<z.ZodString>;
+                /** Generic type parameters for this overload. */
+                genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    /** Parameter name like `T`. */
+                    name: z.ZodString;
+                    /** Constraint like `string` from `T extends string`. */
+                    constraint: z.ZodOptional<z.ZodString>;
+                    /** Default type like `unknown` from `T = unknown`. */
+                    defaultType: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                /** JSDoc/TSDoc comment specific to this overload. */
+                docComment: z.ZodOptional<z.ZodString>;
+                /** Return value description from `@returns` tag on this overload. */
+                returnDescription: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            partial: z.ZodDefault<z.ZodBoolean>;
+            examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            deprecatedMessage: z.ZodOptional<z.ZodString>;
+            seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                type: z.ZodOptional<z.ZodString>;
+                description: z.ZodString;
+            }, z.core.$strict>>>;
+            since: z.ZodOptional<z.ZodString>;
+            docComment: z.ZodOptional<z.ZodString>;
+            typeSignature: z.ZodOptional<z.ZodString>;
+            modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                public: "public";
+                protected: "protected";
+                readonly: "readonly";
+                static: "static";
+                abstract: "abstract";
+                getter: "getter";
+                setter: "setter";
+            }>>>;
+            sourceLine: z.ZodOptional<z.ZodNumber>;
+            genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name like `T`. */
+                name: z.ZodString;
+                /** Constraint like `string` from `T extends string`. */
+                constraint: z.ZodOptional<z.ZodString>;
+                /** Default type like `unknown` from `T = unknown`. */
+                defaultType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>], "kind">>>;
+        alsoExportedFrom: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        aliasOf: z.ZodOptional<z.ZodObject<{
+            module: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>>;
+        mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        partial: z.ZodDefault<z.ZodBoolean>;
+        examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        deprecatedMessage: z.ZodOptional<z.ZodString>;
+        seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, z.core.$strict>>>;
+        since: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        docComment: z.ZodOptional<z.ZodString>;
+        typeSignature: z.ZodOptional<z.ZodString>;
+        modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            public: "public";
+            protected: "protected";
+            readonly: "readonly";
+            static: "static";
+            abstract: "abstract";
+            getter: "getter";
+            setter: "setter";
+        }>>>;
+        sourceLine: z.ZodOptional<z.ZodNumber>;
+        genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name like `T`. */
+            name: z.ZodString;
+            /** Constraint like `string` from `T extends string`. */
+            constraint: z.ZodOptional<z.ZodString>;
+            /** Default type like `unknown` from `T = unknown`. */
+            defaultType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"type">;
+        /**
+         * Types from intersection branches whose properties are all external (filtered out of `members`).
+         *
+         * @see `ComponentDeclarationJson.intersects`, `ClassDeclarationJson.extends`,
+         *   `ClassDeclarationJson.implements`, `InterfaceDeclarationJson.extends`
+         *   for sibling "related type identifiers" fields. Field shapes mirror TS syntax.
+         */
+        intersects: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        /**
+         * Type members: property signatures, method signatures, index signatures,
+         * call/construct signatures.
+         */
+        members: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"function">;
+            /**
+             * User-chosen identifier, or the literal `'(call)'` sentinel for
+             * unnamed call signatures.
+             */
+            name: z.ZodString;
+            /** Whether the member has a `?` token in its declaration. */
+            optional: z.ZodDefault<z.ZodBoolean>;
+            returnType: z.ZodOptional<z.ZodString>;
+            returnDescription: z.ZodOptional<z.ZodString>;
+            parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name (e.g., `options`, `...args`). */
+                name: z.ZodString;
+                /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+                type: z.ZodString;
+                /** Whether the parameter has a `?` token. */
+                optional: z.ZodDefault<z.ZodBoolean>;
+                /** Whether the parameter uses rest syntax (`...args`). */
+                rest: z.ZodDefault<z.ZodBoolean>;
+                /** Description from `@param` tag. */
+                description: z.ZodOptional<z.ZodString>;
+                /** Default value expression from the source (e.g., `'hello'`, `42`). */
+                defaultValue: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            overloads: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Full TypeScript type signature for this overload. */
+                typeSignature: z.ZodString;
+                /** Parameters for this overload. */
+                parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    /** Parameter name (e.g., `options`, `...args`). */
+                    name: z.ZodString;
+                    /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+                    type: z.ZodString;
+                    /** Whether the parameter has a `?` token. */
+                    optional: z.ZodDefault<z.ZodBoolean>;
+                    /** Whether the parameter uses rest syntax (`...args`). */
+                    rest: z.ZodDefault<z.ZodBoolean>;
+                    /** Description from `@param` tag. */
+                    description: z.ZodOptional<z.ZodString>;
+                    /** Default value expression from the source (e.g., `'hello'`, `42`). */
+                    defaultValue: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                /** Return type for this overload. */
+                returnType: z.ZodOptional<z.ZodString>;
+                /** Generic type parameters for this overload. */
+                genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    /** Parameter name like `T`. */
+                    name: z.ZodString;
+                    /** Constraint like `string` from `T extends string`. */
+                    constraint: z.ZodOptional<z.ZodString>;
+                    /** Default type like `unknown` from `T = unknown`. */
+                    defaultType: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                /** JSDoc/TSDoc comment specific to this overload. */
+                docComment: z.ZodOptional<z.ZodString>;
+                /** Return value description from `@returns` tag on this overload. */
+                returnDescription: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            partial: z.ZodDefault<z.ZodBoolean>;
+            examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            deprecatedMessage: z.ZodOptional<z.ZodString>;
+            seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                type: z.ZodOptional<z.ZodString>;
+                description: z.ZodString;
+            }, z.core.$strict>>>;
+            since: z.ZodOptional<z.ZodString>;
+            docComment: z.ZodOptional<z.ZodString>;
+            typeSignature: z.ZodOptional<z.ZodString>;
+            modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                public: "public";
+                protected: "protected";
+                readonly: "readonly";
+                static: "static";
+                abstract: "abstract";
+                getter: "getter";
+                setter: "setter";
+            }>>>;
+            sourceLine: z.ZodOptional<z.ZodNumber>;
+            genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name like `T`. */
+                name: z.ZodString;
+                /** Constraint like `string` from `T extends string`. */
+                constraint: z.ZodOptional<z.ZodString>;
+                /** Default type like `unknown` from `T = unknown`. */
+                defaultType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"variable">;
+            /** Whether the member has a `?` token in its declaration. */
+            optional: z.ZodDefault<z.ZodBoolean>;
+            /** Rune flavor when this field is initialized with a value-producing reactivity rune. */
+            reactivity: z.ZodOptional<z.ZodEnum<{
+                $state: "$state";
+                "$state.raw": "$state.raw";
+                $derived: "$derived";
+                "$derived.by": "$derived.by";
+            }>>;
+            /** Default value documented via `@default`. Authoritative initializer (when human-readable) is in `typeSignature`. */
+            defaultValue: z.ZodOptional<z.ZodString>;
+            mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            partial: z.ZodDefault<z.ZodBoolean>;
+            examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            deprecatedMessage: z.ZodOptional<z.ZodString>;
+            seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                type: z.ZodOptional<z.ZodString>;
+                description: z.ZodString;
+            }, z.core.$strict>>>;
+            since: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            docComment: z.ZodOptional<z.ZodString>;
+            typeSignature: z.ZodOptional<z.ZodString>;
+            modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                public: "public";
+                protected: "protected";
+                readonly: "readonly";
+                static: "static";
+                abstract: "abstract";
+                getter: "getter";
+                setter: "setter";
+            }>>>;
+            sourceLine: z.ZodOptional<z.ZodNumber>;
+            genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name like `T`. */
+                name: z.ZodString;
+                /** Constraint like `string` from `T extends string`. */
+                constraint: z.ZodOptional<z.ZodString>;
+                /** Default type like `unknown` from `T = unknown`. */
+                defaultType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"constructor">;
+            name: z.ZodUnion<readonly [z.ZodLiteral<"constructor">, z.ZodLiteral<"(construct)">]>;
+            parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name (e.g., `options`, `...args`). */
+                name: z.ZodString;
+                /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+                type: z.ZodString;
+                /** Whether the parameter has a `?` token. */
+                optional: z.ZodDefault<z.ZodBoolean>;
+                /** Whether the parameter uses rest syntax (`...args`). */
+                rest: z.ZodDefault<z.ZodBoolean>;
+                /** Description from `@param` tag. */
+                description: z.ZodOptional<z.ZodString>;
+                /** Default value expression from the source (e.g., `'hello'`, `42`). */
+                defaultValue: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            overloads: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Full TypeScript type signature for this overload. */
+                typeSignature: z.ZodString;
+                /** Parameters for this overload. */
+                parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    /** Parameter name (e.g., `options`, `...args`). */
+                    name: z.ZodString;
+                    /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+                    type: z.ZodString;
+                    /** Whether the parameter has a `?` token. */
+                    optional: z.ZodDefault<z.ZodBoolean>;
+                    /** Whether the parameter uses rest syntax (`...args`). */
+                    rest: z.ZodDefault<z.ZodBoolean>;
+                    /** Description from `@param` tag. */
+                    description: z.ZodOptional<z.ZodString>;
+                    /** Default value expression from the source (e.g., `'hello'`, `42`). */
+                    defaultValue: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                /** Return type for this overload. */
+                returnType: z.ZodOptional<z.ZodString>;
+                /** Generic type parameters for this overload. */
+                genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    /** Parameter name like `T`. */
+                    name: z.ZodString;
+                    /** Constraint like `string` from `T extends string`. */
+                    constraint: z.ZodOptional<z.ZodString>;
+                    /** Default type like `unknown` from `T = unknown`. */
+                    defaultType: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                /** JSDoc/TSDoc comment specific to this overload. */
+                docComment: z.ZodOptional<z.ZodString>;
+                /** Return value description from `@returns` tag on this overload. */
+                returnDescription: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            partial: z.ZodDefault<z.ZodBoolean>;
+            examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            deprecatedMessage: z.ZodOptional<z.ZodString>;
+            seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                type: z.ZodOptional<z.ZodString>;
+                description: z.ZodString;
+            }, z.core.$strict>>>;
+            since: z.ZodOptional<z.ZodString>;
+            docComment: z.ZodOptional<z.ZodString>;
+            typeSignature: z.ZodOptional<z.ZodString>;
+            modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                public: "public";
+                protected: "protected";
+                readonly: "readonly";
+                static: "static";
+                abstract: "abstract";
+                getter: "getter";
+                setter: "setter";
+            }>>>;
+            sourceLine: z.ZodOptional<z.ZodNumber>;
+            genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name like `T`. */
+                name: z.ZodString;
+                /** Constraint like `string` from `T extends string`. */
+                constraint: z.ZodOptional<z.ZodString>;
+                /** Default type like `unknown` from `T = unknown`. */
+                defaultType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>], "kind">>>;
+        alsoExportedFrom: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        aliasOf: z.ZodOptional<z.ZodObject<{
+            module: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>>;
+        mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        partial: z.ZodDefault<z.ZodBoolean>;
+        examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        deprecatedMessage: z.ZodOptional<z.ZodString>;
+        seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, z.core.$strict>>>;
+        since: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        docComment: z.ZodOptional<z.ZodString>;
+        typeSignature: z.ZodOptional<z.ZodString>;
+        modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            public: "public";
+            protected: "protected";
+            readonly: "readonly";
+            static: "static";
+            abstract: "abstract";
+            getter: "getter";
+            setter: "setter";
+        }>>>;
+        sourceLine: z.ZodOptional<z.ZodNumber>;
+        genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name like `T`. */
+            name: z.ZodString;
+            /** Constraint like `string` from `T extends string`. */
+            constraint: z.ZodOptional<z.ZodString>;
+            /** Default type like `unknown` from `T = unknown`. */
+            defaultType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"variable">;
+        /** Rune flavor when this variable is initialized with a value-producing reactivity rune. */
+        reactivity: z.ZodOptional<z.ZodEnum<{
+            $state: "$state";
+            "$state.raw": "$state.raw";
+            $derived: "$derived";
+            "$derived.by": "$derived.by";
+        }>>;
+        /** Default value documented via `@default`. Useful when the AST initializer is opaque (a call expression, computed value) and the author wants to document the conceptual default. */
+        defaultValue: z.ZodOptional<z.ZodString>;
+        alsoExportedFrom: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        aliasOf: z.ZodOptional<z.ZodObject<{
+            module: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>>;
+        mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        partial: z.ZodDefault<z.ZodBoolean>;
+        examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        deprecatedMessage: z.ZodOptional<z.ZodString>;
+        seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, z.core.$strict>>>;
+        since: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        docComment: z.ZodOptional<z.ZodString>;
+        typeSignature: z.ZodOptional<z.ZodString>;
+        modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            public: "public";
+            protected: "protected";
+            readonly: "readonly";
+            static: "static";
+            abstract: "abstract";
+            getter: "getter";
+            setter: "setter";
+        }>>>;
+        sourceLine: z.ZodOptional<z.ZodNumber>;
+        genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name like `T`. */
+            name: z.ZodString;
+            /** Constraint like `string` from `T extends string`. */
+            constraint: z.ZodOptional<z.ZodString>;
+            /** Default type like `unknown` from `T = unknown`. */
+            defaultType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"enum">;
+        /** Enum members: name/value pairs with optional JSDoc. */
+        members: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"function">;
+            /**
+             * User-chosen identifier, or the literal `'(call)'` sentinel for
+             * unnamed call signatures.
+             */
+            name: z.ZodString;
+            /** Whether the member has a `?` token in its declaration. */
+            optional: z.ZodDefault<z.ZodBoolean>;
+            returnType: z.ZodOptional<z.ZodString>;
+            returnDescription: z.ZodOptional<z.ZodString>;
+            parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name (e.g., `options`, `...args`). */
+                name: z.ZodString;
+                /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+                type: z.ZodString;
+                /** Whether the parameter has a `?` token. */
+                optional: z.ZodDefault<z.ZodBoolean>;
+                /** Whether the parameter uses rest syntax (`...args`). */
+                rest: z.ZodDefault<z.ZodBoolean>;
+                /** Description from `@param` tag. */
+                description: z.ZodOptional<z.ZodString>;
+                /** Default value expression from the source (e.g., `'hello'`, `42`). */
+                defaultValue: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            overloads: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Full TypeScript type signature for this overload. */
+                typeSignature: z.ZodString;
+                /** Parameters for this overload. */
+                parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    /** Parameter name (e.g., `options`, `...args`). */
+                    name: z.ZodString;
+                    /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+                    type: z.ZodString;
+                    /** Whether the parameter has a `?` token. */
+                    optional: z.ZodDefault<z.ZodBoolean>;
+                    /** Whether the parameter uses rest syntax (`...args`). */
+                    rest: z.ZodDefault<z.ZodBoolean>;
+                    /** Description from `@param` tag. */
+                    description: z.ZodOptional<z.ZodString>;
+                    /** Default value expression from the source (e.g., `'hello'`, `42`). */
+                    defaultValue: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                /** Return type for this overload. */
+                returnType: z.ZodOptional<z.ZodString>;
+                /** Generic type parameters for this overload. */
+                genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    /** Parameter name like `T`. */
+                    name: z.ZodString;
+                    /** Constraint like `string` from `T extends string`. */
+                    constraint: z.ZodOptional<z.ZodString>;
+                    /** Default type like `unknown` from `T = unknown`. */
+                    defaultType: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                /** JSDoc/TSDoc comment specific to this overload. */
+                docComment: z.ZodOptional<z.ZodString>;
+                /** Return value description from `@returns` tag on this overload. */
+                returnDescription: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            partial: z.ZodDefault<z.ZodBoolean>;
+            examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            deprecatedMessage: z.ZodOptional<z.ZodString>;
+            seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                type: z.ZodOptional<z.ZodString>;
+                description: z.ZodString;
+            }, z.core.$strict>>>;
+            since: z.ZodOptional<z.ZodString>;
+            docComment: z.ZodOptional<z.ZodString>;
+            typeSignature: z.ZodOptional<z.ZodString>;
+            modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                public: "public";
+                protected: "protected";
+                readonly: "readonly";
+                static: "static";
+                abstract: "abstract";
+                getter: "getter";
+                setter: "setter";
+            }>>>;
+            sourceLine: z.ZodOptional<z.ZodNumber>;
+            genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name like `T`. */
+                name: z.ZodString;
+                /** Constraint like `string` from `T extends string`. */
+                constraint: z.ZodOptional<z.ZodString>;
+                /** Default type like `unknown` from `T = unknown`. */
+                defaultType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"variable">;
+            /** Whether the member has a `?` token in its declaration. */
+            optional: z.ZodDefault<z.ZodBoolean>;
+            /** Rune flavor when this field is initialized with a value-producing reactivity rune. */
+            reactivity: z.ZodOptional<z.ZodEnum<{
+                $state: "$state";
+                "$state.raw": "$state.raw";
+                $derived: "$derived";
+                "$derived.by": "$derived.by";
+            }>>;
+            /** Default value documented via `@default`. Authoritative initializer (when human-readable) is in `typeSignature`. */
+            defaultValue: z.ZodOptional<z.ZodString>;
+            mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            partial: z.ZodDefault<z.ZodBoolean>;
+            examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            deprecatedMessage: z.ZodOptional<z.ZodString>;
+            seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                type: z.ZodOptional<z.ZodString>;
+                description: z.ZodString;
+            }, z.core.$strict>>>;
+            since: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            docComment: z.ZodOptional<z.ZodString>;
+            typeSignature: z.ZodOptional<z.ZodString>;
+            modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                public: "public";
+                protected: "protected";
+                readonly: "readonly";
+                static: "static";
+                abstract: "abstract";
+                getter: "getter";
+                setter: "setter";
+            }>>>;
+            sourceLine: z.ZodOptional<z.ZodNumber>;
+            genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name like `T`. */
+                name: z.ZodString;
+                /** Constraint like `string` from `T extends string`. */
+                constraint: z.ZodOptional<z.ZodString>;
+                /** Default type like `unknown` from `T = unknown`. */
+                defaultType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"constructor">;
+            name: z.ZodUnion<readonly [z.ZodLiteral<"constructor">, z.ZodLiteral<"(construct)">]>;
+            parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name (e.g., `options`, `...args`). */
+                name: z.ZodString;
+                /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+                type: z.ZodString;
+                /** Whether the parameter has a `?` token. */
+                optional: z.ZodDefault<z.ZodBoolean>;
+                /** Whether the parameter uses rest syntax (`...args`). */
+                rest: z.ZodDefault<z.ZodBoolean>;
+                /** Description from `@param` tag. */
+                description: z.ZodOptional<z.ZodString>;
+                /** Default value expression from the source (e.g., `'hello'`, `42`). */
+                defaultValue: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            overloads: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Full TypeScript type signature for this overload. */
+                typeSignature: z.ZodString;
+                /** Parameters for this overload. */
+                parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    /** Parameter name (e.g., `options`, `...args`). */
+                    name: z.ZodString;
+                    /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+                    type: z.ZodString;
+                    /** Whether the parameter has a `?` token. */
+                    optional: z.ZodDefault<z.ZodBoolean>;
+                    /** Whether the parameter uses rest syntax (`...args`). */
+                    rest: z.ZodDefault<z.ZodBoolean>;
+                    /** Description from `@param` tag. */
+                    description: z.ZodOptional<z.ZodString>;
+                    /** Default value expression from the source (e.g., `'hello'`, `42`). */
+                    defaultValue: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                /** Return type for this overload. */
+                returnType: z.ZodOptional<z.ZodString>;
+                /** Generic type parameters for this overload. */
+                genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    /** Parameter name like `T`. */
+                    name: z.ZodString;
+                    /** Constraint like `string` from `T extends string`. */
+                    constraint: z.ZodOptional<z.ZodString>;
+                    /** Default type like `unknown` from `T = unknown`. */
+                    defaultType: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                /** JSDoc/TSDoc comment specific to this overload. */
+                docComment: z.ZodOptional<z.ZodString>;
+                /** Return value description from `@returns` tag on this overload. */
+                returnDescription: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            partial: z.ZodDefault<z.ZodBoolean>;
+            examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            deprecatedMessage: z.ZodOptional<z.ZodString>;
+            seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                type: z.ZodOptional<z.ZodString>;
+                description: z.ZodString;
+            }, z.core.$strict>>>;
+            since: z.ZodOptional<z.ZodString>;
+            docComment: z.ZodOptional<z.ZodString>;
+            typeSignature: z.ZodOptional<z.ZodString>;
+            modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                public: "public";
+                protected: "protected";
+                readonly: "readonly";
+                static: "static";
+                abstract: "abstract";
+                getter: "getter";
+                setter: "setter";
+            }>>>;
+            sourceLine: z.ZodOptional<z.ZodNumber>;
+            genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /** Parameter name like `T`. */
+                name: z.ZodString;
+                /** Constraint like `string` from `T extends string`. */
+                constraint: z.ZodOptional<z.ZodString>;
+                /** Default type like `unknown` from `T = unknown`. */
+                defaultType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>], "kind">>>;
+        alsoExportedFrom: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        aliasOf: z.ZodOptional<z.ZodObject<{
+            module: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>>;
+        mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        partial: z.ZodDefault<z.ZodBoolean>;
+        examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        deprecatedMessage: z.ZodOptional<z.ZodString>;
+        seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, z.core.$strict>>>;
+        since: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        docComment: z.ZodOptional<z.ZodString>;
+        typeSignature: z.ZodOptional<z.ZodString>;
+        modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            public: "public";
+            protected: "protected";
+            readonly: "readonly";
+            static: "static";
+            abstract: "abstract";
+            getter: "getter";
+            setter: "setter";
+        }>>>;
+        sourceLine: z.ZodOptional<z.ZodNumber>;
+        genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name like `T`. */
+            name: z.ZodString;
+            /** Constraint like `string` from `T extends string`. */
+            constraint: z.ZodOptional<z.ZodString>;
+            /** Default type like `unknown` from `T = unknown`. */
+            defaultType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"component">;
+        /**
+         * Types from intersection branches whose properties are all external (filtered out of `props`).
+         *
+         * @see `TypeDeclarationJson.intersects`, `ClassDeclarationJson.extends`,
+         *   `ClassDeclarationJson.implements`, `InterfaceDeclarationJson.extends`
+         *   for sibling "related type identifiers" fields. Field shapes mirror TS syntax.
+         */
+        intersects: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        /** Svelte component props. */
+        props: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            deprecatedMessage: z.ZodOptional<z.ZodString>;
+            seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                type: z.ZodOptional<z.ZodString>;
+                description: z.ZodString;
+            }, z.core.$strict>>>;
+            since: z.ZodOptional<z.ZodString>;
+            /** Prop name as declared in the component's `$props()` type. */
+            name: z.ZodString;
+            /** Resolved TypeScript type string. */
+            type: z.ZodString;
+            /** Whether the prop is optional in the component's props type. */
+            optional: z.ZodDefault<z.ZodBoolean>;
+            /** Description from JSDoc on the prop's type declaration. */
+            description: z.ZodOptional<z.ZodString>;
+            /** Default value expression from destructuring or `@default` tag. */
+            defaultValue: z.ZodOptional<z.ZodString>;
+            /** Whether the prop uses the `$bindable()` rune, enabling two-way binding. */
+            bindable: z.ZodDefault<z.ZodBoolean>;
+            /**
+             * Structured parameters for callable props (e.g., `Snippet<[text: string]>`).
+             *
+             * Present when the prop has extractable parameters, absent otherwise.
+             * Only populated when there are actual parameters — bare `Snippet` / `Snippet<[]>`
+             * does not set this field. Intentionally `.optional()` rather than
+             * `.default([])` (see the array-field policy note above): absence is a
+             * meaningful signal, not an empty list.
+             */
+            parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                /** Parameter name (e.g., `options`, `...args`). */
+                name: z.ZodString;
+                /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+                type: z.ZodString;
+                /** Whether the parameter has a `?` token. */
+                optional: z.ZodDefault<z.ZodBoolean>;
+                /** Whether the parameter uses rest syntax (`...args`). */
+                rest: z.ZodDefault<z.ZodBoolean>;
+                /** Description from `@param` tag. */
+                description: z.ZodOptional<z.ZodString>;
+                /** Default value expression from the source (e.g., `'hello'`, `42`). */
+                defaultValue: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>>;
+        /** Whether the component accepts children (explicit `children` prop, inherited, or implicit template usage). */
+        acceptsChildren: z.ZodDefault<z.ZodBoolean>;
+        /** Script language. `undefined` means TypeScript (default), `'js'` for JavaScript-only components. */
+        lang: z.ZodOptional<z.ZodEnum<{
+            js: "js";
+        }>>;
+        alsoExportedFrom: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        aliasOf: z.ZodOptional<z.ZodObject<{
+            module: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>>;
+        mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        partial: z.ZodDefault<z.ZodBoolean>;
+        examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        deprecatedMessage: z.ZodOptional<z.ZodString>;
+        seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, z.core.$strict>>>;
+        since: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        docComment: z.ZodOptional<z.ZodString>;
+        typeSignature: z.ZodOptional<z.ZodString>;
+        modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            public: "public";
+            protected: "protected";
+            readonly: "readonly";
+            static: "static";
+            abstract: "abstract";
+            getter: "getter";
+            setter: "setter";
+        }>>>;
+        sourceLine: z.ZodOptional<z.ZodNumber>;
+        genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name like `T`. */
+            name: z.ZodString;
+            /** Constraint like `string` from `T extends string`. */
+            constraint: z.ZodOptional<z.ZodString>;
+            /** Default type like `unknown` from `T = unknown`. */
+            defaultType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"snippet">;
+        /** Snippet parameters. */
+        parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name (e.g., `options`, `...args`). */
+            name: z.ZodString;
+            /** Resolved TypeScript type string (e.g., `string`, `Record<string, unknown>`). */
+            type: z.ZodString;
+            /** Whether the parameter has a `?` token. */
+            optional: z.ZodDefault<z.ZodBoolean>;
+            /** Whether the parameter uses rest syntax (`...args`). */
+            rest: z.ZodDefault<z.ZodBoolean>;
+            /** Description from `@param` tag. */
+            description: z.ZodOptional<z.ZodString>;
+            /** Default value expression from the source (e.g., `'hello'`, `42`). */
+            defaultValue: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        alsoExportedFrom: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        aliasOf: z.ZodOptional<z.ZodObject<{
+            module: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>>;
+        mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        partial: z.ZodDefault<z.ZodBoolean>;
+        examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        deprecatedMessage: z.ZodOptional<z.ZodString>;
+        seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, z.core.$strict>>>;
+        since: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        docComment: z.ZodOptional<z.ZodString>;
+        typeSignature: z.ZodOptional<z.ZodString>;
+        modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            public: "public";
+            protected: "protected";
+            readonly: "readonly";
+            static: "static";
+            abstract: "abstract";
+            getter: "getter";
+            setter: "setter";
+        }>>>;
+        sourceLine: z.ZodOptional<z.ZodNumber>;
+        genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name like `T`. */
+            name: z.ZodString;
+            /** Constraint like `string` from `T extends string`. */
+            constraint: z.ZodOptional<z.ZodString>;
+            /** Default type like `unknown` from `T = unknown`. */
+            defaultType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"namespace">;
+        /** Source module path (relative to `sourceRoot`) projected under this binding. */
+        module: z.ZodString;
+        alsoExportedFrom: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        aliasOf: z.ZodOptional<z.ZodObject<{
+            module: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>>;
+        mutates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        partial: z.ZodDefault<z.ZodBoolean>;
+        examples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        deprecatedMessage: z.ZodOptional<z.ZodString>;
+        seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        throws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, z.core.$strict>>>;
+        since: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        docComment: z.ZodOptional<z.ZodString>;
+        typeSignature: z.ZodOptional<z.ZodString>;
+        modifiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            public: "public";
+            protected: "protected";
+            readonly: "readonly";
+            static: "static";
+            abstract: "abstract";
+            getter: "getter";
+            setter: "setter";
+        }>>>;
+        sourceLine: z.ZodOptional<z.ZodNumber>;
+        genericParams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Parameter name like `T`. */
+            name: z.ZodString;
+            /** Constraint like `string` from `T extends string`. */
+            constraint: z.ZodOptional<z.ZodString>;
+            /** Default type like `unknown` from `T = unknown`. */
+            defaultType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>], "kind">>>;
+    /** File-level JSDoc comment (from `@module` tag). */
+    moduleComment: z.ZodOptional<z.ZodString>;
+    /** Modules this imports (paths relative to `sourceRoot`). */
+    dependencies: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    /** Modules that import this (paths relative to `sourceRoot`). */
+    dependents: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    /**
+     * Modules fully re-exported via `export * from './module'`.
+     * Paths are relative to `sourceRoot`.
+     */
+    starExports: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    /**
+     * Whether the module is a placeholder for a file that couldn't be analyzed.
+     *
+     * Currently only set for Svelte files where svelte2tsx threw at ingest
+     * (the `transform_failed` diagnostic carries the error). Placeholder
+     * modules have `declarations: []` and serve as a structural slot so the
+     * `modules` array reflects the full owned set; consumers render them as
+     * "broken" entries.
+     */
+    partial: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type ModuleJson = z.infer<typeof ModuleJson>;
+export type ModuleJsonInput = z.input<typeof ModuleJson>;
+//# sourceMappingURL=types.d.ts.map