@lynxflow/seo-engine 2.8.0 → 3.2.1

package/dist/plugins/form-analytics/index.d.ts

@@ -0,0 +1,53 @@
+/**
+ * LynxSEO - Form Analytics Plugin
+ * Mesure des performances des formulaires : impressions, débuts, soumissions,
+ * abandons et temps d'hésitation par champ.
+ * Inspiré de Matomo Form Analytics (GPLv3 / AGPLv3 compatible).
+ */
+import { LynxSeoPlugin, type PluginManifest, type PluginContext, type PluginEvent } from "../../plugin/types";
+export interface FormFieldStat {
+    fieldName: string;
+    fieldType?: string;
+    interactions: number;
+    dropOffs: number;
+    averageHesitationMs: number;
+}
+export interface FormSummary {
+    formId: string;
+    formName?: string;
+    pageUrl?: string;
+    views: number;
+    starts: number;
+    submissions: number;
+    conversions: number;
+    dropOffCount: number;
+    dropOffRatePct: number;
+    conversionRatePct: number;
+    avgDurationMs: number;
+}
+export interface FormDetailReport extends FormSummary {
+    fields: FormFieldStat[];
+}
+export declare class FormAnalyticsService {
+    private forms;
+    recordView(siteId: string, formId: string, formName?: string, pageUrl?: string): void;
+    recordStart(siteId: string, formId: string, formName?: string, pageUrl?: string): void;
+    recordFieldInteraction(siteId: string, formId: string, fieldName: string, hesitationMs?: number, fieldType?: string, isDropOff?: boolean): void;
+    recordSubmit(siteId: string, formId: string, durationMs?: number, isSuccessful?: boolean): void;
+    listForms(siteId: string): FormSummary[];
+    getFormDetail(siteId: string, formId: string): FormDetailReport | null;
+    reset(siteId?: string): void;
+    private getFormData;
+}
+export declare class FormAnalyticsPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private service;
+    private ctx?;
+    enable(ctx: PluginContext): Promise<void>;
+    disable(): Promise<void>;
+    onEvent(event: PluginEvent): Promise<void>;
+    getForms(siteId: string): FormSummary[];
+    getFormDetail(siteId: string, formId: string): FormDetailReport | null;
+    getService(): FormAnalyticsService;
+}
+export default FormAnalyticsPlugin;

package/dist/plugins/geoip/index.d.ts

@@ -0,0 +1,50 @@
+/**
+ * LynxSEO - GeoIP Plugin
+ * Résolution IP → pays/région/ville par base en mémoire simplifiée.
+ * Inspiré de Matomo GeoIp2 (GPLv3 / AGPLv3 compatible).
+ */
+import { LynxSeoPlugin, type PluginManifest, type PluginContext, type PluginEvent } from "../../plugin/types";
+export interface GeoLocation {
+    countryCode: string;
+    countryName: string;
+    regionName: string;
+    city: string;
+    latitude: number;
+    longitude: number;
+    timezone: string;
+    isp: string;
+}
+export interface CountryStats {
+    countryCode: string;
+    countryName: string;
+    visits: number;
+}
+export interface CityStats {
+    city: string;
+    countryCode: string;
+    regionName: string;
+    visits: number;
+}
+export declare class GeoIpService {
+    /**
+     * Résout une adresse IPv4 vers ses métadonnées géographiques.
+     * Pour les adresses non reconnues, retourne UNKNOWN_LOCATION.
+     */
+    resolveIp(ip: string): GeoLocation;
+}
+export declare class GeoIpPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private service;
+    private siteData;
+    enable(_ctx: PluginContext): Promise<void>;
+    onEvent(event: PluginEvent): Promise<void>;
+    /** Résout une IP (expose le service). */
+    resolveIp(ip: string): GeoLocation;
+    /** Statistiques par pays pour un site donné. */
+    getCountryStats(siteId: string): CountryStats[];
+    /** Statistiques par ville pour un site donné. */
+    getCityStats(siteId: string): CityStats[];
+    /** Réinitialise les données d'un site (utile pour les tests). */
+    reset(siteId: string): void;
+}
+export default GeoIpPlugin;

