react-inspector-devtools 0.0.0-stage → 0.1.0

package/dist/inspectors/CSSInspector/BoxModel.d.ts

@@ -0,0 +1,4 @@
+/** Chrome-style box model diagram. Values are editable (applied as inline styles). */
+export declare function BoxModel({ el }: {
+    el: Element;
+}): import("react").JSX.Element;

package/dist/inspectors/CSSInspector/ComputedPane.d.ts

@@ -0,0 +1,3 @@
+export declare function ComputedPane({ el }: {
+    el: Element;
+}): import("react").JSX.Element;

package/dist/inspectors/CSSInspector/StylesPane.d.ts

@@ -0,0 +1,3 @@
+export declare function StylesPane({ el }: {
+    el: Element;
+}): import("react").JSX.Element;

package/dist/inspectors/CSSInspector/cssModel.d.ts

@@ -0,0 +1,72 @@
+import { type Specificity } from '../../utils/specificity';
+export interface Declaration {
+    name: string;
+    value: string;
+    important: boolean;
+    /** Disabled through the inspector checkbox (temporarily removed from the style). */
+    disabled: boolean;
+    /** Overridden by a declaration with higher precedence. */
+    overridden: boolean;
+    /** Only meaningful for inherited sections: whether the property inherits. */
+    inherited?: boolean;
+}
+export interface RuleModel {
+    key: string;
+    kind: 'inline' | 'rule';
+    selector: string;
+    /** Selectors from the list that matched the element (for highlighting). */
+    matchedSelectors: string[];
+    source: string;
+    media: string[];
+    style: CSSStyleDeclaration;
+    rule?: CSSStyleRule;
+    element?: Element;
+    declarations: Declaration[];
+    specificity: Specificity;
+    order: number;
+    editable: boolean;
+}
+export interface InheritedSection {
+    ancestor: Element;
+    rules: RuleModel[];
+}
+export interface MatchedStyles {
+    rules: RuleModel[];
+    inherited: InheritedSection[];
+    blockedSheets: string[];
+}
+/** Splits a cssText string into declarations, respecting parentheses and quotes. */
+export declare function parseCssText(text: string): {
+    name: string;
+    value: string;
+    important: boolean;
+}[];
+export declare function hasChanges(): boolean;
+/** Reverts every style change made through the inspector. */
+export declare function revertAllChanges(): void;
+export declare function setDeclaration(model: RuleModel, name: string, value: string, important: boolean, oldName?: string): boolean;
+export declare function removeDeclaration(model: RuleModel, name: string): void;
+export declare function toggleDeclaration(model: RuleModel, decl: Declaration, enable: boolean): void;
+/** Creates a new rule for the element in a devtools-owned "inspector stylesheet". */
+export declare function addNewRule(el: Element): CSSStyleRule | null;
+export declare function setRuleSelector(rule: CSSStyleRule, selector: string): boolean;
+/**
+ * Returns all rules matching an element, in Chrome's display order
+ * (inline style first, then by cascade precedence).
+ */
+export declare function getMatchedRules(el: Element, { inheritedOnly }?: {
+    inheritedOnly?: boolean | undefined;
+}): {
+    rules: RuleModel[];
+    blockedSheets: string[];
+};
+/** Inheritable CSS properties (subset covering everything commonly used). */
+export declare const INHERITED_PROPERTIES: Set<string>;
+export declare const isInheritable: (name: string) => boolean;
+/** Full style information for the Styles pane. */
+export declare function getMatchedStyles(el: Element, maxAncestors?: number): MatchedStyles;
+/**
+ * Computed style of a pristine element with the same tag, used by the Computed
+ * pane to hide properties that still have their default value.
+ */
+export declare function getDefaultComputed(tag: string, host: ShadowRoot | null): Map<string, string> | null;

package/dist/inspectors/CookieInspector/index.d.ts

@@ -0,0 +1 @@
+export declare function CookieInspector(): import("react").JSX.Element;

package/dist/inspectors/DOMInspector/DOMTree.d.ts

@@ -0,0 +1 @@
+export declare function DOMTree(): import("react").JSX.Element;

package/dist/inspectors/DOMInspector/Overlay.d.ts

@@ -0,0 +1,2 @@
+/** Chrome-style element highlight (margin/border/padding/content) with an info tooltip. */
+export declare function HighlightOverlay(): import("react").JSX.Element | null;

package/dist/inspectors/DOMInspector/PropertiesPane.d.ts

