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

package/lib/components/accordion/accordion.component.d.ts

@@ -65,9 +65,16 @@ export declare class UiAccordionComponent implements DoCheck {
     /**
      * Template opzionale per contenuto aggiuntivo nell'header.
      * Il contesto fornisce il descriptor come `$implicit`.
-     * Viene renderizzato tra il titolo e il chevron.
+     * 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
@@ -106,7 +113,7 @@ export declare class UiAccordionComponent implements DoCheck {
     focusFirst(event: Event): void;
     /** @internal Sposta il focus all'ultimo header. */
     focusLast(event: Event): void;
-    /** @internal Recupera tutti gli header button del DOM. */
+    /** @internal Recupera tutti i trigger button del DOM. */
     private getHeaders;
     /**
      * @internal Calcola un fingerprint leggero basato sulle proprieta
@@ -114,5 +121,5 @@ export declare class UiAccordionComponent implements DoCheck {
      */
     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; }; "mode": { "alias": "mode"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, { "itemToggled": "itemToggled"; }, never, never, true, 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/lib/components/accordion/accordion.types.d.ts

@@ -41,6 +41,8 @@ export interface UiAccordionDescriptor {
     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.

package/lib/components/base-layout/base-layout.component.d.ts

@@ -1,7 +1,13 @@
-import { OnInit } from '@angular/core';
-import { UiButtonDescriptor, UiButtonAreaAlign } from '../button/button.types';
-import { UiBackButtonConfig } from './base-layout.types';
+import { type OnInit } from '@angular/core';
+import type { UiButtonAreaAlign, UiButtonDescriptor } from '../button/button.types';
+import type { UiBackButtonConfig } from './base-layout.types';
 import * as i0 from "@angular/core";
+/** Stato letto dalla rotta foglia per header/footer opzionali e `data-route-id`. */
+interface UiBaseLayoutRouteSnapshotFlags {
+    breadcrumbOff: boolean;
+    footerNavOff: boolean;
+    routeId: string | null;
+}
 /**
  * Full-page layout component that combines a page header (breadcrumbs + title),
  * a main content area via `<ng-content>`, and a sticky footer action bar
@@ -10,6 +16,14 @@ import * as i0 from "@angular/core";
  * Optionally renders an automatic "back" button in the footer, derived from
  * the breadcrumb trail (navigates to the parent breadcrumb).
  *
+ * ### Route `data`
+ *
+ * Sulla rotta attiva (foglia) puoi impostare:
+ *
+ * - `breadcrumbOff: true` — nasconde `ui-page-header`
+ * - `footerNavOff: true` — nasconde `ui-base-layout__footer`
+ * - `id: string` — valorizza `data-route-id` sul contenitore `.ui-base-layout`
+ *
  * @selector ui-base-layout
  *
  * @example
@@ -57,12 +71,18 @@ export declare class UiBaseLayoutComponent implements OnInit {
     /** Gap size between footer buttons. */
     footerGap: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
     private readonly router;
-    private readonly location;
     private readonly activatedRoute;
     private readonly breadcrumbService;
     private readonly destroyRef;
-    /** @internal Current breadcrumbs, updated on each navigation. */
-    private breadcrumbs;
+    /**
+     * Flag derivati dalla catena attiva (`breadcrumbOff`, `footerNavOff`, `id`).
+     * Aggiornati a ogni `NavigationEnd`.
+     */
+    protected readonly routeSnapshotFlags: import("@angular/core").WritableSignal<UiBaseLayoutRouteSnapshotFlags>;
+    /** Header visibile se abilitato da input e non disattivato da `data.breadcrumbOff`. */
+    protected readonly effectiveShowHeader: () => boolean;
+    /** Footer azioni visibile se ci sono azioni visibili e non disattivato da `data.footerNavOff`. */
+    protected readonly effectiveShowFooterNav: () => boolean;
     /**
      * Merged action list (back button + consumer actions).
      * Computed on every change-detection check so it stays in sync
@@ -72,12 +92,17 @@ export declare class UiBaseLayoutComponent implements OnInit {
     /** Whether the footer should render (at least one non-hidden action exists). */
     get hasVisibleActions(): boolean;
     ngOnInit(): void;
-    /** @internal Refreshes breadcrumb state from the current route. */
-    private refreshBreadcrumbs;
-    /** @internal Determines the back navigation target from breadcrumbs. */
-    private getBackTarget;
-    /** @internal Navigates to the parent breadcrumb or falls back to browser history. */
+    /** @internal Allinea breadcrumb service e flag layout alla rotta corrente. */
+    private syncFromActivatedRoute;
+    /** @internal Legge `breadcrumbOff`, `footerNavOff`, `id` dalla catena `pathFromRoot` / foglia. */
+    private refreshRouteSnapshotFlags;
+    /** @internal Percorre fino al `ActivatedRoute` foglia sotto il punto di iniezione. */
+    private deepestChildRoute;
+    /** @internal Determina se il back button deve essere nascosto per la rotta corrente. */
+    private shouldHideBackButton;
+    /** @internal Naviga al breadcrumb genitore o esegue il fallback alla home route. */
     private navigateBack;
     static ɵfac: i0.ɵɵFactoryDeclaration<UiBaseLayoutComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<UiBaseLayoutComponent, "ui-base-layout", never, { "showHeader": { "alias": "showHeader"; "required": false; }; "title": { "alias": "title"; "required": false; }; "homeRoute": { "alias": "homeRoute"; "required": false; }; "showHome": { "alias": "showHome"; "required": false; }; "updateDocumentTitle": { "alias": "updateDocumentTitle"; "required": false; }; "titleSuffix": { "alias": "titleSuffix"; "required": false; }; "showBackButton": { "alias": "showBackButton"; "required": false; }; "backButtonConfig": { "alias": "backButtonConfig"; "required": false; }; "actions": { "alias": "actions"; "required": false; }; "footerAlign": { "alias": "footerAlign"; "required": false; }; "footerGap": { "alias": "footerGap"; "required": false; }; }, {}, never, ["*"], true, never>;
 }
+export {};

package/lib/components/base-layout/base-layout.types.d.ts

@@ -4,6 +4,20 @@
  */
 import { UiButtonDescriptor, UiButtonAreaAlign } from '../button/button.types';
 export { UiButtonDescriptor, UiButtonAreaAlign };
+/**
+ * Chiavi opzionali di `data` sulla rotta attiva riconosciute da `UiBaseLayoutComponent`.
+ *
+ * - `id`: stessa risalita usata dai breadcrumb (dal segmento foglia verso il root: primo `id` trovato).
+ * - `breadcrumbOff` / `footerNavOff`: se `true` su **qualsiasi** segmento in `pathFromRoot`, l’area viene nascosta.
+ */
+export interface UiBaseLayoutRouteData {
+    /** Identificativo stabile della rotta; reso come `data-route-id` sul wrapper `.ui-base-layout`. */
+    id?: string;
+    /** Se `true`, non viene renderizzato `ui-page-header` (breadcrumb e titolo). */
+    breadcrumbOff?: boolean;
+    /** Se `true`, non viene renderizzata la barra `ui-base-layout__footer` (azioni / indietro). */
+    footerNavOff?: boolean;
+}
 /**
  * Configuration for the automatic "back" button rendered in the footer action area.
  *

package/lib/components/base-layout/index.d.ts

@@ -10,4 +10,4 @@
  * ```
  */
 export { UiBaseLayoutComponent } from './base-layout.component';
-export { UiBackButtonConfig } from './base-layout.types';
+export { UiBackButtonConfig, UiBaseLayoutRouteData } from './base-layout.types';

package/lib/components/blackbox/blackbox-debugger.component.d.ts

@@ -0,0 +1,80 @@
+/**
+ * @module ng-ui-system/blackbox
+ * Componente debugger BlackBox — aperto in modale fullscreen.
+ *
+ * Layout:
+ * - Header con titolo e chiusura
+ * - Tab group: Dashboard | Timeline | Form Events | HTTP Calls
+ *
+ * Funzionalita:
+ * - Timeline unificata (navigazioni + click + form events + HTTP calls)
+ * - Form events con valori del form visibili
+ * - JSON detail modal al click su dati strutturati
+ */
+import { OnInit, OnDestroy } from '@angular/core';
+import { MatDialogRef } from '@angular/material/dialog';
+import { UiBlackboxSession } from './blackbox.types';
+import * as i0 from "@angular/core";
+/** Discriminated union for the unified timeline. */
+interface TimelineEntry {
+    timestamp: number;
+    kind: 'navigation' | 'click' | 'formEvent' | 'httpCall';
+    route?: string;
+    previousRoute?: string;
+    actionsCount?: number;
+    tag?: string;
+    trackId?: string;
+    text?: string;
+    formId?: string;
+    fieldKey?: string;
+    eventType?: string;
+    metadata?: any;
+    method?: string;
+    url?: string;
+    status?: number;
+    durationMs?: number;
+    requestPayload?: any;
+    responseHeaders?: Record<string, string>;
+}
+export declare class UiBlackboxDebuggerComponent implements OnInit, OnDestroy {
+    dialogRef: MatDialogRef<UiBlackboxDebuggerComponent>;
+    dialogData: any;
+    private readonly blackbox;
+    private readonly http;
+    private readonly modalService;
+    private readonly cdr;
+    private readonly destroy$;
+    /** Whether opened inside a dialog. */
+    isDialogMode: boolean;
+    selectedTab: number;
+    session: UiBlackboxSession | null;
+    viewingSession: UiBlackboxSession | null;
+    pastSessions: UiBlackboxSession[];
+    statsCards: {
+        icon: string;
+        value: number;
+        label: string;
+    }[];
+    /** Unified timeline entries sorted by timestamp. */
+    timelineEntries: TimelineEntry[];
+    constructor(dialogRef: MatDialogRef<UiBlackboxDebuggerComponent>, dialogData: any);
+    get sessionDuration(): string;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    refresh(): void;
+    private updateStats;
+    /** Builds a unified timeline from all event sources. */
+    private buildTimeline;
+    viewSession(s: UiBlackboxSession): void;
+    closeDialog(): void;
+    openJsonModal(title: string, data: any): void;
+    simulateGet(): void;
+    simulatePost(): void;
+    simulateFail(): void;
+    exportSessions(): Promise<void>;
+    importJsonl(): void;
+    clearHistory(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiBlackboxDebuggerComponent, [{ optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UiBlackboxDebuggerComponent, "ui-blackbox-debugger", never, {}, {}, never, never, true, never>;
+}
+export {};

package/lib/components/blackbox/blackbox-debugger.service.d.ts

@@ -0,0 +1,34 @@
+import { MatDialogRef } from '@angular/material/dialog';
+import { UiBlackboxDebuggerComponent } from './blackbox-debugger.component';
+import * as i0 from "@angular/core";
+/**
+ * Servizio per aprire il debugger BlackBox in una modale fullscreen
+ * tramite il UiModalService.
+ *
+ * @usageNotes
+ *
+ * ### Apertura base
+ * ```typescript
+ * const ref = this.debuggerService.open();
+ * ```
+ *
+ * ### Apertura con sessioni importate (JSONL)
+ * ```typescript
+ * this.debuggerService.open({ importedSessions: mySessions });
+ * ```
+ */
+export declare class UiBlackboxDebuggerService {
+    /** @internal Servizio modale per l'apertura. */
+    private readonly modalService;
+    /**
+     * Apre il debugger in una modale fullscreen.
+     *
+     * @param config - Configurazione opzionale
+     * @returns Riferimento alla dialog per gestire chiusura
+     */
+    open(config?: {
+        importedSessions?: any[];
+    }): MatDialogRef<UiBlackboxDebuggerComponent, void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiBlackboxDebuggerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UiBlackboxDebuggerService>;
+}

package/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/lib/components/blackbox/blackbox-json-viewer.component.d.ts

@@ -0,0 +1,18 @@
+import { MatDialogRef } from '@angular/material/dialog';
+import * as i0 from "@angular/core";
+export declare class UiBlackboxJsonViewerComponent {
+    dialogRef: MatDialogRef<UiBlackboxJsonViewerComponent>;
+    data: {
+        title: string;
+        json: any;
+    };
+    copied: boolean;
+    formattedJson: string;
+    constructor(dialogRef: MatDialogRef<UiBlackboxJsonViewerComponent>, data: {
+        title: string;
+        json: any;
+    });
+    copyToClipboard(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiBlackboxJsonViewerComponent, [{ optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UiBlackboxJsonViewerComponent, "ui-blackbox-json-viewer", never, {}, {}, never, never, true, never>;
+}

package/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/lib/components/blackbox/blackbox.interceptor.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @module ng-ui-system/blackbox
+ * HTTP interceptor for BlackBox — captures requests marked with
+ * the `X-Ui-Blackbox` header.
+ *
+ * @usageNotes
+ * ### Setup (functional interceptor, Angular 17+)
+ * ```typescript
+ * // app.config.ts
+ * import { provideHttpClient, withInterceptors } from '@angular/common/http';
+ * import { uiBlackboxInterceptor } from '@gnggln/ng-ui-system';
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideHttpClient(withInterceptors([uiBlackboxInterceptor])),
+ *   ],
+ * };
+ * ```
+ *
+ * ### Marking a request
+ * ```typescript
+ * this.http.get('/api/data', {
+ *   headers: new HttpHeaders({
+ *     'X-Ui-Blackbox': 'true',
+ *     // Optional: filter response headers to capture
+ *     'X-Ui-Blackbox-Headers': 'x-request-id|x-correlation-.*',
+ *   }),
+ * });
+ * ```
+ */
+import { HttpInterceptorFn } from '@angular/common/http';
+/**
+ * Angular functional HTTP interceptor for BlackBox.
+ *
+ * Only processes requests that include the `X-Ui-Blackbox` header.
+ * Strips the custom headers before forwarding the request to the server.
+ */
+export declare const uiBlackboxInterceptor: HttpInterceptorFn;

package/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>;
+}