import { Category, Config, JsonReport, Result, RuleSetting, Severity, defineConfig } from "@svelte-vitals/core";
import { BranchStep, HeadTag, RuleOptionsSpec, SuppressionDirective } from "@svelte-vitals/core/internal";
import { AST } from "svelte/compiler";
//#region src/providers/source/imports.d.ts
/** A resolved import binding: which module, and which export ('default' for default imports). */
interface ImportInfo {
  source: string;
  imported: string;
}
/** local identifier -> import binding. */
type ImportMap = Map<string, ImportInfo>;
//#endregion
//#region src/providers/source/parse.d.ts
/** A head tag parsed from one file, before layout-chain presence is assigned. */
type ParsedTag = Omit<HeadTag, 'presence' | 'file'>;
interface ComponentUse {
  name: string;
  attributes: AST.Component['attributes'];
  hasSpread: boolean;
}
interface ParsedImage {
  hasWidth: boolean;
  hasHeight: boolean;
  hasLoading: boolean;
  hasAlt: boolean;
  lazy: boolean;
  hasSrcset: boolean;
  /** 1-based source line, or 0 if unknown. */
  line: number;
}
/** A page-body heading (<h1>–<h6>) parsed from one file (seo/single-h1). */
interface ParsedHeading {
  /** Heading level 1–6. */
  level: number;
  /** 1-based source line, or 0 if unknown. */
  line: number;
}
interface A11yNode {
  kind: 'landmark' | 'id' | 'idref' | 'component';
  /** landmark → 'main'|'banner'|'contentinfo'|'complementary'; id/idref → the literal id; component → component name */
  key: string;
  line: number;
  /** inside {#each} body or {#snippet} definition at any depth (excluded from duplication counting) */
  repeatable: boolean;
  /** branch address from template root (empty = unconditional) */
  path: BranchStep[];
  /** for kind 'idref': the referencing attribute ('for', 'aria-labelledby', …, 'href') */
  attr?: string;
  /** the landmark ancestor element within this file, if any */
  inLandmark?: string;
  /** for kind 'landmark' from <header>/<footer>: at template top level in this file (which also implies "not inside sectioning content" — depth 0 has no ancestors at all) */
  topLevel?: boolean;
}
interface ParsedA11y {
  nodes: A11yNode[];
  /** landmark ancestor of this file's <slot>/{@render children()} position, if any */
  slotInLandmark?: string;
  /** {@html} tags and spread attributes, located — each poisons the closed world for no-missing-id-ref */
  unknowable: {
    kind: 'spread' | 'html';
    line: number;
  }[];
  /** Distinct lowercased tag names of the body's `RegularElement`s (a11y/required-element's presence set). */
  elementTags: string[];
  /** file contains `{@html}` or a `<svelte:element>` — either can render an element the walk cannot see */
  elementsUnknowable: boolean;
}
interface ParsedFile {
  headTags: ParsedTag[];
  components: ComponentUse[];
  imports: ImportMap;
  images: ParsedImage[];
  headings: ParsedHeading[];
  a11y: ParsedA11y;
  /** Inline `svelte-vitals-disable-next-line` directives in this file, for the central
   *  suppression pass. Collected here because a route-scoped finding can be located in any file
   *  the composition reads, including ones no component-fact collection visited (`--route`). */
  suppressions: SuppressionDirective[];
}
//#endregion
//#region src/providers/source/resolve.d.ts
/**
 * Per-run read+parse memo, keyed by project-root-relative path (as normalized by
 * chainFiles / resolveComponentPath). Shared across routes so a file imported by
 * many pages (a root layout, a common $lib component) is only parsed once per run.
 */
type ParseCache = Map<string, Promise<ParsedFile>>;
//#endregion
//#region src/reporter-resolve.d.ts
type ReporterName = 'console' | 'json' | 'agent' | 'sarif' | 'github' | 'html' | 'md';
//#endregion
//#region src/config-file.d.ts
/**
 * Loads `svelte-vitals.config.{js,ts}` from the analyzed directory (design
 * doc: docs/superpowers/specs/2026-07-05-config-file-design.md). Wired into
 * `analyzeProject` (packages/cli/src/index.ts), so every caller of it inherits
 * the config file.
 *
 * Candidate filenames, in priority order. Only `cwd` itself is searched (no
 * upward directory walk — see design doc §1). Exported so the install wizard's
 * config-file scaffolder (install/config-file-format.ts) detects existing
 * configs against the exact same list — a second hand-maintained copy could
 * drift and make the scaffolder create a duplicate config the loader then
 * shadows or ignores.
 */
