sveld 0.35.2 → 0.36.0

package/lib/element-tag-map.d.ts

@@ -1,146 +0,0 @@
-/**
- * Tag-to-DOM-type map from TypeScript `lib.dom.d.ts`. Unknown tags fall back to `HTMLElement`.
- *
- * @example
- * ```ts
- * tag_map["button"] // "HTMLButtonElement"
- * tag_map["div"]    // "HTMLDivElement"
- * tag_map["input"]  // "HTMLInputElement"
- * ```
- */
-declare const tag_map: {
-    a: string;
-    abbr: string;
-    address: string;
-    applet: string;
-    area: string;
-    article: string;
-    aside: string;
-    audio: string;
-    b: string;
-    base: string;
-    basefont: string;
-    bdi: string;
-    bdo: string;
-    blockquote: string;
-    body: string;
-    br: string;
-    button: string;
-    canvas: string;
-    caption: string;
-    cite: string;
-    code: string;
-    col: string;
-    colgroup: string;
-    data: string;
-    datalist: string;
-    dd: string;
-    del: string;
-    details: string;
-    dfn: string;
-    dialog: string;
-    dir: string;
-    div: string;
-    dl: string;
-    dt: string;
-    em: string;
-    embed: string;
-    fieldset: string;
-    figcaption: string;
-    figure: string;
-    font: string;
-    footer: string;
-    form: string;
-    frame: string;
-    frameset: string;
-    h1: string;
-    h2: string;
-    h3: string;
-    h4: string;
-    h5: string;
-    h6: string;
-    head: string;
-    header: string;
-    hgroup: string;
-    hr: string;
-    html: string;
-    i: string;
-    iframe: string;
-    img: string;
-    input: string;
-    ins: string;
-    kbd: string;
-    label: string;
-    legend: string;
-    li: string;
-    link: string;
-    main: string;
-    map: string;
-    mark: string;
-    marquee: string;
-    menu: string;
-    meta: string;
-    meter: string;
-    nav: string;
-    noscript: string;
-    object: string;
-    ol: string;
-    optgroup: string;
-    option: string;
-    output: string;
-    p: string;
-    param: string;
-    picture: string;
-    pre: string;
-    progress: string;
-    q: string;
-    rp: string;
-    rt: string;
-    ruby: string;
-    s: string;
-    samp: string;
-    script: string;
-    search: string;
-    section: string;
-    select: string;
-    slot: string;
-    small: string;
-    source: string;
-    span: string;
-    strong: string;
-    style: string;
-    sub: string;
-    summary: string;
-    sup: string;
-    table: string;
-    tbody: string;
-    td: string;
-    template: string;
-    textarea: string;
-    tfoot: string;
-    th: string;
-    thead: string;
-    time: string;
-    title: string;
-    tr: string;
-    track: string;
-    u: string;
-    ul: string;
-    var: string;
-    video: string;
-    wbr: string;
-};
-type ElementTag = keyof typeof tag_map;
-export declare function isElementTag(element: string): element is ElementTag;
-/**
- * Returns the DOM interface for a tag, or `HTMLElement` when unknown.
- *
- * @example
- * ```ts
- * getElementByTag("button")  // Returns: "HTMLButtonElement"
- * getElementByTag("div")     // Returns: "HTMLDivElement"
- * getElementByTag("custom")  // Returns: "HTMLElement" (fallback)
- * ```
- */
-export declare function getElementByTag(element: string): string;
-export {};

package/lib/example-check.d.ts

@@ -1,24 +0,0 @@
-import type { ParsedComponent, SourceRange } from "./ComponentParser";
-/**
- * One `@example` block worth type-checking, reduced to what `resolve-types.ts`
- * needs: a declaration for the documented symbol and the example body itself.
- */
-export interface ExampleCheckSource {
-    /** Stable id for diagnostics, e.g. `"prop:variant"` or `"prop:variant#1"` for a second example. */
-    id: string;
-    /** Human-readable name shown in diagnostics, e.g. `"variant"` or `"variant (example 2)"`. */
-    name: string;
-    /** TypeScript type to bind the documented symbol to before running `code`. */
-    type: string;
-    /** The `@example` body, stripped of any surrounding code fence. */
-    code: string;
-    /** Source range of the documented symbol (prop/export/slot/event), when available. */
-    source?: SourceRange;
-}
-/**
- * Collects every `@example` block sveld can type-check for a parsed component:
- * plain TS/JS bodies on props, module exports, slots, and events. Svelte/HTML
- * markup examples (most slot/event examples, many prop examples) are skipped.
- * Checking those needs `svelte2tsx` or similar; sveld stays AST-only.
- */
-export declare function collectExampleSources(component: ParsedComponent): ExampleCheckSource[];

