@lynxflow/seo-engine 2.8.0 → 3.2.0

package/dist/plugins/device-plugins/index.d.ts

@@ -0,0 +1,73 @@
+/**
+ * DevicePlugins & Browser Capabilities Plugin
+ *
+ * Analyse des capacités matérielles et technologiques des navigateurs clients :
+ * - Stockage & Consentement : Cookies activés, LocalStorage, IndexedDB
+ * - Moteurs Modernes : WebAssembly (Wasm), WebGL, Service Workers, WebRTC
+ * - Ergonomie & Affichage : Écrans tactiles (Touch), Écrans Retina/HiDPI, Orientations
+ * - Visualiseur PDF natif
+ *
+ * Parité : Matomo DevicePlugins + Resolution & PostHog Device Capabilities.
+ * Licence : AGPL-3.0-or-later
+ */
+import type { LynxSeoPlugin, PluginContext, PluginEvent, PluginManifest } from "../../plugin";
+export interface BrowserCapabilityStat {
+    capability: string;
+    label: string;
+    category: "storage" | "rendering" | "runtime" | "display";
+    supportedVisits: number;
+    totalVisits: number;
+    supportPercentage: number;
+}
+export interface ScreenResolutionStat {
+    resolution: string;
+    label: string;
+    category: "desktop" | "mobile" | "tablet";
+    visits: number;
+    percentage: number;
+}
+export interface PixelRatioStat {
+    ratio: string;
+    label: string;
+    visits: number;
+    percentage: number;
+}
+export interface DevicePluginsReport {
+    siteId: string;
+    totalVisits: number;
+    capabilities: BrowserCapabilityStat[];
+    screenResolutions: ScreenResolutionStat[];
+    pixelRatios: PixelRatioStat[];
+    orientations: {
+        landscapeVisits: number;
+        portraitVisits: number;
+        landscapePct: number;
+        portraitPct: number;
+    };
+    modernWebReadinessScore: number;
+    insights: string[];
+}
+export interface ClientDeviceCapabilities {
+    pdf?: boolean;
+    cookies?: boolean;
+    localStorage?: boolean;
+    indexedDb?: boolean;
+    serviceWorker?: boolean;
+    webgl?: boolean;
+    webrtc?: boolean;
+    wasm?: boolean;
+    touch?: boolean;
+    hdr?: boolean;
+    screenWidth?: number;
+    screenHeight?: number;
+    pixelRatio?: number;
+    orientation?: "landscape" | "portrait";
+}
+export declare class DevicePluginsPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    enable(_ctx: PluginContext): Promise<void>;
+    private siteStats;
+    onEvent(event: PluginEvent): void;
+    getReport(siteId: string): DevicePluginsReport;
+    private getDefaultReport;
+}

package/dist/plugins/devices-detection/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * LynxSEO - Devices Detection Plugin
+ * Inspiré de Matomo DevicesDetection (GPLv3 / AGPLv3 compatible).
+ */
+import { LynxSeoPlugin, type PluginManifest, type PluginContext, type PluginEvent } from "../../plugin/types";
+export type DeviceType = "desktop" | "smartphone" | "tablet" | "tv" | "bot" | "unknown";
+export interface ParsedDeviceInfo {
+    deviceType: DeviceType;
+    brand: string;
+    model: string;
+    osName: string;
+    osVersion: string;
+    browserName: string;
+    browserVersion: string;
+    isBot: boolean;
+}
+export declare class DeviceDetectorService {
+    /**
+     * Analyse User-Agent et Client-Hints pour déterminer le device, l'OS et le navigateur.
+     */
+    static parse(userAgent: string, clientHints?: Record<string, string>): ParsedDeviceInfo;
+}
+export interface DeviceStatsRecord {
+    deviceTypes: Record<string, number>;
+    browsers: Record<string, number>;
+    operatingSystems: Record<string, number>;
+    brands: Record<string, number>;
+    totalVisits: number;
+}
+export declare class DevicesDetectionPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private siteStats;
+    enable(ctx: PluginContext): Promise<void>;
+    onEvent(event: PluginEvent): Promise<void>;
+    getStats(siteId: string): DeviceStatsRecord | null;
+    parse(userAgent: string, clientHints?: Record<string, string>): ParsedDeviceInfo;
+    reset(siteId: string): void;
+}
+export default DevicesDetectionPlugin;

