@lynxflow/seo-engine 2.8.0 → 3.2.0

package/dist/public-page-interactive.d.ts

@@ -0,0 +1,77 @@
+export type DateRangePreset = "7d" | "30d" | "90d" | "custom";
+export interface DateRangeConfig {
+    preset: DateRangePreset;
+    startDate?: string;
+    endDate?: string;
+    timezone?: string;
+}
+export type WidgetType = "kpi" | "line" | "bar" | "pie" | "table" | "heatmap" | "funnel";
+export interface WidgetConfig {
+    id: string;
+    type: WidgetType;
+    title: string;
+    description?: string;
+    metric: string;
+    width?: "sm" | "md" | "lg" | "full";
+    visible?: boolean;
+    options?: Record<string, unknown>;
+}
+export interface FilterOption {
+    id: string;
+    label: string;
+    values: string[];
+    multi?: boolean;
+}
+export interface PublicDashboardConfig {
+    id: string;
+    slug: string;
+    title: string;
+    description?: string;
+    widgets: WidgetConfig[];
+    filters: FilterOption[];
+    dateRange: DateRangeConfig;
+    theme?: "light" | "dark" | "auto";
+    allowEmbedding?: boolean;
+    shareEnabled?: boolean;
+    createdAt: string;
+    updatedAt: string;
+    token?: string;
+}
+export interface InteractiveState {
+    dashboardId: string;
+    filters: Record<string, string[]>;
+    dateRange: DateRangeConfig;
+    activeWidgetId?: string;
+    lastUpdated: string;
+    readonly: true;
+}
+export interface ShareableUrlParams {
+    slug: string;
+    f?: string;
+    dr?: string;
+    w?: string;
+    t?: string;
+}
+export interface EmbeddableWidget {
+    widgetId: string;
+    embedToken: string;
+    src: string;
+    width?: number | string;
+    height?: number | string;
+    sandbox?: string[];
+    allow?: string[];
+}
+/** Create a new public dashboard configuration with generated ids/slugs. */
+export declare function createDashboardConfig(title: string, widgets: WidgetConfig[], filters?: FilterOption[], dateRange?: DateRangeConfig): PublicDashboardConfig;
+/** Serialize filters to a base64-encoded JSON string for URL params. */
+export declare function serializeFilters(filters: Record<string, string[]>): string;
+/** Deserialize filters from a base64-encoded JSON string from URL params. */
+export declare function deserializeFilters(encoded: string): Record<string, string[]>;
+/** Build a shareable URL with state encoded in params. */
+export declare function buildShareableUrl(baseUrl: string, config: PublicDashboardConfig, state?: Partial<InteractiveState>, token?: string): string;
+/** Parse shareable URL params. */
+export declare function parseShareableUrl(url: string): ShareableUrlParams;
+/** Create a read-only interactive state initialized from dashboard config. */
+export declare function createInteractiveState(config: PublicDashboardConfig, overrides?: Partial<InteractiveState>): InteractiveState;
+/** Create an embeddable widget descriptor for a given widget. */
+export declare function createEmbeddableWidget(config: PublicDashboardConfig, widgetId: string, baseEmbedUrl: string): EmbeddableWidget | null;

package/dist/public-status-pages.d.ts