package/lib/get-svelte-entry.d.ts

@@ -1,3 +0,0 @@
-import { type SvelteEntryPoint } from "./brands";
-export type { SvelteEntryPoint };
-export declare function getSvelteEntry(entryPoint?: string): SvelteEntryPoint | null;

package/lib/load-config.d.ts

@@ -1,62 +0,0 @@
-import type { PluginSveldOptions } from "./plugin";
-/**
- * Options shared by the config file, the CLI, and the programmatic `sveld()`
- * API. Superset of `PluginSveldOptions` with the CLI-oriented flags that only
- * make sense as part of a full `sveld` run (not the Vite/Rollup plugin).
- */
-export interface SveldRuntimeOptions extends PluginSveldOptions {
-    /** Print unresolved-type diagnostics to stderr. */
-    reportDiagnostics?: boolean;
-    /** Exit code 1 when diagnostics exist. Implies `reportDiagnostics`. */
-    strict?: boolean;
-    /**
-     * Diff the parsed component API against a committed snapshot (default:
-     * the `json` writer's `outFile`, or `COMPONENT_API.json`) and assign a
-     * semver bump to each change. Exits `1` on a breaking change. Pass a
-     * string for a custom snapshot path.
-     */
-    check?: boolean | string;
-}
-/**
- * Public shape of a `sveld.config.{js,ts,mjs}` file. Identical to the options
- * accepted by the CLI and the programmatic `sveld()` API.
- */
-export type SveldConfig = SveldRuntimeOptions;
-/** Config file names probed at the project root. First existing file wins. */
-export declare const CONFIG_FILE_NAMES: readonly ["sveld.config.js", "sveld.config.mjs", "sveld.config.ts"];
-/**
- * Identity helper that fully types a `sveld` config object.
- *
- * @example
- * ```ts
- * // sveld.config.js
- * import { defineConfig } from "sveld";
- *
- * export default defineConfig({
- *   glob: true,
- *   json: true,
- *   markdown: true,
- * });
- * ```
- */
-export declare function defineConfig(config: SveldConfig): SveldConfig;
-/** Locate a `sveld.config.{js,mjs,ts}` file in `cwd`, or `null` if none exists. */
-export declare function resolveConfigPath(cwd?: string): string | null;
-/**
- * Load and validate a `sveld` config file by absolute path.
- *
- * The package is ESM-only, so the file is loaded via dynamic `import()`. A
- * cache-busting query is appended so repeated loads (e.g. across tests or
- * watch runs) reflect the latest contents.
- *
- * @throws if the module cannot be imported (e.g. a syntax error or a config
- * that throws at evaluation time) or if it does not default-export an object.
- */
-export declare function loadConfigFrom(configPath: string): Promise<SveldConfig>;
-/**
- * Discover and load a `sveld.config.{js,mjs,ts}` file from `cwd`.
- * Returns an empty object when no config file is present.
- */
-export declare function loadConfig(cwd?: string): Promise<SveldConfig>;
-/** Shallow-merge option sources. Later sources override earlier ones. */
-export declare function mergeConfig<T extends PluginSveldOptions = PluginSveldOptions>(...sources: Array<Partial<T> | undefined>): Partial<T>;

package/lib/parse-cache.d.ts

