import * as i0 from '@angular/core';
import { InjectionToken, OnDestroy, EnvironmentProviders, ApplicationRef } from '@angular/core';

type AngularRenderScanAnimationSpeed = 'slow' | 'fast' | 'off';
type AngularRenderReason = 'input' | 'event' | 'tick' | 'dom' | 'unknown';
type AngularRenderMutationType = 'none' | 'text' | 'attribute' | 'structural';
type AngularRenderScanDarkMode = 'auto' | 'dark' | 'light';
/** The source that caused a change-detection cycle to fire. */
type CdTriggerSource = 'zone:click' | 'zone:input' | 'zone:keydown' | 'zone:keyup' | 'zone:submit' | 'zone:change' | 'zone:focus' | 'zone:blur' | 'zone:scroll' | 'zone:setTimeout' | 'zone:setInterval' | 'zone:xhr' | 'zone:fetch' | 'zone:promise' | 'zone:microtask' | 'zone:macrotask' | 'zone:eventTask' | 'signal:write' | 'manual:markForCheck' | 'manual:detectChanges' | 'router:navigation' | 'zone:unknown' | 'unknown';
interface CdTriggerAttribution {
    /** Primary trigger source */
    source: CdTriggerSource;
    /** Optional detail: event type, XHR URL, timer ID, etc. */
    detail?: string;
    /** Stack frame that triggered the cycle (best-effort) */
    callSite?: string;
    /** Whether this cycle was triggered by user interaction */
    isUserInteraction: boolean;
    /** Whether this is suspected Zone pollution (async with no user action) */
    isZonePollution: boolean;
}
interface OnPushCandidate {
    name: string;
    selector: string;
    totalChecks: number;
    wastedChecks: number;
    wastedPercentage: number;
    /** Share of observed checks that produced no DOM mutation. This is not a verified saving. */
    opportunityPercentage: number;
    /** @deprecated Use opportunityPercentage. Kept for backwards compatibility. */
    estimatedSavingPct: number;
    confidence: 'high' | 'medium' | 'low';
    reason: string;
}
interface ReferentialInstabilityReport {
    /** Component name */
    componentName: string;
    selector: string;
    /** Input property name */
    inputName: string;
    /** Number of times a new reference was passed but value was deeply equal */
    unstableRefCount: number;
    /** Total renders of this component */
    totalRenders: number;
    /** Percentage of renders where this input was referentially unstable */
    unstableRefPct: number;
    /** Last serialized value */
    lastValue: string;
}
interface ZonePollutionEvent {
    /** When this pollution event was detected */
    timestamp: number;
    /** Which async source caused it */
    source: CdTriggerSource;
    detail?: string;
    callSite?: string;
    /** How many components ran in the polluted cycle */
    componentCount: number;
    /** Duration of the polluted cycle in ms */
    cycleDuration: number;
}
interface CdGraphNode {
    id: string;
    name: string;
    selector: string;
    /** parent component id (null = root) */
    parentId: string | null;
    depth: number;
    renderCount: number;
    totalDuration: number;
    wastedChecks: number;
    cdStrategy: 'OnPush' | 'Default' | 'unknown';
    isOnPushCandidate: boolean;
    lastTrigger?: CdTriggerSource;
}
interface CdGraphEdge {
    fromId: string;
    toId: string;
    /** How many times parent triggered child render */
    triggerCount: number;
}
interface CdGraph {
    nodes: CdGraphNode[];
    edges: CdGraphEdge[];
    /** When this snapshot was taken */
    capturedAt: number;
}
interface AngularRenderScanTheme {
    fast: readonly [number, number, number];
    medium: readonly [number, number, number];
    slow: readonly [number, number, number];
    labelBackground: readonly [number, number, number];
    labelBackgroundSlow: readonly [number, number, number];
}
interface AngularRenderScanBudgets {
    warnMs?: number;
    errorMs?: number;
    maxRendersPerSecond?: number;
}
interface RenderCause {
    trigger: string;
    source?: string;
    stack?: string[];
    timestamp: number;
}
interface SignalDependencyNode {
    id: string;
    name: string;
    kind: 'signal' | 'computed' | 'component';
    updateCount: number;
    wastedCount: number;
    value?: string;
}
interface SignalDependencyEdge {
    fromId: string;
    toId: string;
}
interface SignalDependencyGraph {
    nodes: SignalDependencyNode[];
    edges: SignalDependencyEdge[];
}
interface ComponentCostEntry {
    name: string;
    selector: string;
    totalDuration: number;
    averageDuration: number;
    renderCount: number;
    costPercentage: number;
}
interface AngularRenderEntry {
    id: string;
    name: string;
    element: Element;
    rect: DOMRect;
    count: number;
    latestDuration: number;
    averageDuration: number;
    latestCycleId: number;
    reason?: AngularRenderReason;
    changedInputs?: AngularRenderChangedInput[];
    selector?: string;
    wastedChecks: number;
    wastedPercentage: number;
    mutationType?: AngularRenderMutationType;
    /** NEW: Which input props are referentially unstable */
    unstableInputs?: ReferentialInstabilityReport[];
    /** NEW: CD strategy of this component */
    cdStrategy?: 'OnPush' | 'Default' | 'unknown';
    /** NEW: Whether this is an OnPush migration candidate */
    isOnPushCandidate?: boolean;
    /** NEW: parent component id */
    parentId?: string | null;
    /** v0.2: Render cause chain */
    renderCause?: RenderCause;
    /** v0.2: Number of renders that mutated the DOM */
    templateChanges?: number;
}
interface AngularRenderCycle {
    id: number;
    startedAt: number;
    finishedAt: number;
    duration: number;
    renderedCount: number;
    slowest?: AngularRenderEntry;
    entries: AngularRenderEntry[];
    waterfall: WaterfallEntry[];
    /** NEW: What triggered this CD cycle */
    trigger?: CdTriggerAttribution;
    /** NEW: Whether this cycle is suspected Zone pollution */
    isZonePollution?: boolean;
    /** v0.2: Wasted CD Cycle Stats */
    wastedCdStats?: {
        checked: number;
        changed: number;
        wasteScore: number;
    };
}
interface WaterfallEntry {
    id: string;
    name: string;
    startOffset: number;
    selfDuration: number;
    totalDuration: number;
    depth: number;
}
interface BudgetViolation {
    componentName: string;
    selector: string;
    type: 'warn' | 'error' | 'render-rate';
    actual: number;
    budget: number;
    message: string;
    timestamp: number;
}
interface SessionExportData {
    exportedAt: string;
    url: string;
    viewport: string;
    userAgent: string;
    options: Partial<AngularRenderScanOptions>;
    cycles: SessionCycleData[];
    wastedStats: WastedStats;
    budgetViolations: BudgetViolation[];
    /** Components whose host element was disconnected when sampled. This does not prove a memory leak. */
    detachedComponents?: string[];
    /** @deprecated Use detachedComponents. */
    leakedComponents: string[];
    /** NEW */
    onPushCandidates: OnPushCandidate[];
    zonePollutionEvents: ZonePollutionEvent[];
    referentialInstabilityReports: ReferentialInstabilityReport[];
}
type InteractionFindingKind = 'budget-violation' | 'slow-component' | 'wasted-checks' | 'onpush-opportunity' | 'referential-instability' | 'zone-pollution' | 'detached-component';
type InteractionFindingSeverity = 'critical' | 'high' | 'medium' | 'low';
interface InteractionFinding {
    kind: InteractionFindingKind;
    severity: InteractionFindingSeverity;
    confidence: 'high' | 'medium' | 'low';
    score: number;
    title: string;
    summary: string;
    componentName?: string;
    evidence: string[];
    action: string;
}
interface InteractionMetrics {
    cycleCount: number;
    componentCheckCount: number;
    totalCycleDuration: number;
    maxCycleDuration: number;
    wastedChecks: number;
    wastedPercentage: number;
    budgetViolationCount: number;
}
interface InteractionReport {
    schemaVersion: 1;
    name: string;
    startedAt: string;
    finishedAt: string;
    url: string;
    viewport: string;
    metrics: InteractionMetrics;
    findings: InteractionFinding[];
    session: SessionExportData;
}
interface InteractionMetricDelta {
    baseline: number;
    candidate: number;
    absolute: number;
    percentage: number | null;
}
interface InteractionComparison {
    schemaVersion: 1;
    name: string;
    outcome: 'improved' | 'regressed' | 'unchanged';
    baseline: InteractionReport;
    candidate: InteractionReport;
    deltas: {
        totalCycleDuration: InteractionMetricDelta;
        maxCycleDuration: InteractionMetricDelta;
        wastedPercentage: InteractionMetricDelta;
        budgetViolationCount: InteractionMetricDelta;
    };
    regressions: string[];
}
interface SessionCycleData {
    id: number;
    startedAt: number;
    finishedAt: number;
    duration: number;
    renderedCount: number;
    entries: SessionEntryData[];
    waterfall: WaterfallEntry[];
    trigger?: CdTriggerAttribution;
    isZonePollution?: boolean;
}
interface SessionEntryData {
    id: string;
    name: string;
    count: number;
    latestDuration: number;
    averageDuration: number;
    latestCycleId: number;
    reason?: AngularRenderReason;
    changedInputs?: AngularRenderChangedInput[];
    selector?: string;
    wastedChecks: number;
    wastedPercentage: number;
    mutationType?: AngularRenderMutationType;
    cdStrategy?: 'OnPush' | 'Default' | 'unknown';
    isOnPushCandidate?: boolean;
}
interface WastedStats {
    totalChecks: number;
    wastedChecks: number;
    wastedPercentage: number;
}
interface AngularRenderScanOptions {
    enabled?: boolean;
    showToolbar?: boolean;
    animationSpeed?: AngularRenderScanAnimationSpeed;
    showFPS?: boolean;
    log?: boolean;
    dangerouslyForceRunInProduction?: boolean;
    minDurationMs?: number;
    minRenderCount?: number;
    include?: Array<string | RegExp>;
    exclude?: Array<string | RegExp>;
    maxLabelCount?: number;
    maxRecordedCycles?: number;
    showCopyPrompt?: boolean;
    promptContext?: string;
    theme?: Partial<AngularRenderScanTheme>;
    budgets?: AngularRenderScanBudgets;
    editorProtocol?: 'vscode' | 'webstorm' | 'cursor' | string;
    darkMode?: AngularRenderScanDarkMode;
    onCycleStart?: () => void;
    onRender?: (entry: AngularRenderEntry) => void;
    onCycleFinish?: (cycle: AngularRenderCycle) => void;
    onBudgetViolation?: (violation: BudgetViolation) => void;
    /** NEW: callback when Zone pollution is detected */
    onZonePollution?: (event: ZonePollutionEvent) => void;
    /** NEW: show CD graph panel in toolbar */
    showCdGraph?: boolean;
    /** NEW: how many Zone pollution events to retain in session */
    maxZonePollutionEvents?: number;
    /** NEW: Only track specific components by name/regex */
    trackComponents?: Array<string | RegExp>;
    /** NEW: OnPush candidate minimum wasted render % threshold (0-100) */
    onPushCandidateThreshold?: number;
    /** NEW: Enable referential input stability tracking (JSON deep-equal check) */
    trackReferentialStability?: boolean;
    /** NEW: Max depth for deep equality check in referential stability */
    referentialStabilityDepth?: number;
}
interface AngularRenderScanResolvedOptions extends Required<Omit<AngularRenderScanOptions, 'onCycleStart' | 'onRender' | 'onCycleFinish' | 'onBudgetViolation' | 'onZonePollution' | 'theme'>> {
    theme: AngularRenderScanTheme;
    budgets: Required<AngularRenderScanBudgets>;
    onCycleStart?: () => void;
    onRender?: (entry: AngularRenderEntry) => void;
    onCycleFinish?: (cycle: AngularRenderCycle) => void;
    onBudgetViolation?: (violation: BudgetViolation) => void;
    onZonePollution?: (event: ZonePollutionEvent) => void;
}
interface AngularRenderChangedInput {
    name: string;
    previous: string;
    current: string;
    /** NEW: true when reference changed but value is deeply equal */
    isReferentiallyUnstable?: boolean;
}