@@ -0,0 +1,61 @@
+/**
+ * G10 — Public Status Pages
+ *
+ * LynxSEO: pulse-status-pages.schema.ts + StatusPagesTab.tsx + StatusPageEditors.tsx
+ *          + renderPublicStatusPage.ts + pulseStatusPages.ts
+ *          + public-status-pages.ts (nouveau - logique publique pure)
+ * Inspiration: Metabase status pages + documentation mentionnée
+ *
+ * NOTE: pulse-status-pages.schema.ts + StatusPagesTab.tsx + StatusPageEditors.tsx
+ * + renderPublicStatusPage.ts + pulseStatusPages.ts fournissent l'affichage et
+ * le stockage des status pages publiques, mais public-status-pages.ts offre la
+ * logique publique pure (génération de badge, URL publique, validation) réutilisable
+ * en dehors du contexte Next.js/React.
+ */
+import { z } from "zod";
+/** Statut d'une page publique */
+export type PublicStatus = "operational" | "degraded" | "partial_outage" | "major_outage";
+/** Niveau de gravité */
+export type SeverityLevel = "low" | "medium" | "high" | "critical";
+/** Informations de santé d'une page publique */
+export type StatusPageInfo = {
+    id: string;
+    slug: string;
+    title: string;
+    status: PublicStatus;
+    severity: SeverityLevel;
+    lastChecked: Date;
+    details?: string;
+    metadata?: Record<string, unknown>;
+};
+/** Schéma de validation pour une status page */
+export declare const statusPageSchema: z.ZodObject<{
+    id: z.ZodString;
+    slug: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<{
+        degraded: "degraded";
+        operational: "operational";
+        partial_outage: "partial_outage";
+        major_outage: "major_outage";
+    }>;
+    severity: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        critical: "critical";
+    }>;
+    lastChecked: z.ZodDate;
+    details: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/** Générer l'URL publique d'une status page */
+export declare function getPublicStatusUrl(slug: string): string;
+/** Générer le badge SVG pour un statut */
+export declare function generateStatusBadge(status: PublicStatus, severity: SeverityLevel): string;
+/** Valider si un statut est un état dégradé */
+export declare function isDegradedStatus(status: PublicStatus): boolean;
+/** Valider si un statut est une panne majeure */
+export declare function isCriticalStatus(status: PublicStatus, severity: SeverityLevel): boolean;
+/** Mettre à jour le statut dernier vérifié */
+export declare function updateLastChecked(): Date;

package/dist/pulse-remote-config.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Générateur du client de configuration distante du tracker : drapeaux et
+ * sondages consommés depuis `/api/pulse/v1/decide`.
+ *
+ * Le bundle est livré aux sites des clients, où aucune session tableau de bord
+ * n'existe : la décision se prend donc sur l'identifiant de projet et un
+ * identifiant visiteur persistant, et le serveur ne renvoie que ce qui est
+ * allumé.
+ *
+ * Toute écriture DOM passe par `createElement` et `textContent` : les titres de
+ * sondage viennent de la base et ne doivent jamais être analysés comme du
+ * balisage.
+ */
+export interface RemoteConfigOptions {
+    /** Identifiant de projet ; `readScriptTag` peut le déduire du `<script>`. */
+    projectId?: string;
+    apiOrigin?: string;
+    /** Chemin complet du point de décision. */
+    decideUrl?: string;
+    /** Chemin complet du point de réponse aux sondages. */
+    surveyUrl?: string;
+    /** Relit `data-site-id` / `data-domain` sur la balise du tracker. */
+    readScriptTag?: boolean;
+    labels?: Partial<RemoteConfigLabels>;
+}
+export interface RemoteConfigLabels {
+    thanks: string;
+    send: string;
+    dismiss: string;
+    choicePrompt: string;
+    npsPrompt: string;
+    ratingPrompt: string;
+    feedbackPrompt: string;
+    feedbackPlaceholder: string;
+}
+export declare function generatePulseRemoteConfigJs(options?: RemoteConfigOptions): string;

package/dist/pulse-shield-engine.d.ts