@@ -0,0 +1,7 @@
+/** Layout / properties / attributes summary of the selected element. */
+export declare function LayoutPane({ el }: {
+    el: Element;
+}): import("react").JSX.Element;
+export declare function PropertiesPane({ el }: {
+    el: Element;
+}): import("react").JSX.Element;

package/dist/inspectors/DOMInspector/treeModel.d.ts

@@ -0,0 +1,19 @@
+export type RowKind = 'open' | 'close' | 'inline' | 'text' | 'comment' | 'doctype' | 'shadow';
+export interface TreeRow {
+    node: Node;
+    depth: number;
+    kind: RowKind;
+    expandable: boolean;
+    expanded: boolean;
+}
+export declare const VOID_ELEMENTS: Set<string>;
+/** Child nodes shown in the tree (whitespace-only text and devtools nodes hidden). */
+export declare function visibleChildren(node: Node): Node[];
+/** An element whose only child is short text renders on one line: <p>text</p> */
+export declare function inlineText(el: Element): string | null;
+/** Flattens the expanded DOM into rows (with closing-tag rows like Chrome). */
+export declare function flattenTree(root: Document): TreeRow[];
+export declare function expandRecursively(node: Node, maxDepth?: number): void;
+export declare function collapseRecursively(node: Node): void;
+/** Finds nodes matching a CSS selector, falling back to a text/attribute search. */
+export declare function searchDom(query: string): Element[];

package/dist/inspectors/DOMInspector/usePicker.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Element-selection mode ("Select an element in the page to inspect it").
+ * While active, page interactions are intercepted in the capture phase so the
+ * application does not react to clicks; Escape cancels.
+ */
+export declare function usePicker(): void;

package/dist/inspectors/StorageInspector/index.d.ts

@@ -0,0 +1,10 @@
+/** Key/value inspector for localStorage and sessionStorage. Changes apply to the live page immediately. */
+export declare function StorageInspector({ area }: {
+    area: 'local' | 'session';
+}): import("react").JSX.Element;
+export declare function CellInput({ initial, onCommit, onCancel, placeholder }: {
+    initial: string;
+    onCommit: (v: string) => void;
+    onCancel: () => void;
+    placeholder?: string;
+}): import("react").JSX.Element;

package/dist/inspectors/StorageInspector/providers.d.ts

@@ -0,0 +1,2 @@
+export declare function IndexedDBInspector(): import("react").JSX.Element;
+export declare function CacheStorageInspector(): import("react").JSX.Element;

package/dist/instrumentation/console/index.d.ts

@@ -0,0 +1,10 @@
+import type { EventBus, DevToolsEvents } from '../../core/eventBus';
+type Bus = EventBus<DevToolsEvents>;
+declare const PATCHED: readonly ["log", "info", "warn", "error", "debug", "table", "group", "groupCollapsed", "groupEnd", "time", "timeLog", "timeEnd", "count", "countReset", "trace", "assert", "clear", "dir", "dirxml"];
+type Method = (typeof PATCHED)[number];
+/** Errors already reported via console.error, used to de-duplicate uncaught error reports. */
+export declare const reportedErrors: WeakSet<object>;
+/** Original console methods, captured at install time. Used by devtools for its own diagnostics. */
+export declare const originalConsole: Partial<Record<Method, (...args: any[]) => void>>;
+export declare function installConsole(bus: Bus): () => void;
+export {};

package/dist/instrumentation/dom/index.d.ts

@@ -0,0 +1,9 @@
+import type { DevToolsEvents, EventBus } from '../../core/eventBus';
+type Bus = EventBus<DevToolsEvents>;
+/**
+ * Watches the document for changes (including React re-renders) and emits a
+ * single batched 'dom:mutation' per animation frame. Mutations to the devtools
+ * host itself are ignored.
+ */
+export declare function installDomObserver(bus: Bus): () => void;
+export {};

package/dist/instrumentation/errors/index.d.ts

@@ -0,0 +1,5 @@
+import type { EventBus, DevToolsEvents } from '../../core/eventBus';
+type Bus = EventBus<DevToolsEvents>;
+/** Captures uncaught exceptions, unhandled promise rejections and failed resource loads. */
+export declare function installErrors(bus: Bus): () => void;
+export {};

package/dist/instrumentation/index.d.ts