package/dist/plugins/geoip-updater/index.d.ts

@@ -0,0 +1,97 @@
+/**
+ * LynxSEO Engine - GeoIP Auto-Updater Plugin
+ *
+ * Inspiré par Matomo GeoIp2 / DB-IP Auto-Updater & PostHog GeoIP resolver.
+ * Gestion et mise à jour automatique des bases de données MMDB de géolocalisation :
+ * - Téléchargement et synchronisation planifiée (MaxMind GeoLite2 City, ASN, DB-IP)
+ * - Validation cryptographique d'intégrité (SHA-256)
+ * - Test de résolution d'adresses IPv4 / IPv6 en direct avec masquage CNIL/RGPD
+ * - Surveillance de l'obsolescence des bases actives (seuil d'alerte > 30 jours)
+ *
+ * Clean-room implementation sous licence AGPL-3.0-or-later.
+ */
+import type { LynxSeoPlugin, PluginManifest, PluginContext } from "../../plugin/types";
+export type GeoDbProvider = "maxmind_geolite2" | "dbip_lite" | "custom_mmdb";
+export interface GeoDatabaseConfig {
+    id: string;
+    name: string;
+    provider: GeoDbProvider;
+    format: "mmdb" | "csv";
+    licenseKey?: string;
+    downloadUrl: string;
+    updateFrequency: "weekly" | "monthly" | "manual";
+    autoUpdateEnabled: boolean;
+    activeVersion: string;
+    fileSizeBytes: number;
+    sha256Checksum: string;
+    lastUpdatedAt: string;
+    nextScheduledUpdate?: string;
+}
+export interface GeoIpResolutionResult {
+    ip: string;
+    anonymizedIp: string;
+    ipVersion: 4 | 6;
+    countryCode: string;
+    countryName: string;
+    regionCode?: string;
+    cityName?: string;
+    postalCode?: string;
+    latitude?: number;
+    longitude?: number;
+    asn?: number;
+    asnOrg?: string;
+    isCnilCompliant: boolean;
+}
+export interface GeoUpdateExecutionLog {
+    id: string;
+    databaseId: string;
+    databaseName: string;
+    status: "success" | "failed" | "skipped";
+    durationMs: number;
+    downloadedBytes: number;
+    checksumVerified: boolean;
+    executedAt: string;
+    errorDetails?: string;
+}
+export interface GeoIpUpdaterReport {
+    databases: GeoDatabaseConfig[];
+    logs: GeoUpdateExecutionLog[];
+    metrics: {
+        totalDatabases: number;
+        activeDatabases: number;
+        staleDatabasesCount: number;
+        lastSuccessfulUpdate: string;
+        cnilMaskingActive: boolean;
+    };
+}
+export declare class GeoIpAutoUpdaterPlugin implements LynxSeoPlugin {
+    manifest: PluginManifest;
+    readonly id = "geoip-updater";
+    readonly name = "GeoIP2 & MMDB Auto-Updater";
+    readonly version = "1.0.0";
+    readonly description = "Mise \u00E0 jour automatique et int\u00E9grit\u00E9 SHA-256 des bases de donn\u00E9es g\u00E9ographiques MaxMind et DB-IP";
+    private enabled;
+    private databases;
+    private logs;
+    constructor();
+    private seedDefaultDatabases;
+    enable(_context: PluginContext): Promise<void>;
+    disable(): Promise<void>;
+    isEnabled(): boolean;
+    /**
+     * Retourne l'état et l'historique complet
+     */
+    getReport(): GeoIpUpdaterReport;
+    /**
+     * Met à jour la configuration d'une base de données
+     */
+    updateConfig(databaseId: string, updates: Partial<Pick<GeoDatabaseConfig, "licenseKey" | "updateFrequency" | "autoUpdateEnabled">>): GeoDatabaseConfig | null;
+    /**
+     * Déclenche la mise à jour immédiate d'une base
+     */
+    triggerUpdate(databaseId: string): GeoUpdateExecutionLog;
+    /**
+     * Test de résolution d'IP avec application du masquage de confidentialité CNIL
+     */
+    testResolveIp(ipInput: string): GeoIpResolutionResult;
+}