@@ -0,0 +1,76 @@
+/**
+ * PulseShieldEngine — bot & referrer traffic shield.
+ * Provides ingestion-level traffic filtering:
+ * 1. IP exclusion (office/team IPs to avoid polluting stats).
+ * 2. Path exclusion (admin, staging, and preview URLs).
+ * 3. Strict hostname locking (prevents scrapers from firing events with stolen site IDs).
+ * 4. Country exclusion (ISO-3166 alpha-2, e.g. internal QA teams abroad).
+ * 5. User-agent exclusion (case-insensitive substrings, e.g. "HeadlessChrome").
+ * 6. ASN exclusion (autonomous systems, with or without the "AS" prefix).
+ * 7. Query-param exclusion ("name" = param present, "name=value" with * glob).
+ */
+export interface PulseShieldConfig {
+    excludedIps?: string[];
+    excludedPaths?: string[];
+    allowedHostnames?: string[];
+    excludedCountries?: string[];
+    excludedUserAgents?: string[];
+    excludedAsns?: string[];
+    excludedQueryParams?: string[];
+}
+export type PulseShieldReason = "ip_excluded" | "path_excluded" | "hostname_rejected" | "country_excluded" | "user_agent_excluded" | "asn_excluded" | "query_param_excluded";
+export interface PulseShieldDecision {
+    allow: boolean;
+    reason?: PulseShieldReason;
+}
+/** Every rule list the shield understands, in evaluation order. */
+export declare const PULSE_SHIELD_RULE_KEYS: readonly ["excludedIps", "excludedPaths", "allowedHostnames", "excludedCountries", "excludedUserAgents", "excludedAsns", "excludedQueryParams"];
+/**
+ * Checks if an IPv4 address matches a single IP or CIDR block (e.g. 192.168.1.0/24).
+ */
+declare function matchIpOrCidr(clientIp: string, rule: string): boolean;
+/**
+ * Checks if a URL path matches an exclusion pattern (supports * wildcards).
+ */
+declare function matchPathPattern(path: string, pattern: string): boolean;
+/**
+ * Checks if a hostname matches the allowed domain list (supports subdomains with wildcard *.domain.com).
+ */
+declare function matchHostname(hostname: string, allowedPattern: string): boolean;
+/** ISO-3166 alpha-2 comparison, case-insensitive. */
+declare function matchCountry(countryCode: string, rule: string): boolean;
+/** Case-insensitive substring match on the raw user-agent string. */
+declare function matchUserAgent(userAgent: string, rule: string): boolean;
+/** Normalises "AS13335" / "as13335" / "13335" / 13335 to a number (NaN when invalid). */
+declare function normalizeAsn(value: string | number): number;
+declare function matchAsn(asn: string | number, rule: string): boolean;
+type QueryInput = string | URLSearchParams | Record<string, string | string[]>;
+/**
+ * Query-param rule: "name" matches when the parameter is present with any
+ * value; "name=value" matches when one of its values matches the glob.
+ */
+declare function matchQueryParam(query: QueryInput, rule: string): boolean;
+export declare const PulseShieldEngine: {
+    /**
+     * Evaluates an incoming ingestion request against the project's shield rules.
+     */
+    shouldIngestEvent(params: {
+        ip?: string;
+        path?: string;
+        hostname?: string;
+        countryCode?: string;
+        userAgent?: string;
+        asn?: string | number;
+        query?: QueryInput;
+        config?: PulseShieldConfig;
+    }): PulseShieldDecision;
+    matchIpOrCidr: typeof matchIpOrCidr;
+    matchPathPattern: typeof matchPathPattern;
+    matchHostname: typeof matchHostname;
+    matchCountry: typeof matchCountry;
+    matchUserAgent: typeof matchUserAgent;
+    matchAsn: typeof matchAsn;
+    matchQueryParam: typeof matchQueryParam;
+    normalizeAsn: typeof normalizeAsn;
+};
+export {};

package/dist/pulse-telemetry.d.ts

@@ -0,0 +1,77 @@
+/**
+ * 🦁 LynxSEO Engine — PulseTelemetryClient
+ *
+ * High-performance, cookieless, RGPD-compliant client telemetry suite.
+ */
+export interface PulseTelemetryConfig {
+    projectId: string;
+    endpoint?: string;
+    cookieless?: boolean;
+    sessionReplay?: boolean;
+    anonymizeIp?: boolean;
+    autoCapture?: boolean;
+    domain?: string;
+}
+export interface PulseTelemetryEvent {
+    id: string;
+    projectId: string;
+    eventName: "$pageview" | "click" | "scroll" | "form_submit" | "ai_bot_hit" | "custom";
+    timestamp: string;
+    urlPath: string;
+    userLabel: string;
+    countryCode: string;
+    device: "desktop" | "mobile" | "tablet";
+    properties: Record<string, unknown>;
+}
+export interface PulseAiBotDetection {
+    isAiBot: boolean;
+    botName?: "GPTBot" | "ClaudeBot" | "PerplexityBot" | "Google-Extended" | "ByteSpider" | "Other";
+}
+export declare class PulseTelemetryClient {
+    private config;
+    private flags;
+    private static instance;
+    constructor(config: PulseTelemetryConfig);
+    /**
+     * Singleton initializer for web browsers and apps.
+     */
+    static init(config: PulseTelemetryConfig): PulseTelemetryClient;
+    static getInstance(): PulseTelemetryClient | null;
+    /**
+     * Identifies whether the incoming User-Agent belongs to an AI search crawler.
+     */
+    detectAiBot(userAgent?: string): PulseAiBotDetection;
+    /**
+     * Sends a telemetry event to LynxSEO Edge ingestion.
+     */
+    track(eventName: PulseTelemetryEvent["eventName"], properties?: Record<string, unknown>): Promise<{
+        success: boolean;
+        eventId: string;
+    }>;
+    /**
+     * Standard shortcut for $pageview event.
+     */
+    trackPageView(path?: string, title?: string): Promise<{
+        success: boolean;
+        eventId: string;
+    }>;
+    /**
+     * Configures local feature flags (e.g. for SEO title / CTA experiments).
+     */
+    setFeatureFlags(flags: Record<string, string | boolean>): void;
+    /**
+     * Returns active variant for a given feature flag key.
+     */
+    getFeatureFlag(flagKey: string, defaultValue?: string | boolean): string | boolean;
+    /**
+     * Triggers an in-page micro-survey modal or overlay.
+     */
+    triggerSurvey(surveyId: string): {
+        id: string;
+        active: boolean;
+    };
+    /**
+     * Generates the ready-to-copy HTML <script> snippet.
+     */
+    generateSnippetHtml(): string;
+}