@@ -0,0 +1,26 @@
+export interface InstrumentationConfig {
+    console?: boolean;
+    network?: boolean;
+    storage?: boolean;
+    dom?: boolean;
+    /** Patch matchMedia so the device toolbar can emulate viewport media queries. */
+    media?: boolean;
+    ignoreUrls?: (string | RegExp)[];
+    maxConsoleEntries?: number;
+    maxNetworkEntries?: number;
+}
+/**
+ * Installs the requested instrumentation. Reference counted: multiple callers
+ * (StrictMode double-mounts, installEarly + component) patch globals only once.
+ * Returns a release function that restores the original globals when the last
+ * user releases them.
+ */
+export declare function acquireInstrumentation(cfg?: InstrumentationConfig): () => void;
+/**
+ * Starts capturing console output and network requests immediately — call this
+ * in your entry file before rendering so logs/requests made during startup are captured.
+ * Returns a function that undoes the early installation.
+ */
+export declare function installEarly(cfg?: InstrumentationConfig): () => void;
+/** For tests: whether any module is currently installed. */
+export declare function installedModules(): string[];

package/dist/instrumentation/network/fetch.d.ts

@@ -0,0 +1,9 @@
+import type { DevToolsEvents, EventBus } from '../../core/eventBus';
+import { type NetworkConfig } from './shared';
+type Bus = EventBus<DevToolsEvents>;
+/**
+ * Wraps window.fetch. The original promise is returned untouched; response bodies
+ * are read from `response.clone()` so the application's stream is never consumed.
+ */
+export declare function installFetch(bus: Bus, cfg: NetworkConfig): () => void;
+export {};

package/dist/instrumentation/network/resources.d.ts

@@ -0,0 +1,15 @@
+import type { DevToolsEvents, EventBus } from '../../core/eventBus';
+import type { NetworkTiming } from '../../types';
+import { type NetworkConfig } from './shared';
+type Bus = EventBus<DevToolsEvents>;
+export declare function timingFromEntry(e: PerformanceResourceTiming): NetworkTiming;
+/**
+ * Uses the Resource Timing API to list resources loaded by the page (scripts,
+ * stylesheets, images, fonts…) — including ones loaded before devtools mounted.
+ * Fetch/XHR entries are emitted as 'network:resource' so the store can attach
+ * timing data to requests captured by the fetch/XHR wrappers.
+ */
+export declare function installResources(bus: Bus, cfg: NetworkConfig): () => void;
+/** Wraps the WebSocket constructor to record connections and frames. */
+export declare function installWebSocket(bus: Bus, cfg: NetworkConfig): () => void;
+export {};

package/dist/instrumentation/network/shared.d.ts

@@ -0,0 +1,26 @@
+import type { RequestPayload, ResourceType } from '../../types';
+export interface NetworkConfig {
+    ignoreUrls: (string | RegExp)[];
+    isCacheDisabled: () => boolean;
+}
+/** Max response body we keep in memory per request. */
+export declare const MAX_BODY: number;
+export declare const MAX_BINARY_PREVIEW: number;
+export declare const newRequestId: () => string;
+export declare function shouldIgnore(url: string, cfg: NetworkConfig): boolean;
+export declare function absoluteUrl(url: string): string;
+export declare function headersToList(h: HeadersInit | Headers | undefined | null): [string, string][];
+export declare function parseRawHeaders(raw: string): [string, string][];
+export declare function getHeader(list: [string, string][], name: string): string | undefined;
+/** Describes a request body without consuming or mutating it. */
+export declare function describeBody(body: unknown): RequestPayload | undefined;
+export declare function typeFromUrl(url: string): ResourceType | null;
+export declare function typeFromInitiator(initiatorType: string, url: string): ResourceType;
+export declare function isTextual(mime: string | undefined): boolean;
+export declare function shortStack(): string | undefined;
+/** Reads at most `limit` bytes from a (cloned) response body stream. Never touches the original. */
+export declare function readLimitedText(res: Response, limit: number): Promise<{
+    text: string;
+    truncated: boolean;
+    size: number;
+}>;

package/dist/instrumentation/network/xhr.d.ts

@@ -0,0 +1,10 @@
+import type { DevToolsEvents, EventBus } from '../../core/eventBus';
+import { type NetworkConfig } from './shared';
+type Bus = EventBus<DevToolsEvents>;
+/**
+ * Patches XMLHttpRequest.prototype.open/send/setRequestHeader. Only listeners are
+ * added; responses are read through the normal getters after `loadend`, which does
+ * not alter the request.
+ */
+export declare function installXHR(bus: Bus, cfg: NetworkConfig): () => void;
+export {};

