@lynxflow/seo-engine 2.8.0 → 3.2.1

package/dist/row-column-ls.d.ts

@@ -0,0 +1,64 @@
+/**
+ * G12 — Row-Column / RLS / CLS Logic
+ *
+ * LynxSEO: rls-cls-policy.ts + permissions.schema.ts (rowColumnPermissions)
+ *          + row-column-ls.ts (nouveau - logique Row-Column pure + RLS/CLS)
+ * Inspiration: Metabase row-level security + documentation §4
+ *
+ * NOTE: rls-cls-policy.ts + permissions.schema.ts fournissent la RLS (Row-Level
+ * Security) et CLS (Column-Level Security) via la base de données, mais
+ * row-column-ls.ts offre la logique d'attribution Row-Column pure réutilisable
+ * en dehors du contexte base de données (tests, services, etc.).
+ */
+import { z } from "zod";
+/** Type pour les autorisations Row-Level (RLS) */
+export type RowLevelPermission = {
+    /** L'utilisateur peut lire ses propres lignes */
+    readOwn: boolean;
+    /** L'utilisateur peut lire toutes les lignes */
+    readAll: boolean;
+    /** L'utilisateur peut modifier ses propres lignes */
+    updateOwn: boolean;
+    /** L'utilisateur peut modifier toutes les lignes */
+    updateAll: boolean;
+    /** L'utilisateur peut supprimer ses propres lignes */
+    deleteOwn: boolean;
+    /** L'utilisateur peut supprimer toutes les lignes */
+    deleteAll: boolean;
+};
+/** Type pour les autorisations Column-Level (CLS) */
+export type ColumnLevelPermission = {
+    /** Colonnes que l'utilisateur peut lire */
+    read: string[];
+    /** Colonnes que l'utilisateur peut modifier */
+    write: string[];
+    /** Colonnes masquées */
+    hide: string[];
+};
+/** Schéma de validation pour les permissions RLS */
+export declare const rowLevelPermissionSchema: z.ZodObject<{
+    readOwn: z.ZodDefault<z.ZodBoolean>;
+    readAll: z.ZodDefault<z.ZodBoolean>;
+    updateOwn: z.ZodDefault<z.ZodBoolean>;
+    updateAll: z.ZodDefault<z.ZodBoolean>;
+    deleteOwn: z.ZodDefault<z.ZodBoolean>;
+    deleteAll: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+/** Schéma de validation pour les permissions CLS */
+export declare const columnLevelPermissionSchema: z.ZodObject<{
+    read: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    write: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    hide: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/** Vérifier si une action RLS est autorisée */
+export declare function canRowLevelAction(permission: RowLevelPermission, action: "read" | "update" | "delete", ownOnly: boolean): boolean;
+/** Vérifier si une colonne est autorisée en lecture */
+export declare function canColumnRead(permissions: ColumnLevelPermission, columnName: string): boolean;
+/** Vérifier si une colonne est autorisée en écriture */
+export declare function canColumnWrite(permissions: ColumnLevelPermission, columnName: string): boolean;
+/** Vérifier si une colonne est masquée */
+export declare function isColumnHidden(permissions: ColumnLevelPermission, columnName: string): boolean;
+/** Appliquer les filtres RLS à une requête QueryBuilder */
+export declare function applyRowLevelFilter<T extends Record<string, unknown>>(query: T, permission: RowLevelPermission, column: keyof T): T;
+/** Appliquer les filtres CLS à une sélection de colonnes */
+export declare function applyColumnLevelFilter<T extends Record<string, unknown>>(columns: string[], permission: ColumnLevelPermission): string[];

package/dist/rss-syndication-feed.d.ts

@@ -1,5 +1,5 @@
 /**
- * 📰 RSS 2.0 & Atom Syndication Feed Generator (Inspiration: pages-seo/feed.xml.js)
+ * 📰 RSS 2.0 & Atom Syndication Feed Generator
  *
  * Automatically generates standards-compliant RSS 2.0 and Atom feeds for published
  * programmatic landing pages and articles to accelerate syndication and indexing.

package/dist/rules/checks-runner.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Deterministic Search Central Audit Checks Runner
+ */
+import { SearchCentralFinding } from "./search-central-catalog";
+import { CrawlResult, CrawledPageRecord } from "../crawler/native-crawler";
+export declare const GENERIC_ANCHORS: Set<string>;
+export declare function isGenericAnchor(anchor: string): boolean;
+export declare function isHtmlPage(p: CrawledPageRecord): boolean;
+export declare function isIndexablePage(p: CrawledPageRecord): boolean;
+/**
+ * Returns a list of rule IDs from SEARCH_CENTRAL_RULES that were evaluated and did not trigger any finding.
+ */
+export declare function getPassedRules(findings: SearchCentralFinding[]): string[];
+/**
+ * Execute all 52 deterministic Search Central checks against crawl results.
+ */
+export declare function runAuditChecks(crawl: CrawlResult): SearchCentralFinding[];

package/dist/rules/search-central-catalog.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 52 Deterministic Google Search Central & Standards Audit Rules
+ *
+ * Each rule defines:
+ * - category: 'crawl' | 'onpage' | 'content' | 'links' | 'structured' | 'ai' | 'performance' | 'security'
+ * - severity: 'critical' | 'high' | 'medium' | 'low' | 'info'
+ * - effort: 1 (minutes), 2 (hours), 3 (days), 4 (architectural overhaul)
+ * - heuristic: boolean (distinguishes Google hard requirements from editorial best practices)
+ * - source: Official Google Search Central, OWASP, W3C or Web.dev documentation URL
+ */
+export type AuditCategory = "crawl" | "onpage" | "content" | "links" | "structured" | "ai" | "performance" | "security" | "visibility";
+export type RuleSeverity = "critical" | "high" | "medium" | "low" | "info";
+export type EffortLevel = 1 | 2 | 3 | 4;
+export interface SearchCentralRuleDef {
+    id: string;
+    category: AuditCategory;
+    severity: RuleSeverity;
+    title: string;
+    fix: string;
+    source: string;
+    effort: EffortLevel;
+    heuristic: boolean;
+}
+export interface SearchCentralFinding {
+    id: string;
+    origin: "rule" | "semantic";
+    category: AuditCategory;
+    severity: RuleSeverity;
+    title: string;
+    fix: string;
+    source: string;
+    effort: EffortLevel;
+    heuristic: boolean;
+    urls: string[];
+    count: number;
+    evidence: string;
+    detail?: Record<string, unknown>;
+}
+export declare const SEARCH_CENTRAL_SOURCES: Record<string, string>;
+export declare const SEARCH_CENTRAL_RULES: Record<string, SearchCentralRuleDef>;
+export declare const CATEGORY_NAMES: Record<AuditCategory, string>;
+export declare const SEVERITY_WEIGHTS: Record<RuleSeverity, number>;
+export declare function createFinding(ruleId: string, urls: string[], evidence: string, detail?: Record<string, unknown>, severity?: RuleSeverity, fix?: string): SearchCentralFinding;

package/dist/rum-metrics.d.ts

@@ -0,0 +1,20 @@
+export interface RumEntry {
+    visitorId: string;
+    lcp: number | null;
+    cls: number | null;
+    inp: number | null;
+    recordedAt: string;
+}
+export interface RumState {
+    entries: RumEntry[];
+    updatedAt: string;
+}
+export declare function createRumState(now?: Date): RumState;
+export declare function recordRum(state: RumState, entry: Omit<RumEntry, "recordedAt">, now?: Date): RumState;
+export declare function aggregateRum(state: RumState): {
+    lcp: number | null;
+    cls: number | null;
+    inp: number | null;
+    count: number;
+};
+export declare function poorVitalsCount(state: RumState): number;

package/dist/saved-segments.d.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+export interface SegmentFilter {
+    field: string;
+    op: "eq" | "ne" | "gt" | "lt" | "gte" | "lte" | "in" | "contains";
+    value?: unknown;
+}
+export interface SavedSegment {
+    id: string;
+    name: string;
+    description?: string;
+    filters: SegmentFilter[];
+    createdAt: string;
+}
+export declare const SavedSegmentSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    filters: z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        op: z.ZodEnum<{
+            contains: "contains";
+            in: "in";
+            ne: "ne";
+            eq: "eq";
+            gt: "gt";
+            gte: "gte";
+            lt: "lt";
+            lte: "lte";
+        }>;
+        value: z.ZodUnknown;
+    }, z.core.$strip>>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export declare function matchesSegment(segment: SavedSegment, visitor: Record<string, unknown>): boolean;
+export declare function filterVisitors(segment: SavedSegment, visitors: Record<string, unknown>[]): Record<string, unknown>[];
+export declare function createSegment(input: SavedSegment & {
+    createdAt?: string;
+}): SavedSegment;

package/dist/scheduled-reports.d.ts

@@ -0,0 +1,42 @@
+/**
+ * G8 — Scheduled Reports.
+ * Auto PDF/CSV report generation every Monday morning (cron semantics).
+ */
+export type ReportFormat = "pdf" | "csv" | "json";
+export type ReportFrequency = "weekly" | "monthly" | "daily";
+export interface ReportSchedule {
+    frequency: ReportFrequency;
+    dayOfWeek?: number;
+    hour: number;
+    timezone: string;
+}
+export interface ReportData {
+    title: string;
+    period: {
+        from: string;
+        to: string;
+    };
+    metrics: Record<string, number>;
+    rows?: Array<Record<string, string | number>>;
+}
+export interface ScheduledReport {
+    id: string;
+    schedule: ReportSchedule;
+    format: ReportFormat;
+    data: ReportData;
+    enabled: boolean;
+    lastRunAt?: string;
+    nextRunAt: string;
+}
+export declare class ScheduledReportEngine {
+    private reports;
+    constructor(reports?: ScheduledReport[]);
+    addReport(report: Omit<ScheduledReport, "nextRunAt"> & {
+        nextRunAt?: string;
+    }): ScheduledReport;
+    computeNextRun(schedule: ReportSchedule, from?: Date): string;
+    dueReports(now?: Date): ScheduledReport[];
+    markRun(id: string, now?: Date): ScheduledReport | null;
+    renderCsv(report: ScheduledReport): string;
+    renderPdf(report: ScheduledReport): string;
+}

package/dist/schema-builder.d.ts

@@ -30,4 +30,18 @@ export declare class SchemaGraphBuilder {
             datePublished?: string;
         }>;
     }): Record<string, unknown>;