@@ -1,28 +0,0 @@
-import type { ParsedComponent } from "./ComponentParser";
-/** Default on-disk location for the persistent parse cache, relative to the project root. */
-export declare const DEFAULT_CACHE_FILE: string;
-/** Resolves the effective cache file path for `cache: true | string`. */
-export declare function resolveCacheFilePath(rootDir: string, cache: boolean | string): string;
-export declare function hashSource(source: string): string;
-/**
- * Cross-run parse cache. Entries match on file path and sha256 of source.
- * Symbol-keyed TypeScript metadata is stored separately because JSON drops symbols.
- */
-export declare class ParseCache {
-    private readonly cacheFilePath;
-    private readonly file;
-    private readonly next;
-    /** Paths forced to miss this run (e.g. dependents of a changed `@extends` target). */
-    private readonly blocked;
-    constructor(cacheFilePath: string);
-    /** True when `get()` would return a hit for `resolvedPath` and `hash`. */
-    has(resolvedPath: string, hash: string): boolean;
-    /** Returns the cached parse for `resolvedPath` when its content hash still matches. */
-    get(resolvedPath: string, hash: string): ParsedComponent | null;
-    /** Records a freshly parsed component so it can be reused on a future run. */
-    set(resolvedPath: string, hash: string, parsed: ParsedComponent): void;
-    /** Skip cache for `resolvedPath` this run (e.g. an @extends dependent). */
-    invalidate(resolvedPath: string): void;
-    /** Persists this run's cache entries back to disk. */
-    save(): void;
-}

package/lib/parse-entry-exports.d.ts

@@ -1,30 +0,0 @@
-/** One named export from the entry barrel (not a `.svelte` component). */
-export interface EntryExport {
-    name: string;
-    kind: "const" | "let" | "var" | "function" | "class" | "type" | "interface" | "enum";
-    /** Type text from the source, when present. */
-    type?: string;
-    /** Initializer text for simple constants. */
-    value?: string;
-    description?: string;
-    /** Declaring module, relative to the entry file. */
-    source?: string;
-    isTypeOnly: boolean;
-}
-export type EntryExports = EntryExport[];
-/**
- * List consts, functions, and types exported from an entry barrel.
- *
- * Follows re-exports with AST-only traversal. Skips `.svelte` files.
- *
- * @param entryFile - Absolute path to the entry module.
- * @returns Exports deduplicated by name, sorted alphabetically.
- *
- * @example
- * ```ts
- * // entry: export { VERSION } from "./constants"; export type { Theme } from "./types";
- * await parseEntryExports("/abs/src/index.ts");
- * // [{ name: "Theme", kind: "type", isTypeOnly: true, ... }, { name: "VERSION", kind: "const", ... }]
- * ```
- */
-export declare function parseEntryExports(entryFile: string): Promise<EntryExports>;

package/lib/parse-exports.d.ts

@@ -1,25 +0,0 @@
-import { type RelativeSourcePath } from "./brands";
-export type ParsedExports = Record<string, {
-    source: RelativeSourcePath;
-    default: boolean;
-    mixed?: boolean;
-}>;
-/**
- * Parses exports from an entry file and resolves aliases against `dir`.
- *
- * @example
- * ```ts
- * // Source: export { Button } from "./Button.svelte";
- * //        export default App from "./App.svelte";
- * parseExports(source, "./src")
- * // Returns: {
- * //   Button: { source: "./Button.svelte", default: false },
- * //   App: { source: "./App.svelte", default: true }
- * // }
- * ```
- *
- * @param resolving - Absolute paths currently being resolved on this call
- *   stack, used to break `export *` cycles between files that re-export
- *   each other. Callers should not pass this; it is threaded internally.
- */
-export declare function parseExports(source: string, dir: string, resolving?: Set<string>): ParsedExports;

package/lib/parsed-component-metadata.d.ts

@@ -1,13 +0,0 @@
-/**
- * Runtime helpers for `ParsedComponent`'s symbol-keyed TypeScript metadata,
- * split out of `./ComponentParser` so callers that only need to read or
- * write this field (`parse-cache.ts`, `writer/writer-ts-definitions-core.ts`,
- * `bundle.ts`) don't have to import the parser stack to get it.
- */
-import type { ParsedComponent, ParsedComponentTypeScriptMetadata, ResolvedComponentProp } from "./ComponentParser";
-export declare const PARSED_COMPONENT_TYPE_SCRIPT_METADATA: unique symbol;
-export declare function getParsedComponentTypeScriptMetadata(component: {
-    [PARSED_COMPONENT_TYPE_SCRIPT_METADATA]?: ParsedComponentTypeScriptMetadata;
-}): ParsedComponentTypeScriptMetadata | undefined;
-/** Append checker-resolved props. Names the AST walker already found are left alone. */
-export declare function applyResolvedProps(component: ParsedComponent, resolved: ResolvedComponentProp[]): void;