package/dist/instrumentation/storage/index.d.ts

@@ -0,0 +1,9 @@
+import type { DevToolsEvents, EventBus } from '../../core/eventBus';
+type Bus = EventBus<DevToolsEvents>;
+/**
+ * Observes storage writes so the Application panel stays live. Writes from other
+ * tabs arrive via the `storage` event; same-tab writes are observed by wrapping
+ * Storage.prototype methods (behaviour is unchanged — the original is always called).
+ */
+export declare function installStorage(bus: Bus): () => void;
+export {};

package/dist/panels/Application/index.d.ts

@@ -0,0 +1 @@
+export declare function ApplicationPanel(): import("react").JSX.Element;

package/dist/panels/Console/ConsoleInput.d.ts

@@ -0,0 +1,3 @@
+export declare function ConsoleInput({ focusToken }: {
+    focusToken: number;
+}): import("react").JSX.Element;

package/dist/panels/Console/evaluate.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Turns top-level `let`/`const` into `var` so declarations persist between
+ * evaluations, like they do in Chrome's console.
+ */
+export declare function hoistDeclarations(code: string): string;
+export type EvalResult = {
+    ok: true;
+    value: unknown;
+    awaited: boolean;
+} | {
+    ok: false;
+    error: unknown;
+};
+/**
+ * Evaluates code in the page's global scope (indirect eval).
+ * Requires the page CSP to allow 'unsafe-eval'.
+ */
+export declare function evaluate(code: string): Promise<EvalResult>;
+/**
+ * Side-effect-conscious autocompletion: only simple identifier paths
+ * (e.g. `document.body.cl`) are resolved — nothing is ever called.
+ */
+export declare function completions(input: string): {
+    prefix: string;
+    items: string[];
+};

package/dist/panels/Console/format.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+/**
+ * Renders console arguments, applying printf-style substitutions
+ * (%s %d %i %f %o %O %c) to the first string argument.
+ */
+export declare function formatArgs(args: unknown[], preserved?: boolean): ReactNode[];
+/** Plain-text representation used for searching/filtering. */
+export declare function argsToText(args: unknown[]): string;

package/dist/panels/Console/index.d.ts

@@ -0,0 +1 @@
+export declare function ConsolePanel(): import("react").JSX.Element;

package/dist/panels/DeviceToolbar/emulation.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Patches window.matchMedia so lists created from now on report emulated values
+ * while device mode is active (and real values otherwise). The returned object is
+ * still a genuine MediaQueryList, so `instanceof` and listeners keep working.
+ */
+export declare function installMatchMediaPatch(): () => void;
+export declare function resolveTarget(target?: string | HTMLElement): HTMLElement | null;
+export interface EmulationState {
+    width: number;
+    height: number;
+    dpr: number;
+    touch: boolean;
+    zoom: number;
+    left: number;
+    top: number;
+    frame: 'none' | 'mobile' | 'tablet' | 'desktop';
+    dark: boolean;
+    emulateMedia: boolean;
+}
+/** Applies and later restores device emulation for one target element. */
+export declare class DeviceEmulator {
+    private target;
+    private savedTarget;
+    private restorePage;
+    private restoreGlobals;
+    private restoreTouch;
+    private headObserver;
+    private interval;
+    private state;
+    constructor(target: HTMLElement);
+    apply(s: EmulationState): void;
+    private installGlobals;
+    restore(): void;
+}

package/dist/panels/DeviceToolbar/index.d.ts

@@ -0,0 +1 @@
+export declare function DeviceLayer(): import("react").JSX.Element;

package/dist/panels/Elements/index.d.ts

@@ -0,0 +1 @@
+export declare function ElementsPanel(): import("react").JSX.Element;

package/dist/panels/Network/RequestDetails.d.ts

@@ -0,0 +1,5 @@
+import type { NetworkRequest } from '../../types';
+export declare function RequestDetails({ req, onClose }: {
+    req: NetworkRequest;
+    onClose: () => void;
+}): import("react").JSX.Element;

package/dist/panels/Network/index.d.ts

@@ -0,0 +1 @@
+export declare function NetworkPanel(): import("react").JSX.Element;

package/dist/panels/Network/util.d.ts

