@ethlete/query-devtools 1.0.0-next.0

package/types/ethlete-query-devtools.d.ts

@@ -0,0 +1,1777 @@
+import * as _angular_core from '@angular/core';
+import { Signal, WritableSignal, OnInit } from '@angular/core';
+import * as _ethlete_query from '@ethlete/query';
+import { JsonPath, QueryDevtoolsOverridesRecorder, QueryRefreshCause, QueryRepositoryEntryDestroyedCause, Query, QueryRepositoryCacheEntry, HttpRequestRetryState, HttpRequestLoadingProgressState, QueryDevtoolsStats, QueryDevtoolsStatsHandle, QueryDevtoolsEntry, QueryRepository, QueryClient, QueryKeyLockState, QueryDevtoolsFeature, QueryDevtoolsFault, AnyQueryStack, AnyPagedQueryStack, QuerySequence, AnyBearerAuthProvider, WebSocketDevtoolsHandle, QueryDevtoolsFormHandle, QuerySequenceStatus, AnyQuerySnapshot, QueryDevtoolsRun, QueryDevtoolsRunError, WebSocketDevtoolsMessage, QueryDevtoolsStorageScope } from '@ethlete/query';
+import { ResizeEdge, DragMoveEvent, ResizeMoveEvent } from '@ethlete/core';
+
+type AboutRow = {
+    label: string;
+    value: string;
+};
+type AboutGroup = {
+    title: string;
+    rows: AboutRow[];
+};
+/**
+ * What is running: the loaded `@ethlete/*` versions, the Angular version and whatever the app handed to
+ * `provideQueryDevtools({ about })`. A section rather than a tab body, so it can be shown anywhere.
+ */
+declare class QueryDevtoolsAboutComponent {
+    protected readonly groups: AboutGroup[];
+    protected copied: _angular_core.WritableSignal<boolean>;
+    protected copy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryDevtoolsAboutComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QueryDevtoolsAboutComponent, "et-query-devtools-about", never, {}, {}, never, never, true, never>;
+}
+
+/** Which of a node's four pasteable forms a copy action asks for. */
+type QueryDevtoolsCopyPayload = 'value' | 'key' | 'path' | 'entry';
+
+/** A JSON value's kind as the value explorer (and its per-node override menu) categorizes it. */
+type JsonKind = 'string' | 'number' | 'boolean' | 'null' | 'undefined' | 'array' | 'object';
+type JsonEntry = {
+    k: string;
+    v: unknown;
+};
+/** A folded slice of a container's entries, rendered as its own collapsible row. */
+type JsonChunk = {
+    start: number;
+    end: number;
+    label: string;
+};
+declare const kindOf: (value: unknown) => JsonKind;
+/**
+ * A recursive, collapsible, searchable JSON tree used by the query devtools value explorer. Renders
+ * the *transformed* value the app actually sees (post `transformResponse`). Self-recurses via its
+ * own selector - both for child entries and for the folded slices of an oversized container, which
+ * re-enter as the same component with a `chunk` window over the same value.
+ */
+declare class QueryDevtoolsJsonComponent {
+    value: _angular_core.InputSignal<unknown>;
+    nodeKey: _angular_core.InputSignal<string | null>;
+    depth: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Lowercased search term; when set, the tree auto-expands and matches are highlighted. */
+    search: _angular_core.InputSignal<string>;
+    /**
+     * When set, this node is not the value itself but a folded window over its entries. It shares the
+     * container's `path` so a child's persisted expansion does not depend on where the slice borders land.
+     */
+    chunk: _angular_core.InputSignal<JsonChunk | null>;
+    /** Full path of this node from the explorer root, used as the key for persisted expansion. */
+    path: _angular_core.InputSignal<string>;
+    /** Persisted paths explicitly expanded (overrides the depth default). */
+    expandedPaths: _angular_core.InputSignal<ReadonlySet<string> | null>;
+    /** Persisted paths explicitly collapsed (overrides the depth default). */
+    collapsedPaths: _angular_core.InputSignal<ReadonlySet<string> | null>;
+    /** When provided, expansion is externally persisted via this callback instead of local state. */
+    toggleFn: _angular_core.InputSignal<((path: string, expand: boolean) => void) | null>;
+    /** Same node as {@link path}, but as the array-of-steps an override op targets rather than a display key. */
+    jsonPath: _angular_core.InputSignal<JsonPath>;
+    /** The kind of the container holding this node, so its override menu can offer "duplicate this item". */
+    parentKind: _angular_core.InputSignal<JsonKind | null>;
+    /** When provided, every node renders an override menu that arms/clears ops through it. */
+    overrides: _angular_core.InputSignal<QueryDevtoolsOverridesRecorder | null>;
+    /**
+     * The declared type of each field, keyed by its path with array indices as `*` (`items.*.id`) - as
+     * {@link QueryDevtoolsSchemaSeed} produces it. A node with an entry labels itself with it.
+     */
+    annotations: _angular_core.InputSignal<ReadonlyMap<string, string> | null>;
+    protected kind: _angular_core.Signal<JsonKind>;
+    private exotic;
+    /** One annotation covers every element of an array, so the lookup path forgets which index this is. */
+    private shapePath;
+    protected annotation: _angular_core.Signal<string | null>;
+    protected annotationTitle: _angular_core.Signal<string>;
+    /** A `Date` or a `File` is object-typed but has nothing to expand into, so it renders as a leaf. */
+    protected isContainer: _angular_core.Signal<boolean>;
+    /** The entries this node covers: the container's own, or just the window a chunk stands for. */
+    ownEntries: _angular_core.Signal<JsonEntry[]>;
+    protected childChunks: _angular_core.Signal<JsonChunk[]>;
+    /** Entries rendered as rows - empty while they are folded into slices instead. */
+    protected visibleEntries: _angular_core.Signal<JsonEntry[]>;
+    /** Slices carry their window in the key so siblings persist independently of the container. */
+    private togglePath;
+    private defaultExpanded;
+    private localExpanded;
+    protected expanded: _angular_core.Signal<boolean>;
+    /** Only slices that actually contain a match unfold while searching, so a filter stays cheap. */
+    private chunkHasHit;
+    protected effectiveExpanded: _angular_core.Signal<boolean>;
+    /** What the last copy put on the clipboard, or `null` once the tick has expired. */
+    protected copied: _angular_core.WritableSignal<QueryDevtoolsCopyPayload | null>;
+    private copiedReset$;
+    /**
+     * Whether this node has an address of its own to copy. An explorer root has no key, and a folded
+     * slice stands for a range of entries rather than one path - neither can name itself.
+     */
+    protected addressable: _angular_core.Signal<boolean>;
+    private valueLabel;
+    /**
+     * Doubles as the button's `title` and its `aria-label`, and names what landed while the tick is up -
+     * a bare `✓` stopped being unambiguous once the menu put four payloads behind one control.
+     */
+    protected copyLabel: _angular_core.Signal<string>;
+    protected preview: _angular_core.Signal<string>;
+    protected display: _angular_core.Signal<string>;
+    protected keyHit: _angular_core.Signal<boolean>;
+    protected valueHit: _angular_core.Signal<boolean>;
+    constructor();
+    protected childPath(key: string): string;
+    protected childJsonPath(key: string): JsonPath;
+    protected toggle(): void;
+    /**
+     * Writes one of the node's four pasteable forms. All of them go through here so the tick stays a
+     * single readout of what actually landed.
+     */
+    protected copy(payload: QueryDevtoolsCopyPayload): void;
+    /**
+     * Containers copy their whole subtree as JSON, slices only the entries they cover; leaves copy
+     * something pasteable - a raw string without the display quotes, so an id or url can go straight
+     * into a search box. `null` for a subtree that cannot be serialized at all.
+     */
+    private copyTextFor;
+    /** An exotic container copies the entries the tree shows, not the private fields `JSON.stringify` finds. */
+    private copyableValue;
+    private chunkValue;
+    private flagCopied;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryDevtoolsJsonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QueryDevtoolsJsonComponent, "et-query-devtools-json", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "nodeKey": { "alias": "nodeKey"; "required": false; "isSignal": true; }; "depth": { "alias": "depth"; "required": false; "isSignal": true; }; "search": { "alias": "search"; "required": false; "isSignal": true; }; "chunk": { "alias": "chunk"; "required": false; "isSignal": true; }; "path": { "alias": "path"; "required": false; "isSignal": true; }; "expandedPaths": { "alias": "expandedPaths"; "required": false; "isSignal": true; }; "collapsedPaths": { "alias": "collapsedPaths"; "required": false; "isSignal": true; }; "toggleFn": { "alias": "toggleFn"; "required": false; "isSignal": true; }; "jsonPath": { "alias": "jsonPath"; "required": false; "isSignal": true; }; "parentKind": { "alias": "parentKind"; "required": false; "isSignal": true; }; "overrides": { "alias": "overrides"; "required": false; "isSignal": true; }; "annotations": { "alias": "annotations"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * The value explorer's tree chrome, as a styles-only component the tree mounts itself - a session that
+ * never opens a JSON view does not inject it.
+ *
+ * @internal
+ */
+declare class QueryDevtoolsJsonStylesComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryDevtoolsJsonStylesComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QueryDevtoolsJsonStylesComponent, "et-query-devtools-json-styles", never, {}, {}, never, never, true, never>;
+}
+
+/** Whether a path exists only in the newer value, only in the older one, or in both with a new value. */
+type QueryDevtoolsDiffKind = 'added' | 'removed' | 'changed';
+/** One difference between two values, located by the path it sits at. */
+type QueryDevtoolsDiffEntry = {
+    /** Where the difference sits, e.g. `$.items[2].score` or `$.items[id=7].score`. */
+    path: string;
+    kind: QueryDevtoolsDiffKind;
+    /** The older value, or `null` for an added path. */
+    before: unknown;
+    /** The newer value, or `null` for a removed path. */
+    after: unknown;
+};
+type QueryDevtoolsDiff = {
+    entries: QueryDevtoolsDiffEntry[];
+    /** Whether the walk hit its cap, so {@link entries} is only part of the difference. */
+    truncated: boolean;
+};
+
+type AnyQuery = Query<any>;
+/** The query a detail pane is showing, together with the registry entry it was registered as. */
+type QueryDevtoolsSelection = {
+    entry: QueryDevtoolsEntry;
+    query: AnyQuery;
+};
+/**
+ * A body the panel can show. Every one of them but `settings` is a tab in the bar: Settings holds nothing
+ * to count, so the badge/overflow logic would push it behind **More** - it is reached from the header's
+ * gear instead.
+ */
+type DevtoolsTab = 'queries' | 'stacks' | 'sequences' | 'forms' | 'auth' | 'ws' | 'cache' | 'timeline' | 'events' | 'faults' | 'mocks' | 'about' | 'settings';
+/**
+ * The sections of the query detail drawer. The head and its actions stay pinned above them - the detail
+ * holds more than fits a column, and everything below the actions is reading material.
+ */
+type DetailTab = 'overview' | 'history' | 'data';
+/**
+ * Which pane of a two-pane tab a divider drag sizes: the Queries tab's list, or the drawer every
+ * split view opens a query in.
+ */
+type PaneTarget = 'list' | 'drawer';
+/** The axis a two-pane tab splits along: the panes sit side by side, or stack in a side dock. */
+type PaneAxis = 'inline' | 'block';
+type QueryStatus = 'idle' | 'loading' | 'success' | 'error';
+/**
+ * A facet the Queries list can be narrowed to. The first four describe live state; `gone` is the odd
+ * one out - it is the only way a destroyed query's tombstone enters the list at all, which is why it
+ * is off by default rather than just another filter over what is already shown.
+ */
+type QueryListFacet = 'error' | 'loading' | 'stale' | 'idle' | 'gone';
+/**
+ * A chunk of a route as rendered: literal path text, a path param (`name` is the param it fills in) or
+ * the query string of the request that ran. The kind becomes the segment's class.
+ */
+type RouteSegment = {
+    text: string;
+    kind: 'static' | 'param' | 'query';
+    name?: string;
+};
+/**
+ * Which tab refreshes an auth provider's tokens, as the auth tab's chip renders it. `title` carries
+ * the caveats the label has no room for - why every tab reads as the leader, or how approximate the
+ * tab count is.
+ */
+type QueryDevtoolsLeadership = {
+    label: string;
+    tone: 'success' | 'muted';
+    title: string;
+};
+/** An auth provider's access-token expiry as the auth tab renders it, armed override included. */
+type QueryDevtoolsTokenLifetime = {
+    /** Countdown to the expiry the app currently acts on, overridden or not. */
+    expiresIn: string | null;
+    /** Countdown to the token's own `exp`, and only set while an override is making it read differently. */
+    realExpiresIn: string | null;
+    /** The armed lifetime in seconds, or `null` while the token is on the one it was issued with. */
+    ttlSeconds: number | null;
+    /** Whether an override can be applied at all - the token needs an `exp` plus an `iat` or `nbf`. */
+    overridable: boolean;
+};
+/** A query reachable from a stack or sequence card, rendered as a row that opens the detail drawer. */
+type QueryLink = {
+    id: string;
+    query: AnyQuery;
+    method: string;
+    segments: RouteSegment[];
+    clientBaseUrl: string;
+    stats?: QueryDevtoolsStatsHandle;
+};
+/**
+ * Query stats plus the numbers the panel derives from them rather than storing: an execution that never
+ * reached the network was answered from the cache, and the averages come from the running totals.
+ */
+type QueryActivity = {
+    stats: QueryDevtoolsStats;
+    cacheServed: number;
+    avgDurationMs: number | null;
+    avgResponseBytes: number | null;
+    hasActivity: boolean;
+};
+/**
+ * What a query's request is doing beyond `loading`: which attempt it is on, the backoff it is waiting
+ * out, and how much of the payload has moved. Without it a request retried three times behind a 4s
+ * backoff and a plain slow one are the same yellow dot.
+ */
+type RequestProgress = {
+    /** @see HttpRequestSubtle.attempts */
+    attempts: number;
+    retry: HttpRequestRetryState | null;
+    /** How much of the pending backoff is left, or `null` when none is pending. */
+    retryInMs: number | null;
+    progress: HttpRequestLoadingProgressState | null;
+};
+/**
+ * One request a refresh re-executed, as an event row lists it. A cache key is shared by every query
+ * bound to it, so the row carries all of their ids - one to open, and the rest so each of those queries
+ * can still find the refresh under "Refetched by". Empty for a request no registered query holds.
+ */
+type RefreshedRequest = {
+    queryIds: string[];
+    method: string;
+    path: string;
+};
+type EventLogItem = {
+    id: number;
+    timestamp: number;
+    client: string;
+    type: 'entry-created' | 'request-success' | 'request-error' | 'entry-destroyed' | 'unbind-all-secure' | 'queries-refreshed';
+    /** `null` for events that are not about a single request, e.g. the logout-wide secure unbind. */
+    method: string | null;
+    url: string | null;
+    isSecure: boolean;
+    status: number | null;
+    /**
+     * The registered query the request belonged to when the event fired, so the row can open it. Resolved
+     * here rather than at click time so the log holds an id instead of a reference to the request itself.
+     */
+    queryId: string | null;
+    /** What asked for a refresh, for a `queries-refreshed` row. `null` for every other type. */
+    cause: QueryRefreshCause | null;
+    /** Why a cache entry was torn down, for an `entry-destroyed` row. `null` for every other type. */
+    destroyCause: QueryRepositoryEntryDestroyedCause | null;
+    /** The requests that refresh re-executed - the fan-out the panel could not show before. */
+    refreshed: RefreshedRequest[] | null;
+    /**
+     * How long the request took and how big its response was, read off the request as the event fired.
+     * Both `null` for an event that is not one request settling, and the size also for a failure - an
+     * error body is not a payload worth a column.
+     */
+    durationMs: number | null;
+    bytes: number | null;
+    /** @see QueryDevtoolsStats.hasEstimatedBytes */
+    isEstimatedBytes: boolean;
+};
+/**
+ * A cache entry that is gone, as the Cache tab still lists it. Deliberately not a {@link CacheRow}: a
+ * destroyed entry has no consumers, no size, no freshness and nothing to act on, so a full row would be
+ * seven columns of dashes. What is left worth showing is what it was and why it went.
+ */
+type DroppedCacheEntry = {
+    client: string;
+    method: string;
+    url: string;
+    cause: QueryRepositoryEntryDestroyedCause;
+    at: number;
+};
+/** One cache entry as the Cache tab lists it: the repository's own snapshot plus its measured size. */
+type CacheRow = {
+    entry: QueryRepositoryCacheEntry;
+    bytes: number;
+    isEstimatedBytes: boolean;
+};
+/** A repository the panel found, together with the client name/base URL it was registered under. */
+type RepositoryInfo = {
+    repository: QueryRepository;
+    name: string;
+    baseUrl: string;
+    client: QueryClient | null;
+};
+/** One client's cache, as the Cache tab lists it - every entry measured, with the client's poll states. */
+type CacheView = {
+    name: string;
+    baseUrl: string;
+    repository: QueryRepository;
+    rows: CacheRow[];
+    bytes: number;
+    isEstimatedBytes: boolean;
+    unused: number;
+    pollStates: Record<string, QueryKeyLockState>;
+    client: QueryClient | null;
+    /** The entries this client has lost since the panel was loaded, newest first. */
+    dropped: DroppedCacheEntry[];
+};
+/** What each tab holds, as its badge reports it: how many entries, and how many of them are failing. */
+type TabBadge = {
+    count: number;
+    errors: number;
+    errorNoun?: string;
+};
+
+/**
+ * Everything a tab or the shared detail drawer reads from - or writes back into - the always-mounted
+ * `<et-query-devtools>` panel: cross-tab registries, the JIT editor, copy/export actions, the value
+ * explorer and pane sizing. A tab component only ever exists while it is the active one, so anything a
+ * tab needs to survive being switched away from (a drawer's own selection, the persisted panel chrome)
+ * has to live here instead of on the tab itself. Every member below is named and shaped exactly like the
+ * panel's own field/method it stands in for.
+ *
+ * @see injectQueryDevtoolsHost
+ */
+type QueryDevtoolsHost = {
+    selectTab(tab: DevtoolsTab): void;
+    /** Jumps to the Queries tab with this query selected - the Events tab is a way in, not a dead end. */
+    selectQuery(id: string): void;
+    /** Jumps to the Forms tab with this form selected. */
+    selectForm(id: string): void;
+    queryEntries: Signal<QueryDevtoolsEntry[]>;
+    stackEntries: Signal<QueryDevtoolsEntry[]>;
+    sequenceEntries: Signal<QueryDevtoolsEntry[]>;
+    formEntries: Signal<QueryDevtoolsEntry[]>;
+    authEntries: Signal<QueryDevtoolsEntry[]>;
+    wsEntries: Signal<QueryDevtoolsEntry[]>;
+    repositories: Signal<RepositoryInfo[]>;
+    /**
+     * The cache per client, with every entry's size measured. Reading each response inside the computed is
+     * what keeps the totals current: a cache mutation bumps `cacheVersion`, but a response landing in an
+     * entry that is already there does not.
+     */
+    cacheView: Signal<CacheView[]>;
+    refetchCacheEntry(entry: QueryRepositoryCacheEntry): void;
+    evictCacheEntry(repository: QueryRepository, key: string): void;
+    /** Drops every entry of one client, consumers included - the cold-start check that does not need a reload. */
+    evictAllCacheEntries(repository: QueryRepository): void;
+    toggleCacheValue(clientName: string, key: string): void;
+    isCacheValueExpanded(clientName: string, key: string): boolean;
+    cacheFreshness(entry: QueryRepositoryCacheEntry): string;
+    cacheSync(entry: QueryRepositoryCacheEntry, pollStates: Record<string, unknown>): string;
+    cachePersistence(entry: QueryRepositoryCacheEntry): string;
+    /** How many responses this client has on disk, which is usually more than it has in memory. */
+    persistedCount(client: QueryClient): number;
+    clearPersistedQueries(client: QueryClient): void;
+    /** The features of the client behind a cache tab card, or `null` for a client without any. */
+    clientFeatures(client: QueryClient | null | undefined): QueryDevtoolsFeature[] | null;
+    /** Unique client names present across queries and auth providers, for the Queries/Timeline pickers. */
+    clientNames: Signal<string[]>;
+    /** What each tab holds - also drives the tab bar's own badges, so it lives here rather than per-tab. */
+    tabBadges: Signal<Record<DevtoolsTab, TabBadge>>;
+    /**
+     * Every client the Faults tab can arm, with the fault it currently carries. Also feeds the
+     * cross-tab "Faults armed" banner and the session export, so it lives here rather than on the tab.
+     */
+    faultClients: Signal<{
+        name: string;
+        baseUrl: string;
+        fault: QueryDevtoolsFault;
+        armed: boolean;
+    }[]>;
+    /**
+     * The queries in scope before the Queries tab's own search box and status chips narrow them further:
+     * either the picked client's, or exactly the inspected element's. Also what the Timeline tab scopes
+     * its runs to, which is why this lives here rather than on the Queries tab alone.
+     */
+    scopedQueries: Signal<QueryDevtoolsEntry[]>;
+    /** 1-second tick driving every countdown/freshness readout across tabs. */
+    clock: Signal<number>;
+    findQuery(id: string | null): QueryDevtoolsSelection | null;
+    queryLinkFor(entry: QueryDevtoolsEntry | undefined, query?: AnyQuery): QueryLink;
+    asStack(entry: QueryDevtoolsEntry): AnyQueryStack;
+    asPagedStack(entry: QueryDevtoolsEntry): AnyPagedQueryStack;
+    asSequence(entry: QueryDevtoolsEntry): QuerySequence<unknown[]>;
+    asAuth(entry: QueryDevtoolsEntry): AnyBearerAuthProvider;
+    asWs(entry: QueryDevtoolsEntry): WebSocketDevtoolsHandle;
+    asForm(entry: QueryDevtoolsEntry): QueryDevtoolsFormHandle;
+    authTokenPayload(auth: AnyBearerAuthProvider): Record<string, unknown> | null;
+    authQueryKeys(auth: AnyBearerAuthProvider): string[];
+    /** The access-token expiry the app acts on, plus the lifetime the panel has armed over it. */
+    authTokenLifetime(entry: QueryDevtoolsEntry): QueryDevtoolsTokenLifetime;
+    /** The multi-tab leadership chip, or `null` for a provider without `withBearerAuthMultiTabSync`. */
+    authLeadership(auth: AnyBearerAuthProvider): QueryDevtoolsLeadership | null;
+    queryStatus(query: AnyQuery): 'idle' | 'loading' | 'success' | 'error';
+    isStale(query: AnyQuery): boolean;
+    /** Whether an entry is showing an armed response override or a devtools-faulted outcome. */
+    isTampered(entry: QueryDevtoolsEntry): boolean;
+    /** Whether armed response overrides are stored and replayed on the next load. */
+    overridesPersist(): boolean;
+    toggleOverridesPersist(): void;
+    /** Where they are kept, named for a title or a hint (`sessionStorage`, `localStorage`, `not kept`). */
+    overridesScopeLabel(): string;
+    /** Puts the panel's layout, filters, pins and stored overrides back to defaults, keeping the settings. */
+    resetDevtools(): void;
+    requestProgress(query: AnyQuery): RequestProgress | null;
+    retryCause(status: number): string;
+    requestUrl(query: AnyQuery): string | null;
+    requestPath(url: string): string;
+    queryArgs(query: AnyQuery): unknown;
+    routeSegments(entry: QueryDevtoolsEntry | undefined, query: AnyQuery): RouteSegment[];
+    queryActivity(entry: QueryDevtoolsEntry): QueryActivity;
+    linkActivity(link: QueryLink): QueryActivity;
+    stackActivity(stack: AnyQueryStack | AnyPagedQueryStack): QueryActivity;
+    sequenceActivity(sequence: QuerySequence<unknown[]>): QueryActivity;
+    queriesForStack(stack: AnyQueryStack | AnyPagedQueryStack): QueryLink[];
+    queriesForSequence(sequence: QuerySequence<unknown[]>): QueryLink[];
+    /**
+     * The queries a form feeds, discovered from the reads its `value()` recorded while their args were
+     * built - so a form that nothing consumes yet reads as exactly that.
+     */
+    queriesDrivenByForm(entry: QueryDevtoolsEntry): QueryLink[];
+    sequenceStepStatus(sequence: QuerySequence<unknown[]>, index: number): QuerySequenceStatus;
+    stepSnapshot(sequence: QuerySequence<unknown[]>, index: number): AnyQuerySnapshot | null;
+    /** Whether a sequence step's in/out detail (`<entryId>:<stepIndex>`) is expanded - persisted. */
+    isStepExpanded(entryId: string, index: number): boolean;
+    toggleStep(entryId: string, index: number): void;
+    /** Keys of the Queries-list groups of identical rows the user opened - persisted. */
+    expandedQueryGroups: Signal<ReadonlySet<string>>;
+    toggleQueryGroup(key: string): void;
+    expandQueryGroup(key: string): void;
+    /** Which way the Queries list sorts by last-executed time - persisted. */
+    queryRecentFirst: WritableSignal<boolean>;
+    /** Whether the Queries list is arranged as a tree of route paths instead of a flat list - persisted. */
+    queryTreeView: WritableSignal<boolean>;
+    /** The path folders the user closed. Collapsed, not expanded - a tree opens open. */
+    collapsedQueryPaths: Signal<ReadonlySet<string>>;
+    toggleQueryPath(key: string): void;
+    /** The element a query was created in, or `null` for one created outside a component/directive. */
+    locatableElement(entry: QueryDevtoolsEntry): HTMLElement | null;
+    locateQuery(entry: QueryDevtoolsEntry): void;
+    locateState: Signal<'idle' | 'located' | 'offscreen'>;
+    resetStats(entry: QueryDevtoolsEntry): void;
+    executeQuery(selection: QueryDevtoolsSelection, allowCache: boolean): void;
+    resetQuery(query: AnyQuery): void;
+    formatDuration(ms: number | null): string;
+    formatBytes(bytes: number): string;
+    formatTransferred(bytes: number, isEstimated: boolean): string;
+    formatSpeed(bytesPerSecond: number): string;
+    formatPercent(percentage: number): string;
+    formatCountdown(ms: number | null): string;
+    formatTime(timestamp: number | null): string;
+    gqlDocument(doc: string): string;
+    inlineValue(value: unknown): string;
+    featureLabel(type: string): string;
+    featureSummary(feature: QueryDevtoolsFeature): string;
+    detailTab: WritableSignal<DetailTab>;
+    editorMode: WritableSignal<'none' | 'response' | 'args'>;
+    responseDraft: WritableSignal<string>;
+    argsDraft: WritableSignal<string>;
+    /** The text the currently open editor was seeded with - not a signal, see the field's own doc. */
+    editorSeed: string;
+    editError: Signal<string | null>;
+    openResponseEditor(query: AnyQuery): void;
+    openArgsEditor(selection: QueryDevtoolsSelection): void;
+    applyResponse(query: AnyQuery): void;
+    applyArgs(query: AnyQuery): void;
+    cancelEditor(): void;
+    forceLoading(query: AnyQuery): void;
+    forceError(query: AnyQuery): void;
+    forceEmpty(query: AnyQuery): void;
+    clearForced(query: AnyQuery): void;
+    diffRunIndex: WritableSignal<number | null>;
+    /** The run the diff compares against, or `null` to derive it - see the panel's own field. */
+    diffBaseRunIndex: WritableSignal<number | null>;
+    toggleRunDiff(entry: QueryDevtoolsEntry, run: QueryDevtoolsRun): void;
+    /** Which end of the open diff a run is, or `null` if it is not one of the two. */
+    diffRunRole(entry: QueryDevtoolsEntry, run: QueryDevtoolsRun): 'base' | 'compare' | null;
+    responseDiff(entry: QueryDevtoolsEntry): {
+        before: QueryDevtoolsRun;
+        after: QueryDevtoolsRun;
+        diff: QueryDevtoolsDiff;
+    } | null;
+    canDiffRun(entry: QueryDevtoolsEntry, run: QueryDevtoolsRun): boolean;
+    queryRuns(entry: QueryDevtoolsEntry): QueryDevtoolsRun[];
+    runStatus(run: QueryDevtoolsRun): string;
+    /** How many bodies a query retains, which is what bounds how far back a diff can reach. */
+    retainedResponseCount: Signal<number>;
+    /** Moves the whole response diff one run older or newer, from the diff header. */
+    canStepRunDiff(entry: QueryDevtoolsEntry, older: boolean): boolean;
+    stepRunDiff(entry: QueryDevtoolsEntry, older: boolean): void;
+    errorRunIndex: WritableSignal<number | null>;
+    toggleRunError(run: QueryDevtoolsRun): void;
+    pickedRunError(entry: QueryDevtoolsEntry): {
+        run: QueryDevtoolsRun;
+        error: QueryDevtoolsRunError;
+    } | null;
+    copiedReport: Signal<boolean>;
+    copiedInsomnia: Signal<boolean>;
+    copiedCurl: Signal<boolean>;
+    copiedGql: Signal<boolean>;
+    copiedRoute: Signal<boolean>;
+    copyReport(entry: QueryDevtoolsEntry, query: AnyQuery): void;
+    copyInsomniaRequest(entry: QueryDevtoolsEntry, query: AnyQuery): void;
+    copyCurlRequest(entry: QueryDevtoolsEntry, query: AnyQuery): void;
+    copyGqlDocument(doc: string): void;
+    /** The absolute URL of the last request, or the rendered route for a query that has not run. */
+    copyableRoute(entry: QueryDevtoolsEntry, query: AnyQuery): string;
+    copyableRouteTitle(entry: QueryDevtoolsEntry, query: AnyQuery): string;
+    copyRoute(entry: QueryDevtoolsEntry, query: AnyQuery): void;
+    refreshesFor(entryId: string): {
+        id: number;
+        timestamp: number;
+        label: string;
+    }[];
+    /** What asked for a refresh, on one line - shared by the drawer's "Refetched by" and the Events tab. */
+    causeLabel(cause: QueryRefreshCause): string;
+    formsDrivingQuery(entry: QueryDevtoolsEntry): QueryDevtoolsEntry[];
+    /** Shared value-explorer search term, read (and set) from every drawer's Data sub-tab. */
+    jsonSearch: WritableSignal<string>;
+    jsonSearchTerm: Signal<string>;
+    jsonExpandedPaths: Signal<ReadonlySet<string>>;
+    jsonCollapsedPaths: Signal<ReadonlySet<string>>;
+    toggleJsonPath(path: string, expand: boolean): void;
+    selectedClientName: WritableSignal<string | null>;
+    selectedQueryId: WritableSignal<string | null>;
+    selectedQuery: Signal<{
+        entry: QueryDevtoolsEntry;
+        query: AnyQuery;
+    } | null>;
+    queryFilter: WritableSignal<string>;
+    queryFacets: WritableSignal<ReadonlySet<QueryListFacet>>;
+    /** The entry ids sorted to the top of the Queries list. Persisted apart from the rest - see the panel. */
+    pinnedQueryIds: Signal<ReadonlySet<string>>;
+    isQueryPinned(entry: QueryDevtoolsEntry): boolean;
+    toggleQueryPin(entry: QueryDevtoolsEntry): void;
+    /** When set (via inspect), the Queries list is filtered to exactly these entry ids. */
+    inspectFilterIds: WritableSignal<string[] | null>;
+    selectClient(name: string | null): void;
+    clearInspectFilter(): void;
+    toggleFacet(facet: QueryListFacet): void;
+    /** Drops the search term and the status chips, keeping the client / inspection scope. */
+    clearQueryFilters(): void;
+    /**
+     * Downloads the given queries (already scoped/filtered by the caller) as one Insomnia collection,
+     * filed into a folder per query client.
+     */
+    downloadInsomniaCollection(items: {
+        entry: QueryDevtoolsEntry;
+        query: AnyQuery;
+    }[], clientLabel: string | null): void;
+    /** Downloads a file a tab generated. The panel does it because the panel owns the download injector. */
+    downloadTextFile(file: {
+        name: string;
+        content: string;
+        type: string;
+    }): void;
+    stackSelectedQueryId: WritableSignal<string | null>;
+    stackSelectedQuery: Signal<{
+        entry: QueryDevtoolsEntry;
+        query: AnyQuery;
+    } | null>;
+    sequenceSelectedQueryId: WritableSignal<string | null>;
+    sequenceSelectedQuery: Signal<{
+        entry: QueryDevtoolsEntry;
+        query: AnyQuery;
+    } | null>;
+    formSelectedQueryId: WritableSignal<string | null>;
+    formSelectedQuery: Signal<{
+        entry: QueryDevtoolsEntry;
+        query: AnyQuery;
+    } | null>;
+    /** The form whose detail the Forms tab has expanded - persisted. */
+    selectedFormId: WritableSignal<string | null>;
+    /** The rolling event log - persisted only in the sense that it survives a tab switch, not a reload. */
+    eventLog: WritableSignal<EventLogItem[]>;
+    /** The client (by base URL) the event log is scoped to, or `null` for all of them - persisted. */
+    eventClient: WritableSignal<string | null>;
+    /** Whether the event log is narrowed to failures - persisted. */
+    eventErrorsOnly: WritableSignal<boolean>;
+    /** Free-text narrowing of every socket's message log - persisted. */
+    socketFilter: WritableSignal<string>;
+    socketMessages(ws: WebSocketDevtoolsHandle): WebSocketDevtoolsMessage[];
+    socketDirectionLabel(message: WebSocketDevtoolsMessage): string;
+    emitSocketMessage(options: {
+        entry: QueryDevtoolsEntry;
+        event: string;
+        data: string;
+    }): void;
+    /** The message an emit box last failed with, if this is the socket it failed on. */
+    socketEmitErrorFor(entryId: string): string | null;
+    timelineSelectedQueryId: WritableSignal<string | null>;
+    timelineSelectedQuery: Signal<{
+        entry: QueryDevtoolsEntry;
+        query: AnyQuery;
+    } | null>;
+    paneAxis: Signal<PaneAxis>;
+    listWidth: Signal<number | null>;
+    drawerWidth: Signal<number | null>;
+    listHeight: Signal<number | null>;
+    drawerHeight: Signal<number | null>;
+    startPaneResize(event: PointerEvent, target: {
+        pane: PaneTarget;
+        container: HTMLElement;
+    }): void;
+    resetPaneSize(pane: PaneTarget): void;
+};
+
+type ScopeKey = 'viewState' | 'pins' | 'overrides' | 'mocks' | 'armedMocks' | 'armedFaults';
+type ScopeRow = {
+    key: ScopeKey;
+    label: string;
+    /** What is kept, and what `none` costs - the one thing a scope picker cannot show on its own. */
+    hint: string;
+    /**
+     * What to say on the scopes that let this state outlive the page that armed it - a picker cannot show
+     * that an app is about to start lying to itself before anyone opens the panel.
+     */
+    warn?: {
+        scopes: QueryDevtoolsStorageScope[];
+        text: string;
+    };
+};
+type LimitKey = 'maxEvents' | 'maxDroppedCacheEntries';
+type LimitRow = {
+    key: LimitKey;
+    label: string;
+    min: number;
+    max: number;
+    step: number;
+    hint: string;
+};
+/**
+ * Every panel-wide switch in one place - the storage each kind of state uses, the limits the panel would
+ * otherwise hold as constants, and the toggles their own tabs also carry.
+ */
+declare class QueryDevtoolsSettingsComponent {
+    protected host: QueryDevtoolsHost;
+    protected readonly SCOPE_ROWS: ScopeRow[];
+    protected readonly SCOPES: {
+        value: QueryDevtoolsStorageScope;
+        label: string;
+    }[];
+    protected readonly INDEXED_DB_TITLE = "Unavailable: these are read synchronously - view state before the first render, overrides before the first fetch - and IndexedDB cannot answer in time. Only the mock library could tolerate an async store, and it is not wired to one yet.";
+    protected readonly LIMIT_ROWS: LimitRow[];
+    protected readonly ARM_ALL_MOCKS: () => void;
+    protected readonly DISARM_ALL_MOCKS: () => void;
+    protected readonly DISARM_ALL_FAULTS: (clientName?: string) => void;
+    /** What queries actually retain, which is the application's value unless this panel raised it. */
+    protected responseHistory: _angular_core.Signal<number>;
+    protected mockCount: _angular_core.Signal<number>;
+    protected armedMockCount: _angular_core.Signal<number>;
+    protected armedFaultCount: _angular_core.Signal<number>;
+    protected resetConfirming: _angular_core.WritableSignal<boolean>;
+    protected settings(): _ethlete_query.QueryDevtoolsSettings;
+    protected scopeOf(key: ScopeKey): QueryDevtoolsStorageScope;
+    protected limitOf(key: LimitKey): number;
+    /** What the picked scope means beyond where the state is kept, or `null` while it means nothing extra. */
+    protected warningFor(row: ScopeRow, scope: QueryDevtoolsStorageScope): string | null;
+    protected setScope(key: ScopeKey, scope: QueryDevtoolsStorageScope): void;
+    protected setLimit(key: LimitKey, value: string): void;
+    protected setResponseHistory(value: string): void;
+    /** Hands retention back to `provideQueryDevtools({ responseHistory })`. */
+    protected clearResponseHistory(): void;
+    protected reset(): void;
+    protected toggleGoneQueries(): void;
+    protected showsGoneQueries(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryDevtoolsSettingsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QueryDevtoolsSettingsComponent, "et-query-devtools-settings", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The waterfall's grid, axis and bars, as a styles-only component the panel mounts when the Timeline tab
+ * is first opened.
+ *
+ * @internal
+ */
+declare class QueryDevtoolsTimelineStylesComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryDevtoolsTimelineStylesComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QueryDevtoolsTimelineStylesComponent, "et-query-devtools-timeline-styles", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Where the panel sits: attached to an edge, or floating over the page as a window of its own. A
+ * pop-out is not one of these - that is a real browser window, not a position in this document.
+ */
+type DevtoolsDock = 'bottom' | 'top' | 'left' | 'right' | 'float';
+/** What the layout menu offers, in the order it lists them. `popout` is a window, not a position. */
+type DevtoolsLayout = DevtoolsDock | 'popout';
+/** The floating panel's position and size, in CSS px from the viewport's top-left. */
+type FloatRect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/**
+ * A drag in progress: the panel's docked edge, the floating panel being moved or resized, or the
+ * divider between a two-pane tab's panes.
+ */
+type ResizeDrag = {
+    /** The document the pointer moves in - a popped-out panel lives in a window of its own. */
+    doc: Document;
+} & ({
+    kind: 'panel';
+} | {
+    kind: 'pane';
+    pane: PaneTarget;
+    axis: PaneAxis;
+    container: HTMLElement;
+});
+type PersistedState = {
+    open?: boolean;
+    height?: number;
+    width?: number;
+    listWidth?: number | null;
+    drawerWidth?: number | null;
+    listHeight?: number | null;
+    drawerHeight?: number | null;
+    dock?: DevtoolsDock;
+    floatRect?: FloatRect;
+    floatParked?: boolean;
+    activeTab?: DevtoolsTab;
+    detailTab?: DetailTab;
+    selectedClientName?: string | null;
+    selectedQueryId?: string | null;
+    selectedFormId?: string | null;
+    inspectFilterIds?: string[] | null;
+    queryFilter?: string;
+    queryFacets?: QueryListFacet[];
+    queryRecentFirst?: boolean;
+    queryTreeView?: boolean;
+    collapsedQueryPaths?: string[];
+    eventClient?: string | null;
+    eventErrorsOnly?: boolean;
+    socketFilter?: string;
+    jsonSearch?: string;
+    expandedSteps?: string[];
+    expandedQueryGroups?: string[];
+    jsonExpanded?: string[];
+    jsonCollapsed?: string[];
+};
+type ViewportSize = {
+    width: number;
+    height: number;
+};
+/**
+ * The loosest a float may sit: shoved off an edge with only {@link FLOAT_PEEK} left, which is what a
+ * drag and a parked panel are held to. **North is never a parking edge** - the title bar is the only
+ * thing that drags the panel back, so it may never be the part that leaves.
+ */
+declare const clampFloatToPeek: (rect: FloatRect, viewport: ViewportSize) => FloatRect;
+/**
+ * Where a float settles when the pointer is released. Dragged more than halfway off an edge, it stays
+ * parked there with {@link FLOAT_PEEK} showing - the panel gets out of the way of the thing you are
+ * debugging without being closed. Anything short of halfway is pulled back in, so a slightly clumsy
+ * drag does not park it.
+ */
+declare const settledFloatRect: (rect: FloatRect, viewport: ViewportSize) => {
+    rect: FloatRect;
+    collapsed: boolean;
+};
+/**
+ * The rect a resize gesture from `edge` produces, given where the panel was when the gesture started.
+ * A west or north drag grows away from the edge that stays pinned, so the origin follows whatever
+ * size the drag settled on - including when the size hit its floor and the origin must stop with it.
+ */
+declare const resizedFloatRect: (base: FloatRect, { move, viewport }: {
+    move: ResizeMoveEvent;
+    viewport: ViewportSize;
+}) => FloatRect;
+/**
+ * A floating, dockable panel that inspects the live state of the signals-first `@ethlete/query`
+ * system: queries, stacks, sequences, bearer auth providers, the repository cache and a rolling
+ * event log.
+ *
+ * Requires `provideQueryDevtools()` in the application providers - without it the registry stays
+ * empty and the panel shows nothing.
+ */
+declare class QueryDevtoolsComponent implements OnInit {
+    private hostEl;
+    private renderer;
+    private download;
+    private styleManager;
+    private zone;
+    private destroyRef;
+    private document;
+    private viewport;
+    /**
+     * Opens the panel as soon as it is created, whatever the stored view state says. Set by
+     * `<et-query-devtools-lazy>`, which downloads the panel on the click that was meant to open it.
+     */
+    startOpen: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The panel itself, so a pop-out can move it into another window's document. */
+    private panelEl;
+    private eventIdCounter;
+    private lastSelectionKey;
+    /** Where the gear goes back to, so opening Settings does not lose the tab it was opened over. */
+    private tabBeforeSettings;
+    readonly persisted: PersistedState;
+    protected readonly tabs: ({
+        id: "queries";
+        label: string;
+    } | {
+        id: "stacks";
+        label: string;
+    } | {
+        id: "sequences";
+        label: string;
+    } | {
+        id: "forms";
+        label: string;
+    } | {
+        id: "auth";
+        label: string;
+    } | {
+        id: "ws";
+        label: string;
+    } | {
+        id: "cache";
+        label: string;
+    } | {
+        id: "timeline";
+        label: string;
+    } | {
+        id: "events";
+        label: string;
+    } | {
+        id: "faults";
+        label: string;
+    } | {
+        id: "mocks";
+        label: string;
+    } | {
+        id: "about";
+        label: string;
+    })[];
+    /**
+     * Tabs the bar keeps whether they hold anything or not: the one the panel opens on, and the one that
+     * arms faults - which has entries to arm rather than to count.
+     */
+    private readonly PINNED_TABS;
+    protected readonly shortcut: "⌘⌥Q" | "Ctrl+Alt+Q";
+    protected readonly LAYOUTS: readonly [{
+        readonly id: "bottom";
+        readonly glyph: "⬓";
+        readonly label: "Bottom";
+        readonly hint: "Dock to the bottom edge";
+    }, {
+        readonly id: "top";
+        readonly glyph: "⬒";
+        readonly label: "Top";
+        readonly hint: "Dock to the top edge";
+    }, {
+        readonly id: "left";
+        readonly glyph: "◧";
+        readonly label: "Left";
+        readonly hint: "Dock to the left edge";
+    }, {
+        readonly id: "right";
+        readonly glyph: "◨";
+        readonly label: "Right";
+        readonly hint: "Dock to the right edge";
+    }, {
+        readonly id: "float";
+        readonly glyph: "❐";
+        readonly label: "Float";
+        readonly hint: "A window inside the page - move it, resize it, shove it off an edge to park it";
+    }, {
+        readonly id: "popout";
+        readonly glyph: "⧉";
+        readonly label: "Pop out";
+        readonly hint: "Move the panel into a window of its own - the same live panel, on your other screen";
+    }];
+    protected open: WritableSignal<boolean>;
+    private panelHeight;
+    private panelWidth;
+    protected activeTab: WritableSignal<DevtoolsTab>;
+    /**
+     * The dragged sizes of the two-pane tabs, in px, one pair per axis - a side dock stacks the panes, so
+     * the same divider sizes them along the block axis there and a dock switch has to keep both. `null`
+     * keeps the stylesheet's proportional default, which is also what a double-click on a divider restores.
+     */
+    protected listWidth: WritableSignal<number | null>;
+    protected drawerWidth: WritableSignal<number | null>;
+    protected listHeight: WritableSignal<number | null>;
+    protected drawerHeight: WritableSignal<number | null>;
+    protected drag: WritableSignal<ResizeDrag | null>;
+    protected resizing: _angular_core.Signal<boolean>;
+    /** Which edge the panel is docked to, or `float` for a window of its own inside the page. */
+    protected dock: WritableSignal<DevtoolsDock>;
+    /** The entry the layout button shows, so it names where the panel is rather than where it could go. */
+    protected currentLayout: _angular_core.Signal<{
+        readonly id: "bottom";
+        readonly glyph: "⬓";
+        readonly label: "Bottom";
+        readonly hint: "Dock to the bottom edge";
+    } | {
+        readonly id: "top";
+        readonly glyph: "⬒";
+        readonly label: "Top";
+        readonly hint: "Dock to the top edge";
+    } | {
+        readonly id: "left";
+        readonly glyph: "◧";
+        readonly label: "Left";
+        readonly hint: "Dock to the left edge";
+    } | {
+        readonly id: "right";
+        readonly glyph: "◨";
+        readonly label: "Right";
+        readonly hint: "Dock to the right edge";
+    } | {
+        readonly id: "float";
+        readonly glyph: "❐";
+        readonly label: "Float";
+        readonly hint: "A window inside the page - move it, resize it, shove it off an edge to park it";
+    } | {
+        readonly id: "popout";
+        readonly glyph: "⧉";
+        readonly label: "Pop out";
+        readonly hint: "Move the panel into a window of its own - the same live panel, on your other screen";
+    }>;
+    /** Where the floating panel sits and how big it is. Kept while docked, so a return to float restores it. */
+    private floatRect;
+    /** The rect a resize gesture started from, or `null` outside one. */
+    private floatResizeBase;
+    /**
+     * Whether the float is shoved off an edge with only its peek showing. Persisted with the rect, since
+     * restoring the rect without it would either strand the panel off screen or silently un-park it.
+     */
+    protected floatParked: WritableSignal<boolean>;
+    /**
+     * The browser refused the last pop-out. `window.open` returns `null` with no error to catch, so
+     * without this the button simply did nothing - and floating is the fallback it should have offered.
+     */
+    protected popOutBlocked: WritableSignal<boolean>;
+    /**
+     * Whether the panel currently lives in a window of its own. Deliberately not persisted: a reload
+     * cannot re-adopt a window the previous document opened, so it always starts docked.
+     */
+    protected poppedOut: WritableSignal<boolean>;
+    protected floating: _angular_core.Signal<boolean>;
+    /**
+     * Below `md` a side-by-side split cannot fit: the list alone asks for `22rem` and the drawer for
+     * `26rem`, which is wider than a phone. Narrow gets the same stacked layout a right dock does.
+     */
+    private narrowViewport;
+    /** Whether the panel is docked to a side edge, which is what sizes it along the inline axis. */
+    private sideDocked;
+    /** Which axis the two-pane tabs split along. The stylesheet keys the stacked layout off the same value. */
+    protected paneAxis: _angular_core.Signal<PaneAxis>;
+    private popup;
+    /** Stops mirroring the host document's stylesheets into the pop-up. @see syncStylesInto */
+    private popOutStyleSync;
+    protected panelBlockSize: _angular_core.Signal<number | null>;
+    protected panelInlineSize: _angular_core.Signal<number | null>;
+    /** The floating panel's offset from the viewport's top-left, or `null` while it is docked. */
+    protected panelInsetBlock: _angular_core.Signal<number | null>;
+    protected panelInsetInline: _angular_core.Signal<number | null>;
+    /** Which section of the query detail is showing. Shared by the Queries tab and both drawers. */
+    detailTab: WritableSignal<DetailTab>;
+    selectedClientName: WritableSignal<string | null>;
+    selectedQueryId: WritableSignal<string | null>;
+    /** The form whose detail the Forms tab has expanded. */
+    selectedFormId: WritableSignal<string | null>;
+    stackSelectedQueryId: WritableSignal<string | null>;
+    sequenceSelectedQueryId: WritableSignal<string | null>;
+    formSelectedQueryId: WritableSignal<string | null>;
+    timelineSelectedQueryId: WritableSignal<string | null>;
+    /** Free-text narrowing of the Queries list. Every whitespace-separated term has to match. */
+    queryFilter: WritableSignal<string>;
+    /** The status facets the Queries list is narrowed to. Empty means no status narrowing. */
+    queryFacets: WritableSignal<ReadonlySet<QueryListFacet>>;
+    /**
+     * Which way the Queries list sorts by last-executed time. Only the direction is switchable - the field
+     * is not, because "which one just ran" is the question the column exists to answer.
+     */
+    queryRecentFirst: WritableSignal<boolean>;
+    /**
+     * Whether the Queries list is arranged as a tree of route paths. Off by default: the flat list is
+     * still the right shape for "what ran just now", which is what the tab is opened for most of the time.
+     */
+    queryTreeView: WritableSignal<boolean>;
+    /**
+     * The path folders the user closed. Collapsed rather than expanded, because a tree that opens closed
+     * shows nothing but the top segment of every route - which answers no question the flat list didn't.
+     */
+    collapsedQueryPaths: WritableSignal<ReadonlySet<string>>;
+    /**
+     * The entry ids sorted to the top of the Queries list. Ids are derived from a stable descriptor plus a
+     * per-descriptor sequence number, so a pin survives a reload as long as queries are created in the same
+     * order - the same property the restored selection already relies on.
+     */
+    pinnedQueryIds: WritableSignal<ReadonlySet<string>>;
+    eventLog: WritableSignal<EventLogItem[]>;
+    /**
+     * The cache entries that are gone, newest first. Kept here rather than in the repository, which stays
+     * lean in production - it emits the teardown and forgets it.
+     */
+    droppedCacheEntries: WritableSignal<DroppedCacheEntry[]>;
+    /** The client (by base URL) the event log is scoped to, or `null` for all of them. */
+    eventClient: WritableSignal<string | null>;
+    /** Whether the event log is narrowed to failures - the rows a bug report is about. */
+    eventErrorsOnly: WritableSignal<boolean>;
+    /** Free-text narrowing of every socket's message log. Matches the event, the room and the direction. */
+    socketFilter: WritableSignal<string>;
+    /** The cache entry whose response is expanded, as `<client>|<key>`, or `null` while none is. */
+    private expandedCacheKey;
+    /** The socket whose emit box last failed, so the message shows on that card and no other. */
+    private socketEmitError;
+    /** Keys (`<entryId>:<stepIndex>`) of the sequence steps whose in/out detail is expanded. */
+    private expandedSteps;
+    /** Keys of the Queries-list groups the user opened - the tab is rebuilt on every switch back. */
+    expandedQueryGroups: WritableSignal<ReadonlySet<string>>;
+    /** Shared value-explorer search term. */
+    jsonSearch: WritableSignal<string>;
+    jsonSearchTerm: _angular_core.Signal<string>;
+    /** Path-keyed value-explorer expansion overrides (persisted so open trees survive a reload). */
+    jsonExpandedPaths: WritableSignal<ReadonlySet<string>>;
+    jsonCollapsedPaths: WritableSignal<ReadonlySet<string>>;
+    /** Bound callback passed into the value explorer to persist per-path expansion. Assigned in the constructor. */
+    toggleJsonPath: (path: string, expand: boolean) => void;
+    /** The run whose response the diff is comparing, by run index, or `null` while no diff is open. */
+    diffRunIndex: WritableSignal<number | null>;
+    /**
+     * The run the diff compares it *against*, or `null` to derive that side - the newest older run that
+     * still holds a body, which is what one click on **Diff** gives you.
+     */
+    diffBaseRunIndex: WritableSignal<number | null>;
+    errorRunIndex: WritableSignal<number | null>;
+    /** How many bodies a query retains, which is what bounds how far back a diff can reach. */
+    retainedResponseCount: _angular_core.Signal<number>;
+    /** JIT editor state (response / args editing on the selected query). */
+    editorMode: WritableSignal<"none" | "response" | "args">;
+    responseDraft: WritableSignal<string>;
+    argsDraft: WritableSignal<string>;
+    /**
+     * The text the currently open editor was seeded with. The textareas bind `value` to this and not to
+     * the live draft: a `value` binding fed by the draft is written back on every keystroke, and writing
+     * a textarea's `value` puts the caret at the end.
+     */
+    editorSeed: string;
+    editError: WritableSignal<string | null>;
+    /** The args the open editor was seeded from, so applying can put back what the draft cannot carry. */
+    private editedArgsSource;
+    /** Transient "Copied!" feedback for the copy-report, copy-as-Insomnia / cURL and copy-document actions. */
+    copiedReport: WritableSignal<boolean>;
+    copiedInsomnia: WritableSignal<boolean>;
+    copiedCurl: WritableSignal<boolean>;
+    copiedGql: WritableSignal<boolean>;
+    copiedRoute: WritableSignal<boolean>;
+    private copiedReset$;
+    /** 1-second tick driving the cache freshness countdowns. */
+    private clock;
+    /** "Inspect" mode: hover the live UI to find the query that a component created. */
+    protected inspectActive: WritableSignal<boolean>;
+    protected inspectHover: WritableSignal<{
+        rect: DOMRect;
+        entries: QueryDevtoolsEntry[];
+    } | null>;
+    /** Inspect run backwards: the box drawn over the element the selected query was created in. */
+    protected locatedRect: WritableSignal<DOMRect | null>;
+    locateState: WritableSignal<"idle" | "located" | "offscreen">;
+    private locate$;
+    /** When set (via inspect), the Queries list is filtered to exactly these entry ids. */
+    inspectFilterIds: WritableSignal<string[] | null>;
+    private queryEntries;
+    /**
+     * The queries that still exist. Everything that measures what the application is doing right now -
+     * the tab bar's error flags, the tamper dot, the timeline, the identity match behind an event row -
+     * reads this rather than {@link queryEntries}, so a tombstone never inflates a live number.
+     */
+    private liveQueryEntries;
+    protected panelTampered: _angular_core.Signal<boolean>;
+    stackEntries: _angular_core.Signal<QueryDevtoolsEntry[]>;
+    sequenceEntries: _angular_core.Signal<QueryDevtoolsEntry[]>;
+    formEntries: _angular_core.Signal<QueryDevtoolsEntry[]>;
+    authEntries: _angular_core.Signal<QueryDevtoolsEntry[]>;
+    wsEntries: _angular_core.Signal<QueryDevtoolsEntry[]>;
+    /** Unique client names present across queries and auth providers, for the Queries-tab picker. */
+    clientNames: _angular_core.Signal<string[]>;
+    /** Unique repositories (with their client name + base URL) used by the Cache and Events tabs. */
+    private repositories;
+    /**
+     * Every client the Faults tab can arm, with the fault it currently carries. Clients with nothing armed
+     * read as {@link EMPTY_QUERY_DEVTOOLS_FAULT} so the inputs always have a value to show.
+     */
+    faultClients: _angular_core.Signal<{
+        name: string;
+        baseUrl: string;
+        fault: _ethlete_query.QueryDevtoolsFault;
+        armed: boolean;
+    }[]>;
+    /**
+     * The names of the clients currently carrying a fault, or `null` when none do - so a template can `@if`
+     * on it. Armed faults are the one state where the panel is lying to the app on purpose, and a badge on a
+     * tab that isn't open cannot say that: whichever tab you are reading, a red response has to be
+     * attributable to the injection rather than to the API.
+     */
+    protected armedFaultClients: _angular_core.Signal<string[] | null>;
+    /**
+     * The routes currently answered by a designed mock, for the shell's banner. A mocked response is a
+     * stronger lie than an override - nothing was sent at all - so it is named above every tab, not just
+     * badged on the one that armed it.
+     */
+    protected armedMockRoutes: _angular_core.Signal<string[] | null>;
+    /**
+     * The queries the list is scoped to before the search box and the status chips narrow them further:
+     * either the picked client's, or exactly the inspected element's.
+     */
+    scopedQueries: _angular_core.Signal<QueryDevtoolsEntry[]>;
+    /** How many runs every query has recorded, for the Timeline tab's badge. */
+    private runTotals;
+    /** Cache entries across every client, for the Cache tab's badge. */
+    private cacheEntryCount;
+    /**
+     * What each tab holds, so a failing query in a tab that is not open is still visible. Reading it
+     * subscribes the tab bar to every entry's live state - which is the point of the badges.
+     */
+    protected tabBadges: _angular_core.Signal<Record<DevtoolsTab, TabBadge>>;
+    /**
+     * The tabs the bar shows: the pinned ones, the one that is open, and every tab that currently holds
+     * something.
+     */
+    protected visibleTabs: _angular_core.Signal<({
+        id: "queries";
+        label: string;
+    } | {
+        id: "stacks";
+        label: string;
+    } | {
+        id: "sequences";
+        label: string;
+    } | {
+        id: "forms";
+        label: string;
+    } | {
+        id: "auth";
+        label: string;
+    } | {
+        id: "ws";
+        label: string;
+    } | {
+        id: "cache";
+        label: string;
+    } | {
+        id: "timeline";
+        label: string;
+    } | {
+        id: "events";
+        label: string;
+    } | {
+        id: "faults";
+        label: string;
+    } | {
+        id: "mocks";
+        label: string;
+    } | {
+        id: "about";
+        label: string;
+    })[]>;
+    /** The empty tabs, which the bar offers behind "More" instead. */
+    protected overflowTabs: _angular_core.Signal<({
+        id: "queries";
+        label: string;
+    } | {
+        id: "stacks";
+        label: string;
+    } | {
+        id: "sequences";
+        label: string;
+    } | {
+        id: "forms";
+        label: string;
+    } | {
+        id: "auth";
+        label: string;
+    } | {
+        id: "ws";
+        label: string;
+    } | {
+        id: "cache";
+        label: string;
+    } | {
+        id: "timeline";
+        label: string;
+    } | {
+        id: "events";
+        label: string;
+    } | {
+        id: "faults";
+        label: string;
+    } | {
+        id: "mocks";
+        label: string;
+    } | {
+        id: "about";
+        label: string;
+    })[]>;
+    selectedQuery: _angular_core.Signal<{
+        entry: QueryDevtoolsEntry;
+        query: AnyQuery;
+    } | null>;
+    stackSelectedQuery: _angular_core.Signal<{
+        entry: QueryDevtoolsEntry;
+        query: AnyQuery;
+    } | null>;
+    sequenceSelectedQuery: _angular_core.Signal<{
+        entry: QueryDevtoolsEntry;
+        query: AnyQuery;
+    } | null>;
+    formSelectedQuery: _angular_core.Signal<{
+        entry: QueryDevtoolsEntry;
+        query: AnyQuery;
+    } | null>;
+    timelineSelectedQuery: _angular_core.Signal<{
+        entry: QueryDevtoolsEntry;
+        query: AnyQuery;
+    } | null>;
+    /**
+     * The cache per client, with every entry's size measured. Reading each response inside the computed is
+     * what keeps the totals current: a cache mutation bumps `cacheVersion`, but a response landing in an
+     * entry that is already there does not.
+     */
+    cacheView: _angular_core.Signal<{
+        name: string;
+        baseUrl: string;
+        repository: QueryRepository;
+        rows: CacheRow[];
+        bytes: number;
+        isEstimatedBytes: boolean;
+        unused: number;
+        pollStates: Record<string, QueryKeyLockState>;
+        client: QueryClient | null;
+        dropped: DroppedCacheEntry[];
+    }[]>;
+    /** Map of a component's host element to the query entries it created (for the inspect tool). */
+    private elementQueryMap;
+    /** Disarms every client's fault - the shell's "Faults armed" banner offers this above every tab. */
+    protected readonly CLEAR_FAULTS: (clientName?: string) => void;
+    /** Whether what is armed came back from a previous page load, which is what the bars have to say. */
+    protected faultsRestored: _angular_core.Signal<boolean>;
+    protected mocksRestored: _angular_core.Signal<boolean>;
+    /** Stops serving every designed mock - the shell's "Mocks armed" banner offers the same way out. */
+    protected readonly DISARM_MOCKS: () => void;
+    /**
+     * What the previous page load left armed: how many ops came back, how many queries took them, and the
+     * ids nothing claimed. `null` when this page inherited nothing, so a template can `@if` on it.
+     */
+    protected restoredOverrides: _angular_core.Signal<{
+        queries: number;
+        ops: number;
+        firstId: string | null;
+        orphaned: string[];
+        fromLocalStorage: boolean;
+    } | null>;
+    /** Drops everything the reload re-armed, and empties the store it came from. */
+    protected readonly DROP_RESTORED_OVERRIDES: () => void;
+    /** Every edge, so a float resizes the way a window does rather than only from one corner. */
+    protected readonly FLOAT_RESIZE_EDGES: ResizeEdge[];
+    constructor();
+    ngOnInit(): void;
+    /** @see queryDevtoolsOverridePersistence */
+    overridesPersist(): boolean;
+    toggleOverridesPersist(): void;
+    /** Where armed overrides are kept, as the drawer's toggle and the Settings picker both name it. */
+    overridesScopeLabel(): string;
+    /**
+     * Puts the panel back the way it ships: layout, filters, selections, pins and the stored overrides.
+     * The settings themselves stay - a panel behaving oddly is a reason to reset its state, not to lose the
+     * scopes and limits that were chosen deliberately.
+     *
+     * Resetting the live state is the point, not just clearing the keys: the persistence effects would
+     * write the current state straight back into whatever store the scopes name.
+     */
+    resetDevtools(): void;
+    /**
+     * Opens Settings over whatever tab is showing, and the same click closes it again. Settings is not in
+     * the tab bar - see {@link DevtoolsTab}.
+     */
+    protected toggleSettings(): void;
+    /** Opens the first query the reload re-armed, so the banner leads somewhere rather than just warning. */
+    protected reviewRestoredOverrides(id: string): void;
+    /**
+     * Closing while popped out docks back instead: the panel a pop-out shows is the very element the
+     * `@if` below would destroy, so it has to come home before it can be closed.
+     */
+    protected toggleOpen(): void;
+    protected floatPanel(): void;
+    protected selectLayout(layout: DevtoolsLayout): void;
+    /**
+     * Moves the panel into a window of its own - the same element, adopted by the pop-up's document, so
+     * every signal binding in it keeps updating from the app it is inspecting.
+     *
+     * The panel's styles are global `<style>` tags in the host document, and the theming tokens it reads
+     * hang off the root element, so both are copied over; without them the pop-out renders unstyled.
+     */
+    popOut(): void;
+    selectClient(name: string | null): void;
+    clearInspectFilter(): void;
+    toggleFacet(facet: QueryListFacet): void;
+    /** Drops the search term and the status chips, keeping the client / inspection scope. */
+    clearQueryFilters(): void;
+    isQueryPinned(entry: QueryDevtoolsEntry): boolean;
+    toggleQueryPath(key: string): void;
+    toggleQueryPin(entry: QueryDevtoolsEntry): void;
+    protected toggleInspect(): void;
+    protected startResize(event: PointerEvent): void;
+    protected moveFloat(move: DragMoveEvent): void;
+    /** Parks the panel where a drag left it, or pulls it back in if the drag stopped short of an edge. */
+    protected endFloatMove(): void;
+    /** A click on the title bar of a parked panel brings it back - the gesture that parked it, reversed. */
+    protected restoreFloat(): void;
+    /** A resize reports a delta from where the pointer went down, so the rect it started from is kept. */
+    protected startFloatResize(): void;
+    protected resizeFloat(move: ResizeMoveEvent): void;
+    protected endFloatResize(): void;
+    startPaneResize(event: PointerEvent, target: {
+        pane: PaneTarget;
+        container: HTMLElement;
+    }): void;
+    /** Hands a pane back to the stylesheet's proportional default, on the axis it is being sized along. */
+    resetPaneSize(pane: PaneTarget): void;
+    protected inspectLabel(entries: QueryDevtoolsEntry[]): string;
+    /**
+     * A query's route, split so the template can tell its static path from its path params (each carrying
+     * the value the query used, or `:<name>` while it has none yet) and from the query string of the
+     * request that ran - which is what tells two requests to the same endpoint apart.
+     */
+    routeSegments(entry: QueryDevtoolsEntry | undefined, query: AnyQuery): RouteSegment[];
+    /** The full URL of the request a query last made, or `null` while it has not executed. */
+    requestUrl(query: AnyQuery): string | null;
+    /**
+     * The args of a query. A query executed imperatively (`execute({ args })`, a sequence step, an auth
+     * query) never writes them to its own `args` signal - only the `withArgs` feature does - so the args
+     * its current request was built from stand in.
+     */
+    queryArgs(query: AnyQuery): Omit<any, "response"> | null;
+    queryStatus(query: AnyQuery): QueryStatus;
+    /**
+     * A request in flight is already refreshing, so reporting it as stale on top of `loading` is noise -
+     * the same precedence the cache tab's freshness column applies.
+     */
+    isStale(query: AnyQuery): boolean;
+    /**
+     * Whether an entry is showing something other than what the server actually sent - an armed response
+     * override, or a devtools fault that decided its last completed run. Deliberately not "a fault is
+     * armed nearby": an armed-but-idle fault (a `failRate` under 100, say) mostly lets requests through
+     * untouched, so that would over-claim for the vast majority of queries on that client.
+     */
+    isTampered(entry: QueryDevtoolsEntry): boolean;
+    /** Whether a designed mock is armed for this query's own route, so nothing it shows came off the wire. */
+    isMocked(entry: QueryDevtoolsEntry): boolean;
+    /**
+     * What a query's current request is doing beyond being loading, or `null` when there is nothing beyond
+     * the status dot to say - so the readout only takes up room while it carries something.
+     */
+    requestProgress(query: AnyQuery): RequestProgress | null;
+    /** Why a retry was scheduled, as the panel spells it out. A status of 0 never reached the server. */
+    retryCause(status: number): string;
+    formatPercent(percentage: number): string;
+    /** A countdown in whole seconds, spelled out the way the cache freshness column does. */
+    formatCountdown(ms: number | null): string;
+    queryActivity(entry: QueryDevtoolsEntry): QueryActivity;
+    linkActivity(link: QueryLink): QueryActivity;
+    stackActivity(stack: AnyQueryStack | AnyPagedQueryStack): QueryActivity;
+    sequenceActivity(sequence: QuerySequence<unknown[]>): QueryActivity;
+    /** Clears an entry's counters and run history, so the next interaction can be measured on its own. */
+    resetStats(entry: QueryDevtoolsEntry): void;
+    /** A query's runs, newest first - the order a history is read in. */
+    queryRuns(entry: QueryDevtoolsEntry): QueryDevtoolsRun[];
+    /**
+     * What a run's status dot and timeline bar colour by. `pending` reuses the panel's loading colour;
+     * `aborted` matches no rule and so falls back to the neutral one.
+     */
+    runStatus(run: QueryDevtoolsRun): "error" | "loading" | "success" | "aborted";
+    /**
+     * Whether a run can be an end of the diff: it still holds its body, and so does some other run of the
+     * same query. Deliberately not "an *older* run" - a free pair means the oldest body held is pickable
+     * too, as the base of a comparison against something newer.
+     */
+    canDiffRun(entry: QueryDevtoolsEntry, run: QueryDevtoolsRun): boolean;
+    /**
+     * Arms a run as one end of the diff, or - with one end already armed - as the other. Clicking either
+     * end clears both.
+     */
+    toggleRunDiff(entry: QueryDevtoolsEntry, run: QueryDevtoolsRun): void;
+    /** Which end of the comparison a run is, so a row says so and the two ends read differently. */
+    diffRunRole(entry: QueryDevtoolsEntry, run: QueryDevtoolsRun): 'base' | 'compare' | null;
+    responseDiff(entry: QueryDevtoolsEntry): {
+        before: QueryDevtoolsRun;
+        after: QueryDevtoolsRun;
+        diff: QueryDevtoolsDiff;
+    } | null;
+    /** Whether the diff header's older/newer control has a pair to move to. */
+    canStepRunDiff(entry: QueryDevtoolsEntry, older: boolean): boolean;
+    /**
+     * Moves the whole comparison one run older or newer, so re-picking a pair does not mean scrolling back
+     * up to the runs table. Within the handful of retained bodies there are only a few pairs to walk.
+     */
+    stepRunDiff(entry: QueryDevtoolsEntry, older: boolean): void;
+    toggleRunError(run: QueryDevtoolsRun): void;
+    /**
+     * The error body of the picked run. Read off the run rather than off `query.error()`, which is the
+     * only other place a failure is legible and is blanked by anything that resets the query - a logout
+     * resets every secure query, so a 401 is gone from there by the time it is looked for.
+     */
+    pickedRunError(entry: QueryDevtoolsEntry): {
+        run: QueryDevtoolsRun;
+        error: _ethlete_query.QueryDevtoolsRunError;
+    } | null;
+    /** Opens a query in the Queries tab - the Events tab is a way in, not a dead end. */
+    selectQuery(id: string): void;
+    /** A value on one line, for a diff row or a form field. The full tree would bury the row it sits in. */
+    inlineValue(value: unknown): string;
+    formatBytes(bytes: number): string;
+    /**
+     * A transferred size, marked `≈` when any part of it was measured from a decoded body instead of read
+     * from a `content-length` header - such a size ignores transport compression.
+     */
+    formatTransferred(bytes: number, isEstimated: boolean): string;
+    /** A transfer rate, given in bytes per second the way `HttpRequestLoadingProgressState.speed` reports it. */
+    formatSpeed(bytesPerSecond: number): string;
+    formatDuration(ms: number | null): string;
+    /**
+     * Replays a query with the args the panel is already showing. `execute()` would otherwise default to
+     * `state.args()`, which only `withArgs` ever writes - so a query executed imperatively, by a sequence
+     * step or as an auth query would replay with no args at all and a function route would throw.
+     */
+    executeQuery(selection: QueryDevtoolsSelection, allowCache: boolean): void;
+    resetQuery(query: AnyQuery): void;
+    /**
+     * Copies a shareable report (path, args, status, slimmed response) for handing to an API dev.
+     * Writes both rich `text/html` (Slack applies formatting on paste - it does not parse markdown) and
+     * a plain-text fallback.
+     */
+    copyReport(entry: QueryDevtoolsEntry, query: AnyQuery): void;
+    /** Copies one query as an Insomnia collection, for `Import > From Clipboard`. */
+    copyInsomniaRequest(entry: QueryDevtoolsEntry, query: AnyQuery): void;
+    /**
+     * Copies one query as a `curl` command - what goes into a terminal, a ticket or a chat message, where
+     * an Insomnia collection is too heavy to be read at all.
+     */
+    copyCurlRequest(entry: QueryDevtoolsEntry, query: AnyQuery): void;
+    /** Copies the GraphQL document as displayed — dedented, so it pastes straight into a playground. */
+    copyGqlDocument(doc: string): void;
+    /**
+     * The endpoint of a query as one string: the absolute URL its last request used, or - for a query
+     * that has not run - the rendered route on screen.
+     */
+    copyableRoute(entry: QueryDevtoolsEntry, query: AnyQuery): string;
+    /** Names which of the two strings {@link copyableRoute} is offering, so the button says what it copies. */
+    copyableRouteTitle(entry: QueryDevtoolsEntry, query: AnyQuery): string;
+    /** Copies {@link copyableRoute} - the endpoint on its own, where the exports are a whole document. */
+    copyRoute(entry: QueryDevtoolsEntry, query: AnyQuery): void;
+    /**
+     * Downloads the given queries (already scoped/filtered by the caller) as one Insomnia collection,
+     * filed into a folder per query client.
+     */
+    downloadInsomniaCollection(items: {
+        entry: QueryDevtoolsEntry;
+        query: AnyQuery;
+    }[], clientLabel: string | null): void;
+    /**
+     * Downloads the whole panel as one JSON file: every registered entry with what it ran and what it
+     * holds, the event log, the cache totals and anything armed in the Faults tab. Unlike **Copy report**
+     * this is not scoped to one query - it is the attachment for a bug report about a screen.
+     *
+     * Deliberately unfiltered: a report is read by someone who was not there, and a dump that silently
+     * left out the client you were not looking at is worse than no dump.
+     */
+    protected downloadSession(): void;
+    openResponseEditor(query: AnyQuery): void;
+    openArgsEditor({ entry, query }: QueryDevtoolsSelection): void;
+    applyResponse(query: AnyQuery): void;
+    applyArgs(query: AnyQuery): void;
+    cancelEditor(): void;
+    forceLoading(query: AnyQuery): void;
+    forceError(query: AnyQuery): void;
+    forceEmpty(query: AnyQuery): void;
+    clearForced(query: AnyQuery): void;
+    refetchCacheEntry(entry: QueryRepositoryCacheEntry): void;
+    evictCacheEntry(repository: QueryRepository, key: string): void;
+    /**
+     * Drops every entry of one client, consumers included - the cold-start check that does not need a
+     * reload. A query still bound to an evicted entry requests again on its next execution.
+     */
+    evictAllCacheEntries(repository: QueryRepository): void;
+    /**
+     * Expands the response held under a cache key, which is the only way to read an entry no live query is
+     * bound to any more - the Queries tab has nothing to select for it.
+     */
+    toggleCacheValue(clientName: string, key: string): void;
+    isCacheValueExpanded(clientName: string, key: string): boolean;
+    cacheFreshness(entry: QueryRepositoryCacheEntry): string;
+    /**
+     * What multi-tab sync is doing for a cache entry: whether this tab is the one polling the key, and
+     * how long ago it last took a response from another tab. Empty when the client has no sync.
+     */
+    cacheSync(entry: QueryRepositoryCacheEntry, pollStates: Record<string, QueryKeyLockState>): string;
+    /**
+     * Whether a cache entry is showing data that came off the disk rather than the network - the answer
+     * to "why is this here already?" on a cold start. Empty when the client does not persist responses.
+     */
+    cachePersistence(entry: QueryRepositoryCacheEntry): string;
+    /** How many responses this client has on disk, which is usually more than it has in memory. */
+    persistedCount(client: QueryClient): number;
+    clearPersistedQueries(client: QueryClient): void;
+    /** The path + query of a request URL (origin stripped), for readable cache/event identifiers. */
+    requestPath(url: string): string;
+    asStack(entry: QueryDevtoolsEntry): AnyQueryStack;
+    asPagedStack(entry: QueryDevtoolsEntry): AnyPagedQueryStack;
+    asSequence(entry: QueryDevtoolsEntry): QuerySequence<unknown[]>;
+    asAuth(entry: QueryDevtoolsEntry): AnyBearerAuthProvider;
+    asWs(entry: QueryDevtoolsEntry): WebSocketDevtoolsHandle;
+    /**
+     * A socket's messages, narrowed by the filter box. Every whitespace-separated term has to match the
+     * event, the room or the direction, so `out join` finds the room joins the client sent.
+     */
+    socketMessages(ws: WebSocketDevtoolsHandle): WebSocketDevtoolsMessage[];
+    /** How the message log labels a direction: what the client sent, versus what the server pushed. */
+    socketDirectionLabel(message: WebSocketDevtoolsMessage): "↑ sent" | "↓ received";
+    /**
+     * Sends a message as the app would, so a server that only answers a client that asked can be provoked
+     * from the panel. An empty payload sends nothing rather than `""` - a plain event is a valid message.
+     */
+    emitSocketMessage(options: {
+        entry: QueryDevtoolsEntry;
+        event: string;
+        data: string;
+    }): void;
+    socketEmitErrorFor(entryId: string): string | null;
+    asForm(entry: QueryDevtoolsEntry): QueryDevtoolsFormHandle;
+    /**
+     * The queries a form feeds, discovered from the reads its `value()` recorded while their args were
+     * built - so a form that nothing consumes yet reads as exactly that.
+     */
+    queriesDrivenByForm(entry: QueryDevtoolsEntry): QueryLink[];
+    /** The reverse: the forms whose value a query's args read. */
+    formsDrivingQuery(entry: QueryDevtoolsEntry): QueryDevtoolsEntry[];
+    selectForm(id: string): void;
+    /**
+     * The refreshes that re-executed a query, newest first - the answer to "why did this refetch?". Read
+     * off the event log, so it goes back exactly as far as the log does.
+     */
+    refreshesFor(entryId: string): {
+        id: number;
+        timestamp: number;
+        label: string;
+    }[];
+    /** What asked for a refresh, on one line. */
+    causeLabel(cause: QueryRefreshCause): string;
+    /** Derives the per-step status of a sequence step from its live progress signals. */
+    sequenceStepStatus(sequence: QuerySequence<unknown[]>, index: number): QuerySequenceStatus;
+    authTokenPayload(auth: AnyBearerAuthProvider): Record<string, unknown> | null;
+    queriesForStack(stack: AnyQueryStack | AnyPagedQueryStack): QueryLink[];
+    authQueryKeys(auth: AnyBearerAuthProvider): string[];
+    /**
+     * Which tab refreshes this provider's tokens, as a chip: whether it is this one, how many tabs are
+     * in the election, and - when there is no election - why every tab reads as the leader.
+     */
+    authLeadership(auth: AnyBearerAuthProvider): QueryDevtoolsLeadership | null;
+    /**
+     * The access token's expiry as the app sees it, plus whatever the panel is doing to it: an armed
+     * lifetime replaces the countdown, and the token's own is reported next to it so the card never claims
+     * a refresh is due at a time the API would disagree with.
+     */
+    authTokenLifetime(entry: QueryDevtoolsEntry): QueryDevtoolsTokenLifetime;
+    queriesForSequence(sequence: QuerySequence<unknown[]>): QueryLink[];
+    /** The snapshot of a sequence step, once it has run (holds the args in and the response/error out). */
+    stepSnapshot(sequence: QuerySequence<unknown[]>, index: number): AnyQuerySnapshot | null;
+    toggleQueryGroup(key: string): void;
+    expandQueryGroup(key: string): void;
+    isStepExpanded(entryId: string, index: number): boolean;
+    toggleStep(entryId: string, index: number): void;
+    /** Dedents a GraphQL document (template-literal indentation) for readable display. */
+    gqlDocument(doc: string): string;
+    featureLabel(type: string): string;
+    /** A feature and its options on one line, for a report or a chip's tooltip. */
+    featureSummary(feature: QueryDevtoolsFeature): string;
+    /** The features of the client behind a cache tab card, or `null` for a client without any. */
+    clientFeatures(client: QueryClient | null | undefined): QueryDevtoolsFeature[] | null;
+    formatTime(timestamp: number | null): string;
+    /**
+     * The element a query was created in, which is what {@link locateQuery} can point at. `null` for a
+     * query created outside a component or directive injector - a root service, a resolver, a guard.
+     */
+    locatableElement(entry: QueryDevtoolsEntry): HTMLElement | null;
+    /**
+     * Scrolls the element the selected query was created in into view and draws the inspect box over it -
+     * inspect run backwards. Where a query was *created* is not necessarily where its data is rendered,
+     * which is what the button's "created here" wording is for.
+     */
+    locateQuery(entry: QueryDevtoolsEntry): void;
+    /** Downloads a file a tab generated. @see QueryDevtoolsHost.downloadTextFile */
+    downloadTextFile(file: {
+        name: string;
+        content: string;
+        type: string;
+    }): void;
+    /**
+     * The two runs the diff compares, oldest first - normalised by run index, so picking a pair in either
+     * order reads the same way round as the `#before → #after` header prints it.
+     *
+     * `null` unless a run is picked, so a closed diff costs nothing to walk.
+     */
+    /**
+     * The two runs the comparison spans, oldest first - normalised by run index, so picking a pair in
+     * either order reads the same way round as the `#before → #after` header prints it. With only one end
+     * armed, `after` is absent unless an older body-holding run can stand in for the base.
+     *
+     * `null` unless a run is armed, so a closed diff costs nothing to walk.
+     */
+    /**
+     * The pair one step older or newer than the current comparison, keeping whatever gap it has, or `null`
+     * at either end of the retained bodies.
+     */
+    private steppedDiffPair;
+    private diffEnds;
+    private isTabPrimary;
+    /** Moves the panel into a pop-up whose document has finished loading. @see popOut */
+    private mountPopOut;
+    /**
+     * The panel's chrome tokens as the app currently resolves them, so a pop-out keeps the surface it was
+     * docked in. Its own CSS resolves them from the host app's theme, and that theme is set on an ancestor
+     * the pop-out does not have - inherited afresh over there, the panel would take the document's theme
+     * (usually the light one) rather than the one it was just being read against.
+     *
+     * Empty on a browser that does not enumerate custom properties, which leaves the tokens to be
+     * inherited as before.
+     */
+    private chromeTokens;
+    /** Whether a `<head>` child carries CSS the pop-out needs a copy of. */
+    private isStyleNode;
+    /**
+     * Copies the host document's stylesheets into the pop-up and keeps mirroring them while it is
+     * open. Styles keep arriving after the move: Angular inserts a component's CSS and the style
+     * manager mounts overlay strategy CSS the first time each is used - e.g. the first menu opened
+     * over there - so a one-time copy would leave everything first used after the pop-out unstyled.
+     */
+    private syncStylesInto;
+    /** Brings the panel back into the host element and closes the window it was living in. */
+    private dockBack;
+    /** A registered query as a row that opens the detail drawer. */
+    private queryLinkFor;
+    /** The activity of one entry, or the total of a group of them (a stack's queries, a whole tab). */
+    private activityOf;
+    /** An activity summary on one line, for a report. `null` for a query that has not run. */
+    private activitySummary;
+    /** {@link routeSegments} as a plain string, for the places that cannot render markup. */
+    private queryRoute;
+    /**
+     * Describes a query the way a replay outside the app needs it: the URL, headers and body of the
+     * request it last made, or - for a query that has not run - what its current args would send.
+     */
+    private exportedRequest;
+    /**
+     * The token refreshes the given requests authenticate with - one per auth provider they name, and
+     * only for a provider that is logged in, since a refresh request without a refresh token has
+     * nothing to send.
+     */
+    private insomniaTokenRefreshes;
+    private insomniaTokenRefresh;
+    /**
+     * Where the access token sits in the refresh response. A provider's `extractTokens` can pull it out
+     * of any shape, so the path is recovered by finding the live token in the last auth response - with
+     * the default extractor's `$.accessToken` as the fallback.
+     */
+    private accessTokenPath;
+    /**
+     * How long Insomnia may reuse a stored refresh response: the access token's own lifetime with a
+     * margin, so the chain refreshes shortly before the token it hands out would expire. Capped at an
+     * hour - a long-lived (or bogus) `exp` should still hand out a token minted this session.
+     */
+    private accessTokenMaxAge;
+    /**
+     * The headers a replay needs, including the ones the query client adds. Header providers can throw
+     * (a secure query's needs an access token), in which case the request is exported without them.
+     */
+    private insomniaHeaders;
+    private sessionClients;
+    /** Every registered entry, described by whatever its kind carries. */
+    private sessionEntries;
+    private sessionQuery;
+    private sessionActivity;
+    private sessionSequence;
+    private sessionForm;
+    /**
+     * An auth provider without its tokens. A session report is a file that gets attached to a ticket, and
+     * the access token is the one thing in the panel that must never travel with it - which is why only
+     * its presence and its remaining lifetime are exported.
+     */
+    private sessionAuth;
+    private sessionSocket;
+    private sessionEvents;
+    private sessionFaults;
+    /** Only the armed ones: a capture taken while the panel was answering requests has to say which. */
+    private sessionMocks;
+    private downloadFile;
+    private stepKey;
+    private paneSize;
+    /** The panel's size is the distance from the pointer to the edge it is docked to. */
+    private applyResize;
+    /** A pane's size is the distance from the pointer to the container edge that pane sits against. */
+    private applyPaneResize;
+    private closePopup;
+    private updateInspectHover;
+    private selectInspectedQuery;
+    private selectionKey;
+    /** Writes to the clipboard and ticks `copied` on success. `html` is omitted for plain-text payloads. */
+    private writeToClipboard;
+    private responseStatus;
+    private findQuery;
+    private pushEvent;
+    /**
+     * The registered query an event's request belongs to. A request is shared by every query on the same
+     * cache key, so the first owner is as good as any - they all show the same response.
+     *
+     * The url fallback is what makes a row clickable when the query is already gone: an error that fires
+     * as the component holding it is being destroyed (a `401` that redirects to login) has no live owner
+     * left to match on identity, and its tombstone holds a copy of the request rather than the request.
+     */
+    private resolveEventQueryId;
+    /**
+     * The size of a settled request's response, taken from its `content-length` when the response carried
+     * one and measured from the decoded body otherwise.
+     */
+    private measureResponse;
+    private refreshedRequestOf;
+    private pushEventItem;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryDevtoolsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QueryDevtoolsComponent, "et-query-devtools", never, { "startOpen": { "alias": "startOpen"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const QUERY_DEVTOOLS_IMPORTS: readonly [typeof QueryDevtoolsComponent];
+
+/** The version of `@ethlete/query-devtools` this build was cut from. */
+declare const QUERY_DEVTOOLS_VERSION = "1.0.0-next.0";
+
+export { QUERY_DEVTOOLS_IMPORTS, QUERY_DEVTOOLS_VERSION, QueryDevtoolsAboutComponent, QueryDevtoolsComponent, QueryDevtoolsJsonComponent, QueryDevtoolsJsonStylesComponent, QueryDevtoolsSettingsComponent, QueryDevtoolsTimelineStylesComponent, clampFloatToPeek, kindOf, resizedFloatRect, settledFloatRect };
+export type { JsonKind };