package/lib/parser/bindings.d.ts

@@ -1,4 +0,0 @@
-import type ComponentParser from "../ComponentParser";
-import type { ParserContext } from "./context";
-export declare function extractPropertyType(typeStr: string, propName: string): string | undefined;
-export declare function resolveMemberExpressionType(ctx: ParserContext, parser: ComponentParser, expr: unknown): string | undefined;

package/lib/parser/context.d.ts

@@ -1,72 +0,0 @@
-import type { FunctionDeclaration, VariableDeclaration } from "estree";
-import type { ComponentContext, ComponentElement, ComponentEvent, ComponentGenerics, ComponentInlineElement, ComponentProp, ComponentPropBindings, Extends, InternalComponentSlot, LegacyAstRoot, LexicalScope, LocalTypeDeclaration, RestProps, RunesPropsDeclarationMetadata, ScriptLanguage, SourceRange, SyntaxMode, TypeDef, TypeImportBinding } from "../ComponentParser";
-import type { SveldDiagnostic } from "../diagnostics";
-/** Per-parse mutable state for {@link ComponentParser}. Reset via {@link createParserContext} on each parse. */
-export interface ParserContext {
-    syntaxMode: SyntaxMode;
-    scriptLanguage?: ScriptLanguage;
-    source?: string;
-    parsed?: LegacyAstRoot;
-    /**
-     * Explicit `<svelte:options runes={...} />` value. When set, overrides rune-reference detection.
-     */
-    runesOptionOverride?: boolean;
-    sourceLineStartOffsetsCache?: number[];
-    rest_props?: RestProps;
-    extends?: Extends;
-    customElementTag?: string;
-    componentComment?: string;
-    componentCommentSource?: SourceRange;
-    generics: ComponentGenerics;
-    /**
-     * Raw `generics` script attribute (with `lang="ts"` validated). Held until parse end so it can
-     * override JSDoc-derived {@link ParserContext.generics}.
-     */
-    scriptGenericsAttribute?: {
-        value: string;
-        source?: SourceRange;
-    };
-    readonly diagnosticRecords: SveldDiagnostic[];
-    componentFilePath: string;
-    readonly props: Map<string, ComponentProp>;
-    readonly moduleExports: Map<string, ComponentProp>;
-    readonly propLocalToPublicName: Map<string, string>;
-    readonly reactive_vars: Set<string>;
-    readonly funcDecls: Map<string, FunctionDeclaration>;
-    readonly vars: Set<VariableDeclaration>;
-    readonly runesPropsDeclarationMetadataByDeclaratorStart: Map<number, RunesPropsDeclarationMetadata>;
-    readonly typedRunesPropsDeclarations: RunesPropsDeclarationMetadata[];
-    readonly explicitPropTypesByName: Map<string, string>;
-    readonly explicitVariableTypesByName: Map<string, string>;
-    readonly typeImportBindingsByLocalName: Map<string, TypeImportBinding>;
-    readonly localTypeDeclarationsByName: Map<string, LocalTypeDeclaration>;
-    readonly wholePropsLocals: Set<string>;
-    readonly restPropLocals: Set<string>;
-    readonly componentScope: LexicalScope;
-    scopeDeclarations: WeakMap<object, LexicalScope>;
-    readonly activeScopes: LexicalScope[];
-    readonly slots: Map<string | null, InternalComponentSlot>;
-    readonly snippetPropLocals: Set<string>;
-    /** `@template` tags from a `@slot`/`@snippet` block (no `@extends`), held until finalization. */
-    deferredSlotBlockGenerics: Array<{
-        name: string;
-        constraint: string;
-    }>;
-    readonly events: Map<string, ComponentEvent>;
-    readonly eventDescriptions: Map<string, string | undefined>;
-    readonly forwardedEvents: Map<string, ComponentInlineElement | ComponentElement>;
-    readonly jsDocEventNames: Set<string>;
-    /** Source range per `@event` JSDoc tag, for `event-no-source` diagnostics. */
-    readonly jsDocEventSources: Map<string, SourceRange | undefined>;
-    readonly bindings: Map<string, ComponentPropBindings>;
-    readonly contexts: Map<string, ComponentContext>;
-    readonly typedefs: Map<string, TypeDef>;
-    variableInfoCache: Map<string, {
-        type: string;
-        description?: string;
-    }>;
-    /** True after the per-component variable/JSDoc symbol table has populated {@link variableInfoCache}. */
-    variableInfoCacheBuilt: boolean;
-}
-/** Fresh {@link ParserContext}. Keep in sync with new fields on {@link ParserContext}. */
-export declare function createParserContext(): ParserContext;