+    /**
+     * Serializes any schema object into an XSS-safe HTML <script type="application/ld+json"> tag.
+     */
+    static toHtmlScriptTag(data: unknown, id?: string): string;
+    /**
+     * Generates a copy-paste ready TypeScript/React component for Next.js or React apps.
+     */
+    static toReactComponentCode(data: unknown, componentName?: string): string;
 }
+/**
+ * Safe JSON-LD stringifier implementing W3C-recommended escaping.
+ * Escapes </script>, <!--, and --> sequences to protect against XSS injections
+ * without altering JSON structure or breaking URLs with query parameters.
+ */
+export declare function safeJsonLdStringify(data: unknown): string;

package/dist/screaming-frog-importer.d.ts

@@ -0,0 +1,109 @@
+/**
+ * 🐸 @lynxseo/engine - Screaming Frog SEO Spider Importer & Parity Engine
+ *
+ * High-performance offline parser and diagnostic engine for Screaming Frog SEO Spider
+ * export files (internal_all.csv, redirect_chains.csv, canonicals.csv, issues).
+ *
+ * Features:
+ * - Ingests Screaming Frog v22+ CSV exports with zero API overhead
+ * - Automatic indexability breakdown (Indexable vs Non-Indexable with reason)
+ * - Deep redirect & canonical chain resolver (detects loops, chains > 2 hops)
+ * - Content quality diagnostics (thin content, missing titles, missing H1, unlinked pages)
+ * - Crawl health scorecard & prioritized recommendations
+ */
+export interface SfCrawlUrlItem {
+    url: string;
+    statusCode: number;
+    status: string;
+    indexability: "Indexable" | "Non-Indexable";
+    indexabilityReason?: string;
+    title?: string;
+    titleLength?: number;
+    metaDescription?: string;
+    metaDescriptionLength?: number;
+    h1?: string;
+    wordCount: number;
+    canonicalUrl?: string;
+    inlinksCount: number;
+    outlinksCount: number;
+    crawlDepth?: number;
+}
+export interface SfCrawlSummary {
+    totalUrls: number;
+    indexableUrlsCount: number;
+    nonIndexableUrlsCount: number;
+    statusCodesSummary: {
+        "2xx": number;
+        "3xx": number;
+        "4xx": number;
+        "5xx": number;
+    };
+    issuesSummary: {
+        missingTitlesCount: number;
+        duplicateTitlesCount: number;
+        missingMetaDescCount: number;
+        missingH1Count: number;
+        thinContentCount: number;
+        brokenLinks4xxCount: number;
+        serverErrors5xxCount: number;
+        canonicalMismatchCount: number;
+    };
+    averageWordCount: number;
+    items: SfCrawlUrlItem[];
+}
+export interface SfRedirectChainItem {
+    sourceUrl: string;
+    chainLength: number;
+    intermediateUrls: string[];
+    finalDestinationUrl: string;
+    isLoop: boolean;
+    statusCode: number;
+}
+export interface SfCanonicalItem {
+    url: string;
+    canonicalUrl: string;
+    isSelfReferencing: boolean;
+    isCanonicalised: boolean;
+    isMissing: boolean;
+    isRelative: boolean;
+}
+export interface SfCrawlIssue {
+    id: string;
+    category: "Indexability" | "Redirects" | "Canonicals" | "Content" | "Meta" | "Security";
+    severity: "CRITICAL" | "HIGH" | "MEDIUM" | "LOW";
+    title: string;
+    count: number;
+    description: string;
+    howToFix: string;
+    urlsSample: string[];
+}
+export interface SfCrawlHealthReport {
+    healthScore: number;
+    grade: "A+" | "A" | "B" | "C" | "D" | "F";
+    totalCrawled: number;
+    indexabilityPercentage: number;
+    issues: SfCrawlIssue[];
+    topRecommendations: string[];
+}
+export declare class ScreamingFrogImporter {
+    /**
+     * Parse internal_all.csv or internal_html.csv export from Screaming Frog
+     */
+    static parseInternalAllCsv(csvContent: string): SfCrawlSummary;
+    /**
+     * Parse redirect_chains.csv export
+     */
+    static parseRedirectChainsCsv(csvContent: string): SfRedirectChainItem[];
+    /**
+     * Parse canonicals.csv export
+     */
+    static parseCanonicalsCsv(csvContent: string): SfCanonicalItem[];
+    /**
+     * Evaluate crawl health and compile Screaming Frog-style audit report
+     */
+    static evaluateCrawlHealth(summary: SfCrawlSummary): SfCrawlHealthReport;
+    /**
+     * Helper: parse a single CSV line with quoted string handling
+     */
+    private static parseCsvLine;
+}