declare const CONFIG_FILENAMES: string[];
/** Result of loading and validating a config file. */
interface LoadedConfigFile {
  /** The file's contents after validation; invalid optional fields are dropped (see `warnings`). */
  config: Partial<Config>;
  /** Non-fatal issues: unknown top-level keys, invalid enum values (the field is ignored). */
  warnings: string[];
}
/**
 * Find and load `svelte-vitals.config.{js,ts}` from `cwd` (only `cwd`, no
 * upward search). Returns `undefined` when no candidate file exists.
 *
 * Loader mechanism (design doc §2): plain native `import()`. `.js` is parsed as
 * ESM (the project must be `"type": "module"` — SvelteKit's default); `.ts`
 * loads via native type-stripping, unflagged on every supported Node
 * (engines.node >=24.16.0).
 *
 * Throws when: the file exists but has no usable default export, or the loaded
 * config fails validation (unknown rule ids in `rules`, invalid `weights`
 * entries).
 */
declare function loadConfigFile(cwd: string): Promise<LoadedConfigFile | undefined>;
//#endregion
//#region src/providers/source/project.d.ts
/** Thrown when the target directory is not a SvelteKit project (CLI maps to exit 2). */
declare class ProjectError extends Error {
  constructor(message: string);
}
//#endregion
//#region src/route-matcher.d.ts
declare function routeMatcher(glob: string | undefined): (route: string) => boolean;
//#endregion
//#region src/rules-config.d.ts
/** Rule ids passed to --rules/--ignore that aren't part of the built-in registry. */
declare function findUnknownRuleIds(ids: string[]): string[];
/** All built-in rule ids, sorted — for help and error messages. */
declare function knownRuleIds(): string[];
/** The options a rule declares, or undefined when it takes none. */
declare function ruleOptionsSpec(id: string): RuleOptionsSpec | undefined;
/**
 * Stamps the rule registry's provenance onto error messages that list known ids.
 * Two copies of svelte-vitals can coexist in one tree (e.g. the Vite plugin's
 * resolved copy and a directly installed CLI, issue #583); without the versions,
 * a rule that exists in one copy but not the other reads as a mystery rather
 * than a version skew.
 */
declare function registryTag(): string;
//#endregion
//#region src/index.d.ts
interface RunOptions {
  cwd?: string;
  log?: (line: string) => void;
  errorLog?: (line: string) => void;
  metaComponents?: string[];
  treatDynamicAs?: 'pass' | 'warn' | 'fail';
  /** Restrict analysis to routes whose path matches this glob (matched against the route path without leading slash). */
  route?: string;
  reporter?: ReporterName;
  byRoute?: boolean;
  failOn?: Severity;
  /**
   * A complete replacement for the config file's `rules` map — what the Vite plugin and
   * programmatic callers pass. Whole-field, per the per-field precedence every other config
   * field follows.
   */
  rules?: Record<string, RuleSetting>;
  /**
   * Rule ids to silence on top of `rules`/the config file (--ignore). Unlike `rules`, this
   * never replaces anything — it only ever adds `'off'` entries for the ids listed, so a
   * rule not named here keeps whatever `rules`/the file said for it (design:
   * rules-flag-clobbers-config-options).
   */
  ignoreRules?: string[];
  /** `--rules`: run only these rule ids. Selection; the config file still supplies their options. */
  allowRules?: string[];
  /**
   * `--config`: load this config file instead of discovering one in the analyzed directory.
   * Absolute, or relative to `process.cwd()` — never to `cwd`, so the analyzed directory is
   * not the base.
   */
  configPath?: string;
  /** Per-category weights for the combined Health score (flag > config file > default 1 each). */
  weights?: Partial<Record<Category, number>>;
  /** Restrict analysis to rules in these categories (applied after rules/ignore selection). */
  categories?: Category[];
  /** Override process.env for reporter auto-detection (mainly useful in tests). */
  env?: NodeJS.ProcessEnv;
  /** Fail (exit 1) when the combined Health score is below this value (0–100). */
  minHealth?: number;
  /** Print only the combined Health score (integer) to stdout. */
  score?: boolean;
  /** Output path for --reporter html (default 'svelte-vitals-report.html'; '-' = stdout). */
  outFile?: string;
  /** Injected file writer for --reporter html (defaults to node:fs writeFileSync). Mainly for tests. */
  writeFile?: (path: string, content: string) => void;
  /** Report only findings in files changed vs the merge-base with this ref ('HEAD' = uncommitted). Undefined = no gating. */
  diffBase?: string;
  /** Report only findings in files staged for commit. Takes precedence over `diffBase`. */
  staged?: boolean;
  /** Report only findings not present when analyzing this git ref (e.g. the PR base). */
  baseline?: string;
  /** Disable applying svelte-vitals-suppressions.json for this run. */
  noSuppressions?: boolean;
  /** Analyze, then (re)write svelte-vitals-suppressions.json with all currently penalized findings and exit 0. */
  updateSuppressions?: boolean;
  /** Disable ANSI color in console output. */
  noColor?: boolean;
  /** Override stdout TTY detection (tests). */
  stdoutIsTTY?: boolean;
  /** Override stderr TTY detection (tests). */
  stderrIsTTY?: boolean;
  /** Override stdin TTY detection (tests). */
  stdinIsTTY?: boolean;
  /** True when the user passed a path argument — discovery must not run (design: never reinterpret an explicit target). */
  explicitPath?: boolean;
  /** Injected picker for the monorepo app selector (bin.ts wires a clack implementation; null = cancelled). */
  selectApp?: (apps: string[]) => Promise<string | null>;
  /** Show every finding uncapped and ungrouped in console output (default false — capped, grouped by rule). */
  verbose?: boolean;
  /** Disable the Health-score reveal animation even on an interactive stdout. */
  noAnimation?: boolean;
  /** Override the stream the score animation writes to (tests). Defaults to process.stdout. */
  stdoutStream?: NodeJS.WriteStream;
  /** Override the stream the analysis-phase progress indicator writes to (tests). Defaults to process.stderr. */
  stderrStream?: NodeJS.WriteStream;
  /** Override the animation's per-frame delay in ms (tests — 0 runs the real frame loop near-instantly). Defaults to the animation module's own constant. */
  animationFrameDelayMs?: number;
}
/**
 * Whether the "Analyzing…" spinner should run. Unlike color, the spinner animates
 * with carriage returns and escape codes, so it needs a real interactive stderr —
 * `FORCE_COLOR` must NOT force it on in a non-TTY stderr (e.g. CI), where `\r` would
 * clutter the log. So gate on `stderrIsTTY` unconditionally, then reuse the color
 * gating (NO_COLOR / --no-color / agent env) with that same TTY value.
 */
