@gnggln/ng-ui-system 1.0.0-alpha.2 → 1.0.0-alpha.21

package/form-builder/entry-form-builder.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Bootstrap del secondary entry `@gnggln/ng-ui-system/form-builder`. Form Builder e Form Wizard.
+ */
+export * from './lib/components/form-builder/index';

package/form-builder/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@gnggln/ng-ui-system/form-builder" />
+export * from './entry-form-builder';

package/form-builder/lib/components/accordion/accordion.component.d.ts

@@ -0,0 +1,125 @@
+import { EventEmitter, DoCheck, TemplateRef } from '@angular/core';
+import { UiAccordionDescriptor, UiAccordionToggleEvent, UiAccordionMode } from './accordion.types';
+import * as i0 from "@angular/core";
+/**
+ * Accordion configurabile, data-driven, con supporto multi/single expand,
+ * animazioni CSS, icone Lucide e template personalizzabili.
+ *
+ * Il contenuto dei pannelli viene fornito tramite un `itemTemplate`
+ * che riceve il descriptor del pannello come contesto.
+ *
+ * @selector ui-accordion
+ *
+ * @example
+ * ```html
+ * <ui-accordion
+ *   [items]="sections"
+ *   [itemTemplate]="panelTpl"
+ *   mode="single"
+ * >
+ *   <ng-template #panelTpl let-item>
+ *     @switch (item.id) {
+ *       @case ('info')    { <app-info-panel /> }
+ *       @case ('address') { <app-address-form /> }
+ *     }
+ *   </ng-template>
+ * </ui-accordion>
+ * ```
+ *
+ * @example
+ * ```typescript
+ * sections: UiAccordionDescriptor[] = [
+ *   { id: 'info', title: 'Informazioni', icon: 'info', expanded: true },
+ *   { id: 'address', title: 'Indirizzo', icon: 'map-pin' },
+ * ];
+ * ```
+ */
+export declare class UiAccordionComponent implements DoCheck {
+    private readonly cdr;
+    /**
+     * Fingerprint dell'ultimo stato dei descriptor.
+     * Usato da DoCheck per rilevare mutazioni in-place sulle proprieta
+     * degli item senza richiedere un nuovo riferimento dell'array.
+     */
+    private _lastFingerprint;
+    /**
+     * Array di descriptor dei pannelli.
+     * Pannelli con `hidden: true` vengono filtrati automaticamente.
+     *
+     * Supporta sia aggiornamenti immutabili (nuovo array) sia
+     * mutazioni in-place delle proprieta dei descriptor.
+     */
+    items: UiAccordionDescriptor[];
+    /**
+     * Template per il contenuto di ogni pannello.
+     * Il contesto fornisce il descriptor come `$implicit`.
+     *
+     * @example
+     * ```html
+     * <ng-template #tpl let-item>
+     *   <p>Contenuto per: {{ item.title }}</p>
+     * </ng-template>
+     * ```
+     */
+    itemTemplate: TemplateRef<unknown> | null;
+    /**
+     * Template opzionale per contenuto aggiuntivo nell'header.
+     * Il contesto fornisce il descriptor come `$implicit`.
+     * Viene renderizzato all'interno del trigger, tra il titolo e il chevron.
+     */
+    headerTemplate: TemplateRef<unknown> | null;
+    /**
+     * Template opzionale per azioni nell'header del pannello.
+     * Posizionato tra il trigger e il chevron, al di fuori del button
+     * per consentire elementi interattivi (es. pulsanti duplica/elimina).
+     * Il contesto fornisce il descriptor come `$implicit`.
+     */
+    actionsTemplate: TemplateRef<unknown> | null;
+    /**
+     * Modalita di espansione.
+     * - `multi`: piu pannelli aperti contemporaneamente
+     * - `single`: un solo pannello aperto alla volta
+     */
+    mode: UiAccordionMode;
+    /** Label accessibile per il gruppo accordion. */
+    ariaLabel: string;
+    /** Emesso quando un pannello viene aperto o chiuso. */
+    itemToggled: EventEmitter<UiAccordionToggleEvent>;
+    /**
+     * Rileva mutazioni in-place sulle proprieta dei descriptor.
+     * Confronta un fingerprint leggero dello stato corrente con quello
+     * precedente e, se diverso, forza un ciclo di change detection.
+     *
+     * Questo permette al consumatore di fare sia:
+     * - `items[2].hidden = true`  (mutazione in-place)
+     * - `items = [...newItems]`   (nuovo riferimento)
+     */
+    ngDoCheck(): void;
+    /** Pannelli visibili (non hidden). */
+    get visibleItems(): UiAccordionDescriptor[];
+    /** Alterna l'espansione di un pannello. */
+    toggle(item: UiAccordionDescriptor): void;
+    /** Apre un pannello specifico per id. */
+    open(id: string): void;
+    /** Chiude un pannello specifico per id. */
+    close(id: string): void;
+    /** Apre tutti i pannelli (solo in modalita multi). */
+    openAll(): void;
+    /** Chiude tutti i pannelli. */
+    closeAll(): void;
+    /** @internal Classi CSS per il pannello. */
+    getPanelClasses(item: UiAccordionDescriptor): string;
+    /** @internal Sposta il focus al primo header. */
+    focusFirst(event: Event): void;
+    /** @internal Sposta il focus all'ultimo header. */
+    focusLast(event: Event): void;
+    /** @internal Recupera tutti i trigger button del DOM. */
+    private getHeaders;
+    /**
+     * @internal Calcola un fingerprint leggero basato sulle proprieta
+     * reattive dei descriptor (quelle che influenzano il rendering).
+     */
+    private computeFingerprint;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiAccordionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UiAccordionComponent, "ui-accordion", never, { "items": { "alias": "items"; "required": false; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; }; "headerTemplate": { "alias": "headerTemplate"; "required": false; }; "actionsTemplate": { "alias": "actionsTemplate"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, { "itemToggled": "itemToggled"; }, never, never, true, never>;
+}

package/form-builder/lib/components/accordion/accordion.types.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @module ng-ui-system/accordion
+ * Tipi e interfacce per UiAccordion.
+ */
+import { UiIconName } from '../../core/types';
+export { UiIconName };
+/**
+ * Descriptor per un singolo pannello dell'accordion.
+ *
+ * Consente di definire accordion come strutture dati dichiarative,
+ * aggiornabili dinamicamente tramite manipolazione dell'array.
+ *
+ * @usageNotes
+ * ### Utilizzo base
+ * ```typescript
+ * const items: UiAccordionDescriptor[] = [
+ *   { id: 'info', title: 'Informazioni generali', icon: 'info' },
+ *   { id: 'address', title: 'Indirizzo', icon: 'map-pin' },
+ *   { id: 'notes', title: 'Note aggiuntive', expanded: true },
+ * ];
+ * ```
+ *
+ * ### Visibilita condizionale
+ * ```typescript
+ * items[2].hidden = !this.hasNotes;
+ * items[1].disabled = this.isReadonly;
+ * ```
+ */
+export interface UiAccordionDescriptor {
+    /** Identificatore univoco del pannello. */
+    id: string;
+    /** Titolo visualizzato nell'header del pannello. */
+    title: string;
+    /** Icona Lucide opzionale mostrata prima del titolo. @see https://lucide.dev/icons */
+    icon?: UiIconName;
+    /** Stato iniziale di espansione. @default false */
+    expanded?: boolean;
+    /** Disabilita l'interazione con il pannello. @default false */
+    disabled?: boolean;
+    /** Nasconde il pannello dall'interfaccia. @default false */
+    hidden?: boolean;
+    /** Descrizione secondaria mostrata accanto al titolo. */
+    subtitle?: string;
+    /** Indice posizionale del pannello (utile per sezioni repeatable). */
+    index?: number;
+}
+/**
+ * Evento emesso quando un pannello viene aperto o chiuso.
+ */
+export interface UiAccordionToggleEvent {
+    /** Descriptor del pannello coinvolto. */
+    item: UiAccordionDescriptor;
+    /** `true` se il pannello e stato aperto, `false` se chiuso. */
+    expanded: boolean;
+}
+/**
+ * Modalita di espansione dell'accordion.
+ *
+ * | Modalita | Comportamento                                   |
+ * |---------|------------------------------------------------|
+ * | `multi` | Piu pannelli possono essere aperti contemporaneamente |
+ * | `single`| Un solo pannello aperto alla volta (gli altri si chiudono) |
+ */
+export type UiAccordionMode = 'multi' | 'single';

package/form-builder/lib/components/accordion/index.d.ts

@@ -0,0 +1,2 @@
+export { UiAccordionComponent } from './accordion.component';
+export { UiAccordionDescriptor, UiAccordionToggleEvent, UiAccordionMode, } from './accordion.types';

package/form-builder/lib/components/blackbox/blackbox-fingerprint.service.d.ts

@@ -0,0 +1,36 @@
+import type { UiBlackboxFingerprint } from './blackbox.types';
+import * as i0 from "@angular/core";
+/**
+ * Generates and caches a stable browser/device fingerprint.
+ *
+ * Uses `@fingerprintjs/fingerprintjs` (open-source, MIT) which analyses
+ * canvas rendering, WebGL, audio context, screen properties, timezone,
+ * user-agent, and other browser signals to produce a stable hash.
+ *
+ * @usageNotes
+ * ```typescript
+ * const fp = inject(UiBlackboxFingerprintService);
+ * const hash = await fp.getFingerprint();
+ * // => "a1b2c3d4e5f6..." (stable across sessions)
+ * ```
+ */
+export declare class UiBlackboxFingerprintService {
+    private readonly platformId;
+    private cached;
+    /**
+     * Returns the stable fingerprint for this device/browser.
+     *
+     * On first call, loads FingerprintJS dynamically, computes the hash,
+     * and caches it in both memory and `localStorage`.
+     * Subsequent calls return the cached value immediately.
+     */
+    getFingerprint(): Promise<UiBlackboxFingerprint>;
+    /**
+     * Fallback fingerprint when FingerprintJS is unavailable.
+     * Combines basic browser signals into a hash.
+     * @internal
+     */
+    private generateFallbackFingerprint;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiBlackboxFingerprintService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UiBlackboxFingerprintService>;
+}

package/form-builder/lib/components/blackbox/blackbox-storage.service.d.ts

@@ -0,0 +1,55 @@
+import type { UiBlackboxSession } from './blackbox.types';
+import * as i0 from "@angular/core";
+/**
+ * Low-level IndexedDB adapter for reading/writing compressed BlackBox sessions.
+ *
+ * @usageNotes
+ * This service is used internally by `UiBlackboxService`.
+ * Consumers should interact with the higher-level `UiBlackboxService` API.
+ */
+export declare class UiBlackboxStorageService {
+    private readonly platformId;
+    private db;
+    private maxStorageMb;
+    /** Update the storage quota from the parent service config. */
+    setMaxStorageMb(mb: number): void;
+    /** Open (or create) the IndexedDB database. */
+    private openDb;
+    /** Compress a string to a gzip Uint8Array using native CompressionStream. */
+    private compress;
+    /** Decompress a gzip Uint8Array back to a string. */
+    private decompress;
+    /**
+     * Persist a session to IndexedDB (gzip-compressed).
+     * Enforces quota after saving.
+     */
+    saveSession(session: UiBlackboxSession): Promise<void>;
+    /**
+     * Read and decompress a single session by ID.
+     */
+    getSession(sessionId: string): Promise<UiBlackboxSession | null>;
+    /**
+     * Get all stored sessions (decompressed).
+     */
+    getAllSessions(): Promise<UiBlackboxSession[]>;
+    /**
+     * Get all sessions for a given fingerprint.
+     */
+    getSessionsByFingerprint(fingerprint: string): Promise<UiBlackboxSession[]>;
+    /**
+     * Generate a downloadable JSONL Blob of all sessions.
+     * Each line is one JSON-serialised session (decompressed).
+     */
+    exportDump(): Promise<Blob>;
+    /**
+     * Delete all stored sessions.
+     */
+    clearAll(): Promise<void>;
+    /**
+     * Prune oldest sessions until total stored size is under `maxStorageMb`.
+     * @internal
+     */
+    enforceQuota(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiBlackboxStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UiBlackboxStorageService>;
+}

package/form-builder/lib/components/blackbox/blackbox.service.d.ts

@@ -0,0 +1,144 @@
+/**
+ * @module ng-ui-system/blackbox
+ * Core BlackBox observability service — the main entry point for session
+ * recording, event buffering, and export.
+ *
+ * Architecture:
+ * - Root singleton (`providedIn: 'root'`)
+ * - On first inject: generates fingerprint, creates session, subscribes to Router events
+ * - Centralised in-memory buffer with periodic/threshold-based flush to IndexedDB
+ * - `window:beforeunload` triggers a final best-effort async flush
+ */
+import { OnDestroy } from '@angular/core';
+import { UiBlackboxConfig, UiBlackboxFormTrackingConfig, UiBlackboxSession, UiBlackboxFormEvent, UiBlackboxHttpCall } from './blackbox.types';
+import * as i0 from "@angular/core";
+/**
+ * Central BlackBox observability service.
+ *
+ * Records navigation, UI interactions, form events, and HTTP calls
+ * into compressed sessions stored in IndexedDB.
+ *
+ * @usageNotes
+ * The service activates automatically when injected. Provide it at root level
+ * and it will start recording immediately.
+ *
+ * ```typescript
+ * // app.config.ts — just importing the service is enough
+ * import { UiBlackboxService } from '@gnggln/ng-ui-system';
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     // The service is providedIn: 'root', so it's auto-provided.
+ *     // To force eager initialisation:
+ *     { provide: APP_INITIALIZER, useFactory: () => () => inject(UiBlackboxService), multi: true },
+ *   ],
+ * };
+ * ```
+ */
+export declare class UiBlackboxService implements OnDestroy {
+    private readonly platformId;
+    private readonly router;
+    private readonly zone;
+    private readonly fingerprint;
+    private readonly storage;
+    private readonly destroy$;
+    private config;
+    private session;
+    private currentStep;
+    private initialised;
+    private buffer;
+    private flushTimerId;
+    private beforeUnloadHandler;
+    constructor();
+    private init;
+    /**
+     * Update the BlackBox configuration.
+     * Can be called at any time; changes take effect immediately.
+     */
+    configure(config: Partial<Omit<UiBlackboxConfig, 'formTracking'>> & {
+        formTracking?: Partial<UiBlackboxFormTrackingConfig>;
+    }): void;
+    /** Returns the current configuration (readonly snapshot). */
+    getConfig(): Readonly<UiBlackboxConfig>;
+    /**
+     * Manually track a UI action (click).
+     *
+     * Called automatically by `UiButtonAreaComponent` and the `[uiTrack]` directive.
+     * Can also be called programmatically for custom interactions.
+     *
+     * @param trackId - Identifier for the action (e.g. button id, link name).
+     * @param meta - Optional metadata: `tag`, `text`, `id` of the element.
+     */
+    trackAction(trackId: string, meta?: {
+        tag?: string;
+        text?: string;
+        id?: string;
+    }): void;
+    /**
+     * Track a form interaction event.
+     *
+     * Called automatically by `UiFormBuilderComponent` when the BlackBox
+     * service is available.
+     */
+    trackFormEvent(event: UiBlackboxFormEvent): void;
+    /**
+     * Track an intercepted HTTP call.
+     * Called by `UiBlackboxInterceptor`.
+     * @internal
+     */
+    trackHttpCall(call: UiBlackboxHttpCall): void;
+    /**
+     * Returns the current in-memory session (live, not yet flushed).
+     * Useful for debugging or real-time inspection.
+     */
+    getCurrentSession(): UiBlackboxSession;
+    /**
+     * Retrieve all sessions stored in IndexedDB (decompressed).
+     */
+    getSessionHistory(): Promise<UiBlackboxSession[]>;
+    /**
+     * Retrieve sessions for the current device fingerprint.
+     */
+    getSessionsForDevice(): Promise<UiBlackboxSession[]>;
+    /**
+     * Export all sessions as a downloadable JSONL Blob.
+     *
+     * @returns A Blob containing JSONL data (one session per line).
+     *
+     * @example
+     * ```typescript
+     * const blob = await blackbox.exportSessions();
+     * const url = URL.createObjectURL(blob);
+     * const a = document.createElement('a');
+     * a.href = url;
+     * a.download = 'blackbox-sessions.jsonl';
+     * a.click();
+     * ```
+     */
+    exportSessions(): Promise<Blob>;
+    /**
+     * Explicitly end the current session.
+     * Flushes all buffered events and marks the session as ended.
+     */
+    endSession(): Promise<void>;
+    /**
+     * Clear all stored sessions from IndexedDB.
+     */
+    clearHistory(): Promise<void>;
+    /**
+     * Push an event into the centralised buffer.
+     * Triggers an immediate flush if the buffer exceeds the threshold.
+     * @internal
+     */
+    private pushBufferEvent;
+    /**
+     * Flush buffered events to IndexedDB asynchronously.
+     * @internal
+     */
+    private flush;
+    /** Generate a UUID v4. */
+    private generateUuid;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiBlackboxService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UiBlackboxService>;
+}

package/form-builder/lib/components/blackbox/blackbox.types.d.ts

@@ -0,0 +1,238 @@
+/**
+ * @module ng-ui-system/blackbox
+ * Types and interfaces for the BlackBox observability service.
+ *
+ * The BlackBox service acts as a "black box recorder" for user sessions,
+ * capturing navigation, UI interactions, form events and HTTP calls
+ * in a compressed, opaque format stored in IndexedDB.
+ */
+/**
+ * Form tracking granularity flags.
+ *
+ * Controls which form events are captured by the BlackBox service.
+ * All flags default to `true` except `trackValues` which defaults to `false`
+ * for privacy reasons.
+ */
+export interface UiBlackboxFormTrackingConfig {
+    /**
+     * When `true`, the actual field values are stored in form events.
+     * When `false`, only the fact that a change occurred is recorded.
+     * @default false
+     */
+    trackValues: boolean;
+    /** Track focus events on form fields. @default true */
+    trackFocus: boolean;
+    /** Track blur events on form fields. @default true */
+    trackBlur: boolean;
+    /** Track value change events on form fields. @default true */
+    trackValueChanges: boolean;
+    /** Track validation error events on form fields. @default true */
+    trackValidation: boolean;
+    /**
+     * Debounce interval (ms) for `valueChanges` subscriptions.
+     * Higher values reduce noise but increase latency.
+     * @default 500
+     */
+    debounceMs: number;
+}
+/**
+ * Root configuration for the BlackBox service.
+ *
+ * All properties are optional — sensible defaults are applied when omitted.
+ *
+ * @example
+ * ```typescript
+ * blackboxService.configure({
+ *   maxStorageMb: 30,
+ *   formTracking: { trackValues: true, debounceMs: 1000 },
+ * });
+ * ```
+ */
+export interface UiBlackboxConfig {
+    /**
+     * Maximum IndexedDB storage quota in megabytes.
+     * Oldest sessions are pruned when the quota is exceeded.
+     * @default 50
+     */
+    maxStorageMb: number;
+    /**
+     * Interval (ms) at which the in-memory buffer is flushed to IndexedDB.
+     * @default 5000
+     */
+    flushIntervalMs: number;
+    /**
+     * Number of buffered events that trigger an immediate flush.
+     * @default 20
+     */
+    flushThreshold: number;
+    /**
+     * Centralised debounce (ms) applied to the event buffer.
+     * @default 500
+     */
+    bufferDebounceMs: number;
+    /** Per-field form tracking configuration. */
+    formTracking: UiBlackboxFormTrackingConfig;
+}
+/**
+ * Stable device/browser fingerprint generated by FingerprintJS (open-source).
+ * Persists across sessions and incognito mode.
+ */
+export type UiBlackboxFingerprint = string;
+/**
+ * A single recording session, corresponding to one browser tab lifecycle.
+ *
+ * Sessions are associated to a stable `fingerprint` so that multiple
+ * sessions from the same device can be grouped together.
+ */
+export interface UiBlackboxSession {
+    /** Unique session identifier (UUID v4). */
+    sessionId: string;
+    /** Stable device/browser fingerprint. */
+    fingerprint: UiBlackboxFingerprint;
+    /** Timestamp (ms since epoch) when the session started. */
+    startedAt: number;
+    /** Timestamp (ms since epoch) when the session ended (tab closed). */
+    endedAt?: number;
+    /** Raw `navigator.userAgent` string captured at session start. */
+    userAgent: string;
+    /**
+     * Ordered list of navigation steps (route changes).
+     * Each step contains the actions performed on that page.
+     */
+    steps: UiBlackboxStep[];
+    /**
+     * Parallel stream of form interaction events.
+     * Ordered by timestamp, correlated to routes via `route` field.
+     */
+    formEvents: UiBlackboxFormEvent[];
+    /**
+     * Intercepted HTTP calls, ordered by timestamp.
+     * Only requests explicitly marked with the `X-Ui-Blackbox` header.
+     */
+    calls: UiBlackboxHttpCall[];
+}
+/**
+ * A single navigation step created on every `NavigationEnd` event.
+ * Contains all UI actions performed during this route.
+ */
+export interface UiBlackboxStep {
+    /** Timestamp (ms) of the navigation event. */
+    timestamp: number;
+    /** The route URL navigated to. */
+    route: string;
+    /** The previous route URL (undefined for the first step). */
+    previousRoute?: string;
+    /**
+     * Ordered list of UI actions (clicks) performed on this page.
+     */
+    actions: UiBlackboxAction[];
+}
+/**
+ * A single tracked UI action, typically a click.
+ */
+export interface UiBlackboxAction {
+    /** Timestamp (ms) of the action. */
+    timestamp: number;
+    /** Type discriminator. Currently only `click` is supported. */
+    type: 'click';
+    /** Information about the clicked element. */
+    target: UiBlackboxActionTarget;
+}
+/**
+ * Minimal information about the element that was interacted with.
+ */
+export interface UiBlackboxActionTarget {
+    /** HTML tag name (lowercase). */
+    tag: string;
+    /** Element `id` attribute, if present. */
+    id?: string;
+    /**
+     * Custom tracking identifier, set via `data-track-id` attribute
+     * or the `[uiTrack]` directive value.
+     */
+    trackId?: string;
+    /** First 50 characters of `innerText` (trimmed). */
+    text?: string;
+}
+/** Discriminator for form event types. */
+export type UiBlackboxFormEventType = 'focus' | 'blur' | 'valueChange' | 'validationError';
+/**
+ * A single form interaction event from the parallel form stream.
+ *
+ * Each event is timestamped and tagged with the current route, allowing
+ * correlation with navigation steps on a shared timeline.
+ */
+export interface UiBlackboxFormEvent {
+    /** Timestamp (ms) of the event. */
+    timestamp: number;
+    /** Route URL where the event occurred. */
+    route: string;
+    /** Schema `id` of the `UiFormBuilderComponent` that owns the field. */
+    formId: string;
+    /** `key` of the field descriptor from the form schema. */
+    fieldKey: string;
+    /** Type of form interaction. */
+    eventType: UiBlackboxFormEventType;
+    /** Optional metadata depending on event type and config. */
+    metadata?: UiBlackboxFormEventMetadata;
+}
+/**
+ * Optional metadata attached to a `UiBlackboxFormEvent`.
+ */
+export interface UiBlackboxFormEventMetadata {
+    /** Field value (only captured when `config.formTracking.trackValues` is `true`). */
+    value?: any;
+    /** Whether the field is currently valid. */
+    valid?: boolean;
+    /** List of active validation error keys. */
+    errors?: string[];
+    /**
+     * Full form values snapshot at the moment of the event.
+     * Only captured when `config.formTracking.trackValues` is `true`.
+     */
+    formValues?: Record<string, any>;
+}
+/**
+ * A single intercepted HTTP call.
+ *
+ * Only requests bearing the `X-Ui-Blackbox` header are captured.
+ */
+export interface UiBlackboxHttpCall {
+    /** Timestamp (ms) when the request was initiated. */
+    timestamp: number;
+    /** HTTP method (GET, POST, PUT, DELETE, …). */
+    method: string;
+    /** Request URL. */
+    url: string;
+    /** HTTP status code of the response (undefined if the request failed). */
+    status?: number;
+    /** Round-trip duration in milliseconds. */
+    durationMs?: number;
+    /** Request body payload (serialisable). */
+    requestPayload?: any;
+    /** Response headers filtered by the `X-Ui-Blackbox-Headers` regex. */
+    responseHeaders?: Record<string, string>;
+    /** The regex pattern used to filter response headers. */
+    headerFilter?: string;
+}
+/**
+ * Union type for all events flowing through the centralised buffer.
+ * @internal
+ */
+export type UiBlackboxBufferEvent = {
+    kind: 'action';
+    payload: UiBlackboxAction & {
+        route: string;
+    };
+} | {
+    kind: 'formEvent';
+    payload: UiBlackboxFormEvent;
+} | {
+    kind: 'httpCall';
+    payload: UiBlackboxHttpCall;
+} | {
+    kind: 'step';
+    payload: UiBlackboxStep;
+};
+/** Default configuration values. */
+export declare const UI_BLACKBOX_DEFAULTS: UiBlackboxConfig;