package/lib/parser/contexts.d.ts

@@ -1,19 +0,0 @@
-import type { CallExpression, NewExpression } from "estree";
-import type { Node } from "estree-walker";
-import type ComponentParser from "../ComponentParser";
-import type { ComponentContext } from "../ComponentParser";
-import type { ParserContext } from "./context";
-/** Turn `simple-modal` into `SimpleModalContext`. */
-export declare function generateContextTypeName(key: string): string;
-/** Build a {@link ComponentContext} from an object literal or variable reference. */
-export declare function parseContextValue(ctx: ParserContext, parser: ComponentParser, node: Node, key: string): ComponentContext | null;
-/** Static description from `Symbol()` / `Symbol.for()`, or `""` when unknown. Returns `null` for other calls. */
-export declare function resolveSymbolKeyDescription(node: CallExpression | NewExpression): string | null;
-/**
- * Resolve a `setContext` key to the string used in `{PascalCase}Context`.
- * Accepts literals, static templates, `const` chains (depth 5), and `Symbol()`.
- * Description-less symbols fall back to the binding name.
- */
-export declare function resolveContextKey(ctx: ParserContext, keyArg: unknown, depth?: number): string | null;
-/** Parse `setContext(key, value)` when the key resolves statically. */
-export declare function parseSetContextCall(ctx: ParserContext, parser: ComponentParser, node: Node, _parent?: Node): void;

package/lib/parser/diagnostics.d.ts

@@ -1,8 +0,0 @@
-import type { SourceRange } from "../ComponentParser";
-import type { SveldDiagnosticKind } from "../diagnostics";
-import type { ParserContext } from "./context";
-/**
- * Appends a diagnostic (a place sveld had to guess a type) to `ctx.diagnosticRecords`,
- * tagged with the file path of the component currently being parsed.
- */
-export declare function recordDiagnostic(ctx: ParserContext, kind: SveldDiagnosticKind, name: string, message: string, source?: SourceRange): void;

package/lib/parser/events.d.ts

@@ -1,21 +0,0 @@
-import type { CallExpression } from "estree";
-import type { DispatchedEvent } from "../ComponentParser";
-import type { ParserContext } from "./context";
-export declare function literalDetailToTypeText(value: unknown): string;
-/** Merge or add a dispatched event. Detail defaults to `null` when the dispatch has no argument and no `@event` detail. */
-export declare function addDispatchedEvent(ctx: ParserContext, { name, detail, has_argument, description, deprecated, tags, source, }: Pick<DispatchedEvent, "name" | "description" | "deprecated" | "tags" | "source"> & {
-    detail: string;
-    has_argument: boolean;
-}): void;
-/**
- * Detect `$host().dispatchEvent(new CustomEvent("name", { detail }))` (or `new Event(...)`) and
- * record it as a dispatched event, mirroring `createEventDispatcher()` detection.
- */
-export declare function parseHostDispatchEventCall(ctx: ParserContext, dispatchEventCall: CallExpression): string | undefined;
-export declare function buildEventDetailFromProperties(properties: Array<{
-    name: string;
-    type: string;
-    description?: string;
-    optional?: boolean;
-    default?: string;
-}>, _eventName?: string, multiline?: boolean): string;