package/dist/sdk/lynx-mobile-replay.d.ts

@@ -0,0 +1,129 @@
+/**
+ * LynxSEO Mobile Vector Wireframe Session Replay Engine
+ * Clean-room implementation inspirée de PostHog Mobile Session Replay (iOS & Android).
+ * Conforme AGPLv3.
+ *
+ * Encode et compresse les sessions mobiles sous forme d'arbres vectoriels légers (wireframes).
+ * Avantages par rapport à la capture vidéo :
+ * - Bande passante ultra-faible (< 20 KB / minute).
+ * - Respect absolu de la vie privée (RGPD) : masquage automatique systématique des textes sensibles et mots de passe.
+ * - Rendu vectoriel fluide et net quelle que soit la résolution du player.
+ */
+export type MobileReplayNodeType = "view" | "text" | "image" | "button" | "input" | "scrollview";
+export interface MobileReplayNodeBounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface MobileReplayNodeStyle {
+    backgroundColor?: string;
+    borderRadius?: number;
+    opacity?: number;
+    borderColor?: string;
+    borderWidth?: number;
+}
+export interface MobileReplayNode {
+    id: string;
+    type: MobileReplayNodeType;
+    bounds: MobileReplayNodeBounds;
+    style?: MobileReplayNodeStyle;
+    text?: string;
+    isMasked?: boolean;
+    children?: MobileReplayNode[];
+}
+export interface MobileReplayTouchEvent {
+    type: "touch_start" | "touch_move" | "touch_end";
+    x: number;
+    y: number;
+    timestamp: number;
+}
+export interface MobileReplaySnapshot {
+    id: string;
+    timestamp: number;
+    screenName: string;
+    screenWidth: number;
+    screenHeight: number;
+    root: MobileReplayNode;
+}
+export interface MobileReplayMutation {
+    timestamp: number;
+    screenName: string;
+    added: MobileReplayNode[];
+    updated: Array<{
+        id: string;
+    } & Partial<MobileReplayNode>>;
+    removedIds: string[];
+}
+export interface MobileReplayOptions {
+    maskAllText?: boolean;
+    maskSensitiveInputs?: boolean;
+}
+/**
+ * Server-side ceiling enforced by `/api/pulse/v1/replay` (256 KB per chunk).
+ * A vector chunk is a few kilobytes; this guard only catches pathological trees.
+ */
+export declare const MAX_MOBILE_REPLAY_CHUNK_BYTES: number;
+/** Identité d'une session mobile, requise par l'endpoint d'ingestion replay. */
+export interface MobileReplayChunkContext {
+    projectId: string;
+    sessionId: string;
+    visitorId: string;
+    chunkIndex: number;
+    /** Route ou écran courant ; `pulseReplayChunkSchema` attend `urlPath`. */
+    urlPath?: string;
+    hostname?: string;
+    device?: "mobile" | "tablet" | "desktop";
+    hasRageClicks?: boolean;
+    /** Horodatage ISO 8601 ; par défaut l'instant de l'encodage. */
+    timestamp?: string;
+}
+/**
+ * Événement vectoriel mobile tel qu'il est stocké par le pipeline replay.
+ * Volontairement lisible (pas d'index rrweb) : le player mobile rend les nœuds
+ * directement, sans reconstruire un DOM web.
+ */
+export type MobileReplayEvent = ({
+    type: "snapshot";
+} & MobileReplaySnapshot) | ({
+    type: "mutation";
+} & MobileReplayMutation);
+/** Enveloppe acceptée par `/api/pulse/v1/replay` (cf. `pulseReplayChunkSchema`). */
+export interface MobileReplayIngestChunk {
+    projectId: string;
+    sessionId: string;
+    visitorId: string;
+    chunkIndex: number;
+    urlPath: string;
+    hostname?: string;
+    device: "mobile" | "tablet" | "desktop";
+    timestamp: string;
+    events: MobileReplayEvent[];
+    hasRageClicks?: boolean;
+}
+/**
+ * Encode des événements vectoriels (snapshots + mutations) dans l'enveloppe
+ * d'ingestion replay. Sans cet encodage, les collecteurs natifs produisaient des
+ * snapshots que le serveur refusait faute de `sessionId` / `chunkIndex`.
+ */
+export declare function encodeMobileReplayChunk(context: MobileReplayChunkContext, events: MobileReplayEvent[]): MobileReplayIngestChunk;
+/** Encode un snapshot isolé en chunk d'ingestion. */
+export declare function encodeMobileReplaySnapshot(context: MobileReplayChunkContext, snapshot: MobileReplaySnapshot): MobileReplayIngestChunk;
+/** Encode une mutation incrémentale isolée en chunk d'ingestion. */
+export declare function encodeMobileReplayMutation(context: MobileReplayChunkContext, mutation: MobileReplayMutation): MobileReplayIngestChunk;
+/** Taille UTF-8 du chunk sérialisé, pour se prémunir du plafond de 256 KB. */
+export declare function mobileReplayChunkBytes(chunk: MobileReplayIngestChunk): number;
+/** Vrai si le chunk respecte le plafond d'ingestion (HTTP 413 sinon). */
+export declare function isMobileReplayChunkWithinLimit(chunk: MobileReplayIngestChunk): boolean;
+export declare class VectorReplaySanitizer {
+    /**
+     * Sanitise récursivement un arbre de composants pour masquer les données personnelles (PII).
+     */
+    static sanitizeTree(node: MobileReplayNode, options?: MobileReplayOptions): MobileReplayNode;
+}
+export declare class MobileReplayDiffer {
+    /**
+     * Calcule le diff incrémental entre deux arbres pour minimiser le volume réseau.
+     */
+    static diff(prev: MobileReplayNode, next: MobileReplayNode, screenName: string): MobileReplayMutation | null;
+}