package/dist/plugins/goals/index.d.ts

@@ -0,0 +1,85 @@
+/**
+ * LynxSEO - Goals Plugin
+ * Inspiré de Matomo Goals (GPLv3 / AGPLv3 compatible).
+ *
+ * Gestion des objectifs de conversion (création, mise à jour, suppression) et
+ * calcul des conversions à partir du flux d'événements. Reproduit les attributs
+ * de correspondance Matomo : url, title, file, external_website, manually,
+ * visit_duration, event_action, event_category, event_name — chacun combiné à un
+ * type de motif (exact, contains, regex, greater_than).
+ */
+import { LynxSeoPlugin, type PluginManifest, type PluginContext, type PluginEvent } from "../../plugin/types";
+export type GoalMatchAttribute = "url" | "title" | "file" | "external_website" | "manually" | "visit_duration" | "event_action" | "event_category" | "event_name";
+export type GoalPatternType = "exact" | "contains" | "regex" | "greater_than";
+export interface GoalDefinition {
+    id: string;
+    name: string;
+    matchAttribute: GoalMatchAttribute;
+    pattern: string;
+    patternType?: GoalPatternType;
+    /** Valeur de revenu attribuée à chaque conversion. */
+    revenue?: number;
+    /** Coût de l'objectif, utilisé pour dériver le ROI. */
+    cost?: number;
+    /** Session pendant laquelle l'objectif a été créé. */
+    createdAt?: string;
+    /** Objectif actif ou désactivé. */
+    active?: boolean;
+}
+export interface GoalConversion {
+    goalId: string;
+    visitId: string;
+    visitorId: string;
+    timestamp: string;
+    revenue: number;
+    url?: string;
+}
+export interface GoalMetrics {
+    goalId: string;
+    name: string;
+    nbConversions: number;
+    nbVisitsConverted: number;
+    conversionRate: number;
+    revenue: number;
+    cost: number;
+    /** Retour sur investissement dérivé (revenue - cost) / cost. */
+    roi: number;
+}
+export interface GoalsOverview {
+    goals: GoalMetrics[];
+    totals: {
+        nbConversions: number;
+        nbVisits: number;
+        nbVisitsConverted: number;
+        conversionRate: number;
+        revenue: number;
+        cost: number;
+    };
+}
+export declare class GoalsPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private ctx?;
+    private state;
+    enable(ctx: PluginContext): Promise<void>;
+    onEvent(event: PluginEvent): Promise<void>;
+    /** Crée un objectif et renvoie sa définition complète (Matomo addGoal). */
+    addGoal(siteId: string, input: Omit<GoalDefinition, "id"> & {
+        id?: string;
+    }): GoalDefinition;
+    /** Met à jour un objectif existant (Matomo updateGoal). */
+    updateGoal(siteId: string, id: string, patch: Partial<Omit<GoalDefinition, "id">>): GoalDefinition | null;
+    /** Supprime un objectif et ses conversions (Matomo deleteGoal). */
+    deleteGoal(siteId: string, id: string): boolean;
+    getGoals(siteId: string): GoalDefinition[];
+    getGoal(siteId: string, id: string): GoalDefinition | null;
+    /** Conversions détaillées, filtrées par objectif si demandé. */
+    getConversions(siteId: string, goalId?: string, limit?: number): GoalConversion[];
+    /** Métriques détaillées d'un objectif (Matomo Goals.get). */
+    getMetrics(siteId: string, goalId: string): GoalMetrics | null;
+    /** Vue d'ensemble de tous les objectifs d'un site. */
+    getOverview(siteId: string): GoalsOverview;
+    reset(siteId: string): void;
+    disable(): Promise<void>;
+    private getState;
+}
+export default GoalsPlugin;