@@ -0,0 +1,11 @@
+import type { NetworkRequest } from '../../types';
+export declare function statusText(r: NetworkRequest): string;
+export declare function displayName(url: string): {
+    name: string;
+    host: string;
+};
+export declare const TYPE_LABEL: Record<string, string>;
+export declare function isFailed(r: NetworkRequest): boolean;
+export declare function toCurl(r: NetworkRequest): string;
+export declare function toFetch(r: NetworkRequest): string;
+export declare function copyText(text: string): void;

package/dist/panels/Settings/index.d.ts

@@ -0,0 +1 @@
+export declare function SettingsPanel(): import("react").JSX.Element;

package/dist/panels/index.d.ts

@@ -0,0 +1,3 @@
+import type { BuiltInPanelId, PanelDefinition } from '../types';
+export { SettingsPanel } from './Settings';
+export declare const BUILTIN_PANELS: Record<BuiltInPanelId, PanelDefinition>;

package/dist/store/applicationStore.d.ts

@@ -0,0 +1,10 @@
+export type AppSection = 'local' | 'session' | 'cookies' | 'indexeddb' | 'cache';
+interface ApplicationState {
+    section: AppSection;
+    /** Bumped on storage changes to trigger refresh. */
+    versions: Record<'local' | 'session' | 'cookie', number>;
+    setSection: (s: AppSection) => void;
+    bump: (area: 'local' | 'session' | 'cookie') => void;
+}
+export declare const useApplication: import("zustand").UseBoundStore<import("zustand").StoreApi<ApplicationState>>;
+export {};

package/dist/store/consoleStore.d.ts

@@ -0,0 +1,30 @@
+import type { ConsoleEntry, ConsoleLevel } from '../types';
+import type { DevToolsEvents } from '../core/eventBus';
+export type LevelFilter = 'verbose' | 'info' | 'warnings' | 'errors';
+interface ConsoleState {
+    entries: ConsoleEntry[];
+    max: number;
+    filterText: string;
+    levels: Record<LevelFilter, boolean>;
+    /** user-toggled group collapse overrides (group-start entry id -> collapsed) */
+    groupToggles: Record<number, boolean>;
+    history: string[];
+    clear: () => void;
+    setFilterText: (t: string) => void;
+    toggleLevel: (l: LevelFilter) => void;
+    setLevels: (l: Record<LevelFilter, boolean>) => void;
+    toggleGroup: (id: number, collapsed: boolean) => void;
+    pushHistory: (cmd: string) => void;
+}
+export declare const levelToFilter: (l: ConsoleLevel) => LevelFilter;
+export declare const useConsole: import("zustand").UseBoundStore<import("zustand").StoreApi<ConsoleState>>;
+export declare function loadConsoleHistory(): void;
+export declare function setGroupSimilar(v: boolean): void;
+export declare function addConsoleEntry(raw: DevToolsEvents['console:entry']): void;
+/** Applies buffered entries to the store. Batched so heavy logging stays cheap. */
+export declare function flush(): void;
+export declare function resetGroupStack(): void;
+export declare function stringifyForPreserve(v: unknown): string;
+export declare function savePreservedConsole(): void;
+export declare function restorePreservedConsole(): void;
+export {};

package/dist/store/deviceStore.d.ts

@@ -0,0 +1,24 @@
+import type { DevicePreset } from '../types';
+export declare const BUILTIN_PRESETS: DevicePreset[];
+export declare const RESPONSIVE_ID = "responsive";
+export type ZoomSetting = number | 'fit';
+interface DeviceState {
+    presetId: string;
+    width: number;
+    height: number;
+    dpr: number;
+    zoom: ZoomSetting;
+    landscape: boolean;
+    showFrame: boolean;
+    touch: boolean;
+    customPresets: DevicePreset[];
+    set: (patch: Partial<DeviceState>) => void;
+    applyPreset: (id: string) => void;
+    rotate: () => void;
+    saveCustomPreset: (p: DevicePreset) => void;
+    deleteCustomPreset: (id: string) => void;
+}
+export declare function allPresets(custom: DevicePreset[]): DevicePreset[];
+export declare const useDevice: import("zustand").UseBoundStore<import("zustand").StoreApi<DeviceState>>;
+export declare function hydrateDevice(): void;
+export {};

package/dist/store/devtoolsStore.d.ts