declare function spinnerEnabled(opts: {
  reporter: ReporterName;
  rawReporter: ReporterName | undefined;
  stderrIsTTY: boolean;
  env: NodeJS.ProcessEnv;
  noColorFlag?: boolean;
}): boolean;
interface AnalyzeOptions {
  cwd?: string;
  metaComponents?: string[];
  treatDynamicAs?: 'pass' | 'warn' | 'fail';
  /** Restrict analysis to routes whose path matches this glob (matched against the route path without leading slash). */
  route?: string;
  failOn?: Severity;
  /**
   * A complete replacement for the config file's `rules` map — what the Vite plugin and
   * programmatic callers pass. Whole-field, per the per-field precedence every other config
   * field follows.
   */
  rules?: Record<string, RuleSetting>;
  /**
   * Rule ids to silence on top of `rules`/the config file (--ignore). Unlike `rules`, this
   * never replaces anything — it only ever adds `'off'` entries for the ids listed, so a
   * rule not named here keeps whatever `rules`/the file said for it (design:
   * rules-flag-clobbers-config-options).
   */
  ignoreRules?: string[];
  /** `--rules`: run only these rule ids. Selection; the config file still supplies their options. */
  allowRules?: string[];
  /** Per-category weights for the combined Health score (flag > config file > default 1 each). */
  weights?: Partial<Record<Category, number>>;
  /** Restrict analysis to rules in these categories (applied after rules/ignore selection). */
  categories?: Category[];
  /**
   * Reuse this parse cache across multiple `analyzeProject` calls instead of
   * starting fresh each time — the vite dev dashboard passes a long-lived cache
   * and invalidates only the changed file's entry between re-analyses, so
   * unchanged routes/layouts are never re-read or re-parsed. This only covers
   * the route/layout (head-resolution) parse path via `collectRoutes` —
   * `collectComponentFacts` (Correctness facts) is unaffected and still scans
   * every component on each call. Callers that don't need cross-call reuse
   * (the CLI's `run()`, the Action — each analyzes once per process) can
   * omit this; a fresh cache is created automatically.
   */
  parseCache?: ParseCache;
  /**
   * `--config`: load this config file instead of discovering one in the analyzed directory.
   * Absolute, or relative to `process.cwd()` — never to `cwd`, so the analyzed directory is
   * not the base. Ignored (not even read) when `loadedConfig` is set, including `null`.
   */
  configPath?: string;
  /**
   * Result of a `loadConfigFile()` call to reuse instead of loading from `cwd`.
   * Pass the value loaded from the real project so a secondary analysis (the
   * `--baseline` worktree) runs under the same config file; `null` means "the
   * project has no config file — do not look for one". Any value here, `null`
   * included, takes precedence over `configPath`.
   */
  loadedConfig?: LoadedConfigFile | null;
}
interface AnalyzeResult {
  results: Result[];
  config: Config;
  version: string;
  /** Ids of the rules that ran, after `--category` narrowing. The JSON report lists these so a rule that found nothing stays distinguishable from one that was never selected. */
  ruleIds: string[];
  /** Per-rule, per-declaration counts of places examined, unfiltered by `--diff`/`--baseline`/suppressions. */
  examined: Record<string, Record<string, number>>;
  /** Routes a closed-world rule skipped, keyed by rule id — the analysis-side companion to `examined`; unfiltered by `--diff`/`--baseline`/suppressions. Absent when no analyzed route was skipped or the rule was not selected. */
  skipped?: JsonReport['skipped'];
  /** Ids of rules `runRules` caught throwing — already folded into `config` via `withFailedRulesOff`; exposed separately so a caller with its own base config (the vite dev dashboard) can apply the same correction without adopting this call's `config`. */
  failedRuleIds: string[];
  /** Non-fatal issues surfaced during analysis: config-file problems (unknown top-level keys, invalid enum values), version-floor notices, `--rules`/overrides conflicts, closed-world skip notices (`a11y/no-missing-id-ref`), and skipped-file notices. Empty when none apply. */
  warnings: string[];
  /**
   * This analysis's config-file load result (`undefined` when no config file exists at its
   * `cwd`). A caller running a second `analyzeProject` against a different cwd for the same
   * logical project (e.g. `applyScope`'s `--baseline` worktree) should pass this back in via
   * `AnalyzeOptions.loadedConfig` (`?? null`) so both sides run under the same config.
   */
  loadedConfig?: LoadedConfigFile;
}
/**
 * Run static-mode analysis and return the structured findings + resolved config.
 * Throws ProjectError when `cwd` is not a SvelteKit project. Also throws when a
 * `svelte-vitals.config.{js,ts}` file in `cwd` fails to load or fails
 * validation (unknown rule ids in `rules`, invalid `weights` entries) — see
 * `loadConfigFile`. Shared by the CLI's run() and by embedding callers (issue #24).
 *
 * Config precedence is per field: an explicit option here wins, otherwise the
 * config file's value is used, otherwise the built-in default (design doc
 * 2026-07-05-config-file-design.md §3).
 */