declare function getWastedStats(): {
    totalChecks: number;
    wastedChecks: number;
    wastedPercentage: number;
};
declare function getLeakedComponents(): AngularRenderEntry[];
/** Components whose host element is currently disconnected. This alone does not prove retention. */
declare function getDetachedComponents(): AngularRenderEntry[];
declare function getComponentCostEntries(): ComponentCostEntry[];

declare function createInteractionReport(name: string, session: SessionExportData, startedAt?: string): InteractionReport;
declare function compareInteractionReports(baseline: InteractionReport, candidate: InteractionReport): InteractionComparison;
declare function formatInteractionReportMarkdown(report: InteractionReport): string;
declare function formatInteractionReportHtml(report: InteractionReport): string;

declare function scan(options?: AngularRenderScanOptions): void;
declare function setOptions(options: Partial<AngularRenderScanOptions>): void;
declare function getOptions(): AngularRenderScanResolvedOptions;
declare function stop(): void;
declare function getSignalDependencyGraph(): SignalDependencyGraph;
declare function getOnPushCandidates(threshold?: number): OnPushCandidate[];
declare function getReferentialInstability(minUnstable?: number): ReferentialInstabilityReport[];
declare function getZonePollutionEvents(): ZonePollutionEvent[];
declare function getCdGraph(): CdGraph;
declare function getAIPrompt(fps?: number): string;
declare function copyAIPrompt(fps?: number): Promise<boolean>;
declare function getSessionData(): SessionExportData;
/** Start a named, user-visible interaction capture. Only subsequent cycles are included. */
declare function beginInteraction(name: string): void;
/** Finish the active interaction and return ranked, portable evidence. */
declare function endInteraction(): InteractionReport;
declare function getInteractionReport(): InteractionReport | undefined;
declare function setInteractionBaseline(report: InteractionReport): void;
declare function compareWithInteractionBaseline(report?: InteractionReport | undefined): InteractionComparison;