@@ -0,0 +1,49 @@
+import type { DockPosition, PanelId, ThemeSetting } from '../types';
+export interface FloatingRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface DevToolsSettings {
+    dock: DockPosition;
+    theme: ThemeSetting;
+    bottomHeight: number;
+    rightWidth: number;
+    floating: FloatingRect;
+    activePanel: PanelId;
+    preserveConsoleLog: boolean;
+    preserveNetworkLog: boolean;
+    disableCache: boolean;
+    consoleTimestamps: boolean;
+    groupSimilar: boolean;
+    shortcutOverride: string | null;
+    /** Panels hidden by the user from the Settings panel */
+    hiddenPanels: string[];
+    elementsSidebarWidth: number;
+    networkDetailWidth: number;
+}
+interface DevToolsState extends DevToolsSettings {
+    open: boolean;
+    minimized: boolean;
+    maximized: boolean;
+    pickerActive: boolean;
+    deviceMode: boolean;
+    systemDark: boolean;
+    set: (patch: Partial<DevToolsState>) => void;
+    setOpen: (open: boolean) => void;
+    toggle: () => void;
+    updateSettings: (patch: Partial<DevToolsSettings>) => void;
+    resetSettings: () => void;
+}
+export declare const defaultSettings: DevToolsSettings;
+export declare const useDevtools: import("zustand").UseBoundStore<import("zustand").StoreApi<DevToolsState>>;
+export declare function persistSettings(): void;
+/**
+ * Loads persisted settings. Component props act as defaults (like Chrome DevTools,
+ * the user's last choices are remembered and win over the initial configuration).
+ */
+export declare function hydrateSettings(defaults: Partial<DevToolsSettings> & {
+    open?: boolean;
+}): void;
+export {};

package/dist/store/elementsStore.d.ts

@@ -0,0 +1,24 @@
+export type ElementsSidebarTab = 'styles' | 'computed' | 'layout' | 'properties';
+interface ElementsState {
+    selected: Node | null;
+    hovered: Node | null;
+    /** Bumped whenever the observed DOM changes. */
+    domVersion: number;
+    /** Bumped when the expansion set changes. */
+    expandVersion: number;
+    /** Bumped when styles were edited through the inspector. */
+    styleVersion: number;
+    sidebarTab: ElementsSidebarTab;
+    /** Request to scroll the selected node into view in the tree */
+    revealToken: number;
+    select: (node: Node | null, reveal?: boolean) => void;
+    hover: (node: Node | null) => void;
+    setSidebarTab: (t: ElementsSidebarTab) => void;
+    bumpStyles: () => void;
+}
+/** Expanded tree nodes. Kept outside React state: a WeakSet does not leak removed nodes. */
+export declare const expandedNodes: WeakSet<Node>;
+export declare const useElements: import("zustand").UseBoundStore<import("zustand").StoreApi<ElementsState>>;
+export declare function setExpanded(node: Node, expanded: boolean): void;
+export declare function bumpDomVersion(): void;
+export {};

package/dist/store/networkStore.d.ts

@@ -0,0 +1,33 @@
+import type { NetworkRequest, ResourceType } from '../types';
+export type TypeFilter = 'all' | 'fetch-xhr' | Exclude<ResourceType, 'fetch' | 'xhr'>;
+export type StatusFilter = 'all' | '1xx' | '2xx' | '3xx' | '4xx' | '5xx' | 'failed' | 'pending';
+interface NetworkState {
+    requests: NetworkRequest[];
+    max: number;
+    selectedId: string | null;
+    filterText: string;
+    invert: boolean;
+    typeFilters: TypeFilter[];
+    methodFilter: string;
+    statusFilter: StatusFilter;
+    domainFilter: string;
+    recording: boolean;
+    sort: {
+        column: string;
+        dir: 1 | -1;
+    } | null;
+    select: (id: string | null) => void;
+    clear: () => void;
+    set: (patch: Partial<NetworkState>) => void;
+    toggleType: (t: TypeFilter, multi: boolean) => void;
+}
+export declare const useNetwork: import("zustand").UseBoundStore<import("zustand").StoreApi<NetworkState>>;
+export declare function matchesType(r: NetworkRequest, filters: TypeFilter[]): boolean;
+export declare function addRequest(r: NetworkRequest): void;
+export declare function patchRequest(id: string, patch: Partial<NetworkRequest>): void;
+export declare function flushNetwork(): void;
+/** Finds a request (including not-yet-flushed ones). */
+export declare function findRequest(predicate: (r: NetworkRequest) => boolean): NetworkRequest | undefined;
+export declare function savePreservedNetwork(): void;
+export declare function restorePreservedNetwork(): void;
+export {};

package/dist/themes/index.d.ts

@@ -0,0 +1 @@
+export declare const STYLES: string;