package/dist/plugins/early-access-features/index.d.ts

@@ -0,0 +1,51 @@
+/**
+ * EarlyAccessFeatures Plugin — LynxSEO Engine
+ *
+ * Parité fonctionnelle :
+ * - PostHog Platform : Early Access Features & Beta Program (Opt-in bêta, liaison Feature Flags, collecte feedback utilisateur)
+ * - Matomo Core : Marketplace & Experimental Feature Flags
+ *
+ * Licence : AGPL-3.0-or-later
+ */
+import type { LynxSeoPlugin, PluginContext, PluginEvent, PluginManifest } from "../../plugin";
+export type FeatureStage = "concept" | "alpha" | "beta" | "general_availability";
+export interface EarlyAccessFeature {
+    id: string;
+    name: string;
+    description: string;
+    stage: FeatureStage;
+    documentationUrl?: string;
+    flagKey: string;
+    optedInCount: number;
+    feedbackCount: number;
+    isOptInAllowed: boolean;
+    createdAt: string;
+}
+export interface EarlyAccessFeedback {
+    id: string;
+    featureId: string;
+    userId: string;
+    rating: number;
+    comment?: string;
+    submittedAt: string;
+}
+export interface EarlyAccessReport {
+    siteId: string;
+    features: EarlyAccessFeature[];
+    userEnrolledFeatureIds: string[];
+    totalOptIns: number;
+    averageSatisfactionScore: number;
+}
+export declare class EarlyAccessFeaturesPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private features;
+    private userOptIns;
+    private feedbacks;
+    constructor();
+    private seedDefaultFeatures;
+    enable(_ctx: PluginContext): Promise<void>;
+    onEvent(event: PluginEvent): Promise<void>;
+    toggleUserOptIn(userId: string, featureId: string, optIn: boolean): boolean;
+    submitFeedback(feedback: Omit<EarlyAccessFeedback, "id" | "submittedAt">): EarlyAccessFeedback;
+    getReport(siteId: string, userId?: string): EarlyAccessReport;
+}

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

@@ -0,0 +1,52 @@
+/**
+ * LynxSEO - Ecommerce Analytics Plugin
+ * Inspiré de Matomo Ecommerce (GPLv3 / AGPLv3 compatible).
+ * Suivi des commandes, paniers abandonnés, revenus et classement des produits.
+ */
+import { LynxSeoPlugin, type PluginManifest, type PluginContext, type PluginEvent } from "../../plugin/types";
+export interface EcommerceItem {
+    sku: string;
+    name: string;
+    category: string;
+    price: number;
+    quantity: number;
+}
+export interface EcommerceOrder {
+    orderId: string;
+    revenue: number;
+    subTotal: number;
+    tax: number;
+    shipping: number;
+    discount: number;
+    items: EcommerceItem[];
+}
+export interface RevenueStats {
+    totalRevenue: number;
+    totalOrders: number;
+    averageOrderValue: number;
+    abandonedCartCount: number;
+}
+export interface ProductStats {
+    sku: string;
+    name: string;
+    category: string;
+    totalQuantity: number;
+    totalRevenue: number;
+}
+export declare class EcommercePlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private siteData;
+    enable(_ctx: PluginContext): Promise<void>;
+    onEvent(event: PluginEvent): Promise<void>;
+    /** Statistiques de revenu pour un site donné. */
+    getRevenueStats(siteId: string): RevenueStats;
+    /** Classement des produits par quantité vendue (desc). */
+    getTopProducts(siteId: string, limit?: number): ProductStats[];
+    /** Nombre de paniers abandonnés pour un site donné. */
+    getAbandonedCarts(siteId: string): number;
+    /** Réinitialise les données d'un site (utile pour les tests). */
+    reset(siteId: string): void;
+    private processOrder;
+    private getSiteData;
+}
+export default EcommercePlugin;

package/dist/plugins/error-tracking/index.d.ts