package/dist/plugins/group-analytics/index.d.ts

@@ -0,0 +1,65 @@
+/**
+ * GroupAnalytics Plugin — LynxSEO Engine
+ *
+ * Parité fonctionnelle :
+ * - PostHog Platform : Group Analytics (B2B Account-level tracking, Organizations, Workspaces, $group_identify, Group Properties, PQL scoring)
+ * - Matomo MultiSites / B2B Dimensions : Agrégation des métriques d'audience au niveau entreprise
+ *
+ * Licence : AGPL-3.0-or-later
+ */
+import type { LynxSeoPlugin, PluginContext, PluginEvent, PluginManifest } from "../../plugin";
+export interface GroupProfileMetrics {
+    distinctUsersCount: number;
+    totalEventsCount: number;
+    totalSessionsCount: number;
+    lastActiveAt: string;
+    healthScore: number;
+    mrr?: number;
+    plan?: string;
+}
+export interface GroupProfile {
+    groupKey: string;
+    groupType: string;
+    siteId: string;
+    name: string;
+    properties: Record<string, string | number | boolean | null>;
+    createdAt: string;
+    updatedAt: string;
+    metrics: GroupProfileMetrics;
+}
+export interface GroupAnalyticsReport {
+    siteId: string;
+    groupType: string;
+    totalGroups: number;
+    activeGroupsLast30Days: number;
+    totalGroupUsers: number;
+    groups: GroupProfile[];
+    topGroupsByActivity: GroupProfile[];
+    topGroupsByMrr: GroupProfile[];
+    groupsByPlan: Record<string, number>;
+    healthScoreDistribution: {
+        healthy: number;
+        atRisk: number;
+        critical: number;
+    };
+}
+export declare class GroupAnalyticsPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private context?;
+    private groupsBySite;
+    enable(ctx: PluginContext): void;
+    onEvent(event: PluginEvent): void;
+    private getCompositeKey;
+    identifyGroup(siteId: string, groupType: string, groupKey: string, rawProperties: Record<string, unknown>, name?: string): GroupProfile;
+    private trackGroupActivity;
+    private calculateHealthScore;
+    private stripInternalFields;
+    getGroupDetails(siteId: string, groupType: string, groupKey: string): GroupProfile | null;
+    getStats(siteId: string): GroupAnalyticsReport;
+    getReport(siteId: string, options?: {
+        groupType?: string;
+        search?: string;
+        plan?: string;
+    }): GroupAnalyticsReport;
+    private getDefaultGroups;
+}

package/dist/plugins/heartbeat/index.d.ts

@@ -0,0 +1,50 @@
+/**
+ * LynxSEO - Heartbeat Plugin
+ * Inspiré de Matomo Heartbeat (GPLv3 / AGPLv3 compatible).
+ *
+ * Un "ping" signale qu'un visiteur est toujours actif sans ajouter d'action.
+ * Il prolonge la durée de visite (time on site) mais ne crée ni nouvelle
+ * visite, ni nouvelle action, ni nouvelle conversion. Matomo refuse de créer
+ * une nouvelle visite si le ping arrive plus de 30 minutes après la dernière
+ * requête : ici ce seuil pilote la prolongation maximale d'une session.
+ */
+import { LynxSeoPlugin, type PluginManifest, type PluginContext, type PluginEvent } from "../../plugin/types";
+/** Matomo : au-delà de 30 min d'inactivité, le ping ne prolonge plus la visite. */
+export declare const HEARTBEAT_TIMEOUT_SECONDS: number;
+export interface HeartbeatState {
+    visitId: string;
+    visitorId: string;
+    lastActivityAt: string;
+    /** Durée active cumulée en secondes, pings inclus. */
+    activeDuration: number;
+    nbHeartbeats: number;
+    /** true si le dernier ping a dépassé le seuil d'inactivité. */
+    expired: boolean;
+}
+export interface HeartbeatStats {
+    totalHeartbeats: number;
+    activeVisits: number;
+    expiredVisits: number;
+    /** Durée moyenne d'activité (secondes) sur les visites suivies. */
+    averageActiveDuration: number;
+    extendableVisits: number;
+}
+export declare class HeartbeatPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private ctx?;
+    /** siteId → visitId → état */
+    private visits;
+    enable(ctx: PluginContext): Promise<void>;
+    onEvent(event: PluginEvent): Promise<void>;
+    /** État de heartbeat d'une visite. */
+    getVisit(siteId: string, visitId: string): HeartbeatState | null;
+    /** Durée active d'une visite, pings inclus (time on site). */
+    getActiveDuration(siteId: string, visitId: string): number;
+    getStats(siteId: string): HeartbeatStats;
+    /** Visites encore prolongeables (dernier ping/action sous le seuil). */
+    getActiveVisits(siteId: string): HeartbeatState[];
+    reset(siteId: string): void;
+    disable(): Promise<void>;
+    private getStore;
+}
+export default HeartbeatPlugin;

