import * as i0 from '@angular/core';
import { InjectionToken, Type, AfterViewInit, OnDestroy, ElementRef, EventEmitter, NgZone, OnInit, OnChanges, SimpleChanges, ApplicationRef, EnvironmentInjector, ModuleWithProviders } from '@angular/core';
import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
import * as i21 from '@angular/router';
import { Router } from '@angular/router';
import { Backend } from '@blueriq/angular/backend/common';
import * as rxjs from 'rxjs';
import { Observable, Subject } from 'rxjs';
import { Element } from '@blueriq/core';
import { Session, SessionRegistry } from '@blueriq/angular';
import { ElementTemplate } from '@blueriq/core/testing';
import * as i19 from '@angular/common';
import * as i20 from '@angular/forms';

interface BqLensSectionConfig {
    /** Header label and uniqueness key for open/close state. */
    label: string;
    /** Icon name from the bundled bq-icon registry (e.g. 'cog', 'crosshairs'). */
    icon?: string;
    /** Component rendered inside the section body. Standalone or declared. */
    component: Type<unknown>;
    /** If true, section starts open. Default false. */
    initiallyOpen?: boolean;
}
interface BqLensConfig {
    /** Defaults to `!isDevMode()` from @angular/core. Override for non-standard build setups. */
    production?: boolean;
    /** Defaults to the active Blueriq runtime's base URL via SessionRegistry. Override for multi-runtime setups. */
    blueriqBaseUrl?: string;
    title?: string;
    /** Floating tab label. Trimmed to 4 characters. */
    tabLabel?: string;
    /** Host-defined collapsible sections rendered above the main tab switcher. */
    extraSections?: BqLensSectionConfig[];
    /** Initial panel primary color (any CSS color). Mutable later via DevColorsService. */
    primaryColor?: string;
    /** Initial panel secondary color (any CSS color). Mutable later via DevColorsService. */
    secondaryColor?: string;
    /** When true, every element inside the panel renders with `border-radius: 0` — useful for hosts whose design language is square/flat. */
    flatCorners?: boolean;
}
declare const BQ_LENS_CONFIG: InjectionToken<BqLensConfig>;

interface CaptureEntry {
    id: string;
    method: string;
    url: string;
    timestamp: string;
    status: number;
    duration_ms?: number | null;
    requestBody?: any;
    responseBody?: any;
}
interface ElementTreeNode {
    key: string;
    type: string;
    label: string;
    styles: string[];
    children: ElementTreeNode[];
    totalDescendants: number;
    truncated?: boolean;
}
interface PageContext {
    breadcrumb: string[];
    title: string | null;
    statusChips: Array<{
        text: string;
        chipStyle: string;
    }>;
    activeTab: string | null;
    pageFunctionalName: string | null;
}
interface PageSection {
    displayName: string;
    contentStyle: string;
    fieldCount: number;
    buttonCount: number;
}
interface TableSummary {
    name: string | null;
    displayName: string | null;
    contentStyle: string;
    rowCount: number;
}
type CacheEventType = 'clear' | 'skip' | 'parse-error' | 'quota' | 'integrity-violation' | 'slow-merge';
interface CacheEvent {
    type: CacheEventType;
    ts: number;
    detail?: unknown;
}
/**
 * Capture metadata threaded through merge → absorb so an element can
 * record which capture(s) supplied it (`__sources`/`__capturedIn`) and
 * stamp history entries with the originating capture. Optional everywhere
 * because direct `mergeElements(parsed)` calls (fixture replay, fuzz
 * harnesses) don't have a capture context.
 */
interface CaptureMeta {
    captureId?: string;
    url?: string;
    ts?: number;
}
/**
 * Read-only counters surfaced by the Internals panel. Shape is shared
 * between the panel component and any future consumer (e.g. a headless
 * health-check probe) so changes to the counter set fan out via this type.
 * Name kept as `HealthCounters` because the data is health-flavoured —
 * cached/tombstoned counts, integrity violations, slow-merge counts —
 * even though the surface that renders it is now called Internals.
 */
interface HealthCounters {
    cached: number;
    tombstoned: number;
    parentLinks: number;
    cacheEvents: number;
    slowMerges: number;
    integrityViolations: number;
    templateMemoSize: number;
    templateMemoHitRate: number;
    templateMemoEvictions: number;
}
interface Tombstone {
    key: string;
    element: any;
    deletedAt: number;
}
/**
 * A "looks wrong" finding surfaced by the insights panel. Each anomaly is
 * a high-confidence authoring smell or contradiction — clear enough to
 * mention by name, narrow enough that it shouldn't fire on healthy pages.
 *
 * `severity` controls visual weight only (warn = clearly broken, info =
 * suspect / worth confirming). `refs` carries up to a handful of
 * human-readable identifiers (button captions, field labels, section
 * names) so the dev can locate the offender without re-querying.
 */
interface PageAnomaly {
    severity: 'warn' | 'info';
    category: string;
    message: string;
    detail?: string;
    refs?: string[];
}
/**
 * One reason a picked element is in its current state — disabled,
 * read-only, blocked by a validation, etc. Surfaced as a "Why blocked?"
 * row in the inspector popup so the dev doesn't need to read the raw JSON
 * to figure out why a button refuses to fire.
 *
 * `severity` drives the row's colour: `error` for hard blockers,
 * `warn` for likely-but-soft issues, `info` for explanatory context.
 */
interface BlockerReason {
    severity: 'error' | 'warn' | 'info';
    icon: string;
    text: string;
    hint?: string;
}
/**
 * A single change discovered when comparing two `CaptureAnalysis` objects.
 * Lifted from raw element graph diffing because the analysis surface — fields
 * by `functionalKey`, sections by `displayName`, tables by `name` — aligns
 * better with how a dev thinks about page state than DOM-level keys do.
 */
interface AnalysisDiffEntry {
    kind: 'added' | 'removed' | 'modified';
    category: 'field' | 'button' | 'section' | 'table' | 'link' | 'page-context';
    identity: string;
    changes?: Array<{
        attr: string;
        before: unknown;
        after: unknown;
    }>;
}
interface CaptureAnalysis {
    responseType: 'session' | 'start' | 'other';
    page: {
        key: string;
        name: string | null;
        displayName: string | null;
    } | null;
    counts: Record<string, number>;
    totalElements: number;
    messages: Array<{
        key: string;
        message: string;
    }>;
    buttons: Array<{
        caption: string;
        disabled: boolean;
        validate: boolean;
        styles: string[];
        contentStyle?: string;
    }>;
    links: Array<{
        caption: string;
        url?: string;
        styles: string[];
    }>;
    fields: Array<{
        name: string | null;
        questionText: string | null;
        functionalKey: string;
        dataType?: string;
        values: any[];
        editable: boolean;
        required?: boolean;
        refresh?: boolean;
        styles: string[];
        contentStyle?: string;
        validations: Array<{
            blocking: boolean;
            type: string;
            message: string;
            parameters?: any;
        }>;
        fieldMessages: Array<{
            type: string;
            text: string;
        }>;
    }>;
    styles: string[];
    contentStyles: string[];
    sessionId?: string;
    pageContext: PageContext | null;
    sections: PageSection[];
    tables: TableSummary[];
    triggeredBy: string | null;
}

/**
 * Best-effort classification of a captured response body. Detection is purely
 * shape-based — Angular's HttpClient hands us already-parsed objects for
 * Content-Type: application/json, and raw strings for everything else, so we
 * key off `typeof` plus a leading-`<` heuristic for HTML. Misses pathological
 * cases like JSON served as text/plain; for Blueriq those don't happen.
 */
type BodyKind = 'json' | 'html' | 'text' | 'empty';

interface DiffLine {
    type: 'add' | 'remove' | 'same';
    text: string;
}
interface FieldChange {
    field: string;
    before: any;
    after: any;
}
interface SemanticChange {
    kind: 'added' | 'removed' | 'modified';
    key: string;
    type: string;
    label: string;
    changes?: FieldChange[];
}
interface DiffHunk {
    lines: DiffLine[];
    hiddenBefore: number;
}

interface SearchField {
    value: string;
    weight: number;
}
interface SearchFilters {
    types?: string[];
    styles?: string[];
    hasErrors?: boolean;
    required?: boolean;
    readonly?: boolean;
}
interface FilterableElement {
    type: string;
    styles: string[];
    hasErrors: boolean;
    required: boolean;
    readonly: boolean;
}
declare class DevSearchService {
    score<T extends {
        searchFields: SearchField[];
    } & Partial<FilterableElement>>(elements: T[], query: string, limit?: number, filters?: SearchFilters): T[];
    hasActiveFilters(filters: SearchFilters): boolean;
    private applyFilters;
    private scoreElement;
    private bestTokenScore;
    private scoreToken;
    private matchesWordBoundary;
    private fuzzyScore;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevSearchService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DevSearchService>;
}