@@ -0,0 +1,101 @@
+/**
+ * ErrorTracking Plugin — LynxSEO Engine
+ *
+ * Parité fonctionnelle :
+ * - PostHog Platform : Error Tracking & Exception Monitoring ($exception capture, stack trace normalization, fingerprinting, release tagging, status resolution)
+ * - Matomo Core : LogViewer & CoreConsole (surveillance des incidents runtime et détection des ruptures de parcours)
+ *
+ * Impact SEO spécifique :
+ * - Détection des erreurs JavaScript bloquant l'indexation par Googlebot (ex: ChunkLoadError, UnhandledRejection sur rendu SSR/Hydration)
+ * - Évaluation du risque SEO (seoRisk: "high" | "medium" | "low")
+ *
+ * Licence : AGPL-3.0-or-later
+ */
+import type { LynxSeoPlugin, PluginContext, PluginEvent, PluginManifest } from "../../plugin";
+export type ErrorStatus = "active" | "resolved" | "suppressed";
+export type ErrorLevel = "error" | "warning" | "fatal";
+export type SeoRiskLevel = "low" | "medium" | "high";
+export interface ErrorOccurrenceRecord {
+    timestamp: string;
+    userDistinctId?: string;
+    sessionId?: string;
+    url: string;
+    userAgent?: string;
+    browser?: string;
+    os?: string;
+    release?: string;
+    isBot?: boolean;
+}
+export interface TrackedErrorGroup {
+    fingerprint: string;
+    siteId: string;
+    errorType: string;
+    message: string;
+    status: ErrorStatus;
+    level: ErrorLevel;
+    firstSeen: string;
+    lastSeen: string;
+    count: number;
+    usersCount: number;
+    sampleStackTrace?: string;
+    sampleUrl: string;
+    sampleBrowser?: string;
+    sampleOs?: string;
+    sampleRelease?: string;
+    seoRisk: SeoRiskLevel;
+}
+export interface ErrorTrackingReport {
+    siteId: string;
+    totalErrors: number;
+    activeErrorsCount: number;
+    resolvedErrorsCount: number;
+    suppressedErrorsCount: number;
+    affectedUsersTotal: number;
+    errors: TrackedErrorGroup[];
+    topErrorsByFrequency: TrackedErrorGroup[];
+    topErrorsBySeoRisk: TrackedErrorGroup[];
+    seoRiskSummary: {
+        highRiskCount: number;
+        mediumRiskCount: number;
+        lowRiskCount: number;
+    };
+}
+export interface RecordErrorInput {
+    errorType?: string;
+    message: string;
+    stackTrace?: string;
+    url?: string;
+    level?: ErrorLevel;
+    userDistinctId?: string;
+    sessionId?: string;
+    userAgent?: string;
+    browser?: string;
+    os?: string;
+    release?: string;
+    isBot?: boolean;
+}
+export declare class ErrorTrackingPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private context?;
+    private errorGroupsBySite;
+    enable(ctx: PluginContext): void;
+    onEvent(event: PluginEvent): void;
+    /**
+     * Computes a deterministic fingerprint from error type, normalized message, and top stack frame
+     */
+    computeFingerprint(errorType: string, message: string, stackTrace?: string): string;
+    /**
+     * Evaluates SEO Risk for Googlebot indexing
+     */
+    evaluateSeoRisk(url: string, message: string, isBot?: boolean): SeoRiskLevel;
+    recordError(siteId: string, input: RecordErrorInput): TrackedErrorGroup;
+    updateErrorStatus(siteId: string, fingerprint: string, status: ErrorStatus): boolean;
+    getErrorDetails(siteId: string, fingerprint: string): TrackedErrorGroup | null;
+    getStats(siteId: string): ErrorTrackingReport;
+    getReport(siteId: string, options?: {
+        status?: ErrorStatus;
+        search?: string;
+        minRisk?: SeoRiskLevel;
+    }): ErrorTrackingReport;
+    private getDefaultErrors;
+}

package/dist/plugins/event-simulator/index.d.ts