package/dist/plugins/heatmap-scrollmap/index.d.ts

@@ -0,0 +1,63 @@
+/**
+ * HeatmapScrollmap Plugin — LynxSEO Engine
+ *
+ * Parité fonctionnelle :
+ * - PostHog Web Heatmaps & Scrollmaps : Clickmaps (Desktop/Mobile), Scroll Depth et Rage/Dead Clicks
+ * - Matomo Heatmap & Session Recording : Cartographie visuelle et zones chaudes
+ *
+ * Licence : AGPL-3.0-or-later
+ */
+import type { LynxSeoPlugin, PluginContext, PluginEvent, PluginManifest } from "../../plugin";
+export interface ClickDataPoint {
+    xPercent: number;
+    yPercent: number;
+    selector?: string;
+    deviceType: "desktop" | "mobile" | "tablet";
+    isRageClick?: boolean;
+    isDeadClick?: boolean;
+    rageCount?: number;
+    deadCount?: number;
+    count: number;
+}
+export interface ScrollDepthMilestone {
+    depthPercent: 25 | 50 | 75 | 100;
+    reachCount: number;
+    reachPercentage: number;
+}
+export interface PageHeatmapSummary {
+    pageUrl: string;
+    totalClicks: number;
+    rageClicksCount: number;
+    deadClicksCount: number;
+    avgScrollDepthPercent: number;
+    scrollMilestones: ScrollDepthMilestone[];
+    topClickedElements: Array<{
+        selector: string;
+        clicks: number;
+        percentage: number;
+    }>;
+    clickPoints: ClickDataPoint[];
+}
+export interface HeatmapReport {
+    siteId: string;
+    pageUrl: string;
+    deviceFilter: "all" | "desktop" | "mobile";
+    summary: PageHeatmapSummary;
+    recommendations: string[];
+}
+export declare class HeatmapScrollmapPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private context?;
+    private clicksByPage;
+    private scrollsByPage;
+    enable(ctx: PluginContext): void;
+    onEvent(event: PluginEvent): void;
+    recordClick(siteId: string, pageUrl: string, point: ClickDataPoint): void;
+    recordScroll(siteId: string, pageUrl: string, depthPercent: number): void;
+    getStats(siteId: string): HeatmapReport;
+    getReport(siteId: string, pageUrl?: string, options?: {
+        deviceFilter?: "all" | "desktop" | "mobile";
+    }): HeatmapReport;
+    private cleanUrl;
+    private getDefaultReport;
+}

package/dist/plugins/hog-functions/index.d.ts