package/dist/sdk/lynx-mobile-sdk.d.ts

@@ -0,0 +1,152 @@
+/**
+ * LynxSEO Mobile & React Native Analytics SDK
+ * Clean-room implementation inspirée de PostHog React Native & RudderStack Mobile.
+ * Conforme AGPLv3.
+ *
+ * Client mobile léger, avec persistance hors-ligne (compatible AsyncStorage / MMKV),
+ * suivi des écrans (screen views), cycle de vie d'application (foreground/background)
+ * et synchronisation automatique lors du rétablissement réseau.
+ *
+ * Inclut l'envoi des snapshots de session replay vectoriels vers
+ * `/api/pulse/v1/replay`, après masquage PII et encodage dans l'enveloppe
+ * d'ingestion (`encodeMobileReplayChunk`).
+ */
+import { type MobileReplaySnapshot } from "./lynx-mobile-replay";
+export interface LynxMobileStorage {
+    getItem(key: string): Promise<string | null> | string | null;
+    setItem(key: string, value: string): Promise<void> | void;
+    removeItem(key: string): Promise<void> | void;
+}
+export declare class MemoryMobileStorage implements LynxMobileStorage {
+    private store;
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+export interface LynxMobileDeviceInfo {
+    os?: "ios" | "android" | "web" | string;
+    osVersion?: string;
+    appVersion?: string;
+    buildNumber?: string;
+    deviceModel?: string;
+    manufacturer?: string;
+}
+export interface LynxMobileConfig {
+    siteId: string;
+    endpoint?: string;
+    flushAt?: number;
+    flushIntervalMs?: number;
+    maxQueueSize?: number;
+    storage?: LynxMobileStorage;
+    deviceInfo?: LynxMobileDeviceInfo;
+    fetchFn?: typeof fetch;
+    disabled?: boolean;
+    /**
+     * Endpoint d'ingestion des chunks de replay. Par défaut, l'endpoint d'événements
+     * avec `event` remplacé par `replay`.
+     */
+    replayEndpoint?: string;
+    /** Jeton signé `X-Lynx-Replay-Token` requis par l'ingestion publique. */
+    replayToken?: string;
+    /** Active la capture replay (masquage PII actif par défaut). */
+    replayEnabled?: boolean;
+    /** Nombre maximum de chunks replay conservés hors-ligne. */
+    maxReplayBuffer?: number;
+    /** Envoie aussi le replay lors du passage en arrière-plan. */
+    flushReplayOnBackground?: boolean;
+}
+/** Résultat d'une capture replay, utile au diagnostic côté application. */
+export interface LynxMobileReplayResult {
+    sent: boolean;
+    queued: boolean;
+    bytes: number;
+    /** `rejected` : le serveur a refusé le chunk (4xx définitif, pas de retry). */
+    reason?: "disabled" | "too_large" | "network" | "rejected";
+}
+export interface LynxMobileQueuedEvent {
+    id: string;
+    projectId: string;
+    eventName: string;
+    timestamp: string;
+    userLabel: string;
+    properties: Record<string, unknown>;
+}
+export declare class LynxMobileClient {
+    private siteId;
+    private endpoint;
+    private flushAt;
+    private flushIntervalMs;
+    private maxQueueSize;
+    private storage;
+    private deviceInfo;
+    private fetchFn;
+    private disabled;
+    private queue;
+    private distinctId;
+    private currentScreen;
+    private appState;
+    private sessionStartTime;
+    private flushTimer;
+    private isFlushing;
+    private storageKey;
+    private distinctIdKey;
+    private replayEndpoint;
+    private replayToken;
+    private replayEnabled;
+    private maxReplayBuffer;
+    private flushReplayOnBackground;
+    private replaySessionId;
+    private replayChunkIndex;
+    private replayBuffer;
+    private ready;
+    private readonly replaySessionKey;
+    constructor(config: LynxMobileConfig);
+    private init;
+    /**
+     * Enregistre le visionnage d'un écran mobile.
+     */
+    trackScreen(screenName: string, properties?: Record<string, unknown>): void;
+    /**
+     * Enregistre un événement personnalisé.
+     */
+    track(eventName: string, properties?: Record<string, unknown>): void;
+    /**
+     * Identifie l'utilisateur connecté sur l'application.
+     */
+    identify(userId: string, properties?: Record<string, unknown>): Promise<void>;
+    /**
+     * Gère les transitions d'état de l'application mobile (Foreground/Background).
+     */
+    handleAppStateChange(nextState: "active" | "background" | "inactive"): void;
+    /**
+     * Réinitialise l'identité utilisateur (Déconnexion).
+     */
+    reset(): Promise<void>;
+    /**
+     * Force l'envoi immédiat des événements vers l'endpoint.
+     */
+    flush(): Promise<void>;
+    /**
+     * Envoie un snapshot de session replay vectoriel au pipeline Pulse.
+     *
+     * Le masquage PII est appliqué avant l'encodage : aucun texte lisible ni
+     * valeur de champ sensible ne quitte l'appareil.
+     */
+    captureReplaySnapshot(snapshot: MobileReplaySnapshot, options?: {
+        maskAllText?: boolean;
+        maskSensitiveInputs?: boolean;
+    }): Promise<LynxMobileReplayResult>;
+    /**
+     * Réessaie l'envoi des chunks replay mis en attente (hors-ligne).
+     * Les chunks partent dans l'ordre ; le premier échec interrompt la boucle.
+     */
+    flushReplay(): Promise<void>;
+    private bufferReplayChunk;
+    private sendReplayChunk;
+    getReplaySessionId(): string;
+    getReplayBufferLength(): number;
+    private persistQueue;
+    getQueueLength(): number;
+    getDistinctId(): string;
+    destroy(): void;
+}