@@ -0,0 +1,53 @@
+import type { LynxSeoPlugin, PluginManifest, PluginContext } from "../../plugin/types";
+export interface SimulationProfile {
+    id: string;
+    name: string;
+    virtualUsersCount: number;
+    eventsPerMinute: number;
+    eventTypesDistribution: {
+        pageview: number;
+        buttonClick: number;
+        goalConversion: number;
+        javascriptError: number;
+    };
+    durationMinutes: number;
+    targetUrls: string[];
+}
+export interface SimulatedEventRecord {
+    id: string;
+    profileId: string;
+    eventType: "pageview" | "buttonClick" | "goalConversion" | "javascriptError";
+    url: string;
+    virtualUserId: string;
+    country: string;
+    device: "desktop" | "mobile" | "tablet";
+    timestamp: string;
+    isSimulated: true;
+}
+export interface EventSimulatorReport {
+    projectId: string;
+    generatedAt: string;
+    status: "idle" | "running" | "completed";
+    summary: {
+        totalEventsGenerated: number;
+        activeVirtualUsers: number;
+        currentEventsPerSec: number;
+        simulatedErrorsCount: number;
+        simulatedConversionsCount: number;
+    };
+    profiles: SimulationProfile[];
+    recentSimulatedEvents: SimulatedEventRecord[];
+}
+export declare class EventSimulatorPlugin implements LynxSeoPlugin {
+    manifest: PluginManifest;
+    private status;
+    private profiles;
+    private simulatedEvents;
+    constructor();
+    private seedDefaultProfiles;
+    init(_context: PluginContext): Promise<void>;
+    getReport(projectId: string): EventSimulatorReport;
+    generateBatch(profileId: string, count: number): SimulatedEventRecord[];
+    setSimulationStatus(status: "idle" | "running" | "completed"): void;
+    clearSimulatedEvents(): void;
+}

package/dist/plugins/event-usage-budgets/index.d.ts

@@ -0,0 +1,60 @@
+/**
+ * LynxSEO - Event Usage Budgets Plugin
+ * Inspiré de PostHog API Queries Budget & Ingestion Limits / Matomo Archiving Quotas.
+ * AGPL-3.0-or-later.
+ */
+import type { LynxSeoPlugin, PluginContext, PluginEvent, PluginManifest } from "../../plugin/types";
+export type BudgetAction = "alert_only" | "sample_50" | "throttle" | "reject";
+export interface EventUsageBudget {
+    siteId: string;
+    monthlyQuota: number;
+    periodStartIso: string;
+    periodEndIso: string;
+    totalEventsIngested: number;
+    eventsByMetric: Record<string, number>;
+    exceededAction: BudgetAction;
+    warningThresholdPercent: number;
+    criticalThresholdPercent: number;
+    isThrottled: boolean;
+    isRejected: boolean;
+    history: Array<{
+        date: string;
+        count: number;
+    }>;
+}
+export interface BudgetStatusReport {
+    siteId: string;
+    monthlyQuota: number;
+    totalEventsIngested: number;
+    percentageUsed: number;
+    remainingEvents: number;
+    dailyBurnRate: number;
+    projectedMonthEndTotal: number;
+    projectedOverage: number;
+    status: "healthy" | "warning" | "critical" | "exhausted";
+    exceededAction: BudgetAction;
+    topEvents: Array<{
+        event: string;
+        count: number;
+        percentage: number;
+    }>;
+    history: Array<{
+        date: string;
+        count: number;
+    }>;
+}
+export declare class EventUsageBudgetsPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private readonly budgets;
+    enable(_ctx: PluginContext): Promise<void>;
+    getOrCreateBudget(siteId: string, initialQuota?: number): EventUsageBudget;
+    updateBudgetConfig(siteId: string, config: Partial<Pick<EventUsageBudget, "monthlyQuota" | "exceededAction" | "warningThresholdPercent" | "criticalThresholdPercent">>): EventUsageBudget;
+    recordEventIngested(siteId: string, eventName?: string, count?: number): {
+        accepted: boolean;
+        shouldSample: boolean;
+    };
+    private recalculateLimits;
+    getBudgetReport(siteId: string): BudgetStatusReport;
+    onEvent(event: PluginEvent): Promise<void>;
+    disable(): Promise<void>;
+}

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