interface SearchableElement {
    key: string;
    type: string;
    name: string;
    styles: string[];
    hasErrors: boolean;
    required: boolean;
    readonly: boolean;
    searchFields: SearchField[];
}
declare class DevElementSearchComponent implements AfterViewInit, OnDestroy {
    private searchService;
    searchInput: ElementRef<HTMLInputElement>;
    elements: SearchableElement[];
    elementSelected: EventEmitter<string>;
    elementPreviewed: EventEmitter<string>;
    closed: EventEmitter<void>;
    query: string;
    activeIndex: number;
    filters: SearchFilters;
    readonly toggleFilters: {
        id: "hasErrors" | "required" | "readonly";
        label: string;
    }[];
    private previewTimer;
    private scrollTimer;
    constructor(searchService: DevSearchService);
    previewAfterDelay(key: string): void;
    ngAfterViewInit(): void;
    get results(): SearchableElement[];
    get availableTypes(): string[];
    isTypeActive(type: string): boolean;
    toggleType(type: string): void;
    toggleFlag(id: 'hasErrors' | 'required' | 'readonly'): void;
    clearFilters(): void;
    hasActiveFilters(): boolean;
    onQueryChange(q: string): void;
    select(key: string): void;
    onKeydown(e: KeyboardEvent): void;
    private scrollActiveIntoView;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevElementSearchComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DevElementSearchComponent, "app-dev-element-search", never, { "elements": { "alias": "elements"; "required": false; }; }, { "elementSelected": "elementSelected"; "elementPreviewed": "elementPreviewed"; "closed": "closed"; }, never, never, false, never>;
}