@@ -0,0 +1,88 @@
+/**
+ * LynxSEO - Hog Functions Plugin (Transformations d'Événements & Dispatch Webhook)
+ * Inspiré de PostHog Hog Functions / Event Pipelines (AGPLv3 compatible).
+ *
+ * Permet de définir des fonctions de transformation en temps réel sur le flux d'événements :
+ * anonymisation PII/IP, nettoyage d'URL, enrichissement de propriétés, filtrage d'abandon
+ * et dispatch conditionnel vers des webhooks externes avec templating de payload.
+ */
+import type { LynxSeoPlugin, PluginManifest, PluginContext, PluginEvent } from "../../plugin/types";
+export type HogTransformationType = "anonymize_ip" | "scrub_pii_query" | "enrich_properties" | "filter_drop" | "webhook_dispatch";
+export interface HogFunctionDefinition {
+    id: string;
+    siteId: string;
+    name: string;
+    description?: string;
+    enabled: boolean;
+    type: HogTransformationType;
+    filterEventNames?: string[];
+    config: {
+        targetProperty?: string;
+        enrichmentValues?: Record<string, string | number | boolean>;
+        webhookUrl?: string;
+        webhookSecret?: string;
+        payloadTemplate?: string;
+    };
+    metrics: {
+        invocations: number;
+        successes: number;
+        failures: number;
+        avgLatencyMs: number;
+        lastExecutedAt?: string;
+    };
+    createdAt: string;
+    updatedAt: string;
+}
+export interface HogInvocationLog {
+    id: string;
+    functionId: string;
+    functionName: string;
+    siteId: string;
+    eventName: string;
+    distinctId?: string;
+    status: "success" | "dropped" | "failed";
+    actionTaken: string;
+    durationMs: number;
+    timestamp: string;
+    errorMessage?: string;
+}
+export interface ProcessedEventResult {
+    dropped: boolean;
+    modifiedEvent: {
+        eventName: string;
+        distinctId?: string;
+        properties?: Record<string, unknown>;
+    };
+    appliedFunctions: string[];
+}
+export interface HogFunctionsReport {
+    siteId: string;
+    totalFunctions: number;
+    enabledFunctions: number;
+    totalInvocations: number;
+    functions: HogFunctionDefinition[];
+    recentLogs: HogInvocationLog[];
+}
+export declare class HogFunctionsPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private functions;
+    private logs;
+    private context?;
+    enable(context: PluginContext): void;
+    createFunction(siteId: string, def: Omit<HogFunctionDefinition, "id" | "siteId" | "metrics" | "createdAt" | "updatedAt">): HogFunctionDefinition;
+    updateFunction(siteId: string, functionId: string, updates: Partial<HogFunctionDefinition>): HogFunctionDefinition | null;
+    deleteFunction(siteId: string, functionId: string): boolean;
+    /**
+     * Exécute la chaîne de fonctions Hog applicables sur un événement analytique.
+     */
+    processEvent(params: {
+        siteId: string;
+        eventName: string;
+        distinctId?: string;
+        properties?: Record<string, unknown>;
+    }): Promise<ProcessedEventResult>;
+    private recordLog;
+    getReport(siteId: string): HogFunctionsReport;
+    onEvent(event: PluginEvent): Promise<void>;
+    destroy(): Promise<void>;
+}

package/dist/plugins/ingestion-warnings/index.d.ts