package/lib/parser/generics.d.ts

@@ -1,24 +0,0 @@
-import type { ComponentGenerics } from "../ComponentParser";
-import type { ParserContext } from "./context";
-/**
- * Splits a string on top-level commas, ignoring commas nested inside
- * `<>`, `()`, `[]`, or `{}`. Shared by the `generics` script attribute parser
- * and the TypeScript definition writer, both of which must separate generic
- * constraint declarations that may themselves contain commas (e.g. `Value extends Record<string, any>`).
- */
-export declare function splitTopLevelCommas(value: string): string[];
-/**
- * Parses the `generics` script attribute value (a TypeScript type-parameter
- * list, e.g. `"Row extends DataTableRow = DataTableRow, Header"`) into the
- * same `[names, constraints]` tuple the `@generics`/`@template` JSDoc tags produce.
- */
-export declare function parseGenericsAttribute(value: string): ComponentGenerics;
-/**
- * Extends `referencedImportedTypes`/`referencedLocalTypes` with any type names
- * mentioned in the `generics` script attribute (e.g. the `DataTableRow` in
- * `Row extends DataTableRow = DataTableRow`). These names only appear in the
- * raw attribute string, not in the `$props()` type annotation AST that
- * {@link collectReferencedTypeDependencies} normally walks, so without this
- * they would never get hoisted into the emitted `.d.ts`.
- */
-export declare function collectGenericsAttributeTypeDependencies(ctx: ParserContext, referencedImportedTypes: Set<string>, referencedLocalTypes: Set<string>): void;

package/lib/parser/jsdoc.d.ts

@@ -1,55 +0,0 @@
-import { parse as parseComment } from "comment-parser";
-import type ComponentParser from "../ComponentParser";
-import type { ComponentPropBinding, ComponentPropParam, DeprecatedValue, JsDocPassthroughTag } from "../ComponentParser";
-import type { ParserContext } from "./context";
-export declare function formatComment(comment: string): string;
-export declare function getCommentTags(parsed: ReturnType<typeof parseComment>): {
-    type: import("comment-parser").Spec | undefined;
-    param: import("comment-parser").Spec[];
-    returns: import("comment-parser").Spec | undefined;
-    binding: ComponentPropBinding | undefined;
-    deprecated: DeprecatedValue | undefined;
-    additional: import("comment-parser").Spec[];
-    passthrough: import("comment-parser").Spec[];
-    description: string;
-};
-export declare function findJSDocComment(leadingComments: unknown[]): {
-    value: string;
-} | undefined;
-export declare function findAdjacentJSDocComment(ctx: ParserContext, leadingComments: unknown[] | undefined, nodeStart: number | undefined): {
-    value: string;
-} | undefined;
-export declare function processNodeJSDoc(ctx: ParserContext, parser: ComponentParser, node: {
-    leadingComments?: unknown[];
-    start?: number;
-} | null | undefined): {
-    type?: string;
-    params?: ComponentPropParam[];
-    returnType?: string;
-    description?: string;
-    binding?: ComponentPropBinding;
-    deprecated?: DeprecatedValue;
-    tags?: JsDocPassthroughTag[];
-} | undefined;
-export declare function processLeadingCommentsJSDoc(ctx: ParserContext, parser: ComponentParser, node: {
-    leadingComments?: unknown[];
-    start?: number;
-} | null | undefined): {
-    type?: string;
-    params?: ComponentPropParam[];
-    returnType?: string;
-    description?: string;
-    binding?: ComponentPropBinding;
-    deprecated?: DeprecatedValue;
-    tags?: JsDocPassthroughTag[];
-} | undefined;
-export declare function processJSDocComment(parser: ComponentParser, leadingComments: unknown[]): {
-    type?: string;
-    params?: ComponentPropParam[];
-    returnType?: string;
-    description?: string;
-    binding?: ComponentPropBinding;
-    deprecated?: DeprecatedValue;
-    tags?: JsDocPassthroughTag[];
-} | undefined;
-export declare function parseCustomTypes(ctx: ParserContext, parser: ComponentParser): void;