declare class DevBaseUrlService {
    private config;
    private backend;
    private learned;
    private readonly _learned$;
    /** Fires once when sniffing locks in a base URL. Lets the interceptor replay any requests it buffered before learning. */
    readonly learned$: Observable<string>;
    constructor(config: BqLensConfig, backend: Backend | null);
    /** Resolved base URL, or '' when no source is available yet. */
    get(): string;
    /** Inspect an outgoing URL; if it matches a Blueriq shape, lock in the prefix. */
    observe(url: string): void;
    private lockIn;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevBaseUrlService, [null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DevBaseUrlService>;
}

interface StorageEvent {
    type: 'open-error' | 'open-blocked' | 'load-error' | 'save-error' | 'disabled' | 'ready' | 'cleared';
    ts: number;
    detail?: unknown;
}
declare class DevCacheStorageService {
    private readonly tabId;
    private db;
    private dbAvailable;
    private _ready$;
    readonly ready$: Observable<boolean>;
    private pendingCaptures;
    private debounceHandle;
    private storageEvents;
    constructor();
    getStorageEvents(): readonly StorageEvent[];
    getTabId(): string;
    private record;
    private openDb;
    /**
     * Returns this tab's persisted captures, newest-first. Filters by tabId so
     * sibling tabs' histories don't bleed in. Schema mismatches are dropped
     * (and surfaced in storage events) so a future schema bump can recover.
     */
    loadCaptures(): Promise<CaptureEntry[]>;
    /**
     * Schedules a debounced rewrite of this tab's captures. Repeated calls
     * within the debounce window collapse into a single IDB transaction —
     * the live capture path can fire 5 times in 200ms and we still only
     * pay one persistence cost.
     */
    saveCaptures(entries: CaptureEntry[]): void;
    private flushCaptures;
    /**
     * Lazy fetch of a single capture's full body, for the inspector's
     * "view raw body" affordance when callers want to deal with a stub
     * rather than pay the eager-join cost.
     */
    getFullBody(captureId: string): Promise<unknown | null>;
    loadDismissed(): Promise<Set<string>>;
    saveDismissed(ids: Set<string>): void;
    /**
     * Clears this tab's captures and dismissed set. Other tabs' state is
     * untouched — a "Clear" in tab A must not nuke tab B's history.
     */
    clear(): Promise<void>;
    private metaKey;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevCacheStorageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DevCacheStorageService>;
}

type BqRequestKind = 'start project' | 'start task' | 'start flow' | 'load session' | 'refresh' | 'end session' | 'request';
declare class DevCaptureService {
    private readonly storage;
    private _captures$;
    readonly captures$: Observable<CaptureEntry[]>;
    private _lastKeepalive$;
    readonly lastKeepalive$: Observable<Date | null>;
    private _dismissedErrorIds$;
    private _lastFatalError$;
    readonly fatalError$: Observable<CaptureEntry | null>;
    readonly inflightError$: Observable<CaptureEntry | null>;
    readonly hydrated$: Observable<boolean>;
    captureActive: boolean;
    constructor(storage: DevCacheStorageService);
    private hydrate;
    recordKeepalive(): void;
    /**
     * Most recent capture in the rolling FIFO whose responseBody contains the
     * given element key — either as a top-level `elements[].key` (load /
     * refresh / start_*) or as an `events[].changes.changes[]` add with a
     * matching `model.key`. Used to backlink the inspector to its sourcing
     * capture. Returns null if the capture has rolled off or never existed.
     */
    findCaptureForElement(elementKey: string): CaptureEntry | null;
    get captures(): CaptureEntry[];
    /**
     * Dismiss every active error notification at once. Clears the sticky fatal
     * slot outright (so even a future re-emission with the same id stays gone),
     * and marks every currently-known critical capture as dismissed so the
     * inflight banner doesn't pop back up for failures the user already saw.
     * One dismiss = silence everything until something genuinely new fails.
     */
    dismissAllErrors(): void;
    logCapture(entry: CaptureEntry): void;
    toggleCapture(): void;
    clearCaptures(): void;
    /**
     * Walk captures newest-first; return the first fatal start failure unless
     * a successful start appears later (i.e. earlier in the list, since list
     * is newest-first). Used to seed the sticky slot from persisted state.
     */
    private deriveFatalFromCaptures;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevCaptureService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DevCaptureService>;
}

/**
 * Owns the BqLens panel's primary and secondary colors as runtime CSS custom
 * properties. Hosts call setters to recolor the panel — BqLens itself stays
 * domain-agnostic and knows nothing about themes.
 */
declare class DevColorsService {
    constructor(config: BqLensConfig | null);
    setPrimary(color: string): void;
    setSecondary(color: string): void;
    setColors(primary?: string, secondary?: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevColorsService, [{ optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DevColorsService>;
}

declare class DevElementCacheService {
    private static readonly MAX_CACHE_EVENTS;
    private static readonly MAX_TREE_DEPTH;
    private static readonly MAX_TOMBSTONES;
    private static readonly MAX_SESSION_LOADS;
    private static readonly SLOW_MERGE_MS;
    private static readonly MAX_HISTORY;
    private static readonly MAX_PROVENANCE;
    private elementCache;
    private sessionLoadJsons;
    private cacheEvents;
    private parentOf;
    private childrenOf;
    private tombstones;
    private versions;
    private hasRehydrated;
    private lastCaptureSketch;
    clearCache(): void;
    /**
     * Monotonic per-key revision counter. Bumped on every absorb / tombstone,
     * never decreases. Returns 0 for keys that have never been written. Pair
     * with `${key}:${version}` to memoize anything derived from an element
     * (template generation, structural rollups, inspector summaries).
     */
    getCacheVersion(key: string): number;
    private bumpVersion;
    getCacheEvents(): readonly CacheEvent[];
    clearCacheEvents(): void;
    private cacheEvent;
    private parseLogged;
    getElement(key: string, options?: {
        includeTombstoned?: boolean;
    }): any;
    getTombstone(key: string): Tombstone | undefined;
    allTombstones(): readonly Tombstone[];
    /**
     * Snapshot of the parent/child topology, ready for graph rendering.
     *
     * - With a `rootKey`, walks descendants starting from that key (BFS).
     *   Use this for the inspector-popup graph view scoped to a single subtree.
     * - Without a `rootKey`, returns the full topology (every element with a
     *   parent link). Use this for the top-level page graph.
     *
     * Returns plain arrays — the graph component doesn't need Map semantics, and
     * arrays serialize cleanly if we ever export the graph.
     *
     * Tombstones are off by default; pass `{ includeTombstoned: true }` when
     * investigating "what got deleted".
     */
    getGraphSnapshot(rootKey?: string, options?: {
        includeTombstoned?: boolean;
    }): {
        nodes: {
            key: string;
            type: string;
            label: string;
            styles: string[];
            tombstoned: boolean;
        }[];
        edges: {
            from: string;
            to: string;
        }[];
    };
    rehydrateFromCaptures(captures: readonly CaptureEntry[]): void;
    warmCache(entry: CaptureEntry): void;
    mergeElements(parsed: any, options?: {
        transactional?: boolean;
        captureMeta?: CaptureMeta;
    }): void;
    private applyMerge;
    /**
     * Walks the parsed payload to enumerate every element key it would write,
     * plus the keys of any children it references — those are the cells the
     * snapshot has to capture so a rollback can reconstruct prior state.
     * Cheap (no merge), runs once before the apply.
     */
    private collectTouchedKeys;
    private snapshotKeys;
    private restoreSnapshot;
    /**
     * Post-merge audit limited to the touched-keys set. Detects orphans
     * (child reference with no element + no tombstone) and cycles via
     * parentOf chain. Multi-parent is auto-healed in updateParentLinks
     * already and reported there, so we don't double-flag it.
     */
    private auditTouchedKeys;
    private computeBodySketch;
    private extractChanges;
    private absorbElement;
    private updateParentLinks;
    private tombstoneFromCache;
    private evictExcessTombstones;
    maybeSynthesizeLoad(parsed: any, url: string): void;
    private evictExcessSessionLoads;
    buildTemplateJson(selectedJson: string, selectedCaptureUrl: string | null): string;
    withMergedElements(json: string): string;
    /**
     * Enriched JSON rooted at a *specific* capture's response — same shape
     * `_showFromLoadJson` consumes. The capture's elements drive the root set;
     * the global cache fills in descendants. For event-shaped responses, only
     * freshly-added elements are surfaced. Returns null if the capture has no
     * usable element data.
     */
    enrichedJsonForCapture(entry: CaptureEntry): string | null;
    enrichedLoadJson(): string | null;
    buildTree(key: string, depth?: number, visited?: Set<string>): ElementTreeNode;
    buildEnrichedJson(key: string, depth?: number, visited?: Set<string>): any;
    collectElementWithDescendants(key: string, visited?: Set<string>): any[];
    allElements(): any[];
    /**
     * Read-only snapshot of the structural state for off-thread auditing.
     * Returns shallow copies so the audit pass can iterate without racing
     * a concurrent merge. Cheap (one Map clone + one Object.keys) — meant
     * to be called from `requestIdleCallback`, not the live capture path.
     */
    getStructureSnapshot(): {
        elementKeys: ReadonlySet<string>;
        parentOf: ReadonlyMap<string, string>;
        childrenOf: ReadonlyMap<string, ReadonlySet<string>>;
        tombstoneKeys: ReadonlySet<string>;
    };
    /**
     * Surface a structure-audit finding through the regular cacheEvent ring.
     * The audit service runs out-of-band, but we want one merged event log
     * so the internals panel doesn't have to subscribe to two sources.
     */
    reportIntegrityViolation(detail: unknown): void;
    buildBreadcrumbsFromKey(key: string): Array<{
        key: string;
        type: string;
        name: string;
    }>;
    private mergeIntoMap;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevElementCacheService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DevElementCacheService>;
}

declare class DevStructureAuditService implements OnDestroy {
    private readonly cache;
    private readonly zone;
    private intervalHandle;
    private idleHandle;
    private readonly idle;
    private running;
    private lastSummary;
    constructor(cache: DevElementCacheService, zone: NgZone);
    /**
     * Start the periodic audit. Idempotent — calling twice keeps a single
     * timer. Runs outside Angular's zone so the periodic tick doesn't kick
     * change detection on every fire.
     */
    start(): void;
    stop(): void;
    ngOnDestroy(): void;
    /**
     * Run an audit pass synchronously. Exposed so the Internals panel can
     * offer a "force audit now" button without waiting for the next interval.
     * Returns the summary so the caller can render it inline.
     */
    runNow(): {
        violations: number;
        checked: number;
    };
    getLastSummary(): {
        ts: number;
        violations: number;
        checked: number;
    } | null;
    private scheduleAudit;
    private runAudit;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevStructureAuditService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DevStructureAuditService>;
}

declare class DevTemplateCacheService {
    private readonly cache;
    private memo;
    private hits;
    private misses;
    private evictions;
    constructor(cache: DevElementCacheService);
    /**
     * Returns the memoized template for `key`, or `null` if absent. Touch
     * (re-insert) on hit so eviction lands on genuinely cold entries.
     */
    get(key: string): string | null;
    /**
     * Memoize `value` for `key` at the current cache version. Evicts the
     * oldest entry when the limit is reached and reports the quota event
     * back through the cache's event ring.
     */
    set(key: string, value: string): void;
    /**
     * Invalidate every memoized template — invoked when the cache resets,
     * since cacheVersion 0 → 0 wouldn't otherwise expire stale entries.
     */
    clear(): void;
    /**
     * Diagnostic snapshot for the Internals panel — read-only.
     */
    stats(): {
        size: number;
        hits: number;
        misses: number;
        evictions: number;
        hitRate: number;
    };
    private versionedKey;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevTemplateCacheService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DevTemplateCacheService>;
}

declare class DevFormatService {
    private sanitizer;
    constructor(sanitizer: DomSanitizer);
    formatTemplate(code: string): string;
    highlightJson(json: string): SafeHtml;
    highlightStory(code: string): SafeHtml;
    renderMarkdown(md: string): SafeHtml;
    highlightHtml(html: string): SafeHtml;
    highlightTemplate(code: string): SafeHtml;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevFormatService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DevFormatService>;
}

interface PickedElement {
    element: Element;
    host: HTMLElement;
}
declare class DevPickerService {
    private zone;
    readonly picked$: Subject<PickedElement>;
    isActive: boolean;
    private hoverNode;
    private overlay;
    constructor(zone: NgZone);
    activate(): void;
    deactivate(): void;
    showOverlay(el: HTMLElement, mode?: 'hover' | 'selected'): void;
    animateOverlay(): void;
    removeOverlay(): void;
    flashOverlay(): void;
    updateOverlayRect(el: HTMLElement): void;
    positionPopup(hostEl: HTMLElement, popupW?: number, popupH?: number, preferredSide?: 'left' | 'right' | null, excludeRect?: {
        left: number;
        right: number;
    } | null): {
        left: number;
        top: number;
        side: 'left' | 'right';
    };
    scrollToHostIfNeeded(host: HTMLElement): void;
    getComponentClass(el: HTMLElement): Function | null;
    getAngularSelector(cls: Function): string | null;
    private readonly _loggedClasses;
    /**
     * Returns the fully-qualified Blueriq selector for the picked class —
     * `<type><matcher>`, e.g. `field[contentStyle=hint]`. Composed from the two
     * columns of Blueriq's component registry dump:
     *
     *   - `elementType` (lowercased) — always present, gives the element-type
     *     prefix even when the registered matcher omitted it.
     *   - `selector` — the `matcher.toString()` value, or undefined when the
     *     component matches purely by element type.
     *
     * If the matcher already starts with the type prefix, the prefix is not
     * doubled. If there's no matcher, the bare lowercased element type is
     * returned (e.g. `textitem`) — that *is* the selector for that registration.
     *
     * Returns null only when the class isn't in the registry (non-Blueriq
     * component, or the dump hasn't fired — typically because Blueriq's
     * `logComponents` is off or Angular dev mode was stripped at build time).
     * Each distinct miss is logged once per class for diagnostics.
     */
    getBlueriqSelector(_host: HTMLElement, cls: Function): string | null;
    /** The Blueriq registry priority for `cls`, or null if not registered or
     *  the priority column was missing from the dump. */
    getBlueriqSelectorPriority(cls: Function): number | null;
    private _logSelectorMiss;
    getBlueriqTypeOf(el: HTMLElement): string | null;
    findElementAndHost(target: HTMLElement): {
        element: Element | null;
        host: HTMLElement;
    };
    findHostByKey(key: string, root: HTMLElement): HTMLElement | null;
    /**
     * Walks `root`'s DOM descendants and yields the immediate Blueriq
     * children — the first Blueriq element encountered along each
     * downward path. Used by the inspector's background warm to seed
     * the template memo for likely next-navigations. Bounded so a
     * pathologically-deep host doesn't camp the idle tick.
     */
    findImmediateBlueriqChildren(root: HTMLElement, limit?: number): Array<{
        element: Element;
        host: HTMLElement;
    }>;
    findCurrentPageWithHost(): {
        element: Element;
        host: HTMLElement;
    } | null;
    private blueriqElementOf;
    private readonly onPickerClick;
    private readonly onPickerMove;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevPickerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DevPickerService>;
}

type ElementViewMode = 'template' | 'json' | 'insights' | 'structure' | 'story';
type Breadcrumb = {
    key: string;
    type: string;
    name: string;
};
/**
 * Owns all element-inspector state: the popup's currently inspected element,
 * its multiple view modes (template / json / insights / structure / story),
 * navigation history, breadcrumbs, picker overlay tracking, and scroll-follow.
 *
 * Provided at the BqLensComponent level so its lifecycle is bound to the
 * panel's lifetime — ngOnDestroy detaches the global scroll listener.
 */
declare class DevInspectorService implements OnDestroy {
    private zone;
    private pickerService;
    private cacheService;
    private formatService;
    private templateCache;
    inspectedElement: Element | null;
    inspectedHostEl: HTMLElement | null;
    hasParentElement: boolean;
    parentNavKey: number;
    inspectedComponentName: string | null;
    inspectedComponentClass: string | null;
    inspectedBlueriqSelector: string | null;
    inspectedBlueriqSelectorPriority: number | null;
    treeCollapsedKeys: Set<string>;
    elementViewMode: ElementViewMode;
    elementTemplate: string | null;
    elementJson: string | null;
    elementTree: ElementTreeNode | null;
    elementStoryCode: string | null;
    highlightedElementTemplate: SafeHtml | null;
    highlightedElementJson: SafeHtml | null;
    highlightedElementStory: SafeHtml | null;
    popupPos: {
        left: number;
        top: number;
    } | null;
    /** When true, scroll-follow won't re-position the popup. Reset on next inspection. */
    private _popupManuallyPositioned;
    /** Cached side chosen at first placement. Scroll-follow reuses this so sub-pixel
     * wobble around the fits-right/fits-left boundary doesn't flip the popup. */
    private _popupSide;
    breadcrumbs: Breadcrumb[];
    storyProvidersPath: string;
    elementCopied: boolean;
    private _navHistory;
    private _historyPos;
    private _scrollRaf;
    private _warmIdleHandle;
    private _warmTimeoutHandle;
    private _warmCancelToken;
    /** Emits each time the picker hands a fresh element to the inspector. */
    private readonly _inspected$;
    readonly inspected$: Observable<void>;
    readonly onTreeNodeSelect: (key: string) => void;
    readonly onTreeNodeToggle: (key: string) => void;
    constructor(zone: NgZone, pickerService: DevPickerService, cacheService: DevElementCacheService, formatService: DevFormatService, templateCache: DevTemplateCacheService);
    ngOnDestroy(): void;
    get canGoBack(): boolean;
    get canGoForward(): boolean;
    get elementInsightsData(): CaptureAnalysis | null;
    /**
     * Read the cached element's bounded `__history` ring directly (without the
     * `stripInternalFields` pass that scrubs `elementJson`). Returns the entries
     * verbatim — oldest first, capped at 10 by the cache. Empty array if the
     * element isn't cached or has never changed value.
     */
    get elementHistory(): Array<{
        ts: number;
        value: unknown;
        captureId?: string;
    }>;
    /** URLs that touched this element. Empty when uncached or never observed. */
    get elementSources(): string[];
    /** Capture ids that touched this element. */
    get elementCapturedIn(): string[];
    /** Picker callback: apply the new element and record it in history + breadcrumbs. */
    applyAndPushHistory(host: HTMLElement, element: Element): void;
    selectParentElement(): void;
    navigateBack(): void;
    navigateForward(): void;
    selectElementByKey(key: string): void;
    copyInspectedElement(): Promise<void>;
    closeInspector(): void;
    updateStoryProvidersPath(path: string): void;
    /** Navigate to a key without pushing to history (used by back/forward). */
    private _navigateToKey;
    /**
     * Core "show this element in the inspector" sequence used by all navigation
     * paths (parent, back/forward, tree, breadcrumb, and picker). Callers are
     * responsible for parentNavKey++, history push, and breadcrumb rebuild.
     */
    private _applyElement;
    /**
     * Schedule background generation of templates for likely next-navigations
     * — the parent (back button) and immediate children (drill-down). Runs
     * via `requestIdleCallback` so the active inspection's renderer has the
     * main thread first; falls back to `setTimeout` where rIC isn't shipped.
     * Cancellable: a new `_applyElement` call flips the token before the
     * warm runs to completion, and the in-flight generation sees
     * `cancelled = true` at its next recursion boundary.
     */
    private _scheduleWarm;
    private _cancelWarm;
    private _pushHistory;
    private _buildBreadcrumbs;
    /**
     * Show element details from the cache when the live DOM host cannot be found.
     * Works for JSON / insights / structure views; template requires a live element
     * so we fall back to JSON when that mode is active.
     */
    private _showElementFromCache;
    /** After navigating to a new element, fall back to JSON if the current view mode has no content. */
    private _fixViewModeAfterNav;
    private generateElementInfo;
    private _recomputeElementTree;
    private _storyConfig;
    private positionPopup;
    /** External callers (e.g. cross-ref jumps) can pin the popup; scroll-follow respects this until next inspection. */
    setManualPopupPos(pos: {
        left: number;
        top: number;
    }): void;
    private readonly _onScroll;
    private _attachScrollFollow;
    private _detachScrollFollow;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevInspectorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DevInspectorService>;
}

type TourId = 'main' | 'inspector';
interface TourStep {
    target: string | null;
    title: string;
    body: string;
    placement?: 'right' | 'left' | 'top' | 'bottom';
    wireframe?: string;
}
declare class DevTourService {
    private readonly _currentIndex$;
    readonly currentIndex$: rxjs.Observable<number>;
    private _activeTour;
    /** Steps of the active tour, or the main tour as a fallback for callers
     *  that read steps before any tour starts. */
    get steps(): ReadonlyArray<TourStep>;
    get activeTour(): TourId | null;
    get currentIndex(): number | null;
    get currentStep(): TourStep | null;
    get isActive(): boolean;
    get totalSteps(): number;
    /** True when the developer has finished or skipped the given tour. */
    isDone(id?: TourId): boolean;
    /** Start the given tour at step 0. No-op if a tour is already running. */
    start(id?: TourId): void;
    next(): void;
    back(): void;
    /** User dismissed before completion. Persist done flag so we don't pester. */
    skip(): void;
    /** User clicked through the last step. */
    finish(): void;
    /** Re-run the given tour from step 0, regardless of its done flag. */
    replay(id?: TourId): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevTourService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DevTourService>;
}

declare class BqLensComponent implements OnInit, OnDestroy {
    private zone;
    private config;
    private router;
    private el;
    private formatService;
    private captureService;
    private cacheService;
    private structureAudit;
    private templateCache;
    private pickerService;
    inspector: DevInspectorService;
    tour: DevTourService;
    private baseUrlService;
    readonly production: boolean;
    readonly modKey: string;
    readonly title: string;
    readonly tabLabel: string;
    readonly extraSections: BqLensSectionConfig[];
    readonly flatCorners: boolean;
    devEnabled: boolean;
    isOpen: boolean;
    newCaptureCount: number;
    largeView: boolean;
    helpOpen: boolean;
    pageTreemapOpen: boolean;
    helpHtml: SafeHtml | null;
    get isConnected(): boolean;
    get captureActive(): boolean;
    get captures(): CaptureEntry[];
    selectedCapture: CaptureEntry | null;
    selectedJson: string | null;
    highlightedJson: SafeHtml | null;
    bodyKind: BodyKind;
    loadingJson: boolean;
    copiedUrl: boolean;
    filterText: string;
    viewMode: 'json' | 'template' | 'insights' | 'request' | 'structure';
    statusFilter: 'all' | '2xx' | '4xx' | '5xx';
    selectedRequestBody: string | null;
    highlightedRequestBody: SafeHtml | null;
    curlCopied: boolean;
    pinnedCaptures: Set<string>;
    captureAnalysis: CaptureAnalysis | null;
    generatedTemplate: string | null;
    highlightedTemplate: SafeHtml | null;
    templateError: string | null;
    pageViewTitle: string | null;
    pageElementTree: ElementTreeNode | null;
    routeInfo: Record<string, string> | null;
    contextTab: 'route' | 'env';
    sectionOpen: Record<string, boolean>;
    mainTab: 'captures' | 'sessions';
    internalsOpen: boolean;
    panelSide: 'left' | 'right';
    tabTop: number;
    isDragging: boolean;
    isSearchOpen: boolean;
    searchableElements: SearchableElement[];
    lastKeepaliveLabel: string | null;
    private lastKeepaliveDate;
    fatalError: CaptureEntry | null;
    fatalErrorKind: BqRequestKind | null;
    fatalErrorAgeLabel: string | null;
    inflightError: CaptureEntry | null;
    inflightErrorKind: BqRequestKind | null;
    inflightErrorAgeLabel: string | null;
    private errorPulseTimer;
    errorPulse: boolean;
    sourceCapture: CaptureEntry | null;
    isDiffMode: boolean;
    diffBaseCapture: CaptureEntry | null;
    diffResult: DiffLine[] | null;
    diffCompareCapture: CaptureEntry | null;
    private destroy$;
    private devKeyCount;
    private devKeyTimer;
    constructor(zone: NgZone, config: BqLensConfig, router: Router, el: ElementRef, formatService: DevFormatService, captureService: DevCaptureService, cacheService: DevElementCacheService, structureAudit: DevStructureAuditService, templateCache: DevTemplateCacheService, pickerService: DevPickerService, inspector: DevInspectorService, tour: DevTourService, _colors: DevColorsService, baseUrlService: DevBaseUrlService);
    /** Resolved at template-evaluation time so the auto-detected URL appears once the interceptor learns it. */
    get blueriqBaseUrl(): string;
    get isPickerActive(): boolean;
    ngOnInit(): void;
    private tourArmedForFirstOpen;
    /**
     * Subscribe-and-forget: fire the inspector tour the next time the picker
     * hands an element to the inspector. `take(1)` self-disposes; the
     * `tour.isActive` filter avoids colliding with an in-flight main tour.
     */
    private armInspectorTourOnNextPick;
    onKeydown(e: KeyboardEvent): void;
    onDblClick(e: MouseEvent): void;
    private subscribeToCaptures;
    private triggerErrorPulse;
    dismissAllErrors(): void;
    viewFatalErrorCapture(): void;
    viewInflightErrorCapture(): void;
    private openCapture;
    private formatErrorAge;
    get filteredCaptures(): CaptureEntry[];
    togglePin(id: string): void;
    togglePanel(): void;
    openPageTreemap(): void;
    closePageTreemap(): void;
    toggleHelp(): void;
    toggleInternals(): void;
    replayTour(): void;
    replayInspectorTour(): void;
    onTabDragStart(event: MouseEvent): void;
    flipSide(): void;
    toggleSection(key: string): void;
    toggleCapture(): void;
    clearCaptures(): void;
    viewCapture(entry: CaptureEntry): void;
    closeJson(): void;
    showPageFromCapture(entry: CaptureEntry | null): void;
    openSourcingCapture(entry: CaptureEntry): void;
    private movePopupAwayFromPanel;
    private scrollToElementInJsonViewer;
    private scrollAndFlash;
    get sourceCaptureForInspectedElement(): CaptureEntry | null;
    openLargeView(): void;
    jumpToLastError(): void;
    copyCurl(): Promise<void>;
    generateTemplate(): void;
    copyUrl(): Promise<void>;
    get routeInfoEntries(): {
        key: string;
        value: string;
    }[];
    togglePicker(): void;
    showCurrentPage(): void;
    private _showFromLoadJson;
    activatePicker(): void;
    deactivatePicker(): void;
    private navigateCaptures;
    startDiff(): void;
    private runDiff;
    closeDiff(): void;
    private _searchIndexStale;
    private _searchIndexEverOpened;
    private _searchIndexIdleHandle;
    private _searchIndexTimeoutHandle;
    /** Mark the index dirty and, if user has opened search before, schedule an idle rebuild. */
    private markSearchIndexStale;
    private rebuildSearchIndex;
    toggleSearch(): void;
    private resetCaptureView;
    /**
     * Run JsonToTemplatesComponent as a plain class against a load-response JSON string.
     * Returns the raw template string, or null when conversion fails or produces no output.
     */
    private _runConverter;
    private formatKeepaliveAge;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BqLensComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BqLensComponent, "bq-lens-panel", never, {}, {}, never, never, false, never>;
}

declare class DevSessionPanelComponent implements OnDestroy {
    private zone;
    private sessionRegistry;
    selectedSessionName: string | null;
    liveTree: ElementTreeNode | null;
    liveAnalysis: CaptureAnalysis | null;
    liveSelectedKey: string | null;
    liveTreeCollapsedKeys: Set<string>;
    private liveSubscription?;
    readonly onLiveTreeSelect: (key: string) => void;
    readonly onLiveTreeToggle: (key: string) => void;
    get liveSessions(): readonly Readonly<Session>[];
    constructor(zone: NgZone, sessionRegistry: SessionRegistry);
    selectLiveSession(name: string): void;
    private buildTreeFromSession;
    private elementToNode;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevSessionPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DevSessionPanelComponent, "app-dev-session-panel", never, {}, {}, never, never, false, never>;
}

/**
 * Diagnostic surface for the bq-lens storage layers — counters, the
 * cacheEvent ring, audit trigger, and rehydrate trigger. Read-only by
 * default; the action buttons are explicit and confirm-on-click for
 * the destructive ones.
 *
 * Rendered as a header-toggled overlay inside the main bq-lens panel,
 * sibling to (not a tab of) Captures/Sessions. The host listens for
 * `closed` to flip the toggle back. No external CSS dependencies —
 * uses the `dev-*` utility classes already present in `_panel-shell.scss`
 * plus the dedicated `_cache-internals.scss` partial.
 */
declare class DevCacheInternalsPanelComponent implements OnInit, OnDestroy {
    private readonly cache;
    private readonly captures;
    private readonly storage;
    private readonly audit;
    private readonly templateCache;
    closed: EventEmitter<void>;
    counters: HealthCounters;
    events: CacheEvent[];
    filterType: '' | CacheEventType;
    filterText: string;
    lastAuditSummary: {
        ts: number;
        violations: number;
        checked: number;
    } | null;
    private refreshHandle;
    constructor(cache: DevElementCacheService, captures: DevCaptureService, storage: DevCacheStorageService, audit: DevStructureAuditService, templateCache: DevTemplateCacheService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    refresh(): void;
    filteredEvents(): CacheEvent[];
    forceAudit(): void;
    forceRehydrate(): void;
    /**
     * Pack everything a teammate needs to reproduce a bug — captures, cache
     * snapshot (with internals stripped), structure graph, counters, the
     * cache-event ring, and the page tree rooted at whichever capture
     * sourced the most recent page render — into one downloadable JSON.
     *
     * Captures contain raw response bodies, so the bundle inherits whatever
     * sensitivity the captures had. The Export button's tooltip warns about
     * that explicitly.
     */
    exportBugBundle(): void;
    formatTime(ts: number): string;
    iconForEvent(type: string): string;
    formatDetail(detail: unknown): string;
    storageEvents(): readonly {
        type: string;
        ts: number;
        detail?: unknown;
    }[];
    tabId(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevCacheInternalsPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DevCacheInternalsPanelComponent, "app-dev-cache-internals-panel", never, {}, { "closed": "closed"; }, never, never, false, never>;
}

declare class DevTooltipDirective implements OnInit, OnDestroy {
    private tooltipEl;
    private tooltipTarget;
    private showTimer;
    private lastPos;
    ngOnInit(): void;
    ngOnDestroy(): void;
    private readonly onOver;
    private readonly onMove;
    private readonly onOut;
    private show;
    private position;
    private cancelPendingShow;
    private hide;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevTooltipDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DevTooltipDirective, "[appDevTooltip]", never, {}, {}, never, never, false, never>;
}

declare class DevElementTreeComponent {
    nodes: ElementTreeNode[];
    depth: number;
    onSelect: ((key: string) => void) | null;
    collapsedKeys: Set<string>;
    onToggle: ((key: string) => void) | null;
    selectedKey: string | null;
    handleRowClick(key: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevElementTreeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DevElementTreeComponent, "app-dev-element-tree", never, { "nodes": { "alias": "nodes"; "required": false; }; "depth": { "alias": "depth"; "required": false; }; "onSelect": { "alias": "onSelect"; "required": false; }; "collapsedKeys": { "alias": "collapsedKeys"; "required": false; }; "onToggle": { "alias": "onToggle"; "required": false; }; "selectedKey": { "alias": "selectedKey"; "required": false; }; }, {}, never, never, false, never>;
}

/** Hierarchical input. `weight` is computed bottom-up by the caller (1 + sum of child weights). */
interface TreemapNode {
    key: string;
    type: string;
    label: string;
    weight: number;
    children: TreemapNode[];
    tombstoned: boolean;
}
/** Flat layout output — one entry per visible node. Coordinates are in viewport pixels. */
interface LayoutRect {
    node: TreemapNode;
    x: number;
    y: number;
    w: number;
    h: number;
    depth: number;
}
/**
 * Squarified treemap (Bruls / Huijsen / van Wijk 2000).
 *
 * Recursively packs children into their parent rect using rows oriented along
 * the rect's shorter side. Greedily extends a row while doing so improves the
 * worst aspect ratio in that row; commits the row and recurses on the
 * remaining free space when adding the next child would degrade it.
 */
declare class DevTreemapLayoutService {
    layout(root: TreemapNode, viewW: number, viewH: number): LayoutRect[];
    private place;
    /**
     * Worst aspect ratio in the row if it were committed now. The cheaper of
     * `(w²·max)/sum²` (tall rects) and `sum²/(w²·min)` (wide rects) is the
     * standard formulation — see Bruls et al. for the derivation.
     */
    private worstAspect;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevTreemapLayoutService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DevTreemapLayoutService>;
}

declare class DevElementGraphComponent implements AfterViewInit, OnChanges, OnDestroy {
    private cache;
    private treemap;
    private zone;
    /** 'subtree' walks descendants from rootKey; 'page' renders the whole topology. */
    scope: 'subtree' | 'page';
    rootKey: string | null;
    /** Highlights the matching rect; lets the host drive a "current selection" in the treemap. */
    selectedKey: string | null;
    nodeSelected: EventEmitter<string>;
    hostRef: ElementRef<HTMLElement>;
    rects: LayoutRect[];
    hoveredKey: string | null;
    /** Drill-in stack: keys of containers we've zoomed into. Top = current root. */
    drillStack: string[];
    drillLabels: Map<string, string>;
    showErrors: boolean;
    showTombstones: boolean;
    hiddenTypes: Set<string>;
    knownTypes: string[];
    viewW: number;
    viewH: number;
    zoom: number;
    panX: number;
    panY: number;
    isPanning: boolean;
    private readonly minZoom;
    private readonly maxZoom;
    private readonly dragThreshold;
    private dragStart;
    private dragMoved;
    private suppressClick;
    private resizeObserver?;
    private rebuildScheduled;
    private labelFgCache;
    constructor(cache: DevElementCacheService, treemap: DevTreemapLayoutService, zone: NgZone);
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    /** Pull a fresh snapshot, build the tree, squarify. */
    rebuild(): void;
    private scheduleRebuild;
    private measure;
    /** The key the treemap should root at: top of drill stack overrides the input rootKey. */
    private activeRootKey;
    /** Convert flat snapshot to a TreemapNode tree. Returns null if root not found. */
    private buildTree;
    private computeWeights;
    resetLayout(): void;
    toggleType(t: string): void;
    toggleTombstones(): void;
    /** Resolved metadata for the currently hovered rect — pulled lazily from
     * the cache so the tooltip can show fields the layout snapshot doesn't
     * carry (functionalKey, contentStyle, full styles list, type-specific
     * preview value). Returns null when nothing is hovered. */
    get hoveredDetails(): {
        rect: LayoutRect;
        functionalKey: string | null;
        contentStyle: string | null;
        styles: string[];
        preview: string | null;
        descendants: number;
        directChildren: number;
    } | null;
    /** First non-empty type-specific value: button caption, textitem text,
     * field question / values. Trimmed and length-capped so a long value
     * doesn't blow out the tooltip. */
    private previewFor;
    onMouseEnter(key: string): void;
    onMouseLeave(): void;
    onClick(key: string, event: MouseEvent): void;
    onDoubleClick(key: string, event: MouseEvent): void;
    drillTo(key: string): void;
    drillToRoot(): void;
    get viewportTransform(): string;
    resetView(): void;
    onWheel(event: WheelEvent): void;
    get zoomSliderValue(): number;
    get zoomPct(): number;
    onZoomSlider(event: Event): void;
    private zoomAt;
    onPointerDown(event: PointerEvent): void;
    onPointerMove(event: PointerEvent): void;
    onPointerUp(event: PointerEvent): void;
    onPointerCancel(_event: PointerEvent): void;
    private toViewBox;
    fillFor(node: TreemapNode): string;
    private isEmphasised;
    private pastelExpr;
    /** Foreground colour for a rect's label, picked for contrast against the
     * rect's effective fill. */
    labelFillFor(node: TreemapNode): string;
    private computeLabelFg;
    private resolveColor;
    private parseRgb;
    private blend;
    private fgForBg;
    /** Crude character-count truncation; fine until the rect is very narrow. */
    truncate(label: string, rectW: number): string;
    showLabel(r: LayoutRect): boolean;
    trackByKey(_idx: number, r: LayoutRect): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevElementGraphComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DevElementGraphComponent, "app-dev-element-graph", never, { "scope": { "alias": "scope"; "required": false; }; "rootKey": { "alias": "rootKey"; "required": false; }; "selectedKey": { "alias": "selectedKey"; "required": false; }; }, { "nodeSelected": "nodeSelected"; }, never, never, false, never>;
}

type FieldEntry = CaptureAnalysis['fields'][0];
declare class DevInsightsPanelComponent {
    analysis: CaptureAnalysis | null;
    get overallHealth(): 'ok' | 'warn' | 'error';
    private get processedFields();
    private isJustRequiredEmpty;
    get fieldsWithErrors(): FieldEntry[];
    get fieldsWithWarnings(): FieldEntry[];
    get fieldsWithBlockingRules(): FieldEntry[];
    get emptyRequiredFields(): FieldEntry[];
    get refreshFields(): FieldEntry[];
    get pageContext(): PageContext;
    get sections(): PageSection[];
    get tables(): TableSummary[];
    get triggeredBy(): string;
    get allActionRows(): {
        caption: string;
        disabled: boolean;
        validate: boolean;
        styles: string[];
        contentStyle?: string;
    }[];
    get allActionsBlocked(): boolean;
    get filledCount(): number;
    get filledPercent(): number;
    messagesOf(field: FieldEntry, type: string): string[];
    blockingValidations(field: FieldEntry): {
        blocking: boolean;
        type: string;
        message: string;
        parameters?: any;
    }[];
    fieldLabel(field: FieldEntry): string;
    chipClass(chipStyle: string): string;
    private static readonly STYLE_LABELS;
    /** Human-readable description of a Blueriq presentation style name. */
    styleLabel(style: string): string;
    /** Tooltip text: "primary — Main / primary action" */
    styleTooltip(style: string): string;
    formatParams(params: any): string;
    /**
     * "Looks wrong" finder. Each rule fires on a clear authoring smell or
     * contradiction in the page model — empty captions, required-but-readonly,
     * duplicated labels, etc. Narrow on purpose: the panel is only useful if
     * a fired rule is almost certainly a real problem.
     */
    get anomalies(): PageAnomaly[];
    private findDuplicates;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevInsightsPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DevInsightsPanelComponent, "app-dev-insights-panel", never, { "analysis": { "alias": "analysis"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DevCaptureListComponent {
    private sessionRegistry;
    constructor(sessionRegistry: SessionRegistry);
    captures: CaptureEntry[];
    filteredCaptures: CaptureEntry[];
    selectedCapture: CaptureEntry | null;
    filterText: string;
    captureActive: boolean;
    viewMode: 'json' | 'template' | 'insights' | 'request';
    statusFilter: 'all' | '2xx' | '4xx' | '5xx';
    loadingJson: boolean;
    highlightedJson: SafeHtml | null;
    selectedJson: string | null;
    bodyKind: BodyKind;
    highlightedTemplate: SafeHtml | null;
    generatedTemplate: string | null;
    templateError: string | null;
    captureAnalysis: CaptureAnalysis | null;
    selectedRequestBody: string | null;
    highlightedRequestBody: SafeHtml | null;
    curlCopied: boolean;
    pinnedCaptures: Set<string>;
    isDiffMode: boolean;
    diffBaseCapture: CaptureEntry | null;
    filterTextChange: EventEmitter<string>;
    statusFilterChange: EventEmitter<"all" | "2xx" | "4xx" | "5xx">;
    captureToggled: EventEmitter<void>;
    capturesCleared: EventEmitter<void>;
    captureSelected: EventEmitter<CaptureEntry>;
    viewModeChange: EventEmitter<"request" | "template" | "json" | "insights">;
    templateRequested: EventEmitter<void>;
    expandRequested: EventEmitter<void>;
    curlCopyRequested: EventEmitter<void>;
    pinToggled: EventEmitter<string>;
    diffRequested: EventEmitter<void>;
    diffCancelled: EventEmitter<void>;
    showPageRequested: EventEmitter<void>;
    methodClass(method: string): string;
    statusClass(status: number): string;
    isError(c: CaptureEntry): boolean;
    shortUrl(url: string): string;
    urlTooltip(url: string): string;
    urlType(url: string): string | null;
    tickClass(c: CaptureEntry): string;
    setMode(mode: 'json' | 'template' | 'insights' | 'request'): void;
    get bodyKindLabel(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevCaptureListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DevCaptureListComponent, "app-dev-capture-list", never, { "captures": { "alias": "captures"; "required": false; }; "filteredCaptures": { "alias": "filteredCaptures"; "required": false; }; "selectedCapture": { "alias": "selectedCapture"; "required": false; }; "filterText": { "alias": "filterText"; "required": false; }; "captureActive": { "alias": "captureActive"; "required": false; }; "viewMode": { "alias": "viewMode"; "required": false; }; "statusFilter": { "alias": "statusFilter"; "required": false; }; "loadingJson": { "alias": "loadingJson"; "required": false; }; "highlightedJson": { "alias": "highlightedJson"; "required": false; }; "selectedJson": { "alias": "selectedJson"; "required": false; }; "bodyKind": { "alias": "bodyKind"; "required": false; }; "highlightedTemplate": { "alias": "highlightedTemplate"; "required": false; }; "generatedTemplate": { "alias": "generatedTemplate"; "required": false; }; "templateError": { "alias": "templateError"; "required": false; }; "captureAnalysis": { "alias": "captureAnalysis"; "required": false; }; "selectedRequestBody": { "alias": "selectedRequestBody"; "required": false; }; "highlightedRequestBody": { "alias": "highlightedRequestBody"; "required": false; }; "curlCopied": { "alias": "curlCopied"; "required": false; }; "pinnedCaptures": { "alias": "pinnedCaptures"; "required": false; }; "isDiffMode": { "alias": "isDiffMode"; "required": false; }; "diffBaseCapture": { "alias": "diffBaseCapture"; "required": false; }; }, { "filterTextChange": "filterTextChange"; "statusFilterChange": "statusFilterChange"; "captureToggled": "captureToggled"; "capturesCleared": "capturesCleared"; "captureSelected": "captureSelected"; "viewModeChange": "viewModeChange"; "templateRequested": "templateRequested"; "expandRequested": "expandRequested"; "curlCopyRequested": "curlCopyRequested"; "pinToggled": "pinToggled"; "diffRequested": "diffRequested"; "diffCancelled": "diffCancelled"; "showPageRequested": "showPageRequested"; }, never, never, false, never>;
}

declare class DevLargeViewComponent {
    selectedCapture: CaptureEntry | null;
    pageViewTitle: string | null;
    viewMode: 'json' | 'template' | 'insights' | 'request' | 'structure';
    highlightedJson: SafeHtml | null;
    selectedJson: string | null;
    highlightedTemplate: SafeHtml | null;
    generatedTemplate: string | null;
    templateError: string | null;
    captureAnalysis: CaptureAnalysis | null;
    selectedRequestBody: string | null;
    highlightedRequestBody: SafeHtml | null;
    elementTree: ElementTreeNode | null;
    viewModeChange: EventEmitter<"request" | "template" | "json" | "insights" | "structure">;
    templateRequested: EventEmitter<void>;
    closed: EventEmitter<void>;
    collapsedKeys: Set<string>;
    setMode(mode: 'json' | 'template' | 'insights' | 'request' | 'structure'): void;
    toggleTreeKey(key: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevLargeViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DevLargeViewComponent, "app-dev-large-view", never, { "selectedCapture": { "alias": "selectedCapture"; "required": false; }; "pageViewTitle": { "alias": "pageViewTitle"; "required": false; }; "viewMode": { "alias": "viewMode"; "required": false; }; "highlightedJson": { "alias": "highlightedJson"; "required": false; }; "selectedJson": { "alias": "selectedJson"; "required": false; }; "highlightedTemplate": { "alias": "highlightedTemplate"; "required": false; }; "generatedTemplate": { "alias": "generatedTemplate"; "required": false; }; "templateError": { "alias": "templateError"; "required": false; }; "captureAnalysis": { "alias": "captureAnalysis"; "required": false; }; "selectedRequestBody": { "alias": "selectedRequestBody"; "required": false; }; "highlightedRequestBody": { "alias": "highlightedRequestBody"; "required": false; }; "elementTree": { "alias": "elementTree"; "required": false; }; }, { "viewModeChange": "viewModeChange"; "templateRequested": "templateRequested"; "closed": "closed"; }, never, never, false, never>;
}

type SelectorNode = {
    kind: 'union';
    branches: SelectorNode[];
} | {
    kind: 'chain';
    steps: ChainStep[];
} | {
    kind: 'compound';
    facets: Facet[];
} | {
    kind: 'invalid';
    source: string;
};
type Combinator = 'descendant' | 'child' | 'adjacent-sibling' | 'general-sibling';
interface ChainStep {
    combinator: Combinator | null;
    node: SelectorNode;
}
type Facet = {
    kind: 'type';
    value: string;
} | {
    kind: 'wildcard';
} | {
    kind: 'class';
    value: string;
} | {
    kind: 'id';
    value: string;
} | {
    kind: 'attr';
    name: string;
    op?: AttrOp;
    value?: string;
} | {
    kind: 'pseudo';
    name: string;
    arg?: SelectorNode;
    rawArg?: string;
};
type AttrOp = '=' | '~=' | '|=' | '^=' | '$=' | '*=' | '!=';
declare function combinatorLabel(c: Combinator): string;
declare function facetSummary(f: Facet): string;
declare function facetExplanation(f: Facet): string;

/** One entry of an element's value-history ring, surfaced in the Structure tab. */
interface InspectorHistoryEntry {
    ts: number;
    value: unknown;
    captureId?: string;
}
declare class DevInspectorPopupComponent implements OnChanges {
    private zone;
    inspectedElement: Element | null;
    popupPos: {
        left: number;
        top: number;
    } | null;
    isPickerActive: boolean;
    hasParent: boolean;
    parentNavKey: number;
    elementViewMode: 'template' | 'json' | 'insights' | 'structure' | 'story' | 'graph';
    elementStoryCode: string | null;
    highlightedElementStory: SafeHtml | null;
    storyProvidersPath: string;
    storyProvidersPathChange: EventEmitter<string>;
    storySettingsOpen: boolean;
    readonly modKey: string;
    highlightedElementTemplate: SafeHtml | null;
    elementTemplate: string | null;
    highlightedElementJson: SafeHtml | null;
    elementJson: string | null;
    elementInsightsData: CaptureAnalysis | null;
    elementTree: ElementTreeNode | null;
    elementCopied: boolean;
    onTreeNodeSelect: ((key: string) => void) | null;
    collapsedKeys: Set<string>;
    onTreeNodeToggle: ((key: string) => void) | null;
    selectedTreeKey: string | null;
    canGoBack: boolean;
    canGoForward: boolean;
    breadcrumbs: Array<{
        key: string;
        type: string;
        name: string;
    }>;
    componentName: string | null;
    componentClass: string | null;
    blueriqSelector: string | null;
    blueriqSelectorPriority: number | null;
    sourceCapture: CaptureEntry | null;
    elementHistory: InspectorHistoryEntry[];
    elementSources: string[];
    elementCapturedIn: string[];
    elementViewModeChange: EventEmitter<"template" | "json" | "insights" | "structure" | "story" | "graph">;
    copyRequested: EventEmitter<void>;
    pickerToggled: EventEmitter<void>;
    selectParentRequested: EventEmitter<void>;
    navigateBack: EventEmitter<void>;
    navigateForward: EventEmitter<void>;
    breadcrumbSelected: EventEmitter<string>;
    closed: EventEmitter<void>;
    sourceCaptureClicked: EventEmitter<CaptureEntry>;
    tourReplayRequested: EventEmitter<void>;
    /** Final position after the user drags the popup. Lets the host pin the
     * position so scroll-follow / re-positioning doesn't snap it back. */
    popupMoved: EventEmitter<{
        left: number;
        top: number;
    }>;
    private _localPos;
    isDragging: boolean;
    blueriqSelectorTreeOpen: boolean;
    private _parsedSelectorCache;
    constructor(zone: NgZone);
    ngOnChanges(changes: SimpleChanges): void;
    get parsedBlueriqSelector(): SelectorNode | null;
    toggleBlueriqSelectorTree(): void;
    get effectivePos(): {
        left: number;
        top: number;
    } | null;
    onHeaderDragStart(event: MouseEvent): void;
    componentNameCopied: boolean;
    componentClassCopied: boolean;
    blueriqSelectorCopied: boolean;
    copyComponentName(name: string | null): Promise<void>;
    copyComponentClass(name: string | null): Promise<void>;
    copyBlueriqSelector(sel: string | null): Promise<void>;
    /** Plain-English reasons the picked element is in its current state. Empty when nothing's wrong. */
    get blockerReasons(): BlockerReason[];
    /** History ring entries, oldest first (matches the cache append order). */
    get historyRows(): Array<{
        time: string;
        value: string;
        captureId?: string;
    }>;
    /** True when the element has any provenance data — gates the History section. */
    get hasHistoryOrProvenance(): boolean;
    private _formatHistoryValue;
    get elementMeta(): Array<{
        label: string;
        value?: string;
        mono?: boolean;
        muted?: boolean;
        tag?: string;
        chips?: string[];
    }>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevInspectorPopupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DevInspectorPopupComponent, "app-dev-inspector-popup", never, { "inspectedElement": { "alias": "inspectedElement"; "required": false; }; "popupPos": { "alias": "popupPos"; "required": false; }; "isPickerActive": { "alias": "isPickerActive"; "required": false; }; "hasParent": { "alias": "hasParent"; "required": false; }; "parentNavKey": { "alias": "parentNavKey"; "required": false; }; "elementViewMode": { "alias": "elementViewMode"; "required": false; }; "elementStoryCode": { "alias": "elementStoryCode"; "required": false; }; "highlightedElementStory": { "alias": "highlightedElementStory"; "required": false; }; "storyProvidersPath": { "alias": "storyProvidersPath"; "required": false; }; "highlightedElementTemplate": { "alias": "highlightedElementTemplate"; "required": false; }; "elementTemplate": { "alias": "elementTemplate"; "required": false; }; "highlightedElementJson": { "alias": "highlightedElementJson"; "required": false; }; "elementJson": { "alias": "elementJson"; "required": false; }; "elementInsightsData": { "alias": "elementInsightsData"; "required": false; }; "elementTree": { "alias": "elementTree"; "required": false; }; "elementCopied": { "alias": "elementCopied"; "required": false; }; "onTreeNodeSelect": { "alias": "onTreeNodeSelect"; "required": false; }; "collapsedKeys": { "alias": "collapsedKeys"; "required": false; }; "onTreeNodeToggle": { "alias": "onTreeNodeToggle"; "required": false; }; "selectedTreeKey": { "alias": "selectedTreeKey"; "required": false; }; "canGoBack": { "alias": "canGoBack"; "required": false; }; "canGoForward": { "alias": "canGoForward"; "required": false; }; "breadcrumbs": { "alias": "breadcrumbs"; "required": false; }; "componentName": { "alias": "componentName"; "required": false; }; "componentClass": { "alias": "componentClass"; "required": false; }; "blueriqSelector": { "alias": "blueriqSelector"; "required": false; }; "blueriqSelectorPriority": { "alias": "blueriqSelectorPriority"; "required": false; }; "sourceCapture": { "alias": "sourceCapture"; "required": false; }; "elementHistory": { "alias": "elementHistory"; "required": false; }; "elementSources": { "alias": "elementSources"; "required": false; }; "elementCapturedIn": { "alias": "elementCapturedIn"; "required": false; }; }, { "storyProvidersPathChange": "storyProvidersPathChange"; "elementViewModeChange": "elementViewModeChange"; "copyRequested": "copyRequested"; "pickerToggled": "pickerToggled"; "selectParentRequested": "selectParentRequested"; "navigateBack": "navigateBack"; "navigateForward": "navigateForward"; "breadcrumbSelected": "breadcrumbSelected"; "closed": "closed"; "sourceCaptureClicked": "sourceCaptureClicked"; "tourReplayRequested": "tourReplayRequested"; "popupMoved": "popupMoved"; }, never, never, false, never>;
}

declare class DevCodeViewerComponent {
    kind: 'json' | 'template';
    content: string | null;
    highlighted: SafeHtml | null;
    filename: string;
    error: string | null;
    emptyMsg: string | null;
    canExpand: boolean;
    expandRequested: EventEmitter<void>;
    copied: boolean;
    copy(): Promise<void>;
    download(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevCodeViewerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DevCodeViewerComponent, "app-dev-code-viewer", never, { "kind": { "alias": "kind"; "required": false; }; "content": { "alias": "content"; "required": false; }; "highlighted": { "alias": "highlighted"; "required": false; }; "filename": { "alias": "filename"; "required": false; }; "error": { "alias": "error"; "required": false; }; "emptyMsg": { "alias": "emptyMsg"; "required": false; }; "canExpand": { "alias": "canExpand"; "required": false; }; }, { "expandRequested": "expandRequested"; }, never, never, false, never>;
}

declare class DevViewerContainerComponent {
    viewMode: 'json' | 'template' | 'insights' | 'request';
    highlightedJson: SafeHtml | null;
    selectedJson: string | null;
    highlightedRequestBody: SafeHtml | null;
    selectedRequestBody: string | null;
    templateError: string | null;
    highlightedTemplate: SafeHtml | null;
    generatedTemplate: string | null;
    captureAnalysis: CaptureAnalysis | null;
    canExpand: boolean;
    expandRequested: EventEmitter<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevViewerContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DevViewerContainerComponent, "app-dev-viewer-container", never, { "viewMode": { "alias": "viewMode"; "required": false; }; "highlightedJson": { "alias": "highlightedJson"; "required": false; }; "selectedJson": { "alias": "selectedJson"; "required": false; }; "highlightedRequestBody": { "alias": "highlightedRequestBody"; "required": false; }; "selectedRequestBody": { "alias": "selectedRequestBody"; "required": false; }; "templateError": { "alias": "templateError"; "required": false; }; "highlightedTemplate": { "alias": "highlightedTemplate"; "required": false; }; "generatedTemplate": { "alias": "generatedTemplate"; "required": false; }; "captureAnalysis": { "alias": "captureAnalysis"; "required": false; }; "canExpand": { "alias": "canExpand"; "required": false; }; }, { "expandRequested": "expandRequested"; }, never, never, false, never>;
}

type DiffMode = 'structure' | 'semantic' | 'text';
declare class DevCaptureDiffComponent {
    captureA: CaptureEntry | null;
    captureB: CaptureEntry | null;
    diffLines: DiffLine[];
    closed: EventEmitter<void>;
    mode: DiffMode;
    setMode(m: DiffMode): void;
    get addedCount(): number;
    get removedCount(): number;
    get modifiedCount(): number;
    get hunks(): DiffHunk[];
    get semanticChanges(): SemanticChange[];
    get structureChanges(): AnalysisDiffEntry[];
    formatValue(v: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevCaptureDiffComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DevCaptureDiffComponent, "app-dev-capture-diff", never, { "captureA": { "alias": "captureA"; "required": false; }; "captureB": { "alias": "captureB"; "required": false; }; "diffLines": { "alias": "diffLines"; "required": false; }; }, { "closed": "closed"; }, never, never, false, never>;
}

declare class DevSelectorTreeComponent {
    node: SelectorNode | null;
    combinatorLabel: typeof combinatorLabel;
    facetExplanation: typeof facetExplanation;
    facetSummary: typeof facetSummary;
    asUnion(n: SelectorNode | null): Extract<SelectorNode, {
        kind: "union";
    }>;
    asChain(n: SelectorNode | null): Extract<SelectorNode, {
        kind: "chain";
    }>;
    asCompound(n: SelectorNode | null): Extract<SelectorNode, {
        kind: "compound";
    }>;
    asInvalid(n: SelectorNode | null): Extract<SelectorNode, {
        kind: "invalid";
    }>;
    facetTypeClass(f: Facet): string;
    facetBadge(f: Facet): string;
    hasNested(f: Facet): boolean;
    styleChip(f: Facet): string | null;
    nestedNode(f: Facet): SelectorNode | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevSelectorTreeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DevSelectorTreeComponent, "app-dev-selector-tree", never, { "node": { "alias": "node"; "required": false; }; }, {}, never, never, false, never>;
}

interface TemplateCancelToken {
    cancelled: boolean;
}
declare class JsonToTemplatesComponent implements OnChanges {
    template: string | undefined;
    /**
     * Active cancel token for the current `generateTemplateFor` call,
     * checked at every recursion boundary. Cleared when the call returns.
     * The inspector replaces a pending generation by flipping
     * `cancelled = true` on the prior token before launching a new one.
     */
    private currentCancelToken;
    renderTemplate: ElementTemplate | undefined;
    renderExampleOfTemplate: unknown;
    loadSessionResponse: string | undefined;
    keyToTemplate: string | undefined;
    showKeys: boolean | undefined;
    copyElementNames: boolean | undefined;
    copyValidationRules: boolean | undefined;
    copyTextItemNodes: boolean | undefined;
    ignoreProperties: string | undefined;
    copyError: string | undefined;
    copySuccess: string | undefined;
    parseJsonError: string | undefined;
    composeElementTemplate(): void;
    ngOnChanges(): void;
    generateTemplateFor(element: Element, renderNames?: boolean, copyValidationRules?: boolean, copyTextItemNodes?: boolean, ignoreProperties?: string, cancelToken?: TemplateCancelToken): string;
    copyToClipBoard(): void;
    private sessionContext;
    private defaultPageModelService;
    private escapeQuotes;
    private escapeBackticks;
    private presentationStyleString;
    private contentStyleString;
    private displayNameString;
    private nameString;
    private valueString;
    private errorString;
    private warningString;
    private readonlyString;
    private domainString;
    private validationString;
    private linkParameterString;
    private createString;
    private fieldParameterString;
    private questionTextString;
    private explainTextString;
    private captionString;
    private disabledString;
    private textString;
    private plainTextString;
    private createNodeList;
    private nodesString;
    private propertiesString;
    private childAsTemplateString;
    private childrenAsTemplateString;
    private createTemplateStringFrom;
    static ɵfac: i0.ɵɵFactoryDeclaration<JsonToTemplatesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<JsonToTemplatesComponent, "blueriq-json-to-templates", never, { "renderExampleOfTemplate": { "alias": "renderExampleOfTemplate"; "required": false; }; "keyToTemplate": { "alias": "keyToTemplate"; "required": false; }; "showKeys": { "alias": "showKeys"; "required": false; }; "copyElementNames": { "alias": "copyElementNames"; "required": false; }; "copyValidationRules": { "alias": "copyValidationRules"; "required": false; }; "copyTextItemNodes": { "alias": "copyTextItemNodes"; "required": false; }; "ignoreProperties": { "alias": "ignoreProperties"; "required": false; }; }, {}, never, never, false, never>;
}

declare class BqIconComponent {
    private sanitizer;
    spin: boolean;
    private _name;
    private _safeSvg;
    private _isLogo;
    constructor(sanitizer: DomSanitizer);
    set name(value: string);
    get name(): string;
    get svg(): SafeHtml;
    get isLogo(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<BqIconComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BqIconComponent, "bq-icon", never, { "spin": { "alias": "spin"; "required": false; }; "name": { "alias": "name"; "required": false; }; }, {}, never, never, false, never>;
}

interface Rect {
    left: number;
    top: number;
    width: number;
    height: number;
}
declare class DevTourComponent implements OnInit, OnDestroy {
    tour: DevTourService;
    private zone;
    private sanitizer;
    step: TourStep | null;
    stepIndex: number;
    total: number;
    isLast: boolean;
    safeWireframe: SafeHtml | null;
    targetRect: Rect | null;
    cardStyle: Record<string, string>;
    spotlightStyle: Record<string, string>;
    bandTopStyle: Record<string, string>;
    bandBottomStyle: Record<string, string>;
    bandLeftStyle: Record<string, string>;
    bandRightStyle: Record<string, string>;
    private destroy$;
    private rafHandle;
    private readonly onResizeOrScroll;
    constructor(tour: DevTourService, zone: NgZone, sanitizer: DomSanitizer);
    ngOnInit(): void;
    ngOnDestroy(): void;
    next(): void;
    back(): void;
    skip(): void;
    private applyIndex;
    private scheduleRemeasure;
    private measure;
    private centerCardStyle;
    private placeCard;
    static ɵfac: i0.ɵɵFactoryDeclaration<DevTourComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DevTourComponent, "app-dev-tour", never, {}, {}, never, never, false, never>;
}

declare class BqLensModule {
    constructor(appRef: ApplicationRef, envInjector: EnvironmentInjector, platformId: object);
    static forRoot(config?: BqLensConfig): ModuleWithProviders<BqLensModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BqLensModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<BqLensModule, [typeof BqLensComponent, typeof DevSessionPanelComponent, typeof DevCacheInternalsPanelComponent, typeof DevTooltipDirective, typeof DevElementTreeComponent, typeof DevElementGraphComponent, typeof DevInsightsPanelComponent, typeof DevCaptureListComponent, typeof DevLargeViewComponent, typeof DevInspectorPopupComponent, typeof DevCodeViewerComponent, typeof DevViewerContainerComponent, typeof DevCaptureDiffComponent, typeof DevElementSearchComponent, typeof DevSelectorTreeComponent, typeof JsonToTemplatesComponent, typeof BqIconComponent, typeof DevTourComponent], [typeof i19.CommonModule, typeof i20.FormsModule, typeof i21.RouterModule], [typeof BqLensComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<BqLensModule>;
}

export { BQ_LENS_CONFIG, BqLensComponent, BqLensModule, DevColorsService };
export type { BqLensConfig, BqLensSectionConfig };