@@ -0,0 +1,80 @@
+/**
+ * LynxSEO - Ingestion Warnings Plugin (Détection d'Anomalies de Tracking & Dérive de Schéma)
+ * Inspiré de PostHog Ingestion Warnings & Data Management (AGPLv3 compatible).
+ *
+ * Détecte, catégorise et quantifie en temps réel les défaillances de tracking côté client
+ * (timestamps anachroniques, distinct_id invalides, dépassements de taille de payload,
+ * dérives de types sur les propriétés d'événements et saturation de débit).
+ */
+import type { LynxSeoPlugin, PluginManifest, PluginContext, PluginEvent } from "../../plugin/types";
+export type IngestionWarningCode = "timestamp_out_of_bounds" | "payload_oversized" | "schema_type_drift" | "distinct_id_invalid" | "event_name_malformed" | "high_volume_spike";
+export type IngestionWarningSeverity = "warning" | "error" | "critical";
+export interface IngestionWarningRecord {
+    id: string;
+    siteId: string;
+    code: IngestionWarningCode;
+    severity: IngestionWarningSeverity;
+    title: string;
+    description: string;
+    recommendation: string;
+    count: number;
+    firstSeen: string;
+    lastSeen: string;
+    resolved: boolean;
+    sampleEvent?: {
+        eventName?: string;
+        distinctId?: string;
+        properties?: Record<string, string | number | boolean | null>;
+        rawSize?: number;
+        errorDetail?: string;
+    };
+}
+export interface IngestionWarningFilter {
+    severity?: IngestionWarningSeverity | IngestionWarningSeverity[];
+    code?: IngestionWarningCode | IngestionWarningCode[];
+    resolved?: boolean;
+    search?: string;
+    since?: string;
+    until?: string;
+    limit?: number;
+}
+export interface IngestionWarningsReport {
+    siteId: string;
+    totalWarningsCount: number;
+    unresolvedCount: number;
+    criticalCount: number;
+    breakdownByCode: Record<IngestionWarningCode, number>;
+    breakdownBySeverity: Record<IngestionWarningSeverity, number>;
+    warnings: IngestionWarningRecord[];
+    healthScore: number;
+}
+export interface ValidateEventInput {
+    siteId: string;
+    eventName: string;
+    timestamp?: string;
+    distinctId?: string;
+    properties?: Record<string, unknown>;
+    rawSizeBytes?: number;
+}
+export declare class IngestionWarningsPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private warnings;
+    private knownPropertyTypes;
+    private context?;
+    private maxPayloadBytes;
+    private maxFutureTimestampMs;
+    private maxPastTimestampMs;
+    enable(context: PluginContext): void;
+    /**
+     * Analyse et valide un événement entrant pour détecter d'éventuelles anomalies d'ingestion.
+     * Retourne la liste des codes d'avertissement levés.
+     */
+    validateIncomingEvent(input: ValidateEventInput): IngestionWarningCode[];
+    private sanitizeSampleProperties;
+    private recordWarning;
+    resolveWarning(warningId: string): boolean;
+    getReport(siteId: string, filter?: IngestionWarningFilter): IngestionWarningsReport;
+    clearWarnings(siteId: string): void;
+    onEvent(event: PluginEvent): Promise<void>;
+    destroy(): Promise<void>;
+}

package/dist/plugins/insights/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * LynxSEO - Insights Plugin (Movers & Shakers)
+ * Inspiré de Matomo Insights (GPLv3 / AGPLv3 compatible).
+ *
+ * Détection automatique des anomalies et tendances dans les métriques :
+ * pics de trafic, baisses soudaines, pages en forte progression.
+ */
+import { LynxSeoPlugin, type PluginManifest, type PluginContext, type PluginEvent } from "../../plugin/types";
+export interface MetricPoint {
+    metric: string;
+    value: number;
+    timestamp: string;
+    siteId: string;
+    period: "hour" | "day" | "week" | "month";
+}
+export interface Insight {
+    id: string;
+    type: "spike" | "drop" | "trend" | "anomaly";
+    metric: string;
+    severity: "low" | "medium" | "high";
+    message: string;
+    currentValue: number;
+    previousValue: number;
+    changePercent: number;
+    siteId: string;
+    timestamp: string;
+}
+export declare class InsightsPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private ctx?;
+    private metrics;
+    private insights;
+    enable(ctx: PluginContext): Promise<void>;
+    onEvent(event: PluginEvent): Promise<void>;
+    private extractMetricValue;
+    private detectAnomaly;
+    /**
+     * Récupère les insights pour un site.
+     */
+    getInsights(siteId: string, limit?: number): Insight[];
+    /**
+     * Récupère l'historique d'une métrique.
+     */
+    getMetricHistory(metricKey: string, limit?: number): MetricPoint[];
+    disable(): Promise<void>;
+}
+export default InsightsPlugin;