declare function analyzeProject(opts?: AnalyzeOptions): Promise<AnalyzeResult>;
interface ApplyScopeOptions {
  cwd: string;
  staged?: boolean;
  diffBase?: string;
  baseline?: string;
  /**
   * Resolved config, needed to decide which findings count as "penalized" when
   * applying svelte-vitals-suppressions.json (`isPenalized`). Suppression
   * application is skipped entirely when omitted, keeping such callers'
   * behavior unchanged (the CLI and @svelte-vitals/action both pass it).
   */
  config?: Config;
  /** Disable applying svelte-vitals-suppressions.json for this run. */
  noSuppressions?: boolean;
  errorLog?: (line: string) => void;
  /**
   * Also doubles as this call's route-scoping signal: `analyzeOpts.route !== undefined`
   * tells the suppressions block that `results` (this function's first argument) was
   * itself collected route-scoped, not just project-wide-then-narrowed — see the comment
   * at that check.
   */
  analyzeOpts?: AnalyzeOptions;
}
/**
 * Narrow `results` to what a PR gate cares about: `--staged`/`--diff` restrict to
 * changed files, `--baseline` drops findings that already existed at that ref,
 * and (last) svelte-vitals-suppressions.json drops findings that were explicitly
 * accepted via `--update-suppressions`. Shared by `run()` and
 * `@svelte-vitals/action` (issue #154) so the git-diff/baseline orchestration
 * lives in exactly one place.
 */
declare function applyScope(results: Result[], opts: ApplyScopeOptions): Promise<Result[]>;
/**
 * Run static-mode analysis once and return the process exit code (design §6):
 *   0 = no failing findings, 1 = critical finding present, 2 = execution error.
 */
declare function run(opts?: RunOptions): Promise<number>;
//#endregion
export { AnalyzeOptions, AnalyzeResult, ApplyScopeOptions, CONFIG_FILENAMES, type LoadedConfigFile, type ParseCache, ProjectError, RunOptions, analyzeProject, applyScope, defineConfig, findUnknownRuleIds, knownRuleIds, loadConfigFile, registryTag, routeMatcher, ruleOptionsSpec, run, spinnerEnabled };