/**
 * parse-imports — pure function that extracts every `import` declaration
 * from a candidate code block as a flat list of per-binding entries.
 *
 * Output shape is intentionally flat: the W0198 preflight checks each
 * `(source, imported)` pair against the resolved package surface, so a
 * flat list is the natural input. Multi-binding declarations
 * (`import { a, b as c } from "pkg"`) produce one entry per binding;
 * default + named combos (`import def, { a } from "pkg"`) likewise.
 *
 * Implementation: delegates to `oxc-parser`'s `staticImports` view, which
 * already decomposes each import statement into entries with explicit
 * `importName` / `localName` / `isType` fields. The TS-aware grammar
 * means dynamic `import(...)`, `import.meta`, and malformed statements
 * are all handled by the parser itself — we just translate the entries
 * into our `CandidateImportBinding` shape.
 *
 * Recognized grammar (handled by oxc-parser):
 *   - `import { a, b as c } from "pkg"`
 *   - `import def from "pkg"`
 *   - `import * as ns from "pkg"`
 *   - `import def, { a } from "pkg"` and `import def, * as ns from "pkg"`
 *   - `import type { ... } from "pkg"` and `import { type a, b } from "pkg"`
 *   - `import "pkg"` (side-effect; surfaced as a single `side-effect` entry)
 *   - Multi-line variants of all of the above.
 *
 * Out of scope (intentionally — both regex and oxc-parser ignore these):
 *   - Dynamic `import("pkg")` — runtime, not statically resolvable here.
 *   - `export { a } from "pkg"` re-exports from candidate code.
 *   - TypeScript `import = require()` and `import("...").Type` ambient
 *     references — neither pattern shows up in the App SDK / Studio
 *     candidate corpus the preflight grades against.
 */
export type CandidateImportKind = "named" | "default" | "namespace" | "side-effect";
export interface CandidateImportBinding {
    /** Source specifier as written by the candidate (e.g. `"@sanity/sdk-react"`). */
    source: string;
    /** Which import-clause shape this binding came from. */
    kind: CandidateImportKind;
    /**
     * Name to look up against the package surface:
     *   - `kind: "named"` — the imported identifier.
     *   - `kind: "default"` — the literal string `"default"`.
     *   - `kind: "namespace"` — the literal string `"*"`.
     *   - `kind: "side-effect"` — empty string (no binding).
     */
    imported: string;
    /** Local alias used in the candidate's body. Same as `imported` when no alias. */
    local: string;
    /**
     * Whether this binding is type-only — either the whole declaration was
     * `import type`, or this specifier was prefixed with `type`
     * (`import { type X, Y } from "pkg"`).
     */
    isType: boolean;
    /**
     * 1-based line number where the import declaration starts in the
     * source. Useful for surfacing findings back to a reviewer.
     */
    line: number;
}
export declare function parseImports(src: string): CandidateImportBinding[];