declare const ANGULAR_RENDER_SCAN_OPTIONS: InjectionToken<AngularRenderScanOptions>;
declare class AngularRenderScanMarkDirective implements OnDestroy {
    private readonly element;
    private readonly parent;
    private readonly id;
    private checkStartedAt;
    private childrenDuration;
    private name;
    readonly angularRenderScanMark: i0.InputSignal<string | undefined>;
    constructor();
    ngDoCheck(): void;
    ngAfterViewChecked(): void;
    ngOnDestroy(): void;
    private register;
    private inferName;
    static ɵfac: i0.ɵɵFactoryDeclaration<AngularRenderScanMarkDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AngularRenderScanMarkDirective, "[angularRenderScanMark]", never, { "angularRenderScanMark": { "alias": "angularRenderScanMark"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare function provideAngularRenderScan(options?: AngularRenderScanOptions): EnvironmentProviders;
declare function restoreApplicationRef(appRef: ApplicationRef): void;

interface RenderAuditPage {
    evaluate<Result>(pageFunction: () => Result | Promise<Result>): Promise<Awaited<Result>>;
    evaluate<Result, Argument>(pageFunction: (argument: Argument) => Result | Promise<Result>, argument: Argument): Promise<Awaited<Result>>;
}
interface RenderAuditReport {
    rendersFor(name: string): Promise<number>;
    maxDurationFor(name: string): Promise<number>;
    wastedRenderPercentage(): Promise<number>;
    budgetViolations(): Promise<BudgetViolation[]>;
    sessionData(): Promise<SessionExportData>;
    interactionReport(): Promise<InteractionReport>;
    compareWith(baseline: InteractionReport): Promise<InteractionComparison>;
    toMarkdown(): Promise<string>;
    toHtml(): Promise<string>;
}
interface RenderAuditSession {
    stop(): Promise<RenderAuditReport>;
}
/** Starts a named, Playwright-compatible interaction audit. */
declare function startRenderAudit(page: RenderAuditPage, name?: string): Promise<RenderAuditSession>;

export { ANGULAR_RENDER_SCAN_OPTIONS, AngularRenderScanMarkDirective, beginInteraction, compareInteractionReports, compareWithInteractionBaseline, copyAIPrompt, createInteractionReport, endInteraction, formatInteractionReportHtml, formatInteractionReportMarkdown, getAIPrompt, getCdGraph, getComponentCostEntries as getComponentCostAnalysis, getDetachedComponents, getInteractionReport, getLeakedComponents, getOnPushCandidates, getOptions, getReferentialInstability, getSessionData, getSignalDependencyGraph, getWastedStats, getZonePollutionEvents, provideAngularRenderScan, restoreApplicationRef, scan, setInteractionBaseline, setOptions, startRenderAudit, stop };
export type { AngularRenderChangedInput, AngularRenderCycle, AngularRenderEntry, AngularRenderMutationType, AngularRenderReason, AngularRenderScanBudgets, AngularRenderScanOptions, BudgetViolation, CdGraph, CdGraphEdge, CdGraphNode, CdTriggerAttribution, CdTriggerSource, ComponentCostEntry, InteractionComparison, InteractionFinding, InteractionFindingKind, InteractionFindingSeverity, InteractionMetricDelta, InteractionMetrics, InteractionReport, OnPushCandidate, ReferentialInstabilityReport, RenderAuditReport, RenderAuditSession, SessionExportData, SignalDependencyGraph, WastedStats, WaterfallEntry, ZonePollutionEvent, ZonePollutionEvent as ZonePollutionEventType };
//# sourceMappingURL=angular-render-scan.d.ts.map