@@ -0,0 +1,72 @@
+/**
+ * LynxSEO - Events Plugin
+ * Inspiré de Matomo Events (GPLv3 / AGPLv3 compatible).
+ *
+ * Agrégation des événements personnalisés : catégorie (e_c), action (e_a),
+ * nom (e_n) et valeur numérique (e_v). Expose les rapports getCategory /
+ * getAction / getName avec dimension secondaire, ainsi que les métriques de
+ * valeur (somme, min, max, moyenne) définies par Matomo Events.
+ */
+import { LynxSeoPlugin, type PluginManifest, type PluginContext, type PluginEvent } from "../../plugin/types";
+/** Dimension utilisable comme sous-tableau d'un rapport d'événements. */
+export type SecondaryDimension = "eventCategory" | "eventAction" | "eventName";
+export interface TrackedEvent {
+    category: string;
+    action: string;
+    name?: string;
+    /** Valeur numérique optionnelle (e_v). */
+    value?: number;
+    visitorId: string;
+    visitId: string;
+    url?: string;
+    timestamp: string;
+}
+export interface EventRow {
+    label: string;
+    nbEvents: number;
+    nbVisits: number;
+    nbUniqueVisitors: number;
+    subtable?: EventRow[];
+    secondaryDimension?: SecondaryDimension;
+}
+export interface EventValueStats {
+    nbEventsWithValue: number;
+    sumEventValue: number;
+    minEventValue: number;
+    maxEventValue: number;
+    avgEventValue: number;
+}
+export interface EventsReport {
+    rows: EventRow[];
+    totals: {
+        nbEvents: number;
+        nbVisits: number;
+        nbUniqueVisitors: number;
+    };
+    values: EventValueStats;
+}
+interface ReportOptions {
+    secondaryDimension?: SecondaryDimension;
+    limit?: number;
+}
+export declare class EventsPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private ctx?;
+    private events;
+    enable(ctx: PluginContext): Promise<void>;
+    onEvent(event: PluginEvent): Promise<void>;
+    /** Rapport par catégorie d'événement (Matomo Events.getCategory). */
+    getCategory(siteId: string, options?: ReportOptions): EventsReport;
+    /** Rapport par action d'événement (Matomo Events.getAction). */
+    getAction(siteId: string, options?: ReportOptions): EventsReport;
+    /** Rapport par nom d'événement (Matomo Events.getName). */
+    getName(siteId: string, options?: ReportOptions): EventsReport;
+    /** Événements bruts (debug / inspection). */
+    getRecentEvents(siteId: string, limit?: number): TrackedEvent[];
+    /** Métriques de valeur agrégées pour un site. */
+    getValueStats(siteId: string): EventValueStats;
+    reset(siteId: string): void;
+    disable(): Promise<void>;
+    private report;
+}
+export default EventsPlugin;

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