package/lib/parser/prop-shared.d.ts

@@ -1,84 +0,0 @@
-import type { ComponentPropParam, ComponentPropTypeSource } from "../ComponentParser";
-/**
- * Decides a prop's provenance for docs UIs. Order is fixed and mirrors the
- * precedence used to pick the prop's final `type` text in
- * {@link resolvePropTypeAndDocs}: an explicit TypeScript annotation always
- * wins, then JSDoc `@type`/`@param`/`@returns`, then a type resolved from an
- * identifier default's own JSDoc, and only then a bare inferred/initializer
- * type. `"unknown"` means none of the above produced any type text at all.
- */
-export declare function resolveTypeSource({ hasTypeScriptType, hasJSDocType, inferredType, finalType, }: {
-    hasTypeScriptType?: boolean;
-    hasJSDocType?: boolean;
-    inferredType?: string;
-    finalType?: string;
-}): ComponentPropTypeSource;
-export interface ResolvePropTypeAndDocsInput {
-    /** Explicit TypeScript type text: a legacy `: T` annotation, or the matching `$props()` type-literal member in runes. */
-    explicitType?: string;
-    /**
-     * Lowest-precedence type text, used only when nothing else applies: the
-     * initializer's inferred type, or the literal `"() => any"` seed for a
-     * bare `export function` declaration (which has no initializer).
-     */
-    typeSeed?: string;
-    /**
-     * Value fed to {@link resolveTypeSource}'s `inferredType` bucket. Distinct
-     * from `typeSeed` for function declarations, which have an initializer-less
-     * `typeSeed` placeholder but no actual inferred type.
-     */
-    inferredTypeForSource?: string;
-    jsdocType?: string;
-    jsdocDescription?: string;
-    jsdocParams?: ComponentPropParam[];
-    jsdocReturnType?: string;
-    /**
-     * Type/description/params/returnType resolved from an identifier default's
-     * own JSDoc (e.g. `export let onClick = defaultHandler;` where
-     * `defaultHandler` carries its own doc comment). Callers should gate this
-     * to `undefined` whenever `explicitType`/`jsdocType` is already set, so it
-     * only ever fills a genuine gap (see {@link resolvePropIsFunction}, which
-     * relies on the same gating).
-     */
-    resolvedType?: string;
-    resolvedDescription?: string;
-    resolvedParams?: ComponentPropParam[];
-    resolvedReturnType?: string;
-    /** True when the initializer itself is an arrow/function expression. */
-    initializerIsFunction: boolean;
-    /** True for a bare `export function foo() {}` declaration. */
-    isFunctionDeclaration: boolean;
-    /**
-     * Runes-only: also treat the prop as a function when its resolved type
-     * text looks like a callback signature (`@param`/`@returns`/`=>` from
-     * TypeScript, JSDoc, or an identifier default). Legacy `export let` never
-     * applies this signature check; the mode difference predates this helper
-     * and is preserved here rather than silently converged.
-     */
-    inferIsFunctionFromTypeSignature?: boolean;
-    /**
-     * Legacy-only: fall back to a `@typedef`'s own description when the prop
-     * has none of its own. Runes omits this today (a preserved mode
-     * difference); pass `undefined` there.
-     */
-    typedefs?: Map<string, {
-        description?: string;
-    }>;
-}
-export interface ResolvedPropTypeAndDocs {
-    type?: string;
-    typeSource: ComponentPropTypeSource;
-    description?: string;
-    params?: ComponentPropParam[];
-    returnType?: string;
-    isFunction: boolean;
-}
-/**
- * Resolves the type/description/params/returnType/isFunction decisions
- * shared by every prop front-end (legacy module exports, legacy instance
- * `export let`/`export function`, and runes `$props()` destructuring). The
- * front-ends differ only in how they extract the raw signals below from
- * their respective AST shapes; once extracted, the decisions are identical
- * except where explicitly parameterized above.
- */
-export declare function resolvePropTypeAndDocs(input: ResolvePropTypeAndDocsInput): ResolvedPropTypeAndDocs;