package/dist/rank-math-parity.d.ts

@@ -1,5 +1,5 @@
 /**
- * 👑 Rank Math Parity & Real-Time Content SEO Score Engine
+ * 👑 Real-Time Content SEO Score Engine
  *
  * Implements the core features that made Rank Math famous (3M+ installs):
  * 1. Real-Time 0-100 On-Page Content SEO Score (Checklist: Title, Slug, H2, Density, Words, Internal/External links)
@@ -35,7 +35,7 @@ export interface RedirectRule {
 }
 export declare class RankMathParityEngine {
     /**
-     * 1. Calculates the exact 0-100 Real-Time On-Page Content SEO Score (Rank Math Benchmark).
+     * 1. Calculates the exact 0-100 Real-Time On-Page Content SEO Score.
      */
     static calculateOnPageScore(opts: {
         focusKeyword: string;

package/dist/rbac-granular.d.ts

@@ -0,0 +1,47 @@
+/**
+ * G9 — RBAC Granular
+ *
+ * LynxSEO: team-rbac.ts + permissions.schema.ts (rowColumnPermissions)
+ *          + rbac-granular.ts (nouveau - logique RBAC pure indépendante de l'UI)
+ * Inspiration: Metabase permissions + documentation mentionnée
+ *
+ * NOTE: team-rbac.ts fournit lmiddleware d'autorisation actif (hasProjectRole),
+ * mais rbac-granular.ts offre la logique RBAC pure réutilisable sans dépendance
+ * au contexte projet (pour usage dans des services non-HTTP, tests, etc.).
+ */
+import { z } from "zod";
+/** Rôles disponibles dans le système */
+export type Role = "viewer" | "editor" | "admin" | "projectOwner";
+/** Permissions par ressource */
+export type ResourcePermission = {
+    /** Peut lire */
+    read: boolean;
+    /** Peut écrire */
+    write: boolean;
+    /** Peut supprimer */
+    delete: boolean;
+    /** Peut administrer */
+    admin: boolean;
+};
+/** Permissions complètes par rôle */
+export declare const ROLE_PERMISSIONS: Record<Role, ResourcePermission>;
+/** Vérifier si un rôle a une permission spécifique */
+export declare function hasRolePermission(role: Role, permission: keyof ResourcePermission): boolean;
+/** Vérifier si un rôle peut effectuer une action sur une ressource */
+export declare function can(role: Role, action: "read" | "write" | "delete" | "admin"): boolean;
+/** Schema for role assignment */
+export declare const roleSchema: z.ZodObject<{
+    role: z.ZodEnum<{
+        admin: "admin";
+        editor: "editor";
+        viewer: "viewer";
+        projectOwner: "projectOwner";
+    }>;
+    resource: z.ZodString;
+    allowed: z.ZodObject<{
+        read: z.ZodBoolean;
+        write: z.ZodBoolean;
+        delete: z.ZodBoolean;
+        admin: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;

package/dist/reader-cleaner.d.ts

@@ -0,0 +1,40 @@
+/**
+ * ReaderCleaner - Nettoyeur sémantique et extracteur de contenu pur pour le RAG, AEO et GEO.
+ * Extraction de type Reader View / Readability pour un contenu net.
+ * Conçu pour fonctionner sur n'importe quel runtime (Node, Cloudflare Worker, Bun).
+ */
+export interface ReaderCleanOptions {
+    /** Nombre maximal de caractères à extraire (par défaut: illimité) */
+    maxChars?: number;
+    /** Conserver les balises d'images utiles */
+    keepImages?: boolean;
+}
+export interface ReaderCleanResult {
+    title: string;
+    byline: string;
+    excerpt: string;
+    cleanHtml: string;
+    textContent: string;
+    content?: string;
+    wordCount: number;
+    charCount: number;
+    estimatedReadTimeMinutes: number;
+}
+export declare const ReaderCleaner: {
+    extract: typeof extractReaderContent;
+    cleanHtml: (html: string, options?: {
+        stripPromptInjections?: boolean;
+        maxLength?: number;
+    }) => {
+        content: string;
+        title: string;
+        byline: string;
+        excerpt: string;
+        cleanHtml: string;
+        textContent: string;
+        wordCount: number;
+        charCount: number;
+        estimatedReadTimeMinutes: number;
+    };
+};
+export declare function extractReaderContent(rawHtml: string, options?: ReaderCleanOptions): ReaderCleanResult;

package/dist/real-user-monitoring.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Page Performance (RUM) — Matomo Plugin "PagePerformance"
+ *
+ * Collecte les métriques de chargement réel des pages depuis la Navigation Timing API
+ * du navigateur (network, server, transfer, DOM, onload, FCP, LCP, CLS, INP).
+ */
+export interface NavigationTimingMetrics {
+    dnsLookup?: number;
+    tcpConnect?: number;
+    tlsNegotiation?: number;
+    serverResponse?: number;
+    contentTransfer?: number;
+    domProcessing?: number;
+    domComplete?: number;
+    onLoad?: number;
+    pageLoadTime?: number;
+    firstPaint?: number;
+    firstContentfulPaint?: number;
+    largestContentfulPaint?: number;
+    cumulativeLayoutShift?: number;
+    interactionToNextPaint?: number;
+    firstInputDelay?: number;
+    navigationStart?: number;
+    fetchStart?: number;
+    domainLookupStart?: number;
+    domainLookupEnd?: number;
+    connectStart?: number;
+    connectEnd?: number;
+    secureConnectionStart?: number;
+    requestStart?: number;
+    responseStart?: number;
+    responseEnd?: number;
+    domLoading?: number;
+    domInteractive?: number;
+    domContentLoadedEventStart?: number;
+    domContentLoadedEventEnd?: number;
+    loadEventStart?: number;
+    loadEventEnd?: number;
+    pageUrl: string;
+    siteId: string;
+    timestamp?: Date;
+    visitorId?: string;
+    userId?: string;
+    connectionType?: string;
+    deviceType?: string;
+}
+export interface PagePerformanceAggregated {
+    siteId: string;
+    pageUrl: string;
+    sampleCount: number;
+    avgLoadTime: number;
+    avgTTFB: number;
+    avgLCP: number;
+    avgCLS: number;
+    avgINP: number;
+    p75LoadTime: number;
+    p95LoadTime: number;
+    p75LCP: number;
+    p95LCP: number;
+    slowPageRate: number;
+    lastUpdated: Date;
+}
+export declare class RealUserMonitoring {
+    private samples;
+    private maxSamples;
+    /**
+     * Enregistre un échantillon de performance RUM.
+     */
+    recordSample(metrics: NavigationTimingMetrics): void;
+    /**
+     * Calcule les métriques agrégées pour un site et une page.
+     */
+    aggregate(siteId: string, pageUrl?: string): PagePerformanceAggregated | null;
+    /**
+     * Récupère les échantillons bruts pour un site.
+     */
+    getSamples(siteId: string, limit?: number): NavigationTimingMetrics[];
+    /**
+     * Nombre total d'échantillons pour un site.
+     */
+    countSamples(siteId: string): number;
+}
+export declare const realUserMonitoring: RealUserMonitoring;
+/**
+ * Transforme un payload Navigation Timing brut (depuis le tracker JS) en métriques structurées.
+ */
+export declare function parseNavigationTiming(raw: {
+    pageUrl: string;
+    siteId: string;
+    visitorId?: string;
+    userId?: string;
+    [key: string]: unknown;
+}): NavigationTimingMetrics;

package/dist/real-volume-indexability-gate.d.ts

@@ -0,0 +1,37 @@
+export interface PseoPageVolume {
+    url: string;
+    slug?: string;
+    title?: string;
+    monthlySearchVolume: number;
+    keywords?: string[];
+}
+export interface IndexabilityDecision {
+    url: string;
+    monthlySearchVolume: number;
+    robotsDirective: string;
+    isIndexable: boolean;
+    reason: string;
+}
+export interface IndexabilityGateResult {
+    decisions: IndexabilityDecision[];
+    totalPages: number;
+    indexablePages: number;
+    noindexPages: number;
+    crawlBudgetSavingPercent: number;
+    capturedMonthlyVolumePercent: number;
+    recommendations: string[];
+    summary: string;
+}
+export interface IndexabilityGateOptions {
+    minMonthlyVolume?: number;
+    indexDirective?: string;
+    noindexDirective?: string;
+    unknownVolumeStrategy?: 'noindex' | 'index' | 'noindex-if-zero';
+}
+export declare class RealVolumeIndexabilityGate {
+    /**
+     * Évalue l'indexabilité de chaque page pSEO en fonction de son volume de recherche mensuel réel.
+     */
+    static evaluate(pages: PseoPageVolume[], options?: IndexabilityGateOptions): IndexabilityGateResult;
+    private static _buildRecommendations;
+}

package/dist/realtime-visitors.d.ts

@@ -0,0 +1,87 @@
+/**
+ * 👥 Real-time Visitor Tracker
+ *
+ * Suit les visiteurs actifs sur un site web en temps réel, à la manière d'un
+ * tableau de bord d'analytics temps réel. Stocke en mémoire avec TTL (5 min par défaut).
+ * Aucune dépendance externe, pur TypeScript, zéro I/O.
+ */
+export interface RealtimeVisitor {
+    id: string;
+    sessionId: string;
+    path: string;
+    referrer?: string;
+    userAgent?: string;
+    country?: string;
+    city?: string;
+    firstSeenAt: string;
+    lastSeenAt: string;
+    pageViews: number;
+    events: RealtimeEvent[];
+}
+export interface RealtimeEvent {
+    type: "pageview" | "click" | "scroll" | "custom";
+    name: string;
+    timestamp: string;
+    properties?: Record<string, unknown>;
+}
+export interface RealtimeStats {
+    activeVisitors: number;
+    totalPageViews: number;
+    topPaths: Array<{
+        path: string;
+        visitors: number;
+    }>;
+    byCountry: Array<{
+        country: string;
+        visitors: number;
+    }>;
+    lastUpdated: string;
+}
+export declare class RealtimeVisitorTracker {
+    private visitors;
+    private ttlMs;
+    private started;
+    constructor(ttlMs?: number);
+    private ensureCleanup;
+    private now;
+    private iso;
+    private generateId;
+    private cleanup;
+    /**
+     * Enregistre une pageview pour un visiteur. Met à jour ou crée l'entrée.
+     * Retourne l'identifiant du visiteur.
+     */
+    recordPageview(params: {
+        sessionId?: string;
+        path: string;
+        referrer?: string;
+        userAgent?: string;
+        country?: string;
+        city?: string;
+    }): string;
+    /**
+     * Enregistre un événement personnalisé pour un visiteur existant.
+     */
+    recordEvent(visitorId: string, event: Omit<RealtimeEvent, "timestamp">): boolean;
+    /**
+     * Retourne la liste des visiteurs actifs actuellement.
+     */
+    getActiveVisitors(): RealtimeVisitor[];
+    /**
+     * Retourne le nombre de visiteurs actifs.
+     */
+    getActiveCount(): number;
+    /**
+     * Retourne des statistiques agrégées en temps réel.
+     */
+    getStats(): RealtimeStats;
+    /**
+     * Vide tous les visiteurs (utile pour les tests).
+     */
+    clear(): void;
+    /**
+     * Retourne un visiteur par son identifiant.
+     */
+    getVisitor(visitorId: string): RealtimeVisitor | undefined;
+}
+export declare const defaultRealtimeTracker: RealtimeVisitorTracker;