@@ -0,0 +1,87 @@
+/**
+ * LynxSEO - Experiments Plugin (A/B testing)
+ * Stockage et calcul de significativité pour les tests A/B posés côté tracker.
+ * Complète `ab-testing-engine` (calcul pur) avec un état par site + onEvent.
+ */
+import { LynxSeoPlugin, type PluginManifest, type PluginContext, type PluginEvent } from "../../plugin/types";
+export interface ExperimentVariant {
+    id: string;
+    name: string;
+    /** Part de trafic en 0..1, la somme des variantes d'un test vaut 1. */
+    trafficPercentage: number;
+}
+export interface ExperimentVariantStats {
+    id: string;
+    name: string;
+    exposures: number;
+    conversions: number;
+    conversionRate: number;
+    lift: number | null;
+}
+export interface ExperimentDefinition {
+    id: string;
+    siteId: string;
+    name: string;
+    description?: string;
+    /** Métrique principale suivie par le test. */
+    primaryMetric: "conversion" | "ctr" | "revenue" | "engagement";
+    variants: ExperimentVariant[];
+    /** Seuil de confiance (0..1), 0.95 par défaut. */
+    significanceLevel: number;
+    /** Taille d'échantillon minimale par variante avant verdict. */
+    minSampleSize: number;
+    status: "running" | "stopped";
+    createdAt: string;
+}
+export interface ExperimentStats {
+    experimentId: string;
+    variants: ExperimentVariantStats[];
+    winnerId: string | null;
+    significant: boolean;
+    confidence: number;
+    enoughSamples: boolean;
+}
+export declare class ExperimentsService {
+    private experiments;
+    private assignments;
+    create(input: Omit<ExperimentDefinition, "siteId" | "status" | "createdAt"> & {
+        siteId: string;
+        status?: "running" | "stopped";
+        createdAt?: string;
+    }): ExperimentDefinition;
+    get(experimentId: string): ExperimentDefinition | undefined;
+    list(siteId?: string): ExperimentDefinition[];
+    update(experimentId: string, patch: Partial<Omit<ExperimentDefinition, "id" | "siteId" | "createdAt">>): ExperimentDefinition;
+    delete(experimentId: string): boolean;
+    stop(experimentId: string): ExperimentDefinition;
+    /** Attribution déterministe d'un visiteur à une variante (hash FNV-1a). */
+    assign(experimentId: string, visitorId: string): string | undefined;
+    recordConversion(experimentId: string, visitorId: string): boolean;
+    /** Significativité simplifiée : écart de taux > 5 % + tailles suffisantes. */
+    private significant;
+    stats(experimentId: string): ExperimentStats;
+    clear(): void;
+}
+export declare class ExperimentsPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private service;
+    private ctx?;
+    enable(ctx: PluginContext): Promise<void>;
+    disable(): Promise<void>;
+    onEvent(event: PluginEvent): Promise<void>;
+    create(input: Omit<ExperimentDefinition, "siteId" | "status" | "createdAt"> & {
+        siteId: string;
+        status?: "running" | "stopped";
+        createdAt?: string;
+    }): ExperimentDefinition;
+    get(experimentId: string): ExperimentDefinition | undefined;
+    list(siteId?: string): ExperimentDefinition[];
+    update(experimentId: string, patch: Partial<Omit<ExperimentDefinition, "id" | "siteId" | "createdAt">>): ExperimentDefinition;
+    delete(experimentId: string): boolean;
+    stop(experimentId: string): ExperimentDefinition;
+    assign(experimentId: string, visitorId: string): string | undefined;
+    recordConversion(experimentId: string, visitorId: string): boolean;
+    stats(experimentId: string): ExperimentStats;
+    reset(): void;
+}
+export default ExperimentsPlugin;

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

@@ -0,0 +1,47 @@
+/**
+ * LynxSEO - Feedback Plugin
+ * Collecte et gestion du feedback utilisateur (satisfaction, commentaires, notes).
+ * Inspiré de Matomo Feedback (GPLv3 / AGPLv3 compatible).
+ */
+import { LynxSeoPlugin, type PluginManifest, type PluginContext, type PluginEvent } from "../../plugin/types";
+export interface FeedbackEntry {
+    id: string;
+    siteId: string;
+    visitorId?: string;
+    userId?: string;
+    pageUrl?: string;
+    rating: number;
+    comment?: string;
+    category?: string;
+    createdAt: string;
+}
+export declare class FeedbackService {
+    private feedbacks;
+    create(entry: Omit<FeedbackEntry, "id" | "createdAt"> & {
+        id?: string;
+    }): FeedbackEntry;
+    get(feedbackId: string): FeedbackEntry | undefined;
+    list(siteId?: string): FeedbackEntry[];
+    delete(feedbackId: string): boolean;
+    count(siteId?: string): number;
+    averageRating(siteId?: string): number;
+    clear(): void;
+}
+export declare class FeedbackPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private service;
+    private ctx?;
+    enable(_ctx: PluginContext): Promise<void>;
+    disable(): Promise<void>;
+    onEvent(event: PluginEvent): Promise<void>;
+    create(entry: Omit<FeedbackEntry, "id" | "createdAt"> & {
+        id?: string;
+    }): FeedbackEntry;
+    get(feedbackId: string): FeedbackEntry | undefined;
+    list(siteId?: string): FeedbackEntry[];
+    delete(feedbackId: string): boolean;
+    count(siteId?: string): number;
+    averageRating(siteId?: string): number;
+    reset(): void;
+}
+export default FeedbackPlugin;